trinity-config 1.2.5 → 1.3.1

package/README.md

@@ -1,6 +1,6 @@
 # trinity-config
 
-一键接入 Trinity：Claude Code / Codex / OpenCode / OpenClaw / ZCode。
+一键接入 Trinity：Claude Code / Codex / OpenCode / OpenClaw / ZCode / **CC Switch**。
 
 协议按 `GET /v1/models/{code}` 的 `capabilities.text.interfaces` **自动择优**（Anthropic → Responses → Completions），再与工具能力求交。
 
@@ -8,15 +8,29 @@
 
 ```bash
 npx -y trinity-config --type zcode -k xh-你的key --model gpt-5.4
+
+# CC Switch：按 App 槽位生成 Deep Link（非 Universal）
+npx -y trinity-config --type ccswitch --app claude -k xh-你的key
+npx -y trinity-config --type ccswitch --app codex -k xh-你的key --model gpt-5.4
+npx -y trinity-config --type ccswitch --app claude,codex -k xh-你的key --print-only
 ```
 
-| type | 配置文件 |
+| type | 配置方式 |
 | --- | --- |
-| claude | `~/.claude/settings.json` |
-| codex | `~/.codex/config.toml` |
-| opencode | `~/.config/opencode/opencode.json` |
-| openclaw | `~/.openclaw/openclaw.json` |
-| zcode | `~/.zcode/v2/config.json` |
+| claude | `~/.claude/settings.json`（直连） |
+| codex | `~/.codex/config.toml` + `auth.json`（直连） |
+| opencode | `~/.config/opencode/opencode.json`（直连） |
+| openclaw | `~/.openclaw/openclaw.json`（直连） |
+| zcode | `~/.zcode/v2/config.json`（直连） |
+| ccswitch | `ccswitch://v1/import` Deep Link；落盘 `~/.cc-switch/trinity-imports/` |
+
+### CC Switch 注意
+
+- **必填** `--app`：`claude` / `codex` / `opencode` / `openclaw`（不支持 `gemini` / Universal）
+- 与直连 `--type claude` 等**不要混用**同一工具，以免互相覆盖
+- Claude：Anthropic Messages，Endpoint **不带** `/v1`
+- Codex：`wire_api=responses`，Endpoint **带** `/v1`，关闭 Needs Local Routing
+- `--print-only`：只生成链接，不唤起应用
 
 Anthropic Base **不带** `/v1`；Responses / Completions **带** `/v1`。
 

package/dist/index.js

@@ -9,7 +9,7 @@ import pc from "picocolors";
 
 // src/constants.ts
 var PACKAGE_NAME = "trinity-config";
-var PACKAGE_VERSION = "1.2.5";
+var PACKAGE_VERSION = "1.3.1";
 var TRINITY_BASE_URL = "https://api.trinitydesk.ai";
 var DEFAULT_CLAUDE_MODEL = "claude-sonnet-4-6";
 var DEFAULT_CLAUDE_FAST_MODEL = "claude-sonnet-4-6";
@@ -20,7 +20,23 @@ var DEFAULT_ZCODE_MODEL = "gpt-5.4";
 var VERIFY_TIMEOUT_MS = 15e3;
 
 // src/model.ts
