trinity-config 1.2.4 → 1.3.0

package/README.md

@@ -1,22 +1,36 @@
 # 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），再与工具能力求交。
 
-写入客户端的模型列表来自 `GET /v1/models?modality=text`（仅生文/多模态，不含生图/生视频）。
+写入客户端的模型列表来自该 API Key 的 `GET /v1/models?modality=text`（Call Allowlist 内生文/多模态；不含生图/生视频，也不含无权限模型）。
 
 ```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/chunk-5WZW5Y4W.js

@@ -0,0 +1,45 @@
+// src/text-models.ts
+function isLikelyNonTextModel(id) {
+  const lower = id.toLowerCase();
+  return lower.includes("image") || lower.includes("video") || lower.includes("seedance") || lower.includes("wan-") || lower.includes("kling") || lower.includes("og-image") || lower.includes("midjourney") || lower.includes("flux");
+}
+function filterTextModelIds(primaryModel, modelIds, limit = 80) {
+  const ids = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (raw, enforceTextHeuristic) => {
+    const trimmed = raw?.trim();
+    if (!trimmed || seen.has(trimmed)) return;
+    if (enforceTextHeuristic && isLikelyNonTextModel(trimmed)) return;
+    seen.add(trimmed);
+    ids.push(trimmed);
+  };
+  if (modelIds && modelIds.length > 0) {
+    const allow = new Set(
+      modelIds.map((id) => id?.trim()).filter((id) => Boolean(id))
+    );
+    if (allow.has(primaryModel.trim())) {
+      push(primaryModel, false);
+    }
+    for (const id of modelIds) {
+      if (ids.length >= limit) break;
+      push(id, true);
+    }
+    return ids;
+  }
+  push(primaryModel, true);
+  return ids;
+}
+function pickAllowedDefaultModel(preferred, allowlist, candidates) {
+  const allow = new Set(allowlist.map((id) => id.trim()).filter(Boolean));
+  if (allow.has(preferred.trim())) return preferred.trim();
+  for (const c of candidates) {
+    const t = c?.trim();
+    if (t && allow.has(t)) return t;
+  }
+  return allowlist.map((id) => id.trim()).find(Boolean);
+}
+
+export {
+  filterTextModelIds,
+  pickAllowedDefaultModel
+};

package/dist/index.js

@@ -1,11 +1,15 @@
 #!/usr/bin/env node
+import {
+  pickAllowedDefaultModel
+} from "./chunk-5WZW5Y4W.js";
+
 // src/index.ts
 import * as p from "@clack/prompts";
 import pc from "picocolors";
 
 // src/constants.ts
 var PACKAGE_NAME = "trinity-config";
-var PACKAGE_VERSION = "1.2.4";
+var PACKAGE_VERSION = "1.3.0";
 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";
@@ -16,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;
@@ -30,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 toolLabel(type) {
+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 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";
@@ -66,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";
   }
 }
 
@@ -75,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
   };
@@ -119,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();
@@ -131,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;
@@ -155,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) {
@@ -167,22 +272,262 @@ 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";
+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
+      }
+    },
+    null,
+    2
+  )}
+`;
+}
+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
+temp_env_key = "TRINITY_API_KEY"
+`;
+}
+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 }
+          }
+        }
+      }
+    },
+    null,
+    2
+  )}
+`;
+}
+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/*": {} }
+        }
+      }
+    },
+    null,
+    2
+  )}
+`;
+}
+function notesForCcSwitchApp(app, protocol) {
+  const common = [
+    "App-specific Provider\uFF08\u975E Universal\uFF09",
+    "\u5BFC\u5165\u540E\u8BF7\u5728 CC Switch \u4E2D Activate Trinity",
+    "\u52FF\u518D\u5BF9\u540C\u4E00\u5DE5\u5177\u8DD1 trinity-config --type \u76F4\u8FDE\uFF0C\u4EE5\u514D\u4E92\u76F8\u8986\u76D6",
+    "\u6A21\u578B\u5217\u8868\u4EE5\u8BE5 API Key Call Allowlist \u4E3A\u51C6"
+  ];
+  switch (app) {
+    case "claude":
+      return [
+        ...common,
+        "API Format = Anthropic Messages\uFF08\u9ED8\u8BA4\uFF09",
+        "Endpoint \u4E0D\u5E26 /v1",
+        protocol !== "anthropic_messages" ? `\u8B66\u544A: \u5F53\u524D\u62E9\u4F18\u534F\u8BAE\u4E3A ${protocol}\uFF0CClaude \u69FD\u4ECD\u6309 Messages \u5199\u5165\uFF1B\u82E5\u6A21\u578B\u65E0 Messages \u8BF7\u6362\u6A21\u578B` : ""
+      ].filter(Boolean).join("\uFF1B");
+    case "codex":
+      return [
+        ...common,
+        "wire_api=responses\uFF1B\u8BF7\u5173\u95ED Needs Local Routing\uFF08\u76F4\u8FDE Trinity Responses\uFF09",
+        "Endpoint \u586B\u5E26 /v1 \u7684\u524D\u7F00\uFF0C\u907F\u514D\u5199\u6210 \u2026/v1/v1"
+      ].join("\uFF1B");
+    case "opencode":
+      return [...common, `\u534F\u8BAE: ${protocol}`].join("\uFF1B");
+    case "openclaw":
+      return [...common, `\u534F\u8BAE: ${protocol}`, "\u6539\u5B8C\u8BF7\u91CD\u542F OpenClaw Gateway"].join("\uFF1B");
+    case "gemini":
+      return "\u4E0D\u652F\u6301";
+  }
+}
+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 notes = notesForCcSwitchApp(options.app, options.protocol);
+  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("notes", notes);
+  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,
+    notes,
+    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) {
+  const platform = process.platform;
+  if (platform === "win32") {
+    await execa("cmd", ["/c", "start", "", url], {
+      windowsHide: true,
+      reject: false
+    });
+    return;
+  }
+  if (platform === "darwin") {
+    await execa("open", [url], { reject: false });
+    return;
+  }
+  await execa("xdg-open", [url], { reject: false });
+}
+
+// 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);
@@ -195,8 +540,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");
 }
 
@@ -362,7 +707,7 @@ function protocolLabel(protocol) {
 }
 
 // src/zcf.ts
-import { execa } from "execa";
+import { execa as execa2 } from "execa";
 function sharedZcfArgs(verbose) {
   return [
     "zcf",
@@ -401,7 +746,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
@@ -422,7 +767,7 @@ async function configureCodex(apiKey, codexBaseUrl, codexModel, _verbose) {
   return configureCodexDirect(apiKey, codexBaseUrl, codexModel);
 }
 async function configureOpenCode(apiKey, openCodeBaseUrl, model, modelIds, protocol) {
-  const { configureOpenCodeDirect } = await import("./merge-opencode-config-XGIZYPOW.js");
+  const { configureOpenCodeDirect } = await import("./merge-opencode-config-JTWAGCET.js");
   return configureOpenCodeDirect({
     apiKey,
     baseUrl: openCodeBaseUrl,
@@ -432,7 +777,7 @@ async function configureOpenCode(apiKey, openCodeBaseUrl, model, modelIds, proto
   });
 }
 async function configureOpenClaw(apiKey, openClawBaseUrl, model, modelIds, protocol) {
-  const { configureOpenClawDirect } = await import("./merge-openclaw-config-KMG3FYK6.js");
+  const { configureOpenClawDirect } = await import("./merge-openclaw-config-F77TZKPG.js");
   return configureOpenClawDirect({
     apiKey,
     baseUrl: openClawBaseUrl,
@@ -442,7 +787,7 @@ async function configureOpenClaw(apiKey, openClawBaseUrl, model, modelIds, proto
   });
 }
 async function configureZCode(apiKey, zcodeBaseUrl, model, modelIds, protocol) {
-  const { configureZCodeDirect } = await import("./merge-zcode-config-PTPY6RXN.js");
+  const { configureZCodeDirect } = await import("./merge-zcode-config-LGTBU4UC.js");
   return configureZCodeDirect({
     apiKey,
     baseUrl: zcodeBaseUrl,
@@ -532,7 +877,7 @@ async function verifyTrinityApi(apiKey, baseUrl = TRINITY_BASE_URL) {
     return {
       ok: true,
       statusCode,
-      message: `\u8FDE\u901A\u6210\u529F\uFF08${modelIds.length} \u4E2A\u751F\u6587\u6A21\u578B\uFF09`,
+      message: `\u8FDE\u901A\u6210\u529F\uFF08\u8BE5 Key \u53EF\u7528\u751F\u6587\u6A21\u578B ${modelIds.length} \u4E2A\uFF09`,
       modelIds
     };
   } catch (error) {
@@ -577,11 +922,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)) {
@@ -590,13 +936,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) => {
@@ -609,8 +973,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":
@@ -623,6 +987,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 {
@@ -641,38 +1012,192 @@ 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);
-  const 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);
     if (result.ok) {
       spinner2.stop(pc.green(result.message));
-      verifiedModelIds = result.modelIds;
-      const recommended = pickRecommendedModels(result.modelIds ?? []);
-      const hint = recommendedHint(toolType, recommended);
-      if (hint && hint !== model) {
+      verifiedModelIds = result.modelIds ?? [];
+      if (verifiedModelIds.length === 0) {
+        p.outro(pc.red("\u8BE5 API Key \u6CA1\u6709\u53EF\u7528\u7684\u751F\u6587\u6A21\u578B\uFF08Call Allowlist \u4E3A\u7A7A\uFF09"));
+        return 1;
+      }
+      const recommended = pickRecommendedModels(verifiedModelIds);
+      const hint = recommendedHint(protocolToolHint, recommended);
+      const allowed = pickAllowedDefaultModel(model, verifiedModelIds, [
+        hint,
+        recommended.claude,
+        recommended.codex,
+        recommended.opencode,
+        recommended.openclaw,
+        recommended.zcode,
+        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"));
+        return 1;
+      }
+      if (allowed !== model) {
+        p.note(
+          `\u6A21\u578B ${model} \u4E0D\u5728\u8BE5 Key \u53EF\u7528\u5217\u8868\u4E2D\uFF0C\u5DF2\u6539\u4E3A ${allowed}\uFF08\u5171 ${verifiedModelIds.length} \u4E2A\u53EF\u7528\u751F\u6587\u6A21\u578B\uFF09`,
+          "\u6743\u9650"
+        );
+        model = allowed;
+      } else if (hint && hint !== model) {
         p.note(`\u540C\u7C7B\u578B\u63A8\u8350\u6A21\u578B: ${hint}`, "\u6A21\u578B");
       }
     } else {
       verifyFailed = true;
       spinner2.stop(pc.yellow(result.message));
       p.note(
-        "\u8FDE\u901A\u6027\u68C0\u67E5\u672A\u901A\u8FC7\uFF1B\u4ECD\u5C06\u5C1D\u8BD5\u5199\u5165\u672C\u5730\u914D\u7F6E\u3002\u8BF7\u68C0\u67E5 API Key\u3001\u7F51\u7EDC\uFF0C\u6216\u5728\u63A7\u5236\u53F0\u786E\u8BA4 Key \u6709\u6548\u3002",
+        "\u8FDE\u901A\u6027\u68C0\u67E5\u672A\u901A\u8FC7\uFF1B\u4ECD\u5C06\u5C1D\u8BD5\u5199\u5165\u672C\u5730\u914D\u7F6E\uFF08\u4E0D\u4F1A\u540C\u6B65\u6A21\u578B\u5217\u8868\uFF09\u3002\u8BF7\u68C0\u67E5 API Key\u3001\u7F51\u7EDC\uFF0C\u6216\u5728\u63A7\u5236\u53F0\u786E\u8BA4 Key \u6709\u6548\u3002",
         "\u63D0\u793A"
       );
     }
+  } else {
+    p.note(
+      "--skip-verify \u5DF2\u8DF3\u8FC7\uFF1A\u65E0\u6CD5\u6309 Key \u6743\u76CA\u62C9\u53D6\u53EF\u7528\u6A21\u578B\u5217\u8868\uFF0C\u4EC5\u5199\u5165\u6307\u5B9A\u9ED8\u8BA4\u6A21\u578B\u3002",
+      "\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.note(link.notes, `${app} \u6CE8\u610F`);
+        p.log.info(`Deep Link \u5DF2\u4FDD\u5B58: ${files.txtFile}`);
+        if (link.url.length > 2e3) {
+          p.note(
+            "Deep Link \u8F83\u957F\uFF0C\u82E5\u7CFB\u7EDF\u65E0\u6CD5\u5524\u8D77\uFF0C\u8BF7\u53CC\u51FB\u843D\u76D8\u7684 .url \u6587\u4EF6\u5BFC\u5165",
+            "\u63D0\u793A"
+          );
+        }
+        if (!opts.printOnly) {
+          await openCcSwitchDeepLink(link.url);
+          p.log.info("\u5DF2\u5C1D\u8BD5\u5524\u8D77 CC Switch \u5BFC\u5165\u5BF9\u8BDD\u6846\uFF08\u82E5\u672A\u5F39\u51FA\u8BF7\u53CC\u51FB .url \u6587\u4EF6\uFF09");
+        } else {
+          p.log.info(link.url);
+        }
+      } 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("\u914D\u7F6E\u5B8C\u6210\uFF08\u9A8C\u8BC1\u672A\u901A\u8FC7\uFF09"));
+      return 1;
+    }
+    p.note(
+      [
+        "\u5728 CC Switch \u5BFC\u5165\u786E\u8BA4\u6846\u4E2D\u6838\u5BF9\u540E Confirm",
+        "\u5207\u6362\u5230\u5BF9\u5E94 App \u9875\u7B7E\uFF0CActivate\u300CTrinity\u300D",
+        `\u843D\u76D8\u6587\u4EF6: ${saved.join(" | ")}`,
+        opts.printOnly ? "\u5DF2 --print-only\uFF0C\u672A\u81EA\u52A8\u6253\u5F00\u5E94\u7528" : "\u82E5\u672A\u5F39\u7A97\uFF1A\u53CC\u51FB\u4E0A\u8FF0 .url\uFF0C\u6216\u68C0\u67E5 ccswitch:// \u534F\u8BAE\u6CE8\u518C"
+      ].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/dist/{merge-openclaw-config-KMG3FYK6.js → merge-openclaw-config-F77TZKPG.js}

@@ -1,6 +1,6 @@
 import {
   filterTextModelIds
-} from "./chunk-QS4QYSMM.js";
+} from "./chunk-5WZW5Y4W.js";
 
 // src/merge-openclaw-config.ts
 import fs from "fs";
@@ -71,22 +71,13 @@ function mergeOpenClawConfig(options) {
   modelsBlock.mode = modelsBlock.mode ?? "merge";
   const providers = modelsBlock.providers && typeof modelsBlock.providers === "object" ? { ...modelsBlock.providers } : {};
   const existing = providers[TRINITY_OPENCLAW_PROVIDER] ?? {};
-  const existingModels = Array.isArray(existing.models) ? existing.models : [];
-  const byId = /* @__PURE__ */ new Map();
-  for (const m of existingModels) {
-    if (m && typeof m === "object" && typeof m.id === "string") {
-      byId.set(m.id, m);
-    }
-  }
-  for (const m of buildModelEntries(options.model, options.modelIds)) {
-    byId.set(m.id, { ...byId.get(m.id), ...m });
-  }
+  const nextModels = buildModelEntries(options.model, options.modelIds);
   providers[TRINITY_OPENCLAW_PROVIDER] = {
     ...existing,
     baseUrl: options.baseUrl.replace(/\/+$/, ""),
     apiKey: options.apiKey,
     api,
-    models: [...byId.values()]
+    models: nextModels
   };
   modelsBlock.providers = providers;
   doc.models = modelsBlock;

