576 lines
22 KiB
Python
576 lines
22 KiB
Python
"""
|
||
llm-manager 主入口 CLI。
|
||
|
||
子命令：
|
||
health 快速离线健康检查
|
||
version 输出版本 JSON
|
||
add <platform> [api_key] 添加 API Key（不传 api_key 则走网页账号关联）
|
||
key list [platform] 列出 Key（打码）
|
||
key del <key_id> 删除 Key
|
||
generate <platform_or_account_id> 生成内容（优先网页模式，备用 API Key 模式）
|
||
"<prompt>"
|
||
|
||
generate 调度规则：
|
||
1. 若 target 为纯数字 → 视为 account-manager 账号 ID → 强制网页模式
|
||
2. 若 target 为平台名/别名：
|
||
a. 先查 account-manager 有无该平台已登录账号 → 网页模式（免费）
|
||
b. 再查 llm_keys 有无可用 Key → API Key 模式（付费）
|
||
c. 两者均无 → 报错并给出操作指引
|
||
"""
|
||
import sys
|
||
import json
|
||
import os
|
||
import asyncio
|
||
import subprocess
|
||
|
||
# Windows GBK 编码兼容修复
|
||
if sys.platform == "win32":
|
||
import io
|
||
sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8", errors="replace")
|
||
sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding="utf-8", errors="replace")
|
||
|
||
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||
OPENCLAW_DIR = os.path.dirname(BASE_DIR)
|
||
|
||
# 确保 scripts 目录在 sys.path，使 providers/db 可直接 import
|
||
_scripts_dir = os.path.dirname(os.path.abspath(__file__))
|
||
if _scripts_dir not in sys.path:
|
||
sys.path.insert(0, _scripts_dir)
|
||
|
||
from providers import (
|
||
LLM_PROVIDERS,
|
||
resolve_provider_key,
|
||
provider_list_cn,
|
||
find_logged_in_account,
|
||
resolve_chromium_channel,
|
||
)
|
||
from db import (
|
||
add_key,
|
||
upsert_web_account,
|
||
list_keys,
|
||
list_web_accounts,
|
||
get_key_by_id,
|
||
delete_key,
|
||
find_active_key,
|
||
mark_key_used,
|
||
_mask_key,
|
||
)
|
||
from engines.api_engine import ApiEngine
|
||
from engines.kimi import KimiEngine
|
||
from engines.doubao import DoubaoEngine
|
||
from engines.deepseek import DeepSeekEngine
|
||
from engines.qianwen import QianwenEngine
|
||
from engines.yiyan import YiyanEngine
|
||
from engines.yuanbao import YuanbaoEngine
|
||
|
||
# 平台 slug → 网页引擎类（全部 6 个平台）
|
||
WEB_ENGINES = {
|
||
"doubao": DoubaoEngine,
|
||
"deepseek": DeepSeekEngine,
|
||
"qianwen": QianwenEngine,
|
||
"kimi": KimiEngine,
|
||
"yiyan": YiyanEngine,
|
||
"yuanbao": YuanbaoEngine,
|
||
}
|
||
|
||
SKILL_VERSION = "1.0.3"
|
||
|
||
|
||
def _engine_result_is_error(text: str) -> bool:
|
||
"""网页/API 引擎约定：失败时返回以 ERROR: 开头的字符串，不得当作正文包进 LLM 标记块。"""
|
||
return (text or "").lstrip().startswith("ERROR:")
|
||
|
||
|
||
def _unix_to_iso(ts):
|
||
if ts is None:
|
||
return ""
|
||
try:
|
||
import datetime as _dt
|
||
|
||
return _dt.datetime.fromtimestamp(int(ts)).isoformat(timespec="seconds")
|
||
except Exception:
|
||
return str(ts)
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# account-manager 跨 Skill 调用
|
||
# ---------------------------------------------------------------------------
|
||
|
||
def _get_account_from_manager(account_id) -> dict | None:
|
||
"""通过 account-manager CLI 按 ID 取账号 JSON。"""
|
||
script = os.path.join(OPENCLAW_DIR, "account-manager", "scripts", "main.py")
|
||
try:
|
||
result = subprocess.run(
|
||
[sys.executable, script, "get", str(account_id)],
|
||
capture_output=True, text=True, encoding="utf-8", errors="replace",
|
||
)
|
||
raw = result.stdout.strip()
|
||
if raw.startswith("ERROR"):
|
||
return None
|
||
return json.loads(raw)
|
||
except Exception:
|
||
return None
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# 网页模式
|
||
# ---------------------------------------------------------------------------
|
||
|
||
async def _run_web_generate(account: dict, prompt: str) -> bool:
|
||
from playwright.async_api import async_playwright
|
||
|
||
platform = account.get("platform", "")
|
||
profile_dir = account.get("profile_dir", "").strip()
|
||
|
||
engine_cls = WEB_ENGINES.get(platform)
|
||
if not engine_cls:
|
||
print(f"ERROR:ENGINE_NOT_FOUND 平台 {platform} 暂无网页引擎实现。")
|
||
return False
|
||
|
||
if not profile_dir or not os.path.isdir(profile_dir):
|
||
print(f"ERROR:PROFILE_DIR_MISSING 账号 {account.get('id')} 的浏览器数据目录不存在：{profile_dir}")
|
||
print("请先通过 account-manager 执行登录：python account-manager/scripts/main.py login <id>")
|
||
return False
|
||
|
||
channel = resolve_chromium_channel()
|
||
if not channel:
|
||
print("ERROR:浏览器未找到。请安装 Google Chrome 或 Microsoft Edge 后重试。")
|
||
return False
|
||
|
||
print(f"[llm-manager] 使用网页模式 | 平台: {LLM_PROVIDERS.get(platform, {}).get('label', platform)} | 账号: {account.get('name', account.get('id'))}")
|
||
|
||
async with async_playwright() as p:
|
||
browser = await p.chromium.launch_persistent_context(
|
||
user_data_dir=profile_dir,
|
||
headless=False,
|
||
channel=channel,
|
||
no_viewport=True,
|
||
permissions=["clipboard-read", "clipboard-write"],
|
||
args=["--start-maximized"],
|
||
)
|
||
try:
|
||
page = browser.pages[0] if browser.pages else await browser.new_page()
|
||
engine = engine_cls(page)
|
||
try:
|
||
result = await engine.generate(prompt)
|
||
except Exception as e:
|
||
print(f"ERROR:WEB_GENERATE_FAILED 网页模式生成失败：{e}")
|
||
return False
|
||
|
||
result = (result or "").strip()
|
||
if _engine_result_is_error(result):
|
||
print(result)
|
||
return False
|
||
|
||
print("===LLM_START===")
|
||
print(result)
|
||
print("===LLM_END===")
|
||
return True
|
||
finally:
|
||
await asyncio.sleep(3)
|
||
await browser.close()
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# API Key 模式
|
||
# ---------------------------------------------------------------------------
|
||
|
||
def _run_api_generate(provider_key: str, key_record: dict, prompt: str) -> bool:
|
||
provider = LLM_PROVIDERS[provider_key]
|
||
api_base = provider.get("api_base")
|
||
model = (key_record.get("default_model") or "").strip() or (provider.get("api_model") or "").strip()
|
||
|
||
if not api_base:
|
||
print(f"ERROR:NO_API_BASE {provider['label']} 暂无 API 地址（不支持 API 模式）。")
|
||
return False
|
||
if not model:
|
||
print(
|
||
f"ERROR:API_MODEL_MISSING {provider['label']} 需要指定模型名称。\n"
|
||
f"提示：{provider.get('api_note', '')}\n"
|
||
f"请删除该 Key 并重新添加时带上 --model 参数：python main.py add {provider_key} \"Key\" --model \"模型名\""
|
||
)
|
||
return False
|
||
|
||
print(f"[llm-manager] 使用 API Key 模式 | 平台: {provider['label']} | 模型: {model}")
|
||
|
||
try:
|
||
engine = ApiEngine(api_base=api_base, api_key=key_record["api_key"], model=model)
|
||
result = engine.generate(prompt)
|
||
except Exception as e:
|
||
print(f"ERROR:API_GENERATE_FAILED API 模式调用失败：{e}")
|
||
return False
|
||
result = (result or "").strip()
|
||
if _engine_result_is_error(result):
|
||
print(result)
|
||
return False
|
||
mark_key_used(key_record["id"])
|
||
|
||
print("===LLM_START===")
|
||
print(result)
|
||
print("===LLM_END===")
|
||
return True
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# generate 命令
|
||
# ---------------------------------------------------------------------------
|
||
|
||
def cmd_generate(target: str, prompt: str) -> bool:
|
||
"""
|
||
target 可以是：
|
||
- 纯数字 → account-manager 账号 ID（强制网页模式）
|
||
- 平台名/别名 → 自动选择模式（网页优先，API Key 备用）
|
||
成功返回 True，任一步失败返回 False（调用方应设进程退出码非 0）。
|
||
"""
|
||
target = (target or "").strip()
|
||
prompt = (prompt or "").strip()
|
||
if not prompt:
|
||
print("ERROR:PROMPT_EMPTY 提示词不能为空。")
|
||
return False
|
||
|
||
# ---- 情况 1：显式 account_id（纯数字）→ 强制网页模式 ----
|
||
if target.isdigit():
|
||
account = _get_account_from_manager(target)
|
||
if not account:
|
||
print(f"ERROR:ACCOUNT_NOT_FOUND 未在「模型管理」对应的账号列表中找到 id={target}。")
|
||
print("请先在模型管理中添加该平台账号，或检查 id 是否抄错。")
|
||
return False
|
||
if account.get("login_status") != 1:
|
||
print(
|
||
f"ERROR:REQUIRE_LOGIN 账号「{account.get('name', target)}」尚未完成网页登录。\n"
|
||
"请先在「模型管理」里确认已添加该账号，再执行下面命令完成登录：\n"
|
||
f" python account-manager/scripts/main.py login {target}\n"
|
||
"若使用网页模式：请先在对应平台官网注册好账号，再回到本工具添加并登录。"
|
||
)
|
||
return False
|
||
return asyncio.run(_run_web_generate(account, prompt))
|
||
|
||
# ---- 情况 2：平台名 → 自动选模式 ----
|
||
provider_key = resolve_provider_key(target)
|
||
if not provider_key:
|
||
print(f"ERROR:INVALID_PLATFORM 无法识别的平台「{target}」。")
|
||
print("支持的平台：" + provider_list_cn())
|
||
return False
|
||
|
||
provider = LLM_PROVIDERS[provider_key]
|
||
label = provider["label"]
|
||
web_url = (provider.get("web_url") or "").strip()
|
||
|
||
# 优先级 1：查 account-manager 已登录账号（网页模式，免费）
|
||
account = find_logged_in_account(provider_key)
|
||
if account:
|
||
return asyncio.run(_run_web_generate(account, prompt))
|
||
|
||
# 优先级 2：查本地 API Key（付费）
|
||
key_record = find_active_key(provider_key)
|
||
if key_record:
|
||
return _run_api_generate(provider_key, key_record, prompt)
|
||
|
||
# 两种凭据均无 → 明确说明「模型管理 + 网页模式需官网账号」
|
||
print(f"ERROR:NO_CREDENTIAL 当前没有可用的「{label}」调用凭据（既没有已登录的网页账号，也没有可用的 API Key）。")
|
||
print()
|
||
print("【推荐 · 网页模式（免费）】按顺序做：")
|
||
print(f" ① 打开「模型管理」（与 OpenClaw 里 account-manager 账号管理是同一套数据），先把「{label}」账号添加进去。")
|
||
print(" 命令行示例（在 OpenClaw 根目录执行）：")
|
||
print(f" python account-manager/scripts/main.py add \"{label}\" \"你的手机号或登录名\"")
|
||
print(" python account-manager/scripts/main.py login <上一步返回的账号 id>")
|
||
print(" ② 若走网页模式：请先在对应平台官方网站注册并创建好账号（否则浏览器里登录会失败）。")
|
||
if web_url:
|
||
print(f" 「{label}」网页入口：{web_url}")
|
||
print()
|
||
if provider.get("has_api"):
|
||
print("【备选 · API Key（付费）】若已在厂商控制台开通 API，可本地登记 Key 后走接口调用：")
|
||
print(f" python llm-manager/scripts/main.py add {provider_key} \"你的API Key\"")
|
||
if provider.get("api_note"):
|
||
print(f" 说明：{provider['api_note']}")
|
||
else:
|
||
print(f"说明：「{label}」暂无公开 API，只能使用上面的网页模式。")
|
||
return False
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# key 子命令
|
||
# ---------------------------------------------------------------------------
|
||
|
||
def cmd_key_add(provider_input: str, api_key: str = "", model: str = None, label: str = ""):
|
||
provider_key = resolve_provider_key(provider_input)
|
||
if not provider_key:
|
||
print(f"ERROR:INVALID_PLATFORM 无法识别的平台「{provider_input}」。")
|
||
print("支持：" + provider_list_cn())
|
||
return
|
||
provider = LLM_PROVIDERS[provider_key]
|
||
api_key = (api_key or "").strip()
|
||
|
||
# 不传 api_key：默认走网页版本，检查 account-manager 是否已有该平台已登录账号
|
||
if not api_key:
|
||
account = find_logged_in_account(provider_key)
|
||
if account:
|
||
web_row_id = upsert_web_account(
|
||
provider=provider_key,
|
||
account_id=int(account.get("id")),
|
||
account_name=(account.get("name") or account.get("account_name") or ""),
|
||
login_status=int(account.get("login_status") or 0),
|
||
)
|
||
print(
|
||
f"OK:WEB_ACCOUNT_READY 已关联网页模式账号 | 平台: {provider['label']} "
|
||
f"| account_id: {account.get('id')} | 账号: {account.get('name') or account.get('account_name') or ''}"
|
||
)
|
||
print(f"已写入 llm-manager 记录：WEB_ID {web_row_id}")
|
||
print(f"后续可直接调用：python main.py generate {provider_key} \"<提示词>\"")
|
||
return
|
||
print(f"ERROR:WEB_ACCOUNT_NOT_FOUND 未找到已登录的「{provider['label']}」账号，暂时无法走网页模式。")
|
||
print("请先在 account-manager 添加并登录该平台账号：")
|
||
print(f" python account-manager/scripts/main.py add \"{provider['label']}\" \"你的登录名\"")
|
||
print(" python account-manager/scripts/main.py login <账号id>")
|
||
if provider.get("has_api"):
|
||
print("或直接提供 API Key：")
|
||
print(f" python main.py add {provider_key} \"<API_Key>\"")
|
||
return
|
||
|
||
if not provider.get("has_api"):
|
||
print(f"ERROR:{provider['label']} 暂无公开 API，不支持 API Key 模式。")
|
||
print("请改用网页模式并先在 account-manager 完成登录。")
|
||
return
|
||
|
||
new_id = add_key(provider=provider_key, api_key=api_key, model=model, label=label)
|
||
print(f"✅ 已保存 API Key：ID {new_id} | {provider['label']} | 模型: {model or provider.get('api_model') or '(未指定)'} | {_mask_key(api_key)}")
|
||
if not model and not provider.get("api_model"):
|
||
print(f"⚠️ 注意：该平台需要指定模型名称，否则调用时会报错。")
|
||
print(f" {provider.get('api_note', '')}")
|
||
print(f" 可删除后重新添加：python main.py key del {new_id}")
|
||
|
||
|
||
def cmd_key_list(provider_input: str = None, limit: int = 10):
|
||
provider_key = None
|
||
if provider_input:
|
||
provider_key = resolve_provider_key(provider_input)
|
||
if not provider_key:
|
||
print(f"ERROR:INVALID_PLATFORM 无法识别的平台「{provider_input}」。")
|
||
return
|
||
|
||
keys = list_keys(provider_key, limit=limit)
|
||
web_accounts = list_web_accounts(provider_key, limit=limit)
|
||
if not keys and not web_accounts:
|
||
print("暂无记录（API Key / 网页账号关联 都为空）。")
|
||
print("添加 API Key：python main.py add <platform> \"API Key\" [--model 模型名]")
|
||
print("添加网页账号关联：python main.py add <platform>")
|
||
return
|
||
|
||
sep_line = "_" * 39
|
||
rows = []
|
||
for k in keys:
|
||
rows.append({
|
||
"type": "api_key",
|
||
"created_at": int(k.get("created_at") or 0),
|
||
"payload": k,
|
||
})
|
||
for w in web_accounts:
|
||
rows.append({
|
||
"type": "web_account",
|
||
"created_at": int(w.get("created_at") or 0),
|
||
"payload": w,
|
||
})
|
||
rows.sort(key=lambda x: (x["created_at"], int(x["payload"].get("id") or 0)), reverse=True)
|
||
|
||
for idx, row in enumerate(rows):
|
||
if row["type"] == "api_key":
|
||
k = row["payload"]
|
||
print("record_type：api_key")
|
||
print(f"id：{k['id']}")
|
||
print(f"platform：{k['provider']}")
|
||
print(f"platform_cn：{LLM_PROVIDERS.get(k['provider'], {}).get('label', k['provider'])}")
|
||
print(f"label：{k.get('label') or ''}")
|
||
print(f"api_key：{_mask_key(k.get('api_key') or '')}")
|
||
print(f"default_model：{k.get('default_model') or ''}")
|
||
print(f"is_active：{int(k.get('is_active') or 0)}")
|
||
print(f"last_used_at：{_unix_to_iso(k.get('last_used_at'))}")
|
||
print(f"created_at：{_unix_to_iso(k.get('created_at'))}")
|
||
else:
|
||
w = row["payload"]
|
||
print("record_type：web_account")
|
||
print(f"id：{w['id']}")
|
||
print(f"platform：{w['provider']}")
|
||
print(f"platform_cn：{LLM_PROVIDERS.get(w['provider'], {}).get('label', w['provider'])}")
|
||
print(f"account_id：{w.get('account_id')}")
|
||
print(f"account_name：{w.get('account_name') or ''}")
|
||
print(f"login_status：{int(w.get('login_status') or 0)}")
|
||
print(f"created_at：{_unix_to_iso(w.get('created_at'))}")
|
||
print(f"updated_at：{_unix_to_iso(w.get('updated_at'))}")
|
||
if idx != len(rows) - 1:
|
||
print(sep_line)
|
||
print()
|
||
|
||
|
||
def cmd_key_del(key_id_str: str):
|
||
if not key_id_str.isdigit():
|
||
print(f"ERROR:INVALID_ID key_id 须为正整数，收到「{key_id_str}」。")
|
||
return
|
||
key_id = int(key_id_str)
|
||
key = get_key_by_id(key_id)
|
||
if not key:
|
||
print(f"ERROR:KEY_NOT_FOUND 未找到 ID={key_id} 的 API Key。")
|
||
return
|
||
delete_key(key_id)
|
||
label_str = f"（{key['label']}）" if key.get("label") else ""
|
||
print(f"✅ 已删除：ID {key_id} | {LLM_PROVIDERS.get(key['provider'], {}).get('label', key['provider'])}{label_str} | {_mask_key(key['api_key'])}")
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# health / version
|
||
# ---------------------------------------------------------------------------
|
||
|
||
def cmd_health():
|
||
ok = sys.version_info >= (3, 10)
|
||
sys.exit(0 if ok else 1)
|
||
|
||
|
||
def cmd_version():
|
||
print(json.dumps({"version": SKILL_VERSION, "skill": "llm-manager"}, ensure_ascii=False))
|
||
|
||
|
||
# ---------------------------------------------------------------------------
|
||
# CLI 解析
|
||
# ---------------------------------------------------------------------------
|
||
|
||
def _print_usage():
|
||
print("用法：")
|
||
print(" python main.py health")
|
||
print(" python main.py version")
|
||
print(" python main.py generate <平台名或account_id> \"<提示词>\"")
|
||
print(" python main.py add <平台> [API_Key] [--model 模型名] [--label 备注]")
|
||
print(" python main.py list [平台] [--limit 条数]")
|
||
print(" python main.py del <key_id>")
|
||
print()
|
||
print("支持的平台：" + provider_list_cn())
|
||
print()
|
||
print("generate 说明：")
|
||
print(" · 传入 account_id（数字）→ 指定账号网页模式（需先用 account-manager 登录）")
|
||
print(" · 传入平台名 → 自动选择：优先网页模式（免费），无可用账号时才用 API Key（付费）")
|
||
print()
|
||
print("兼容说明：key add/list/del 旧写法仍可用。")
|
||
|
||
|
||
def main(argv=None) -> int:
|
||
args = argv if argv is not None else sys.argv[1:]
|
||
if not args:
|
||
_print_usage()
|
||
return 1
|
||
if args[0] in ("-h", "--help"):
|
||
_print_usage()
|
||
return 0
|
||
|
||
def _parse_list_args(rest_args):
|
||
platform_filter = None
|
||
limit = 10
|
||
i = 0
|
||
while i < len(rest_args):
|
||
if rest_args[i] == "--limit" and i + 1 < len(rest_args):
|
||
try:
|
||
limit = int(rest_args[i + 1])
|
||
except ValueError:
|
||
print(f"ERROR:CLI_KEY_LIST_BAD_LIMIT limit 必须是整数，收到「{rest_args[i + 1]}」。")
|
||
return None, None, 1
|
||
i += 2
|
||
else:
|
||
if platform_filter is None:
|
||
platform_filter = rest_args[i]
|
||
i += 1
|
||
return platform_filter, limit, 0
|
||
|
||
def _parse_add_args(rest_args):
|
||
if len(rest_args) < 1:
|
||
print("ERROR:CLI_ADD_MISSING_ARGS")
|
||
print("用法：python main.py add <平台> [API_Key] [--model 模型] [--label 备注]")
|
||
return None, None, None, None, 1
|
||
platform_arg = rest_args[0]
|
||
api_key_arg = ""
|
||
model_arg = None
|
||
label_arg = ""
|
||
i = 1
|
||
if i < len(rest_args) and not rest_args[i].startswith("--"):
|
||
api_key_arg = rest_args[i]
|
||
i += 1
|
||
while i < len(rest_args):
|
||
if rest_args[i] == "--model" and i + 1 < len(rest_args):
|
||
model_arg = rest_args[i + 1]
|
||
i += 2
|
||
elif rest_args[i] == "--label" and i + 1 < len(rest_args):
|
||
label_arg = rest_args[i + 1]
|
||
i += 2
|
||
else:
|
||
i += 1
|
||
return platform_arg, api_key_arg, model_arg, label_arg, 0
|
||
|
||
cmd = args[0]
|
||
|
||
if cmd == "health":
|
||
cmd_health()
|
||
|
||
elif cmd == "version":
|
||
cmd_version()
|
||
|
||
elif cmd == "generate":
|
||
if len(args) < 3:
|
||
print("ERROR:CLI_GENERATE_MISSING_ARGS")
|
||
print("用法：python main.py generate <平台名或account_id> \"<提示词>\"")
|
||
return 1
|
||
if not cmd_generate(args[1], args[2]):
|
||
return 1
|
||
|
||
elif cmd == "list":
|
||
platform_filter, limit, err = _parse_list_args(args[1:])
|
||
if err:
|
||
return err
|
||
cmd_key_list(platform_filter, limit=limit)
|
||
|
||
elif cmd == "add":
|
||
platform_arg, api_key_arg, model_arg, label_arg, err = _parse_add_args(args[1:])
|
||
if err:
|
||
return err
|
||
cmd_key_add(platform_arg, api_key_arg, model=model_arg, label=label_arg)
|
||
|
||
elif cmd == "del":
|
||
if len(args) < 2:
|
||
print("ERROR:CLI_DEL_MISSING_ARGS 用法：python main.py del <key_id>")
|
||
return 1
|
||
cmd_key_del(args[1])
|
||
|
||
elif cmd == "key":
|
||
if len(args) < 2:
|
||
print("ERROR:CLI_KEY_MISSING_SUBCOMMAND 请指定子命令：add / list / del")
|
||
return 1
|
||
sub = args[1]
|
||
|
||
if sub == "add":
|
||
platform_arg, api_key_arg, model_arg, label_arg, err = _parse_add_args(args[2:])
|
||
if err:
|
||
return err
|
||
cmd_key_add(platform_arg, api_key_arg, model=model_arg, label=label_arg)
|
||
|
||
elif sub == "list":
|
||
platform_filter, limit, err = _parse_list_args(args[2:])
|
||
if err:
|
||
return err
|
||
cmd_key_list(platform_filter, limit=limit)
|
||
|
||
elif sub == "del":
|
||
if len(args) < 3:
|
||
print("ERROR:CLI_KEY_DEL_MISSING_ARGS 用法：python main.py key del <key_id>")
|
||
return 1
|
||
cmd_key_del(args[2])
|
||
|
||
else:
|
||
print(f"ERROR:CLI_UNKNOWN_KEY_SUB 未知 key 子命令「{sub}」，支持：add / list / del")
|
||
return 1
|
||
|
||
else:
|
||
print(f"ERROR:CLI_UNKNOWN_COMMAND 未知命令「{cmd}」。")
|
||
_print_usage()
|
||
return 1
|
||
|
||
return 0
|
||
|
||
|
||
if __name__ == "__main__":
|
||
raise SystemExit(main())
|