easyrouter-config 1.0.5 → 1.0.7

package/dist/index.js

@@ -5,98 +5,126 @@ import {
   intro,
   outro,
   text,
-  select,
+  multiselect,
   confirm,
   spinner,
-  isCancel,
+  isCancel as isCancel2,
   cancel,
-  log,
+  log as log3,
   note
 } from "@clack/prompts";
-import { execa } from "execa";
-import pc from "picocolors";
+import pc6 from "picocolors";
+
+// src/cli/args.ts
 import { parseArgs } from "util";
-var VERSION = true ? "1.0.5" : "0.0.0-dev";
+import pc from "picocolors";
+
+// src/config/constants.ts
+var VERSION = true ? "1.0.7" : "0.0.0-dev";
 var PRIMARY_HOST = "https://easyrouter.io";
 var FALLBACK_HOSTS = ["https://ezr.sh"];
-var PROBE_TIMEOUT_MS = 5e3;
+var HOST_PROBE_TIMEOUT_MS = 5e3;
+var FETCH_MODELS_TIMEOUT_MS = 8e3;
+var VERIFY_TIMEOUT_MS = 1e4;
+var SUBPROCESS_IDLE_TIMEOUT_MS = 6e4;
+var SUBPROCESS_HARD_TIMEOUT_MS = 3e5;
+var PROGRESS_THROTTLE_MS = 200;
 var CODEX_FALLBACK_MODEL = "gpt-5.5";