package/dist/{merge-opencode-config-XGIZYPOW.js → merge-opencode-config-JTWAGCET.js}

@@ -1,6 +1,6 @@
 import {
   filterTextModelIds
-} from "./chunk-QS4QYSMM.js";
+} from "./chunk-5WZW5Y4W.js";
 
 // src/merge-opencode-config.ts
 import fs from "fs";
@@ -65,7 +65,7 @@ function mergeOpenCodeConfig(options) {
   doc.model = `${TRINITY_OPENCODE_PROVIDER}/${options.model}`;
   const providers = doc.provider && typeof doc.provider === "object" ? { ...doc.provider } : {};
   const existing = providers[TRINITY_OPENCODE_PROVIDER] ?? {};
-  const existingModels = existing.models && typeof existing.models === "object" ? existing.models : {};
+  const nextModels = buildModelMap(options.model, options.modelIds);
   providers[TRINITY_OPENCODE_PROVIDER] = {
     ...existing,
     npm,
@@ -75,10 +75,7 @@ function mergeOpenCodeConfig(options) {
       baseURL: options.baseUrl.replace(/\/+$/, ""),
       apiKey: options.apiKey
     },
-    models: {
-      ...existingModels,
-      ...buildModelMap(options.model, options.modelIds)
-    }
+    models: nextModels
   };
   doc.provider = providers;
   fs.mkdirSync(path.dirname(configPath), { recursive: true });

package/dist/{merge-zcode-config-PTPY6RXN.js → merge-zcode-config-LGTBU4UC.js}

@@ -1,6 +1,6 @@
 import {
   filterTextModelIds
-} from "./chunk-QS4QYSMM.js";
+} from "./chunk-5WZW5Y4W.js";
 
 // src/merge-zcode-config.ts
 import fs from "fs";