-function defaultModelForType(type) {
+var CC_SWITCH_APPS = [
+  "claude",
+  "codex",
+  "gemini",
+  "opencode",
+  "openclaw"
+];
+var CC_SWITCH_SUPPORTED_APPS = [
+  "claude",
+  "codex",
+  "opencode",
+  "openclaw"
+];
+function defaultModelForType(type, app) {
+  if (type === "ccswitch") {
+    return defaultModelForCcSwitchApp(app ?? "claude");
+  }
   switch (type) {
     case "claude":
       return DEFAULT_CLAUDE_MODEL;
@@ -34,17 +50,77 @@ function defaultModelForType(type) {
       return DEFAULT_ZCODE_MODEL;
   }
 }
-function resolveModel(type, model) {
-  return model?.trim() || defaultModelForType(type);
+function defaultModelForCcSwitchApp(app) {
+  switch (app) {
+    case "claude":
+      return DEFAULT_CLAUDE_MODEL;
+    case "codex":
+    case "opencode":
+    case "openclaw":
+      return DEFAULT_CODEX_MODEL;
+    case "gemini":
+      return DEFAULT_CODEX_MODEL;
+  }
+}
+function resolveModel(type, model, app) {
+  return model?.trim() || defaultModelForType(type, app);
 }
 function parseToolType(raw) {
   const value = raw.trim().toLowerCase();
-  if (value === "claude" || value === "codex" || value === "opencode" || value === "openclaw" || value === "zcode") {
+  if (value === "claude" || value === "codex" || value === "opencode" || value === "openclaw" || value === "zcode" || value === "ccswitch") {
     return value;
   }
-  throw new Error("--type \u987B\u4E3A claude\u3001codex\u3001opencode\u3001openclaw \u6216 zcode");
+  throw new Error(
+    "--type \u987B\u4E3A claude\u3001codex\u3001opencode\u3001openclaw\u3001zcode \u6216 ccswitch"
+  );
+}
+function parseCcSwitchApps(raw) {
+  const parts = raw.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
+  if (parts.length === 0) {
+    throw new Error("--app \u4E0D\u80FD\u4E3A\u7A7A\uFF08\u4F8B: --app claude \u6216 --app claude,codex\uFF09");
+  }
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const p2 of parts) {
+    if (!CC_SWITCH_APPS.includes(p2)) {
+      throw new Error(
+        `--app \u65E0\u6548: ${p2}\uFF08\u652F\u6301: ${CC_SWITCH_SUPPORTED_APPS.join(" / ")}\uFF09`
+      );
+    }
+    assertCcSwitchAppSupported(p2);
+    if (seen.has(p2)) continue;
+    seen.add(p2);
+    out.push(p2);
+  }
+  return out;
+}
+function protocolToolForCcSwitchApp(app) {
+  switch (app) {
+    case "claude":
+      return "claude";
+    case "codex":
+      return "codex";
+    case "opencode":
+      return "opencode";
+    case "openclaw":
+      return "openclaw";
+    case "gemini":
+      throw new Error(
+        "CC Switch --app gemini\uFF1ATrinity \u5BF9\u5916\u672A\u63D0\u4F9B Gemini \u539F\u751F\u534F\u8BAE"
+      );
+  }
 }
-function toolLabel(type) {
+function assertCcSwitchAppSupported(app) {
+  if (app === "gemini") {
+    throw new Error(
+      "CC Switch --app gemini\uFF1ATrinity \u5BF9\u5916\u672A\u63D0\u4F9B Gemini \u539F\u751F\u534F\u8BAE\uFF0C\u8BF7\u6539\u7528 --app claude / codex / opencode / openclaw"
+    );
+  }
+}
+function toolLabel(type, app) {
+  if (type === "ccswitch") {
+    return app ? `CC Switch \xB7 ${app}` : "CC Switch";
+  }
   switch (type) {
     case "claude":
       return "Claude Code";
@@ -70,6 +146,8 @@ function launchCommand(type) {
       return "openclaw dashboard";
     case "zcode":
       return "ZCode \u684C\u9762\u5E94\u7528";
+    case "ccswitch":
+      return "CC Switch \u684C\u9762\u5E94\u7528";
   }
 }
 
@@ -79,27 +157,33 @@ function printHelp() {
 trinity-config \u2014 \u4E00\u952E\u628A Trinity API \u63A5\u5165\u7EC8\u7AEF / Agent / \u684C\u9762\u7F16\u7A0B\u52A9\u624B
 
 \u7528\u6CD5:
-  npx -y trinity-config --type <claude|codex|opencode|openclaw|zcode> [\u9009\u9879]
+  npx -y trinity-config --type <claude|codex|opencode|openclaw|zcode|ccswitch> [\u9009\u9879]
 
 \u9009\u9879:
   -t, --type <\u2026>         \u8981\u914D\u7F6E\u7684\u5DE5\u5177\uFF08\u975E\u4EA4\u4E92\u987B\u6307\u5B9A\uFF09
   -k, --api-key <key>    Trinity API Key\uFF08xh- \u524D\u7F00\uFF09
   -M, --model <code>     \u9ED8\u8BA4\u6A21\u578B\uFF1B\u534F\u8BAE\u6309\u6A21\u578B\u8BE6\u60C5\u81EA\u52A8\u62E9\u4F18\uFF08\u975E completions \u4F18\u5148\uFF09
+  --app <apps>           \u4EC5 --type ccswitch\uFF1A\u76EE\u6807\u69FD\u4F4D\uFF0C\u9017\u53F7\u5206\u9694
+                         claude|codex|opencode|openclaw\uFF08\u4E0D\u652F\u6301 gemini / Universal\uFF09
+  --print-only           \u4EC5 --type ccswitch\uFF1A\u53EA\u751F\u6210 Deep Link\uFF0C\u4E0D\u5524\u8D77\u5E94\u7528
   --base-url <url>       API \u6839\u5730\u5740\uFF08\u9ED8\u8BA4 https://api.trinitydesk.ai\uFF09
   --skip-verify          \u8DF3\u8FC7\u8FDE\u901A\u6027 / \u8BE6\u60C5\u62C9\u53D6
-  -v, --verbose          \u663E\u793A zcf \u8BE6\u7EC6\u8F93\u51FA\uFF08\u4EC5 Claude\uFF09
+  -v, --verbose          \u663E\u793A zcf \u8BE6\u7EC6\u8F93\u51FA\uFF08\u4EC5 Claude \u76F4\u8FDE\uFF09
   -h, --help             \u663E\u793A\u5E2E\u52A9
   -V, --version          \u663E\u793A\u7248\u672C
 
 \u793A\u4F8B:
   npx -y trinity-config --type zcode -k xh-your-key --model gpt-5.4
-  npx -y trinity-config --type openclaw -k xh-your-key
+  npx -y trinity-config --type ccswitch --app claude -k xh-your-key
+  npx -y trinity-config --type ccswitch --app codex -k xh-your-key --model gpt-5.4
+  npx -y trinity-config --type ccswitch --app claude,codex -k xh-your-key
 `);
 }
 function parseArgs(argv) {
   const opts = {
     skipVerify: false,
     verbose: false,
+    printOnly: false,
     help: false,
     version: false
   };
@@ -123,6 +207,9 @@ function parseArgs(argv) {
       case "--skip-verify":
         opts.skipVerify = true;
         break;
+      case "--print-only":
+        opts.printOnly = true;
+        break;
       case "-k":
       case "--api-key":
         opts.apiKey = args.shift();
@@ -135,6 +222,9 @@ function parseArgs(argv) {
       case "--model":
         opts.model = args.shift();
         break;
+      case "--app":
+        opts.apps = parseCcSwitchApps(String(args.shift() ?? ""));
+        break;
       case "--base-url":
         opts.baseUrl = args.shift();
         break;
@@ -159,6 +249,17 @@ function parseArgs(argv) {
   if (opts.help) {
     printHelp();
   }
+  if (opts.type === "ccswitch" && (!opts.apps || opts.apps.length === 0) && opts.apiKey) {
+    throw new Error(
+      "\u975E\u4EA4\u4E92\u914D\u7F6E CC Switch \u987B\u6307\u5B9A --app\uFF08\u4F8B: --app claude \u6216 --app claude,codex\uFF09"
+    );
+  }
+  if (opts.apps && opts.type && opts.type !== "ccswitch") {
+    throw new Error("--app \u4EC5\u7528\u4E8E --type ccswitch");
+  }
+  if (opts.printOnly && opts.type && opts.type !== "ccswitch") {
+    throw new Error("--print-only \u4EC5\u7528\u4E8E --type ccswitch");
+  }
   return opts;
 }
 function normalizeApiKey(raw) {
@@ -171,22 +272,222 @@ function normalizeApiKey(raw) {
 function requireType(type, hasApiKeyFlag) {
   if (type) return type;
   if (!hasApiKeyFlag) return void 0;
-  throw new Error("\u975E\u4EA4\u4E92\u6A21\u5F0F\u987B\u6307\u5B9A --type claude\u3001codex\u3001opencode\u3001openclaw \u6216 zcode");
+  throw new Error(
+    "\u975E\u4EA4\u4E92\u6A21\u5F0F\u987B\u6307\u5B9A --type claude\u3001codex\u3001opencode\u3001openclaw\u3001zcode \u6216 ccswitch"
+  );
 }
 
-// src/merge-claude-env.ts
+// src/ccswitch-deeplink.ts
 import fs from "fs";
 import os from "os";
 import path from "path";
+import { execa } from "execa";
+var TRINITY_CCSWITCH_PROVIDER_NAME = "Trinity";
+var CCSWITCH_URL_SAFE_MAX = 2e3;
+function encodeConfigBase64(raw) {
+  return Buffer.from(raw, "utf8").toString("base64");
+}
+function buildClaudeConfigJson(apiKey, endpoint, model) {
+  return JSON.stringify({
+    env: {
+      ANTHROPIC_AUTH_TOKEN: apiKey,
+      ANTHROPIC_API_KEY: apiKey,
+      ANTHROPIC_BASE_URL: endpoint.replace(/\/v1\/?$/, "").replace(/\/+$/, ""),
+      ANTHROPIC_MODEL: model,
+      ANTHROPIC_DEFAULT_SONNET_MODEL: model,
+      ANTHROPIC_DEFAULT_HAIKU_MODEL: model
+    }
+  });
+}
+function buildCodexConfigToml(_apiKey, endpointWithV1, model) {
+  const base = endpointWithV1.replace(/\/+$/, "");
+  return [
+    'model_provider = "trinity"',
+    `model = ${JSON.stringify(model)}`,
+    "disable_response_storage = true",
+    "",
+    "[model_providers.trinity]",
+    'name = "Trinity"',
+    `base_url = ${JSON.stringify(base)}`,
+    'wire_api = "responses"',
+    "requires_openai_auth = true"
+  ].join("\n");
+}
+function buildOpenCodeConfigJson(apiKey, endpoint, model, protocol) {
+  const npm = protocol === "anthropic_messages" ? "@ai-sdk/anthropic" : protocol === "responses" ? "@ai-sdk/openai" : "@ai-sdk/openai-compatible";
+  return JSON.stringify({
+    $schema: "https://opencode.ai/config.json",
+    model: `trinity/${model}`,
+    provider: {
+      trinity: {
+        npm,
+        name: "Trinity",
+        options: {
+          baseURL: endpoint.replace(/\/+$/, ""),
+          apiKey
+        },
+        models: {
+          [model]: { name: model }
+        }
+      }
+    }
+  });
+}
+function buildOpenClawConfigJson(apiKey, endpoint, model, protocol) {
+  const api = protocol === "anthropic_messages" ? "anthropic-messages" : protocol === "responses" ? "openai-responses" : "openai-completions";
+  return JSON.stringify({
+    models: {
+      mode: "merge",
+      providers: {
+        trinity: {
+          baseUrl: endpoint.replace(/\/+$/, ""),
+          apiKey,
+          api,
+          models: [
+            {
+              id: model,
+              name: model,
+              reasoning: false,
+              input: ["text"],
+              contextWindow: 128e3,
+              maxTokens: 8192
+            }
+          ]
+        }
+      }
+    },
+    agents: {
+      defaults: {
+        model: { primary: `trinity/${model}` },
+        models: { "trinity/*": {} }
+      }
+    }
+  });
+}
+function buildCcSwitchDeepLink(options) {
+  const root = (options.rootBaseUrl ?? TRINITY_BASE_URL).replace(/\/+$/, "");
+  const withoutV1 = root.replace(/\/v1\/?$/, "");
+  const withV1 = `${withoutV1}/v1`;
+  let endpoint;
+  let config;
+  let configFormat;
+  switch (options.app) {
+    case "claude": {
+      endpoint = withoutV1;
+      configFormat = "json";
+      config = buildClaudeConfigJson(options.apiKey, endpoint, options.model);
+      break;
+    }
+    case "codex": {
+      endpoint = withV1;
+      configFormat = "toml";
+      config = buildCodexConfigToml(options.apiKey, endpoint, options.model);
+      break;
+    }
+    case "opencode": {
+      endpoint = options.protocol === "anthropic_messages" ? withoutV1 : withV1;
+      configFormat = "json";
+      config = buildOpenCodeConfigJson(
+        options.apiKey,
+        endpoint,
+        options.model,
+        options.protocol
+      );
+      break;
+    }
+    case "openclaw": {
+      endpoint = options.protocol === "anthropic_messages" ? withoutV1 : withV1;
+      configFormat = "json";
+      config = buildOpenClawConfigJson(
+        options.apiKey,
+        endpoint,
+        options.model,
+        options.protocol
+      );
+      break;
+    }
+    case "gemini":
+      throw new Error("gemini \u4E0D\u53D7\u652F\u6301");
+  }
+  const params = new URLSearchParams();
+  params.set("resource", "provider");
+  params.set("app", options.app);
+  params.set("name", TRINITY_CCSWITCH_PROVIDER_NAME);
+  params.set("endpoint", endpoint);
+  params.set("apiKey", options.apiKey);
+  params.set("homepage", "https://trinitydesk.ai");
+  params.set("model", options.model);
+  if (options.app === "claude") {
+    params.set("sonnetModel", options.model);
+    params.set("haikuModel", options.model);
+  }
+  params.set("config", encodeConfigBase64(config));
+  params.set("configFormat", configFormat);
+  if (options.enabled !== false) {
+    params.set("enabled", "true");
+  }
+  return {
+    url: `ccswitch://v1/import?${params.toString()}`,
+    endpoint,
+    configFormat
+  };
+}
+function ccSwitchImportDir() {
+  return path.join(os.homedir(), ".cc-switch", "trinity-imports");
+}
+function persistCcSwitchDeepLink(app, url) {
+  const dir = ccSwitchImportDir();
+  fs.mkdirSync(dir, { recursive: true });
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const base = path.join(dir, `trinity-${app}-${stamp}`);
+  const urlFile = `${base}.url`;
+  const txtFile = `${base}.txt`;
+  fs.writeFileSync(
+    urlFile,
+    `[InternetShortcut]\r
+URL=${url}\r
+`,
+    "utf8"
+  );
+  fs.writeFileSync(txtFile, `${url}
+`, "utf8");
+  return { urlFile, txtFile };
+}
+async function openCcSwitchDeepLink(url, urlFile) {
+  if (url.length > CCSWITCH_URL_SAFE_MAX) {
+    return "too_long";
+  }
+  const platform = process.platform;
+  if (platform === "win32") {
+    const command = urlFile && fs.existsSync(urlFile) ? `Start-Process -LiteralPath ${JSON.stringify(urlFile)}` : `Start-Process ${JSON.stringify(url)}`;
+    await execa(
+      "powershell.exe",
+      ["-NoProfile", "-NonInteractive", "-Command", command],
+      { reject: false, windowsHide: true }
+    );
+    return "opened";
+  }
+  if (platform === "darwin") {
+    await execa("open", [url], { reject: false });
+    return "opened";
+  }
+  await execa("xdg-open", [url], { reject: false });
+  return "opened";
+}
+
+// src/merge-claude-env.ts
+import fs2 from "fs";
+import os2 from "os";
+import path2 from "path";
 function claudeSettingsPath() {
-  return path.join(os.homedir(), ".claude", "settings.json");
+  return path2.join(os2.homedir(), ".claude", "settings.json");
 }
 function mergeClaudeEnv(claudeModel, fastModel, baseUrl) {
   const filePath = claudeSettingsPath();
-  if (!fs.existsSync(filePath)) {
+  if (!fs2.existsSync(filePath)) {
     return;
   }
-  const raw = fs.readFileSync(filePath, "utf8");
+  const raw = fs2.readFileSync(filePath, "utf8");
   let settings;
   try {
     settings = JSON.parse(raw);
@@ -199,8 +500,8 @@ function mergeClaudeEnv(claudeModel, fastModel, baseUrl) {
     ANTHROPIC_MODEL: claudeModel,
     ANTHROPIC_SMALL_FAST_MODEL: fastModel
   };
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, `${JSON.stringify(settings, null, 2)}
+  fs2.mkdirSync(path2.dirname(filePath), { recursive: true });
+  fs2.writeFileSync(filePath, `${JSON.stringify(settings, null, 2)}
 `, "utf8");
 }
 
@@ -366,7 +667,7 @@ function protocolLabel(protocol) {
 }
 
 // src/zcf.ts
-import { execa } from "execa";
+import { execa as execa2 } from "execa";
 function sharedZcfArgs(verbose) {
   return [
     "zcf",
@@ -405,7 +706,7 @@ async function runZcfInit(options) {
     args.push("--api-haiku-model", options.fastModel);
     args.push("--api-sonnet-model", options.primaryModel);
   }
-  await execa("npx", ["-y", ...args], {
+  await execa2("npx", ["-y", ...args], {
     stdio: options.verbose ? "inherit" : "pipe",
     reject: true,
     timeout: 18e4
@@ -581,11 +882,12 @@ async function promptToolType(initial) {
   const value = await p.select({
     message: "\u8981\u914D\u7F6E\u54EA\u4E2A\u5DE5\u5177\uFF1F",
     options: [
-      { value: "claude", label: "Claude Code" },
-      { value: "codex", label: "Codex CLI" },
-      { value: "opencode", label: "OpenCode" },
-      { value: "openclaw", label: "OpenClaw" },
-      { value: "zcode", label: "ZCode" }
+      { value: "claude", label: "Claude Code\uFF08\u76F4\u8FDE\uFF09" },
+      { value: "codex", label: "Codex CLI\uFF08\u76F4\u8FDE\uFF09" },
+      { value: "opencode", label: "OpenCode\uFF08\u76F4\u8FDE\uFF09" },
+      { value: "openclaw", label: "OpenClaw\uFF08\u76F4\u8FDE\uFF09" },
+      { value: "zcode", label: "ZCode" },
+      { value: "ccswitch", label: "CC Switch\uFF08\u6309 App \u69FD\u4F4D\u5BFC\u5165\uFF09" }
     ]
   });
   if (p.isCancel(value)) {
@@ -594,13 +896,31 @@ async function promptToolType(initial) {
   }
   return value;
 }
-async function promptModel(type, initial) {
+async function promptCcSwitchApps(initial) {
+  if (initial && initial.length > 0) {
+    return initial;
+  }
+  const value = await p.multiselect({
+    message: "\u8981\u5199\u5165 CC Switch \u7684\u54EA\u4E9B App \u69FD\u4F4D\uFF1F\uFF08\u975E Universal\uFF09",
+    options: CC_SWITCH_SUPPORTED_APPS.map((app) => ({
+      value: app,
+      label: app
+    })),
+    required: true
+  });
+  if (p.isCancel(value)) {
+    p.cancel("\u5DF2\u53D6\u6D88");
+    process.exit(0);
+  }
+  return value;
+}
+async function promptModel(type, app, initial) {
   if (initial?.trim()) {
     return initial.trim();
   }
-  const fallback = defaultModelForType(type);
+  const fallback = defaultModelForType(type, app);
   const value = await p.text({
-    message: `${toolLabel(type)} \u9ED8\u8BA4 model_code`,
+    message: `${toolLabel(type, app)} \u9ED8\u8BA4 model_code`,
     placeholder: fallback,
     initialValue: fallback,
     validate: (input) => {
@@ -613,8 +933,8 @@ async function promptModel(type, initial) {
   }
   return String(value).trim();
 }
-function recommendedHint(toolType, recommended) {
-  switch (toolType) {
+function recommendedHint(protocolTool, recommended) {
+  switch (protocolTool) {
     case "claude":
       return recommended.claude;
     case "codex":
@@ -627,6 +947,13 @@ function recommendedHint(toolType, recommended) {
       return recommended.zcode;
   }
 }
+function protocolToolFor(type, app) {
+  if (type === "ccswitch") {
+    if (!app) throw new Error("ccswitch \u7F3A\u5C11 --app");
+    return protocolToolForCcSwitchApp(app);
+  }
+  return type;
+}
 async function run() {
   let opts;
   try {
@@ -645,13 +972,38 @@ async function run() {
   }
   p.intro(pc.bgCyan(pc.black(` ${PACKAGE_NAME} v${PACKAGE_VERSION} `)));
   const toolType = await promptToolType(opts.type);
+  const ccApps = toolType === "ccswitch" ? await promptCcSwitchApps(opts.apps) : void 0;
+  if (ccApps) {
+    for (const app of ccApps) {
+      try {
+        assertCcSwitchAppSupported(app);
+      } catch (error) {
+        console.error(pc.red(error instanceof Error ? error.message : String(error)));
+        return 1;
+      }
+    }
+  }
+  const primaryApp = ccApps?.[0];
   const apiKey = await promptApiKey(opts.apiKey);
-  let model = opts.model?.trim() ? opts.model.trim() : opts.apiKey ? resolveModel(toolType) : await promptModel(toolType);
+  let model = opts.model?.trim() ? opts.model.trim() : opts.apiKey ? resolveModel(toolType, void 0, primaryApp) : await promptModel(toolType, primaryApp);
   const apiRoot = rootBaseUrl(opts.baseUrl);
-  p.log.info(`\u5DE5\u5177: ${toolLabel(toolType)} \xB7 \u6A21\u578B: ${model}`);
+  p.log.info(
+    `\u5DE5\u5177: ${toolLabel(toolType, primaryApp)}` + (ccApps && ccApps.length > 1 ? `\uFF08${ccApps.join(",")}\uFF09` : "") + ` \xB7 \u6A21\u578B: ${model}`
+  );
+  if (toolType === "ccswitch") {
+    p.note(
+      [
+        "\u5C06\u751F\u6210 App-specific Provider Deep Link\uFF08\u975E Universal\uFF09",
+        "\u5BFC\u5165\u540E\u8BF7\u5728\u5BF9\u5E94 App \u4E0B Activate\u300CTrinity\u300D",
+        "\u8BF7\u52FF\u540C\u65F6\u5BF9\u672C\u5DE5\u5177\u518D\u8DD1 --type \u76F4\u8FDE\uFF0C\u4EE5\u514D\u914D\u7F6E\u4E92\u76F8\u8986\u76D6"
+      ].join("\n"),
+      "CC Switch"
+    );
+  }
   const spinner2 = p.spinner();
   let verifiedModelIds;
   let verifyFailed = false;
+  const protocolToolHint = protocolToolFor(toolType, primaryApp);
   if (!opts.skipVerify) {
     spinner2.start("\u9A8C\u8BC1 Trinity API \u8FDE\u901A\u6027\u2026");
     const result = await verifyTrinityApi(apiKey, apiRoot);
@@ -663,7 +1015,7 @@ async function run() {
         return 1;
       }
       const recommended = pickRecommendedModels(verifiedModelIds);
-      const hint = recommendedHint(toolType, recommended);
+      const hint = recommendedHint(protocolToolHint, recommended);
       const allowed = pickAllowedDefaultModel(model, verifiedModelIds, [
         hint,
         recommended.claude,
@@ -671,7 +1023,7 @@ async function run() {
         recommended.opencode,
         recommended.openclaw,
         recommended.zcode,
-        defaultModelForType(toolType)
+        defaultModelForType(toolType, primaryApp)
       ]);
       if (!allowed) {
         p.outro(pc.red("\u65E0\u6CD5\u5728\u8BE5 API Key \u7684\u53EF\u7528\u751F\u6587\u6A21\u578B\u4E2D\u9009\u51FA\u9ED8\u8BA4\u6A21\u578B"));
@@ -700,11 +1052,107 @@ async function run() {
       "\u63D0\u793A"
     );
   }
+  if (toolType === "ccswitch" && ccApps) {
+    const saved = [];
+    for (const app of ccApps) {
+      spinner2.start(`\u751F\u6210 CC Switch Deep Link\uFF08${app}\uFF09\u2026`);
+      let appModel = model;
+      let protocolRes2;
+      try {
+        protocolRes2 = await resolveProtocol({
+          tool: protocolToolForCcSwitchApp(app),
+          apiKey,
+          model: appModel,
+          rootBaseUrl: apiRoot,
+          skipFetch: opts.skipVerify
+        });
+      } catch (firstError) {
+        const fallback = defaultModelForCcSwitchApp(app);
+        const canRetry = fallback !== appModel && (!verifiedModelIds || verifiedModelIds.includes(fallback));
+        if (!canRetry) {
+          spinner2.stop(pc.red(`${app} \u534F\u8BAE\u89E3\u6790\u5931\u8D25`));
+          console.error(
+            pc.red(
+              firstError instanceof Error ? firstError.message : String(firstError)
+            )
+          );
+          p.note(
+            `\u591A App \u5171\u7528\u4E00\u4E2A --model \u65F6\uFF0C\u8BF7\u786E\u4FDD\u6A21\u578B\u534F\u8BAE\u5339\u914D\u5404\u69FD\u4F4D\uFF1B\u6216\u5206\u5F00\u6267\u884C\u4E0D\u540C --app / --model`,
+            "\u63D0\u793A"
+          );
+          return 1;
+        }
+        try {
+          protocolRes2 = await resolveProtocol({
+            tool: protocolToolForCcSwitchApp(app),
+            apiKey,
+            model: fallback,
+            rootBaseUrl: apiRoot,
+            skipFetch: opts.skipVerify
+          });
+          p.note(
+            `${app} \u69FD\uFF1A\u6A21\u578B ${appModel} \u4E0D\u517C\u5BB9\uFF0C\u5DF2\u6539\u7528 ${fallback}`,
+            "\u6A21\u578B"
+          );
+          appModel = fallback;
+        } catch (error) {
+          spinner2.stop(pc.red(`${app} \u534F\u8BAE\u89E3\u6790\u5931\u8D25`));
+          console.error(
+            pc.red(error instanceof Error ? error.message : String(error))
+          );
+          return 1;
+        }
+      }
+      const protocol2 = protocolRes2.protocol;
+      try {
+        const link = buildCcSwitchDeepLink({
+          app,
+          apiKey,
+          rootBaseUrl: apiRoot,
+          model: appModel,
+          protocol: protocol2
+        });
+        const files = persistCcSwitchDeepLink(app, link.url);
+        saved.push(files.urlFile);
+        spinner2.stop(
+          `\u5DF2\u751F\u6210 ${app}\uFF1A${protocolLabel(protocol2)} \u2192 ${link.endpoint}`
+        );
+        p.log.info(`\u5BFC\u5165\u6587\u4EF6: ${files.urlFile}`);
+        if (opts.printOnly) {
+          continue;
+        }
+        const openResult = await openCcSwitchDeepLink(link.url, files.urlFile);
+        if (openResult === "too_long") {
+          p.log.warn(
+            `\u94FE\u63A5\u8FC7\u957F\uFF08${link.url.length}\uFF09\uFF0C\u672A\u81EA\u52A8\u5524\u8D77\uFF1B\u8BF7\u53CC\u51FB\u5BFC\u5165\u6587\u4EF6`
+          );
+        } else {
+          p.log.info("\u5DF2\u5524\u8D77 CC Switch\uFF0C\u8BF7\u5728\u5BFC\u5165\u6846\u4E2D\u786E\u8BA4");
+        }
+      } catch (error) {
+        spinner2.stop(pc.red(`${app} Deep Link \u5931\u8D25`));
+        console.error(pc.red(error instanceof Error ? error.message : String(error)));
+        return 1;
+      }
+    }
+    if (verifyFailed) {
+      p.outro(pc.yellow("\u5B8C\u6210\uFF08\u9A8C\u8BC1\u672A\u901A\u8FC7\uFF09"));
+      return 1;
+    }
+    p.note(
+      opts.printOnly ? `\u5DF2\u751F\u6210\u5BFC\u5165\u6587\u4EF6\uFF08\u672A\u5524\u8D77\uFF09:
+${saved.join("\n")}` : `\u8BF7\u5728 CC Switch \u5BFC\u5165\u6846\u70B9\u786E\u8BA4\uFF1B\u672A\u5F39\u7A97\u5219\u53CC\u51FB:
+${saved.join("\n")}`,
+      "\u4E0B\u4E00\u6B65"
+    );
+    p.outro(pc.green("\u5B8C\u6210"));
+    return 0;
+  }
   spinner2.start("\u89E3\u6790\u6A21\u578B\u534F\u8BAE\u2026");
   let protocolRes;
   try {
     protocolRes = await resolveProtocol({
-      tool: toolType,
+      tool: protocolToolFor(toolType),
       apiKey,
       model,
       rootBaseUrl: apiRoot,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "trinity-config",
-  "version": "1.2.5",
-  "description": "一键把 Trinity API 接入 Claude Code、Codex、OpenCode、OpenClaw、ZCode",
+  "version": "1.3.1",
+  "description": "一键把 Trinity API 接入 Claude Code、Codex、OpenCode、OpenClaw、ZCode、CC Switch",
   "license": "MIT",
   "type": "module",
   "bin": {
@@ -31,6 +31,8 @@
     "codex",
     "opencode",
     "openclaw",
+    "zcode",
+    "cc-switch",
     "cli",
     "ai-gateway",
     "zcf"