+
+// src/clients/types.ts
+var ALL_CLIENT_IDS = ["claude", "codex", "openclaw", "hermes"];
+
+// src/cli/args.ts
 function parseCliArgs() {
-  try {
-    const { values } = parseArgs({
-      args: process.argv.slice(2),
-      options: {
-        "api-key": { type: "string", short: "k" },
-        only: { type: "string" },
-        "skip-verify": { type: "boolean" },
-        verbose: { type: "boolean", short: "v" },
-        help: { type: "boolean", short: "h" },
-        version: { type: "boolean", short: "V" }
-      },
-      allowPositionals: false,
-      strict: false
-    });
-    return {
-      apiKey: values["api-key"],
-      only: values.only,
-      skipVerify: values["skip-verify"],
-      verbose: values.verbose,
-      help: values.help,
-      version: values.version
-    };
-  } catch {
-    return {};
+  const { values } = parseArgs({
+    args: process.argv.slice(2),
+    options: {
+      "api-key": { type: "string", short: "k" },
+      only: { type: "string" },
+      "skip-verify": { type: "boolean" },
+      verbose: { type: "boolean", short: "v" },
+      help: { type: "boolean", short: "h" },
+      version: { type: "boolean", short: "V" }
+    },
+    allowPositionals: false,
+    strict: false
+  });
+  return {
+    apiKey: values["api-key"],
+    only: parseOnlyValue(values.only),
+    skipVerify: values["skip-verify"],
+    verbose: values.verbose,
+    help: values.help,
+    version: values.version
+  };
+}
+function parseOnlyValue(raw) {
+  if (!raw) return void 0;
+  if (raw === "all") return [...ALL_CLIENT_IDS];
+  const tokens = raw.split(",").map((t) => t.trim().toLowerCase()).filter(Boolean);
+  for (const t of tokens) {
+    if (!ALL_CLIENT_IDS.includes(t)) {
+      throw new Error(
+        `--only \u5305\u542B\u672A\u77E5\u5BA2\u6237\u7AEF "${t}"\u3002
+  \u53EF\u9009\u503C\uFF1A${ALL_CLIENT_IDS.join(", ")} \u6216 all`
+      );
+    }
   }
+  return tokens;
 }
 function printHelp() {
   console.log(`
 ${pc.bold(pc.cyan("easyrouter-config"))} ${pc.dim("v" + VERSION)}
-\u4E00\u952E\u628A EasyRouter \u63A5\u5165 Claude Code & Codex\uFF08\u6309\u91CF\u4ED8\u8D39\uFF09
+\u4E00\u952E\u628A EasyRouter \u63A5\u5165 Claude Code / Codex / OpenClaw / Hermes\uFF08\u6309\u91CF\u4ED8\u8D39\uFF09
 
 ${pc.bold("\u7528\u6CD5:")}
-  ${pc.green("npx -y easyrouter-config")}                       \u4EA4\u4E92\u5F0F\uFF08\u63A8\u8350\uFF09
-  ${pc.green("npx -y easyrouter-config -k sk-xxx")}             \u4E00\u884C\u547D\u4EE4\u914D\u7F6E
-  ${pc.green("npx -y easyrouter-config -k sk-xxx --only claude")}  \u53EA\u914D Claude Code
+  ${pc.green("npx -y easyrouter-config")}                            \u4EA4\u4E92\u5F0F\uFF08\u63A8\u8350 \u2014 \u9009\u4F60\u60F3\u914D\u7684\u5BA2\u6237\u7AEF\uFF09
+  ${pc.green("npx -y easyrouter-config -k sk-xxx")}                  \u975E\u4EA4\u4E92\uFF1A\u9ED8\u8BA4\u914D Claude Code + Codex
+  ${pc.green("npx -y easyrouter-config -k sk-xxx --only claude")}    \u53EA\u914D Claude Code
+  ${pc.green("npx -y easyrouter-config -k sk-xxx --only claude,codex,openclaw")}   \u914D\u591A\u4E2A
+  ${pc.green("npx -y easyrouter-config -k sk-xxx --only all")}       \u914D\u5168\u90E8 4 \u4E2A\u5BA2\u6237\u7AEF
 
 ${pc.bold("\u53C2\u6570:")}
   -k, --api-key <key>     EasyRouter API Key\uFF08\u53EF\u7701\u7565 sk- \u524D\u7F00\uFF09
-      --only <tool>       claude | codex \uFF08\u53EA\u914D\u5176\u4E00\uFF09
+      --only <list>       \u9017\u53F7\u5206\u9694\u7684\u5BA2\u6237\u7AEF\uFF1A${ALL_CLIENT_IDS.join("|")}|all
       --skip-verify       \u8DF3\u8FC7\u8FDE\u901A\u6027\u9A8C\u8BC1
-  -v, --verbose           \u663E\u793A\u5E95\u5C42\u7EC6\u8282\uFF08\u5305\u62EC BaseURL \u63A2\u6D4B\u8FC7\u7A0B\uFF09
+  -v, --verbose           \u663E\u793A\u5E95\u5C42\u7EC6\u8282\uFF08\u542B BaseURL \u63A2\u6D4B\u3001\u6A21\u578B\u6311\u9009\u7B49\uFF09
   -h, --help              \u663E\u793A\u5E2E\u52A9
   -V, --version           \u663E\u793A\u7248\u672C
 
 ${pc.bold("\u5185\u7F6E BaseURL:")}
-  Claude Code \u2192 ${PRIMARY_HOST}
-  Codex       \u2192 ${PRIMARY_HOST}/v1
+  EasyRouter \u2192 ${PRIMARY_HOST}
+  \u8DEF\u5F84\u4E0E\u8BA4\u8BC1\u7531\u5404\u5BA2\u6237\u7AEF\u81EA\u884C\u5904\u7406\uFF08OpenAI \u517C\u5BB9\u7528 /v1\uFF0CClaude \u76F4\u8FDE\u6839\u57DF\u540D\uFF09
 
 ${pc.bold("\u539F\u7406:")}
-  Claude Code \u914D\u7F6E\u7531 ${pc.underline("zcf")} (https://github.com/UfoMiao/zcf) \u81EA\u52A8\u5199\u5165
-  Codex \u914D\u7F6E\u7531\u672C\u5DE5\u5177\u76F4\u63A5\u5199\u5165\uFF08\u66F4\u53EF\u63A7\u3001\u66F4\u7A33\u5B9A\uFF09
-
-  \u5B9E\u9645\u5199\u5165\u7684\u6587\u4EF6\uFF1A
-    \u2022 Claude Code \u2192 ~/.claude/settings.json
-    \u2022 Codex       \u2192 ~/.codex/config.toml + ~/.codex/auth.json
+  Claude Code & Codex \u2192 \u8C03\u7528 ${pc.underline("zcf")} (UfoMiao/zcf) \u5B50\u8FDB\u7A0B
+  OpenClaw            \u2192 \u8C03\u7528\u672C\u5730 ${pc.underline("openclaw onboard")} \u5B50\u547D\u4EE4\uFF08\u9700\u5148\u88C5 openclaw\uFF09
+  Hermes              \u2192 \u8C03\u7528\u672C\u5730 ${pc.underline("hermes config set")} \u5B50\u547D\u4EE4\uFF08\u9700\u5148\u88C5 hermes\uFF09
 `);
 }
+
+// src/config/host.ts
+import { log } from "@clack/prompts";
+import pc2 from "picocolors";
 async function pickAvailableHost(verbose) {
   const candidates = [PRIMARY_HOST, ...FALLBACK_HOSTS];
   for (const host of candidates) {
     const ok = await probeHost(host);
     if (verbose) {
-      const tag = ok ? pc.green("\u2713") : pc.red("\u2717");
+      const tag = ok ? pc2.green("\u2713") : pc2.red("\u2717");
       log.info(`${tag} \u63A2\u6D4B ${host} \u2192 ${ok ? "\u53EF\u8FBE" : "\u4E0D\u53EF\u8FBE"}`);
     }
     if (ok) return host;
   }
-  if (verbose) log.warn(`\u6240\u6709\u5019\u9009\u57DF\u540D\u5747\u4E0D\u53EF\u8FBE\uFF0C\u4F7F\u7528\u4E3B\u57DF\u540D ${PRIMARY_HOST}`);
+  if (verbose)
+    log.warn(`\u6240\u6709\u5019\u9009\u57DF\u540D\u5747\u4E0D\u53EF\u8FBE\uFF0C\u4F7F\u7528\u4E3B\u57DF\u540D ${PRIMARY_HOST}`);
   return PRIMARY_HOST;
 }
 async function probeHost(host) {
   const url = host.replace(/\/+$/, "") + "/v1/models";
   try {
     const ctrl = new AbortController();
-    const timer = setTimeout(() => ctrl.abort(), PROBE_TIMEOUT_MS);
+    const timer = setTimeout(() => ctrl.abort(), HOST_PROBE_TIMEOUT_MS);
     const res = await fetch(url, { method: "HEAD", signal: ctrl.signal });
     clearTimeout(timer);
     return res.status > 0;
@@ -104,64 +132,75 @@ async function probeHost(host) {
     return false;
   }
 }
-var FETCH_MODELS_TIMEOUT_MS = 8e3;
-async function fetchEasyRouterModels(host, verbose) {
-  const url = host.replace(/\/+$/, "") + "/api/pricing";
+
+// src/config/apiKey.ts
+function normalizeApiKey(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return trimmed;
+  if (trimmed.startsWith("sk-")) return trimmed;
+  return "sk-" + trimmed;
+}
+function maskKey(key) {
+  if (key.length <= 8) return "*".repeat(key.length);
+  return key.slice(0, 6) + "*".repeat(Math.max(4, key.length - 10)) + key.slice(-4);
+}
+
+// src/utils/verify.ts
+async function verifyConnection(baseUrl, apiKey) {
+  const probeUrl = baseUrl.replace(/\/+$/, "") + "/v1/models";
   try {
     const ctrl = new AbortController();
-    const timer = setTimeout(() => ctrl.abort(), FETCH_MODELS_TIMEOUT_MS);
-    const res = await fetch(url, { signal: ctrl.signal });
+    const timer = setTimeout(() => ctrl.abort(), VERIFY_TIMEOUT_MS);
+    const res = await fetch(probeUrl, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "anthropic-version": "2023-06-01"
+      },
+      signal: ctrl.signal
+    });
     clearTimeout(timer);
-    if (!res.ok) {
-      if (verbose) log.warn(`\u62C9\u53D6\u6A21\u578B\u5217\u8868\u5931\u8D25\uFF1AHTTP ${res.status}\uFF08\u5C06\u4F7F\u7528\u515C\u5E95\u6A21\u578B\uFF09`);
-      return [];
-    }
-    const json = await res.json();
-    const models = Array.isArray(json?.data) ? json.data : [];
-    if (verbose) log.info(`\u2713 \u62C9\u53D6\u5230 ${models.length} \u4E2A EasyRouter \u6A21\u578B`);
-    return models;
+    return { ok: res.ok, status: res.status };
   } catch (err) {
-    if (verbose) log.warn(`\u62C9\u53D6\u6A21\u578B\u5217\u8868\u5F02\u5E38\uFF1A${err?.message || err}\uFF08\u5C06\u4F7F\u7528\u515C\u5E95\u6A21\u578B\uFF09`);
-    return [];
+    return { ok: false, error: err?.message || String(err) };
   }
 }
-function pickBestCodexModel(models) {
-  const isLlm = (m) => (m.tags || "").toUpperCase().includes("LLM");
-  const supportsOpenAI = (m) => !m.supported_endpoint_types || m.supported_endpoint_types.includes("openai");
-  const isGpt5 = (m) => /^gpt-5(\b|[.\-])/i.test(m.model_name);
-  const isSmallTier = (m) => /(^|[\-_.])(mini|nano|small|lite|tiny)([\-_.]|$)/i.test(m.model_name);
-  const byNameDesc = (a, b) => b.model_name.localeCompare(a.model_name, "en");
-  const gpt5Big = models.filter((m) => isGpt5(m) && isLlm(m) && supportsOpenAI(m) && !isSmallTier(m)).sort(byNameDesc);
-  if (gpt5Big.length) return gpt5Big[0].model_name;
-  const gpt5Any = models.filter((m) => isGpt5(m) && isLlm(m) && supportsOpenAI(m)).sort(byNameDesc);
-  if (gpt5Any.length) return gpt5Any[0].model_name;
-  const anyBig = models.filter((m) => isLlm(m) && supportsOpenAI(m) && !isSmallTier(m)).sort(byNameDesc);
-  if (anyBig.length) return anyBig[0].model_name;
-  return null;
-}
-async function resolveCodexModel(host, interactive, verbose) {
-  const models = await fetchEasyRouterModels(host, verbose);
-  const auto = pickBestCodexModel(models);
-  if (auto) {
-    if (verbose) log.info(`\u81EA\u52A8\u9009\u62E9 Codex \u6A21\u578B\uFF1A${pc.cyan(auto)}`);
-    return auto;
-  }
-  if (interactive && models.length) {
-    const candidates = models.filter((m) => /^gpt-5|codex/i.test(m.model_name)).sort((a, b) => b.model_name.localeCompare(a.model_name, "en")).slice(0, 8);
-    if (candidates.length) {
-      const picked = await select({
-        message: "\u672A\u81EA\u52A8\u8BC6\u522B Codex \u63A8\u8350\u6A21\u578B\uFF0C\u8BF7\u624B\u52A8\u9009\u62E9",
-        options: candidates.map((m) => ({ value: m.model_name, label: m.model_name }))
-      });
-      if (!isCancel(picked)) return picked;
+
+// src/clients/detect.ts
+import { execa } from "execa";
+async function detectCommand(opts) {
+  const args = opts.args ?? ["--version"];
+  const timeout = opts.timeoutMs ?? 5e3;
+  try {
+    const result = await execa(opts.command, args, {
+      reject: false,
+      timeout,
+      windowsHide: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (result?.errno === "ENOENT" || result?.code === "ENOENT") {
+      return { installed: false };
     }
+    if (result?.failed && /\bENOENT\b|not found|command not found/i.test(
+      String(result?.shortMessage || result?.stderr || "")
+    )) {
+      return { installed: false };
+    }
+    const out = ((result?.stdout || "") + "\n" + (result?.stderr || "")).split(/\r?\n/)[0]?.trim();
+    const v = out?.match(/v?(\d+\.\d+(?:\.\d+)?(?:[\-+][\w.]+)?)/)?.[1];
+    return { installed: true, version: v };
+  } catch (err) {
+    if (err?.code === "ENOENT" || /ENOENT/.test(String(err?.message))) {
+      return { installed: false };
+    }
+    return { installed: false };
   }
-  if (verbose) log.warn(`\u65E0\u6CD5\u81EA\u52A8\u9009\u62E9 Codex \u6A21\u578B\uFF0C\u4F7F\u7528\u515C\u5E95\uFF1A${CODEX_FALLBACK_MODEL}`);
-  return CODEX_FALLBACK_MODEL;
 }
-var IDLE_TIMEOUT_MS = 6e4;
-var HARD_TIMEOUT_MS = 3e5;
-async function configureViaZcf(opts) {
+
+// src/clients/zcf-runner.ts
+import { execa as execa2 } from "execa";
+import pc3 from "picocolors";
+async function runZcf(opts) {
   const args = [
     "-y",
     "zcf",
@@ -170,7 +209,7 @@ async function configureViaZcf(opts) {
     // --skip-prompt 非交互模式
     "-T",
     opts.target,
-    // 'cc' | 'codex'（用文档推荐的简写 -T）
+    // 'cc' | 'codex'
     // EasyRouter 是 OpenAI 兼容网关，统一用 api_key（Bearer Authorization）
     "--api-type",
     "api_key",
@@ -180,10 +219,8 @@ async function configureViaZcf(opts) {
     opts.baseUrl,
     "-r",
     "backup",
-    // 已有配置自动备份
     "--mcp-services",
     "skip",
-    // 不装 MCP（即便 zcf 偶尔忽略也无伤）
     "--workflows",
     "skip",
     "--output-styles",
@@ -201,8 +238,7 @@ async function configureViaZcf(opts) {
   let lastDataAt = Date.now();
   let killedReason = null;
   let lastProgressAt = 0;
-  const PROGRESS_THROTTLE_MS = 200;
-  const child = execa(cmd, args, {
+  const child = execa2(cmd, args, {
     stdio: ["ignore", "pipe", "pipe"],
     env: {
       ...process.env,
@@ -234,8 +270,10 @@ async function configureViaZcf(opts) {
   child.stdout?.on("data", (c) => handleChunk(c, "out"));
   child.stderr?.on("data", (c) => handleChunk(c, "err"));
   const idleTimer = setInterval(() => {
-    if (Date.now() - lastDataAt > IDLE_TIMEOUT_MS) {
-      killedReason = `\u5B50\u8FDB\u7A0B\u5DF2 ${Math.floor(IDLE_TIMEOUT_MS / 1e3)} \u79D2\u65E0\u8F93\u51FA\uFF08\u7591\u4F3C\u5361\u5728\u4EA4\u4E92\u5F0F\u63D0\u95EE\u6216\u7F51\u7EDC\u95EE\u9898\uFF09`;
+    if (Date.now() - lastDataAt > SUBPROCESS_IDLE_TIMEOUT_MS) {
+      killedReason = `\u5B50\u8FDB\u7A0B\u5DF2 ${Math.floor(
+        SUBPROCESS_IDLE_TIMEOUT_MS / 1e3
+      )} \u79D2\u65E0\u8F93\u51FA\uFF08\u7591\u4F3C\u5361\u5728\u4EA4\u4E92\u5F0F\u63D0\u95EE\u6216\u7F51\u7EDC\u95EE\u9898\uFF09`;
       child.kill("SIGTERM");
       setTimeout(() => {
         try {
@@ -246,7 +284,9 @@ async function configureViaZcf(opts) {
     }
   }, 5e3);
   const hardTimer = setTimeout(() => {
-    killedReason = `\u5B50\u8FDB\u7A0B\u8D85\u8FC7 ${Math.floor(HARD_TIMEOUT_MS / 1e3)} \u79D2\u672A\u7ED3\u675F\uFF08\u5F3A\u5236\u8D85\u65F6\uFF09`;
+    killedReason = `\u5B50\u8FDB\u7A0B\u8D85\u8FC7 ${Math.floor(
+      SUBPROCESS_HARD_TIMEOUT_MS / 1e3
+    )} \u79D2\u672A\u7ED3\u675F\uFF08\u5F3A\u5236\u8D85\u65F6\uFF09`;
     child.kill("SIGTERM");
     setTimeout(() => {
       try {
@@ -254,7 +294,7 @@ async function configureViaZcf(opts) {
       } catch {
       }
     }, 5e3);
-  }, HARD_TIMEOUT_MS);
+  }, SUBPROCESS_HARD_TIMEOUT_MS);
   const result = await child.catch((e) => e);
   clearInterval(idleTimer);
   clearTimeout(hardTimer);
@@ -269,7 +309,7 @@ async function configureViaZcf(opts) {
   \u2022 npm \u955C\u50CF/\u7F51\u7EDC\u6162\uFF0Cnpx \u4E0B\u8F7D zcf \u5305\u5361\u4F4F
   \u2022 \u9632\u706B\u5899\u62E6\u622A\u4E86 registry.npmjs.org
 
-\u5EFA\u8BAE\uFF1A\u7528 ${pc.green("--verbose")} \u91CD\u65B0\u8FD0\u884C\u67E5\u770B\u8BE6\u7EC6\u65E5\u5FD7`
+\u5EFA\u8BAE\uFF1A\u7528 ${pc3.green("--verbose")} \u91CD\u65B0\u8FD0\u884C\u67E5\u770B\u8BE6\u7EC6\u65E5\u5FD7`
     );
   }
   if (exitCode !== 0 || signal) {
@@ -278,7 +318,7 @@ async function configureViaZcf(opts) {
       `zcf \u5F02\u5E38\u9000\u51FA\uFF08exit=${exitCode}\uFF09:
 ${detail}
 
-\u{1F4A1} \u7528 ${pc.green("--verbose")} \u91CD\u65B0\u8FD0\u884C\u53EF\u770B\u5230\u5B8C\u6574\u65E5\u5FD7`
+\u{1F4A1} \u7528 ${pc3.green("--verbose")} \u91CD\u65B0\u8FD0\u884C\u53EF\u770B\u5230\u5B8C\u6574\u65E5\u5FD7`
     );
   }
   const combined = capturedOut + "\n" + capturedErr;
@@ -292,35 +332,544 @@ ${detail}
     );
   }
 }
-async function verifyConnection(baseUrl, apiKey) {
-  const probeUrl = baseUrl.replace(/\/+$/, "") + "/v1/models";
+
+// src/clients/claude.ts
+var claudeClient = {
+  id: "claude",
+  label: "Claude Code",
+  hint: "~/.claude/settings.json",
+  launchCommand: "claude",
+  async detect() {
+    const r = await detectCommand({ command: "claude" });
+    return {
+      installed: r.installed,
+      version: r.version,
+      installHint: "\u524D\u5F80 https://claude.com/claude-code \u5B89\u88C5\uFF0C\u6216\u8FD0\u884C\uFF1A\n  npm install -g @anthropic-ai/claude-code"
+    };
+  },
+  async configure(ctx) {
+    await runZcf({
+      target: "cc",
+      baseUrl: ctx.host,
+      apiKey: ctx.apiKey,
+      verbose: ctx.verbose,
+      onProgress: ctx.onProgress
+    });
+    return { configPaths: ["~/.claude/settings.json"] };
+  }
+};
+
+// src/config/models.ts
+import { log as log2, select, isCancel } from "@clack/prompts";
+import pc4 from "picocolors";
+function toOpenClawCost(m) {
+  const ratio = m.model_ratio ?? 0;
+  const compRatio = m.completion_ratio ?? 1;
+  const cacheRatio = m.cache_ratio ?? 0;
+  const input = round6(ratio * 2e-3);
+  const output = round6(ratio * compRatio * 2e-3);
+  const cacheRead = round6(ratio * cacheRatio * 2e-3);
+  const cacheWrite = round6(input * 1.25);
+  const tiered = m.tiered_pricing;
+  const contextWindow = tiered?.input?.threshold ?? tiered?.output?.threshold ?? tiered?.cache_read?.threshold ?? 131072;
+  const maxTokens = Math.min(32768, Math.max(4096, Math.floor(contextWindow / 4)));
+  return {
+    cost: { input, output, cacheRead, cacheWrite },
+    contextWindow,
+    maxTokens
+  };
+}
+function round6(n) {
+  return Math.round(n * 1e6) / 1e6;
+}
+async function fetchEasyRouterModels(host, verbose) {
+  const url = host.replace(/\/+$/, "") + "/api/pricing";
   try {
     const ctrl = new AbortController();
-    const timer = setTimeout(() => ctrl.abort(), 1e4);
-    const res = await fetch(probeUrl, {
-      method: "GET",
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-        "anthropic-version": "2023-06-01"
-      },
-      signal: ctrl.signal
-    });
+    const timer = setTimeout(() => ctrl.abort(), FETCH_MODELS_TIMEOUT_MS);
+    const res = await fetch(url, { signal: ctrl.signal });
     clearTimeout(timer);
-    return { ok: res.ok, status: res.status };
+    if (!res.ok) {
+      if (verbose)
+        log2.warn(`\u62C9\u53D6\u6A21\u578B\u5217\u8868\u5931\u8D25\uFF1AHTTP ${res.status}\uFF08\u5C06\u4F7F\u7528\u515C\u5E95\u6A21\u578B\uFF09`);
+      return [];
+    }
+    const json = await res.json();
+    const models = Array.isArray(json?.data) ? json.data : [];
+    if (verbose) log2.info(`\u2713 \u62C9\u53D6\u5230 ${models.length} \u4E2A EasyRouter \u6A21\u578B`);
+    return models;
   } catch (err) {
-    return { ok: false, error: err?.message || String(err) };
+    if (verbose)
+      log2.warn(`\u62C9\u53D6\u6A21\u578B\u5217\u8868\u5F02\u5E38\uFF1A${err?.message || err}\uFF08\u5C06\u4F7F\u7528\u515C\u5E95\u6A21\u578B\uFF09`);
+    return [];
   }
 }
-function normalizeApiKey(raw) {
-  const trimmed = raw.trim();
-  if (!trimmed) return trimmed;
-  if (trimmed.startsWith("sk-")) return trimmed;
-  return "sk-" + trimmed;
+function filterOpenAICompatibleLLMs(models) {
+  return models.filter((m) => {
+    const isLlm = (m.tags || "").toUpperCase().includes("LLM");
+    const supportsOpenAI = !m.supported_endpoint_types || m.supported_endpoint_types.length === 0 || m.supported_endpoint_types.includes("openai");
+    return isLlm && supportsOpenAI;
+  });
 }
-function maskKey(key) {
-  if (key.length <= 8) return "*".repeat(key.length);
-  return key.slice(0, 6) + "*".repeat(Math.max(4, key.length - 10)) + key.slice(-4);
+function pickBestCodexModel(models) {
+  const isLlm = (m) => (m.tags || "").toUpperCase().includes("LLM");
+  const supportsOpenAI = (m) => !m.supported_endpoint_types || m.supported_endpoint_types.includes("openai");
+  const isGpt5 = (m) => /^gpt-5(\b|[.\-])/i.test(m.model_name);
+  const isSmallTier = (m) => /(^|[\-_.])(mini|nano|small|lite|tiny)([\-_.]|$)/i.test(m.model_name);
+  const extractVersion = (name) => {
+    const m = name.match(/^gpt-(\d+(?:\.\d+)*)/i);
+    return m ? m[1] : "0";
+  };
+  const compareVersion = (a, b) => {
+    const pa = a.split(".").map(Number);
+    const pb = b.split(".").map(Number);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+      const x = pa[i] || 0;
+      const y = pb[i] || 0;
+      if (x !== y) return x - y;
+    }
+    return 0;
+  };
+  const pickFromPool = (pool) => {
+    if (!pool.length) return null;
+    const byVersion = /* @__PURE__ */ new Map();
+    for (const m of pool) {
+      const v = extractVersion(m.model_name);
+      if (!byVersion.has(v)) byVersion.set(v, []);
+      byVersion.get(v).push(m);
+    }
+    const maxVersion = Array.from(byVersion.keys()).sort(compareVersion).pop();
+    const sameVersion = byVersion.get(maxVersion);
+    const withCodex = sameVersion.filter((m) => /codex/i.test(m.model_name));
+    if (withCodex.length) {
+      return withCodex.sort(
+        (a, b) => a.model_name.localeCompare(b.model_name)
+      )[0].model_name;
+    }
+    return sameVersion.sort(
+      (a, b) => a.model_name.localeCompare(b.model_name)
+    )[0].model_name;
+  };
+  const tier1 = pickFromPool(
+    models.filter(
+      (m) => isGpt5(m) && isLlm(m) && supportsOpenAI(m) && !isSmallTier(m)
+    )
+  );
+  if (tier1) return tier1;
+  const tier2 = pickFromPool(
+    models.filter((m) => isGpt5(m) && isLlm(m) && supportsOpenAI(m))
+  );
+  if (tier2) return tier2;
+  const tier3 = pickFromPool(
+    models.filter((m) => isLlm(m) && supportsOpenAI(m) && !isSmallTier(m))
+  );
+  if (tier3) return tier3;
+  return null;
 }
+async function resolveCodexModel(host, interactive, verbose) {
+  const models = await fetchEasyRouterModels(host, verbose);
+  const auto = pickBestCodexModel(models);
+  if (auto) {
+    if (verbose) log2.info(`\u81EA\u52A8\u9009\u62E9 Codex \u6A21\u578B\uFF1A${pc4.cyan(auto)}`);
+    return auto;
+  }
+  if (interactive && models.length) {
+    const candidates = models.filter((m) => /^gpt-5|codex/i.test(m.model_name)).sort((a, b) => b.model_name.localeCompare(a.model_name, "en")).slice(0, 8);
+    if (candidates.length) {
+      const picked = await select({
+        message: "\u672A\u81EA\u52A8\u8BC6\u522B Codex \u63A8\u8350\u6A21\u578B\uFF0C\u8BF7\u624B\u52A8\u9009\u62E9",
+        options: candidates.map((m) => ({
+          value: m.model_name,
+          label: m.model_name
+        }))
+      });
+      if (!isCancel(picked)) return picked;
+    }
+  }
+  if (verbose)
+    log2.warn(`\u65E0\u6CD5\u81EA\u52A8\u9009\u62E9 Codex \u6A21\u578B\uFF0C\u4F7F\u7528\u515C\u5E95\uFF1A${CODEX_FALLBACK_MODEL}`);
+  return CODEX_FALLBACK_MODEL;
+}
+
+// src/clients/codex.ts
+var codexClient = {
+  id: "codex",
+  label: "Codex",
+  hint: "~/.codex/config.toml + auth.json",
+  launchCommand: "codex",
+  async detect() {
+    const r = await detectCommand({ command: "codex" });
+    return {
+      installed: r.installed,
+      version: r.version,
+      installHint: "\u524D\u5F80 https://github.com/openai/codex \u5B89\u88C5\uFF0C\u6216\u8FD0\u884C\uFF1A\n  npm install -g @openai/codex\n  # \u6216 macOS: brew install --cask codex"
+    };
+  },
+  async configure(ctx) {
+    const interactive = typeof process !== "undefined" && !!process.stdout.isTTY;
+    const model = await resolveCodexModel(ctx.host, interactive, ctx.verbose);
+    const codexBaseUrl = ctx.host.replace(/\/+$/, "") + "/v1";
+    await runZcf({
+      target: "codex",
+      baseUrl: codexBaseUrl,
+      apiKey: ctx.apiKey,
+      apiModel: model,
+      verbose: ctx.verbose,
+      onProgress: ctx.onProgress
+    });
+    return {
+      configPaths: ["~/.codex/config.toml", "~/.codex/auth.json"],
+      model
+    };
+  }
+};
+
+// src/clients/openclaw.ts
+import { execa as execa3 } from "execa";
+import { promises as fs } from "fs";
+import { homedir } from "os";
+import { join, dirname } from "path";
+import pc5 from "picocolors";
+var OPENCLAW_PROVIDER_ID = "custom-easyrouter-io";
+var openClawClient = {
+  id: "openclaw",
+  label: "OpenClaw",
+  hint: "~/.openclaw/openclaw.json",
+  launchCommand: "openclaw",
+  async detect() {
+    const r = await detectCommand({ command: "openclaw" });
+    return {
+      installed: r.installed,
+      version: r.version,
+      installHint: "\u524D\u5F80 https://openclaw.ai \u5B89\u88C5\uFF0C\u6216\u8FD0\u884C\uFF1A\n  curl -fsSL https://openclaw.ai/install.sh | bash\n  # \u6216 npm install -g openclaw\n  # \u6216 macOS: brew install openclaw-cli"
+    };
+  },
+  async configure(ctx) {
+    const interactive = typeof process !== "undefined" && !!process.stdout.isTTY;
+    const allModels = await fetchEasyRouterModels(ctx.host, ctx.verbose);
+    const llms = filterOpenAICompatibleLLMs(allModels);
+    const defaultModel = await resolveCodexModel(
+      ctx.host,
+      interactive,
+      ctx.verbose
+    );
+    const baseUrl = ctx.host.replace(/\/+$/, "") + "/v1";
+    const args = [
+      "onboard",
+      "--non-interactive",
+      "--auth-choice",
+      "custom-api-key",
+      "--custom-base-url",
+      baseUrl,
+      "--custom-model-id",
+      defaultModel,
+      "--custom-api-key",
+      ctx.apiKey,
+      "--custom-compatibility",
+      "openai",
+      "--secret-input-mode",
+      "plaintext",
+      "--accept-risk",
+      // 自定义 provider 必填
+      "--skip-health"
+      // 不要求 gateway daemon 启动
+    ];
+    await runOpenClawSubprocess(args, ctx);
+    let registered = 0;
+    if (llms.length > 1) {
+      registered = await patchOpenClawJson(llms, defaultModel, ctx);
+    }
+    return {
+      configPaths: ["~/.openclaw/openclaw.json"],
+      model: registered > 1 ? `${defaultModel} (+${registered - 1} more)` : defaultModel
+    };
+  }
+};
+async function patchOpenClawJson(llms, defaultModel, ctx) {
+  const configPath = join(homedir(), ".openclaw", "openclaw.json");
+  let json;
+  try {
+    const raw = await fs.readFile(configPath, "utf8");
+    json = JSON.parse(raw);
+  } catch (err) {
+    if (ctx.verbose) {
+      console.warn(
+        `[openclaw] \u8DF3\u8FC7 patch\uFF1A\u8BFB ${configPath} \u5931\u8D25\uFF08${err?.code || err?.message}\uFF09`
+      );
+    }
+    return 1;
+  }
+  const providers = json?.models?.providers;
+  if (!providers || typeof providers !== "object") {
+    if (ctx.verbose) {
+      console.warn(`[openclaw] \u8DF3\u8FC7 patch\uFF1Amodels.providers \u6BB5\u4E0D\u5B58\u5728`);
+    }
+    return 1;
+  }
+  const provider = providers[OPENCLAW_PROVIDER_ID];
+  if (!provider || !Array.isArray(provider.models)) {
+    if (ctx.verbose) {
+      console.warn(
+        `[openclaw] \u8DF3\u8FC7 patch\uFF1Amodels.providers.${OPENCLAW_PROVIDER_ID}.models \u4E0D\u662F\u6570\u7EC4`
+      );
+    }
+    return 1;
+  }
+  const existingById = /* @__PURE__ */ new Map();
+  provider.models.forEach((m, i) => {
+    existingById.set(m.id, i);
+  });
+  const before = provider.models.length;
+  let updated = 0;
+  const agentsModels = json?.agents?.defaults?.models ?? null;
+  for (const m of llms) {
+    const { cost, contextWindow, maxTokens } = toOpenClawCost(m);
+    const idx = existingById.get(m.model_name);
+    if (idx !== void 0) {
+      const existing = provider.models[idx];
+      if (existing.cost?.input === 0 && existing.cost?.output === 0) {
+        existing.cost = cost;
+        existing.contextWindow = contextWindow;
+        existing.maxTokens = maxTokens;
+        updated++;
+      }
+    } else {
+      provider.models.push({
+        id: m.model_name,
+        name: m.model_name + " (EasyRouter)",
+        contextWindow,
+        maxTokens,
+        input: ["text"],
+        cost,
+        reasoning: false
+      });
+    }
+    if (agentsModels !== null) {
+      const agentKey = `${OPENCLAW_PROVIDER_ID}/${m.model_name}`;
+      const existing = agentsModels[agentKey];
+      if (!existing || Object.keys(existing).length === 0) {
+        agentsModels[agentKey] = { alias: agentKey };
+      }
+    }
+  }
+  const added = provider.models.length - before;
+  if (added === 0 && updated === 0) {
+    if (ctx.verbose) {
+      console.warn(
+        `[openclaw] \u6240\u6709 ${llms.length} \u4E2A\u6A21\u578B\u5747\u5DF2\u662F\u6700\u65B0\uFF0C\u8DF3\u8FC7\u5199\u5165`
+      );
+    }
+    return provider.models.length;
+  }
+  await fs.copyFile(configPath, configPath + ".bak." + Date.now());
+  await atomicWriteJson(configPath, json);
+  if (ctx.verbose) {
+    const parts = [];
+    if (added > 0) parts.push(`\u65B0\u589E ${added} \u4E2A`);
+    if (updated > 0) parts.push(`\u4FEE\u6B63 cost/ctx ${updated} \u4E2A`);
+    console.warn(
+      `[openclaw] \u2713 ${parts.join("\uFF0C")}\uFF0C\u5171 ${provider.models.length} \u4E2A\uFF08\u9ED8\u8BA4\uFF1A${defaultModel}\uFF09`
+    );
+  }
+  return provider.models.length;
+}
+async function atomicWriteJson(path, obj) {
+  const tmp = path + ".tmp." + process.pid;
+  await fs.mkdir(dirname(path), { recursive: true });
+  await fs.writeFile(tmp, JSON.stringify(obj, null, 2) + "\n", "utf8");
+  await fs.rename(tmp, path);
+}
+async function runOpenClawSubprocess(args, ctx) {
+  let capturedOut = "";
+  let capturedErr = "";
+  let lastDataAt = Date.now();
+  let killedReason = null;
+  let lastProgressAt = 0;
+  const child = execa3("openclaw", args, {
+    stdio: ["ignore", "pipe", "pipe"],
+    env: { ...process.env, FORCE_COLOR: "0" },
+    reject: false,
+    windowsHide: true
+  });
+  const handleChunk = (chunk, target) => {
+    const text2 = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    if (target === "out") capturedOut += text2;
+    else capturedErr += text2;
+    lastDataAt = Date.now();
+    if (ctx.onProgress) {
+      const now = Date.now();
+      if (now - lastProgressAt >= PROGRESS_THROTTLE_MS) {
+        lastProgressAt = now;
+        const lines = text2.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+        const last = lines[lines.length - 1];
+        if (last) ctx.onProgress(last.slice(0, 60));
+      }
+    }
+    if (ctx.verbose) process.stderr.write(text2);
+  };
+  child.stdout?.on("data", (c) => handleChunk(c, "out"));
+  child.stderr?.on("data", (c) => handleChunk(c, "err"));
+  const idleTimer = setInterval(() => {
+    if (Date.now() - lastDataAt > SUBPROCESS_IDLE_TIMEOUT_MS) {
+      killedReason = `openclaw \u5DF2 ${Math.floor(
+        SUBPROCESS_IDLE_TIMEOUT_MS / 1e3
+      )} \u79D2\u65E0\u8F93\u51FA\uFF08\u7591\u4F3C\u5361\u4F4F\uFF09`;
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+      }, 5e3);
+    }
+  }, 5e3);
+  const hardTimer = setTimeout(() => {
+    killedReason = `openclaw \u8D85\u8FC7 ${Math.floor(
+      SUBPROCESS_HARD_TIMEOUT_MS / 1e3
+    )} \u79D2\u672A\u7ED3\u675F\uFF08\u5F3A\u5236\u8D85\u65F6\uFF09`;
+    child.kill("SIGTERM");
+    setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+    }, 5e3);
+  }, SUBPROCESS_HARD_TIMEOUT_MS);
+  const result = await child.catch((e) => e);
+  clearInterval(idleTimer);
+  clearTimeout(hardTimer);
+  const exitCode = result?.exitCode ?? null;
+  if (killedReason) {
+    throw new Error(
+      `openclaw \u8C03\u7528\u5931\u8D25\uFF1A${killedReason}
+
+\u5EFA\u8BAE\uFF1A\u7528 ${pc5.green("--verbose")} \u91CD\u65B0\u8FD0\u884C\u67E5\u770B\u8BE6\u7EC6\u65E5\u5FD7`
+    );
+  }
+  if (exitCode !== 0) {
+    const detail = (capturedErr || capturedOut || "").slice(-2e3) || `exit ${exitCode}`;
+    throw new Error(
+      `openclaw \u5F02\u5E38\u9000\u51FA\uFF08exit=${exitCode}\uFF09:
+${detail}
+
+\u{1F4A1} \u7528 ${pc5.green("--verbose")} \u91CD\u65B0\u8FD0\u884C\u53EF\u770B\u5230\u5B8C\u6574\u65E5\u5FD7`
+    );
+  }
+}
+
+// src/clients/hermes.ts
+import { execa as execa4 } from "execa";
+import { promises as fs2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var HERMES_PROVIDER_NAME = "easyrouter";
+var HERMES_KEY_ENV = "EASYROUTER_API_KEY";
+var hermesClient = {
+  id: "hermes",
+  label: "Hermes",
+  hint: "~/.hermes/config.yaml + .env",
+  launchCommand: "hermes",
+  async detect() {
+    const r = await detectCommand({ command: "hermes" });
+    return {
+      installed: r.installed,
+      version: r.version,
+      installHint: "\u524D\u5F80 https://hermes.nousresearch.com \u5B89\u88C5\uFF0C\u6216\u8FD0\u884C\uFF1A\n  curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash"
+    };
+  },
+  async configure(ctx) {
+    const interactive = typeof process !== "undefined" && !!process.stdout.isTTY;
+    const defaultModel = await resolveCodexModel(
+      ctx.host,
+      interactive,
+      ctx.verbose
+    );
+    const baseUrl = ctx.host.replace(/\/+$/, "") + "/v1";
+    await runHermesConfigSet(
+      `providers.${HERMES_PROVIDER_NAME}.base_url`,
+      baseUrl,
+      ctx
+    );
+    if (ctx.onProgress) ctx.onProgress(`provider \u6CE8\u518C`);
+    await runHermesConfigSet(
+      `providers.${HERMES_PROVIDER_NAME}.key_env`,
+      HERMES_KEY_ENV,
+      ctx
+    );
+    await runHermesConfigSet(
+      `providers.${HERMES_PROVIDER_NAME}.kind`,
+      "openai",
+      ctx
+    );
+    const fullDefaultId = `${HERMES_PROVIDER_NAME}/${defaultModel}`;
+    await runHermesConfigSet("model.default", fullDefaultId, ctx);
+    await runHermesConfigSet("model.provider", HERMES_PROVIDER_NAME, ctx);
+    await runHermesConfigSet("model.base_url", baseUrl, ctx);
+    if (ctx.onProgress) ctx.onProgress(`\u9ED8\u8BA4 model = ${defaultModel}`);
+    const envPath = join2(homedir2(), ".hermes", ".env");
+    await fs2.mkdir(join2(homedir2(), ".hermes"), { recursive: true });
+    let envContent = "";
+    try {
+      envContent = await fs2.readFile(envPath, "utf8");
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+    envContent = upsertEnvVar(envContent, HERMES_KEY_ENV, ctx.apiKey);
+    await fs2.writeFile(envPath, envContent, { encoding: "utf8", mode: 384 });
+    if (ctx.onProgress) ctx.onProgress("\u5199\u5165 ~/.hermes/.env");
+    return {
+      configPaths: ["~/.hermes/config.yaml", "~/.hermes/.env"],
+      model: defaultModel
+    };
+  }
+};
+async function runHermesConfigSet(key, value, ctx) {
+  const result = await execa4("hermes", ["config", "set", key, value], {
+    reject: false,
+    timeout: 3e4,
+    windowsHide: true,
+    env: { ...process.env, FORCE_COLOR: "0" },
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  if (ctx.verbose && (result.stdout || result.stderr)) {
+    process.stderr.write(
+      `[hermes config set ${key}]
+${result.stdout}
+${result.stderr}
+`
+    );
+  }
+  if (result.exitCode !== 0) {
+    const detail = (result.stderr || result.stdout || "").slice(-1e3);
+    throw new Error(
+      `hermes config set ${key} \u5931\u8D25\uFF08exit=${result.exitCode}\uFF09:
+${detail}`
+    );
+  }
+}
+function upsertEnvVar(content, key, value) {
+  const escaped = value.replace(/(["\\])/g, "\\$1");
+  const line = `${key}="${escaped}"`;
+  const re = new RegExp(`^${key}=.*$`, "m");
+  if (re.test(content)) {
+    return content.replace(re, line);
+  }
+  const trailing = content.length === 0 || content.endsWith("\n") ? "" : "\n";
+  return content + trailing + line + "\n";
+}
+
+// src/clients/registry.ts
+var CLIENT_REGISTRY = {
+  claude: claudeClient,
+  codex: codexClient,
+  openclaw: openClawClient,
+  hermes: hermesClient
+};
+function listClients() {
+  return Object.values(CLIENT_REGISTRY);
+}
+
+// src/index.ts
 async function main() {
   const args = parseCliArgs();
   if (args.help) {
@@ -332,15 +881,16 @@ async function main() {
     return;
   }
   console.log();
-  intro(pc.bgCyan(pc.black(" EasyRouter Config ")) + pc.dim(" v" + VERSION));
+  intro(
+    pc6.bgCyan(pc6.black(" EasyRouter Config ")) + pc6.dim(" v" + VERSION)
+  );
   const verbose = !!args.verbose;
-  const selectedHost = await pickAvailableHost(verbose);
-  const claudeBaseUrl = selectedHost;
-  const codexBaseUrl = selectedHost.replace(/\/+$/, "") + "/v1";
+  const interactive = !args.apiKey;
+  const host = await pickAvailableHost(verbose);
   let apiKey;
   if (args.apiKey) {
     apiKey = normalizeApiKey(args.apiKey);
-    log.info(`API Key: ${pc.dim(maskKey(apiKey))}\uFF08\u6765\u81EA\u547D\u4EE4\u884C\u53C2\u6570\uFF09`);
+    log3.info(`API Key: ${pc6.dim(maskKey(apiKey))}\uFF08\u6765\u81EA\u547D\u4EE4\u884C\u53C2\u6570\uFF09`);
   } else {
     const input = await text({
       message: "\u8BF7\u8F93\u5165\u4F60\u7684 EasyRouter API Key",
@@ -351,134 +901,148 @@ async function main() {
         return void 0;
       }
     });
-    if (isCancel(input)) {
+    if (isCancel2(input)) {
       cancel("\u5DF2\u53D6\u6D88");
       process.exit(0);
     }
     apiKey = normalizeApiKey(input);
   }
-  let configClaude = true;
-  let configCodex = true;
-  if (args.only === "claude") {
-    configCodex = false;
-  } else if (args.only === "codex") {
-    configClaude = false;
-  } else if (!args.apiKey) {
-    const target = await select({
-      message: "\u8BF7\u9009\u62E9\u8981\u914D\u7F6E\u7684\u5BA2\u6237\u7AEF",
-      options: [
-        { value: "both", label: "Claude Code + Codex", hint: "\u4E24\u4E2A\u90FD\u914D\uFF08\u63A8\u8350\uFF09" },
-        { value: "claude", label: "\u4EC5 Claude Code", hint: "\u53EA\u914D ~/.claude/settings.json" },
-        { value: "codex", label: "\u4EC5 Codex", hint: "\u53EA\u914D ~/.codex/config.toml" }
-      ],
-      initialValue: "both"
-    });
-    if (isCancel(target)) {
-      cancel("\u5DF2\u53D6\u6D88");
-      process.exit(0);
-    }
-    if (target === "claude") configCodex = false;
-    else if (target === "codex") configClaude = false;
-  }
-  note(
-    [
-      `${pc.bold("\u8BA1\u8D39\u6A21\u5F0F")}    \u6309\u91CF\u4ED8\u8D39`,
-      configClaude ? `${pc.bold("Claude URL")}  ${PRIMARY_HOST}` : null,
-      configCodex ? `${pc.bold("Codex URL")}   ${PRIMARY_HOST}/v1` : null,
-      `${pc.bold("API Key")}     ${maskKey(apiKey)}`,
-      `${pc.bold("\u5C06\u914D\u7F6E")}      ${[
-        configClaude && "Claude Code",
-        configCodex && "Codex"
-      ].filter(Boolean).join(" + ")}`
-    ].filter(Boolean).join("\n"),
-    "\u914D\u7F6E\u9884\u89C8"
-  );
-  if (!args.apiKey) {
+  const selected = await pickClients(args.only, interactive);
+  if (selected.length === 0) {
+    cancel("\u672A\u9009\u62E9\u4EFB\u4F55\u5BA2\u6237\u7AEF");
+    process.exit(0);
+  }
+  const detection = await detectAll(selected, verbose);
+  const missing = detection.filter((d) => !d.availability.installed);
+  if (missing.length > 0) {
+    printMissingHints(missing);
+    process.exit(1);
+  }
+  printSummary({ apiKey, selected });
+  if (interactive) {
     const ok = await confirm({ message: "\u7EE7\u7EED\uFF1F", initialValue: true });
-    if (isCancel(ok) || !ok) {
+    if (isCancel2(ok) || !ok) {
       cancel("\u5DF2\u53D6\u6D88");
       process.exit(0);
     }
   }
-  if (configClaude) {
-    const useSpinner = !verbose && process.stdout.isTTY;
-    const s = useSpinner ? spinner() : null;
-    s?.start("\u914D\u7F6E Claude Code");
-    if (!s) log.info("\u6B63\u5728\u914D\u7F6E Claude Code\uFF08\u9996\u6B21\u8FD0\u884C\u9700\u4E0B\u8F7D zcf\uFF0C\u7EA6 30~60 \u79D2\uFF09...");
-    try {
-      await configureViaZcf({
-        target: "cc",
-        baseUrl: claudeBaseUrl,
-        apiKey,
-        verbose,
-        // 节流的进度回调：spinner 不会高频闪烁
-        onProgress: (line) => s?.message(`\u914D\u7F6E Claude Code \xB7 ${pc.dim(line)}`)
-      });
-      s?.stop(pc.green("\u2713 Claude Code \u914D\u7F6E\u5B8C\u6210 ") + pc.dim("\u2192 ~/.claude/settings.json"));
-      if (!s) log.success(pc.green("\u2713 Claude Code \u914D\u7F6E\u5B8C\u6210 \u2192 ~/.claude/settings.json"));
-    } catch (err) {
-      s?.stop(pc.red("\u2717 Claude Code \u914D\u7F6E\u5931\u8D25"));
-      console.error(err.message);
-      process.exit(1);
-    }
-  }
-  if (configCodex) {
-    const codexModel = await resolveCodexModel(
-      selectedHost,
-      /* interactive */
-      !args.apiKey,
-      verbose
-    );
-    const useSpinner = !verbose && process.stdout.isTTY;
-    const s = useSpinner ? spinner() : null;
-    s?.start("\u914D\u7F6E Codex");
-    if (!s) log.info("\u6B63\u5728\u914D\u7F6E Codex...");
-    try {
-      await configureViaZcf({
-        target: "codex",
-        baseUrl: codexBaseUrl,
-        apiKey,
-        apiModel: codexModel,
-        verbose,
-        onProgress: (line) => s?.message(`\u914D\u7F6E Codex \xB7 ${pc.dim(line)}`)
-      });
-      s?.stop(pc.green("\u2713 Codex \u914D\u7F6E\u5B8C\u6210 ") + pc.dim(`\u2192 model=${codexModel}`));
-      if (!s) log.success(pc.green(`\u2713 Codex \u914D\u7F6E\u5B8C\u6210 \u2192 model=${codexModel}`));
-    } catch (err) {
-      s?.stop(pc.red("\u2717 Codex \u914D\u7F6E\u5931\u8D25"));
-      console.error(err.message);
-      process.exit(1);
-    }
+  for (const client of selected) {
+    await configureOne(client, { host, apiKey, verbose });
   }
   if (!args.skipVerify) {
     const useSpinner = process.stdout.isTTY;
     const s = useSpinner ? spinner() : null;
     s?.start("\u9A8C\u8BC1\u8FDE\u901A\u6027");
-    if (!s) log.info("\u6B63\u5728\u9A8C\u8BC1\u8FDE\u901A\u6027...");
-    const result = await verifyConnection(claudeBaseUrl, apiKey);
+    if (!s) log3.info("\u6B63\u5728\u9A8C\u8BC1\u8FDE\u901A\u6027...");
+    const result = await verifyConnection(host, apiKey);
     if (result.ok) {
-      const msg = pc.green("\u2713 \u94FE\u8DEF\u9A8C\u8BC1\u901A\u8FC7");
-      s?.stop(msg) ?? log.success(msg);
+      const msg = pc6.green("\u2713 \u94FE\u8DEF\u9A8C\u8BC1\u901A\u8FC7");
+      s?.stop(msg) ?? log3.success(msg);
     } else {
-      const msg = pc.yellow(
+      const msg = pc6.yellow(
         `\u26A0 \u9A8C\u8BC1\u672A\u901A\u8FC7${result.status ? ` (HTTP ${result.status})` : ""}` + (result.error ? `: ${result.error}` : "") + ` \u2014\u2014 \u914D\u7F6E\u5DF2\u5199\u5165\uFF0C\u53EF\u624B\u52A8\u6D4B\u8BD5`
       );
-      s?.stop(msg) ?? log.warn(msg);
+      s?.stop(msg) ?? log3.warn(msg);
     }
   }
-  const tips = [];
-  if (configClaude) tips.push(pc.cyan("claude") + pc.dim("  # \u542F\u52A8 Claude Code"));
-  if (configCodex) tips.push(pc.cyan("codex") + pc.dim("   # \u542F\u52A8 Codex"));
+  const tips = selected.map(
+    (c) => pc6.cyan(c.launchCommand) + pc6.dim(`  # \u542F\u52A8 ${c.label}`)
+  );
   note(tips.join("\n"), "\u{1F389} \u5168\u90E8\u5B8C\u6210\uFF01\u73B0\u5728\u53EF\u4EE5\u8FD0\u884C\uFF1A");
   outro(
-    pc.dim("\u611F\u8C22\u4F7F\u7528 EasyRouter ") + pc.underline(pc.cyan(PRIMARY_HOST)) + pc.dim("  \xB7  Claude Code auto-configuration is powered by ") + pc.underline("UfoMiao/zcf")
+    pc6.dim("\u611F\u8C22\u4F7F\u7528 EasyRouter ") + pc6.underline(pc6.cyan(PRIMARY_HOST)) + pc6.dim("  \xB7  Claude Code auto-configuration is powered by ") + pc6.underline("UfoMiao/zcf")
   );
 }
+async function pickClients(only, interactive) {
+  if (only && only.length) {
+    return only.map((id) => CLIENT_REGISTRY[id]);
+  }
+  if (!interactive) {
+    return [CLIENT_REGISTRY.claude, CLIENT_REGISTRY.codex];
+  }
+  const all = listClients();
+  const picked = await multiselect({
+    message: "\u8BF7\u9009\u62E9\u8981\u914D\u7F6E\u7684\u5BA2\u6237\u7AEF\uFF08\u7A7A\u683C\u5207\u6362\uFF0C\u56DE\u8F66\u786E\u8BA4\uFF09",
+    options: all.map((c) => ({
+      value: c.id,
+      label: c.label,
+      hint: c.hint
+    })),
+    initialValues: [],
+    required: false
+  });
+  if (isCancel2(picked)) {
+    cancel("\u5DF2\u53D6\u6D88");
+    process.exit(0);
+  }
+  return picked.map((id) => CLIENT_REGISTRY[id]);
+}
+async function detectAll(clients, verbose) {
+  const results = [];
+  for (const c of clients) {
+    const availability = await c.detect();
+    results.push({ client: c, availability });
+    if (verbose) {
+      if (availability.installed) {
+        log3.info(
+          `\u2713 ${c.label}${availability.version ? ` v${availability.version}` : ""} \u5DF2\u5B89\u88C5`
+        );
+      } else {
+        log3.warn(`\u2717 ${c.label} \u672A\u68C0\u6D4B\u5230`);
+      }
+    }
+  }
+  return results;
+}
+function printMissingHints(missing) {
+  console.error();
+  console.error(pc6.red("\u2717 \u4EE5\u4E0B\u5BA2\u6237\u7AEF\u5C1A\u672A\u5B89\u88C5\uFF0C\u8BF7\u5148\u5B89\u88C5\u518D\u8FD0\u884C\u672C\u547D\u4EE4\uFF1A"));
+  console.error();
+  for (const { client, availability } of missing) {
+    const hint = availability.installHint || "\u8BF7\u67E5\u770B\u5B98\u65B9\u6587\u6863";
+    console.error(`  ${pc6.bold(client.label)}\uFF1A`);
+    hint.split("\n").forEach((line) => {
+      console.error(`    ${pc6.dim(line)}`);
+    });
+    console.error();
+  }
+  console.error(pc6.dim("\u5B89\u88C5\u5B8C\u6210\u540E\u91CD\u65B0\u8FD0\u884C\u672C\u547D\u4EE4\u5373\u53EF\u7EE7\u7EED\u914D\u7F6E\u3002"));
+}
+function printSummary(opts) {
+  const lines = [
+    `${pc6.bold("\u8BA1\u8D39\u6A21\u5F0F")}    \u6309\u91CF\u4ED8\u8D39`,
+    `${pc6.bold("BaseURL")}     ${PRIMARY_HOST}`,
+    `${pc6.bold("API Key")}     ${maskKey(opts.apiKey)}`,
+    `${pc6.bold("\u5C06\u914D\u7F6E")}      ${opts.selected.map((c) => c.label).join(" + ")}`
+  ];
+  note(lines.join("\n"), "\u914D\u7F6E\u9884\u89C8");
+}
+async function configureOne(client, ctx) {
+  const useSpinner = !ctx.verbose && process.stdout.isTTY;
+  const s = useSpinner ? spinner() : null;
+  s?.start(`\u914D\u7F6E ${client.label}`);
+  if (!s) log3.info(`\u6B63\u5728\u914D\u7F6E ${client.label}...`);
+  try {
+    const result = await client.configure({
+      host: ctx.host,
+      apiKey: ctx.apiKey,
+      verbose: ctx.verbose,
+      onProgress: (line) => s?.message(`\u914D\u7F6E ${client.label} \xB7 ${pc6.dim(line)}`)
+    });
+    const summary = `\u2192 ${result.configPaths.join(" + ")}` + (result.model ? `   model=${result.model}` : "");
+    s?.stop(pc6.green(`\u2713 ${client.label} \u914D\u7F6E\u5B8C\u6210 `) + pc6.dim(summary));
+    if (!s) log3.success(pc6.green(`\u2713 ${client.label} \u914D\u7F6E\u5B8C\u6210 ${summary}`));
+  } catch (err) {
+    s?.stop(pc6.red(`\u2717 ${client.label} \u914D\u7F6E\u5931\u8D25`));
+    console.error(err.message);
+    process.exit(1);
+  }
+}
 main().catch((err) => {
   console.error();
-  console.error(pc.red("\u2717 \u81F4\u547D\u9519\u8BEF\uFF1A"), err?.message || err);
+  console.error(pc6.red("\u2717 \u81F4\u547D\u9519\u8BEF\uFF1A"), err?.message || err);
   if (err?.stack && process.env.DEBUG) {
-    console.error(pc.dim(err.stack));
+    console.error(pc6.dim(err.stack));
   }
   process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "easyrouter-config",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "🚀 一键把 EasyRouter 接入 Claude Code & Codex —— 粘贴 Key 即用",
   "type": "module",
   "bin": {