@@ -108,17 +108,13 @@ function mergeZCodeConfig(options) {
     }
   }
   const existing = providers[TRINITY_ZCODE_PROVIDER] ?? {};
-  const existingModels = existing.models && typeof existing.models === "object" ? existing.models : {};
   const root = options.baseUrl.replace(/\/v1\/?$/, "").replace(/\/+$/, "");
   const withV1 = `${root}/v1`;
   const withoutV1 = root;
   const binding = zcodeProtocolBinding(options.protocol);
   const primaryBase = options.protocol === "anthropic_messages" ? withoutV1 : withV1;
   const now = Date.now();
-  const models = {
-    ...existingModels,
-    ...buildModels(options.model, options.modelIds, binding)
-  };
+  const models = buildModels(options.model, options.modelIds, binding);
   providers[TRINITY_ZCODE_PROVIDER] = {
     ...existing,
     enabled: true,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "trinity-config",
-  "version": "1.2.4",
-  "description": "一键把 Trinity API 接入 Claude Code、Codex、OpenCode、OpenClaw、ZCode",
+  "version": "1.3.0",
+  "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"

package/dist/chunk-QS4QYSMM.js

@@ -1,26 +0,0 @@
-// src/text-models.ts
-function isLikelyNonTextModel(id) {
-  const lower = id.toLowerCase();
-  return lower.includes("image") || lower.includes("video") || lower.includes("seedance") || lower.includes("wan-") || lower.includes("kling") || lower.includes("og-image") || lower.includes("midjourney") || lower.includes("flux");
-}
-function filterTextModelIds(primaryModel, modelIds, limit = 80) {
-  const ids = [];
-  const seen = /* @__PURE__ */ new Set();
-  const push = (raw) => {
-    const trimmed = raw?.trim();
-    if (!trimmed || seen.has(trimmed)) return;
-    if (ids.length > 0 && isLikelyNonTextModel(trimmed)) return;
-    seen.add(trimmed);
-    ids.push(trimmed);
-  };
-  push(primaryModel);
-  for (const id of modelIds ?? []) {
-    if (ids.length >= limit) break;
-    push(id);
-  }
-  return ids;
-}
-
-export {
-  filterTextModelIds
-};