trinity-config 1.1.0 → 1.2.1

package/README.md

@@ -1,56 +1,24 @@
 # trinity-config
 
-> 一键把 [Trinity API](https://trinitydesk.ai) 接入 **Claude Code** 或 **Codex CLI** —— 指定工具类型 + 粘贴 `xh-` Key 即用
+> 一键把 [Trinity API](https://trinitydesk.ai) 接入 **Claude Code** / **Codex CLI** / **OpenCode** / **OpenClaw**
 
 ## 快速开始
 
-### 交互式
-
 ```bash
-npx -y trinity-config
-```
-
-按提示选择 **工具类型**、粘贴 Key、确认 **model_code**。
-
-### 一行命令（推荐）
-
-```bash
-# Claude Code
 npx -y trinity-config --type claude -k xh-你的key
-
-# Codex CLI
 npx -y trinity-config --type codex -k xh-你的key --model gpt-5.4
+npx -y trinity-config --type opencode -k xh-你的key --model gpt-5.4
+npx -y trinity-config --type openclaw -k xh-你的key --model gpt-5.4
 ```
 
-每次只配置 **一个** 工具；两个都要用时各执行一次。
-
-## 命令行参数
-
-| 参数 | 简写 | 说明 |
-| --- | --- | --- |
-| `--type` | `-t` | **必填（非交互）**：`claude` \| `codex` |
-| `--api-key` | `-k` | Trinity API Key |
-| `--model` | `-M` | 默认 model_code（省略则按 type 内置推荐） |
-| `--base-url` | | 默认 `https://api.trinitydesk.ai` |
-| `--skip-verify` | | 跳过连通性验证 |
-| `--verbose` | `-v` | 显示 zcf 详细输出 |
-
-### 按 type 的默认模型
-
-| `--type` | 默认 `--model` |
-| --- | --- |
-| `claude` | `claude-sonnet-4-6` |
-| `codex` | `gpt-5.4` |
-
-## 扩展新工具
-
-后续增加 Cursor、OpenCode 等时，只需新增 `type` 枚举与对应写入逻辑，**不再**为每个工具增加 `--xxx-model` 参数。
-
-## 注意
+| `--type` | 默认模型 | 接口 | 写入 |
+| --- | --- | --- | --- |
+| `claude` | `claude-sonnet-4-6` | `/v1/messages` | `~/.claude/settings.json` |
+| `codex` | `gpt-5.4` | `/v1/responses` | `~/.codex/config.toml` + `auth.json` |
+| `opencode` | `gpt-5.4` | `/v1/chat/completions` | `~/.config/opencode/opencode.json` |
+| `openclaw` | `gpt-5.4` | `/v1/chat/completions` | `~/.openclaw/openclaw.json` |
 
-- 配置后**所有模型调用走 Trinity 计费**。
-- 非交互模式必须同时提供 `--type` 与 `-k`。
-- Codex 侧 zcf 写入仍可能有已知限制，见设计文档。
+OpenClaw 改完后请重启 Gateway（或重新 `openclaw dashboard`）。
 
 ## License
 

package/dist/index.js

@@ -5,52 +5,86 @@ import pc from "picocolors";
 
 // src/constants.ts
 var PACKAGE_NAME = "trinity-config";
-var PACKAGE_VERSION = "1.1.0";
+var PACKAGE_VERSION = "1.2.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";
 var DEFAULT_CODEX_MODEL = "gpt-5.4";
+var DEFAULT_OPENCODE_MODEL = "gpt-5.4";
+var DEFAULT_OPENCLAW_MODEL = "gpt-5.4";
 var VERIFY_TIMEOUT_MS = 15e3;
 
 // src/model.ts
 function defaultModelForType(type) {
-  return type === "claude" ? DEFAULT_CLAUDE_MODEL : DEFAULT_CODEX_MODEL;
+  switch (type) {
+    case "claude":
+      return DEFAULT_CLAUDE_MODEL;
+    case "codex":
+      return DEFAULT_CODEX_MODEL;
+    case "opencode":
+      return DEFAULT_OPENCODE_MODEL;
+    case "openclaw":
+      return DEFAULT_OPENCLAW_MODEL;
+  }
 }
 function resolveModel(type, model) {
   return model?.trim() || defaultModelForType(type);
 }
 function parseToolType(raw) {
   const value = raw.trim().toLowerCase();
-  if (value === "claude" || value === "codex") {
+  if (value === "claude" || value === "codex" || value === "opencode" || value === "openclaw") {
     return value;
   }
-  throw new Error("--type \u987B\u4E3A claude \u6216 codex");
+  throw new Error("--type \u987B\u4E3A claude\u3001codex\u3001opencode \u6216 openclaw");
 }
 function toolLabel(type) {
-  return type === "claude" ? "Claude Code" : "Codex CLI";
+  switch (type) {
+    case "claude":
+      return "Claude Code";
+    case "codex":
+      return "Codex CLI";
+    case "opencode":
+      return "OpenCode";
+    case "openclaw":
+      return "OpenClaw";
+  }
+}
+function launchCommand(type) {
+  switch (type) {
+    case "claude":
+      return "claude";
+    case "codex":
+      return "codex";
+    case "opencode":
+      return "opencode";
+    case "openclaw":
+      return "openclaw dashboard";
+  }
 }
 
 // src/args.ts
 function printHelp() {
   console.log(`
-trinity-config \u2014 \u4E00\u952E\u628A Trinity API \u63A5\u5165\u7EC8\u7AEF\u7F16\u7A0B\u52A9\u624B
+trinity-config \u2014 \u4E00\u952E\u628A Trinity API \u63A5\u5165\u7EC8\u7AEF\u7F16\u7A0B\u52A9\u624B / Agent \u7F51\u5173
 
 \u7528\u6CD5:
-  npx -y trinity-config --type <claude|codex> [\u9009\u9879]
+  npx -y trinity-config --type <claude|codex|opencode|openclaw> [\u9009\u9879]
 
 \u9009\u9879:
-  -t, --type <claude|codex>  \u8981\u914D\u7F6E\u7684\u5DE5\u5177\uFF08\u975E\u4EA4\u4E92\u987B\u6307\u5B9A\uFF1B\u4EA4\u4E92\u5F0F\u53EF\u7701\u7565\uFF09
-  -k, --api-key <key>        Trinity API Key\uFF08xh- \u524D\u7F00\uFF09
-  -M, --model <model_code>   \u9ED8\u8BA4\u6A21\u578B\uFF08\u7701\u7565\u5219\u6309 type \u4F7F\u7528\u5185\u7F6E\u63A8\u8350\uFF09
-  --base-url <url>           API \u6839\u5730\u5740\uFF08\u9ED8\u8BA4 https://api.trinitydesk.ai\uFF09
-  --skip-verify              \u8DF3\u8FC7 GET /v1/models \u8FDE\u901A\u6027\u68C0\u67E5
-  -v, --verbose              \u663E\u793A zcf \u8BE6\u7EC6\u8F93\u51FA
-  -h, --help                 \u663E\u793A\u5E2E\u52A9
-  -V, --version              \u663E\u793A\u7248\u672C
+  -t, --type <claude|codex|opencode|openclaw>  \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 <model_code>                     \u9ED8\u8BA4\u6A21\u578B\uFF08\u7701\u7565\u5219\u6309 type \u63A8\u8350\uFF09
+  --base-url <url>                             API \u6839\u5730\u5740\uFF08\u9ED8\u8BA4 https://api.trinitydesk.ai\uFF09
+  --skip-verify                                \u8DF3\u8FC7 GET /v1/models \u8FDE\u901A\u6027\u68C0\u67E5
+  -v, --verbose                                \u663E\u793A zcf \u8BE6\u7EC6\u8F93\u51FA\uFF08\u4EC5 Claude\uFF09
+  -h, --help                                   \u663E\u793A\u5E2E\u52A9
+  -V, --version                                \u663E\u793A\u7248\u672C
 
 \u793A\u4F8B:
   npx -y trinity-config --type claude -k xh-your-key
   npx -y trinity-config --type codex -k xh-your-key --model gpt-5.4
+  npx -y trinity-config --type opencode -k xh-your-key --model gpt-5.4
+  npx -y trinity-config --type openclaw -k xh-your-key --model gpt-5.4
   npx -y trinity-config
 `);
 }
@@ -98,7 +132,7 @@ function parseArgs(argv) {
         break;
       case "--only": {
         const legacy = args.shift();
-        console.warn("\u8B66\u544A: --only \u5DF2\u5E9F\u5F03\uFF0C\u8BF7\u6539\u7528 --type claude \u6216 --type codex");
+        console.warn("\u8B66\u544A: --only \u5DF2\u5E9F\u5F03\uFF0C\u8BF7\u6539\u7528 --type");
         opts.type = parseToolType(String(legacy ?? ""));
         break;
       }
@@ -129,7 +163,7 @@ 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 \u6216 --type codex");
+  throw new Error("\u975E\u4EA4\u4E92\u6A21\u5F0F\u987B\u6307\u5B9A --type claude\u3001codex\u3001opencode \u6216 openclaw");
 }
 
 // src/merge-claude-env.ts
@@ -218,14 +252,9 @@ async function configureClaude(apiKey, baseUrl, claudeModel, verbose) {
     verbose
   });
 }
-async function configureCodex(apiKey, codexBaseUrl, codexModel, verbose) {
-  await runZcfInit({
-    codeType: "cx",
-    apiKey,
-    baseUrl: codexBaseUrl,
-    primaryModel: codexModel,
-    verbose
-  });
+async function configureCodex(apiKey, codexBaseUrl, codexModel, _verbose) {
+  const { configureCodexDirect } = await import("./merge-codex-config-GC7ZDP7R.js");
+  return configureCodexDirect(apiKey, codexBaseUrl, codexModel);
 }
 function resolveBaseUrls(baseUrl) {
   const root = (baseUrl ?? TRINITY_BASE_URL).replace(/\/+$/, "");
@@ -237,6 +266,24 @@ function baseUrlForType(type, baseUrl) {
   const { claudeBaseUrl, codexBaseUrl } = resolveBaseUrls(baseUrl);
   return type === "claude" ? claudeBaseUrl : codexBaseUrl;
 }
+async function configureOpenCode(apiKey, openCodeBaseUrl, model, modelIds) {
+  const { configureOpenCodeDirect } = await import("./merge-opencode-config-P4QJ63DF.js");
+  return configureOpenCodeDirect({
+    apiKey,
+    baseUrl: openCodeBaseUrl,
+    model,
+    modelIds
+  });
+}
+async function configureOpenClaw(apiKey, openClawBaseUrl, model, modelIds) {
+  const { configureOpenClawDirect } = await import("./merge-openclaw-config-XV25MSSC.js");
+  return configureOpenClawDirect({
+    apiKey,
+    baseUrl: openClawBaseUrl,
+    model,
+    modelIds
+  });
+}
 
 // src/verify.ts
 import https from "https";
@@ -332,7 +379,9 @@ async function verifyTrinityApi(apiKey, baseUrl = TRINITY_BASE_URL) {
 function pickRecommendedModels(modelIds) {
   const claude = modelIds.find((id) => id === DEFAULT_CLAUDE_MODEL) ?? modelIds.find((id) => id.includes("claude-sonnet")) ?? modelIds.find((id) => id.toLowerCase().includes("claude"));
   const codex = modelIds.find((id) => id === DEFAULT_CODEX_MODEL) ?? modelIds.find((id) => id === "gpt-5.4") ?? modelIds.find((id) => id.startsWith("gpt-5")) ?? modelIds.find((id) => id.toLowerCase().includes("gpt"));
-  return { claude, codex };
+  const opencode = modelIds.find((id) => id === DEFAULT_OPENCODE_MODEL) ?? codex ?? modelIds.find((id) => id.toLowerCase().includes("qwen"));
+  const openclaw = modelIds.find((id) => id === DEFAULT_OPENCLAW_MODEL) ?? opencode ?? codex;
+  return { claude, codex, opencode, openclaw };
 }
 
 // src/index.ts
@@ -361,7 +410,9 @@ async function promptToolType(initial) {
     message: "\u8981\u914D\u7F6E\u54EA\u4E2A\u5DE5\u5177\uFF1F",
     options: [
       { value: "claude", label: "Claude Code\uFF08/v1/messages\uFF09" },
-      { value: "codex", label: "Codex CLI\uFF08/v1/responses\uFF09" }
+      { value: "codex", label: "Codex CLI\uFF08/v1/responses\uFF09" },
+      { value: "opencode", label: "OpenCode\uFF08/v1/chat/completions\uFF09" },
+      { value: "openclaw", label: "OpenClaw\uFF08/v1/chat/completions\uFF09" }
     ]
   });
   if (p.isCancel(value)) {
@@ -389,6 +440,18 @@ async function promptModel(type, initial) {
   }
   return String(value).trim();
 }
+function recommendedHint(toolType, recommended) {
+  switch (toolType) {
+    case "claude":
+      return recommended.claude;
+    case "codex":
+      return recommended.codex;
+    case "opencode":
+      return recommended.opencode;
+    case "openclaw":
+      return recommended.openclaw;
+  }
+}
 async function run() {
   let opts;
   try {
@@ -413,6 +476,26 @@ async function run() {
   const { claudeBaseUrl } = resolveBaseUrls(opts.baseUrl);
   p.log.info(`\u5DE5\u5177: ${toolLabel(toolType)} \xB7 \u6A21\u578B: ${model}`);
   const spinner2 = p.spinner();
+  let verifiedModelIds;
+  if (!opts.skipVerify) {
+    spinner2.start("\u9A8C\u8BC1 Trinity API \u8FDE\u901A\u6027\u2026");
+    const result = await verifyTrinityApi(apiKey, claudeBaseUrl);
+    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) {
+        p.note(`\u540C\u7C7B\u578B\u63A8\u8350\u6A21\u578B: ${hint}`, "\u6A21\u578B");
+      }
+    } else {
+      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",
+        "\u63D0\u793A"
+      );
+    }
+  }
   if (toolType === "claude") {
     spinner2.start("\u914D\u7F6E Claude Code\u2026");
     try {
@@ -421,53 +504,80 @@ async function run() {
       spinner2.stop("Claude Code \u914D\u7F6E\u5DF2\u5199\u5165 ~/.claude/settings.json");
     } catch (error) {
       spinner2.stop(pc.red("Claude Code \u914D\u7F6E\u5931\u8D25"));
-      console.error(formatZcfError(error));
+      console.error(formatConfigError(error));
       return 1;
     }
-  } else {
+  } else if (toolType === "codex") {
     spinner2.start("\u914D\u7F6E Codex CLI\u2026");
     try {
-      await configureCodex(apiKey, apiBaseUrl, model, opts.verbose);
-      spinner2.stop("Codex \u914D\u7F6E\u5DF2\u5199\u5165 ~/.codex/");
+      const backupDir = await configureCodex(apiKey, apiBaseUrl, model, opts.verbose);
+      const backupHint = backupDir ? `
+\u5907\u4EFD: ${backupDir}` : "";
+      spinner2.stop(`Codex \u914D\u7F6E\u5DF2\u5199\u5165 ~/.codex/config.toml \u4E0E auth.json${backupHint}`);
     } catch (error) {
       spinner2.stop(pc.red("Codex \u914D\u7F6E\u5931\u8D25"));
-      console.error(formatZcfError(error));
+      console.error(formatConfigError(error));
       return 1;
     }
-  }
-  if (!opts.skipVerify) {
-    spinner2.start("\u9A8C\u8BC1 Trinity API \u8FDE\u901A\u6027\u2026");
-    const result = await verifyTrinityApi(apiKey, claudeBaseUrl);
-    if (result.ok) {
-      spinner2.stop(pc.green(result.message));
-      const recommended = pickRecommendedModels(result.modelIds ?? []);
-      const hint = toolType === "claude" ? recommended.claude : recommended.codex;
-      if (hint && hint !== model) {
-        p.note(`\u540C\u7C7B\u578B\u63A8\u8350\u6A21\u578B: ${hint}`, "\u6A21\u578B");
-      }
-    } else {
-      spinner2.stop(pc.yellow(result.message));
-      p.note(
-        "\u672C\u5730\u914D\u7F6E\u5DF2\u5199\u5165\uFF0C\u4F46\u8FDE\u901A\u6027\u68C0\u67E5\u672A\u901A\u8FC7\u3002\u8BF7\u68C0\u67E5 API Key\u3001\u7F51\u7EDC\uFF0C\u6216\u5728\u63A7\u5236\u53F0\u786E\u8BA4 Key \u6709\u6548\u3002",
-        "\u63D0\u793A"
+  } else if (toolType === "opencode") {
+    spinner2.start("\u914D\u7F6E OpenCode\u2026");
+    try {
+      const backupDir = await configureOpenCode(
+        apiKey,
+        apiBaseUrl,
+        model,
+        verifiedModelIds
+      );
+      const backupHint = backupDir ? `
+\u5907\u4EFD: ${backupDir}` : "";
+      spinner2.stop(
+        `OpenCode \u914D\u7F6E\u5DF2\u5199\u5165 ~/.config/opencode/opencode.json${backupHint}`
       );
-      p.outro(pc.yellow("\u914D\u7F6E\u5B8C\u6210\uFF08\u9A8C\u8BC1\u672A\u901A\u8FC7\uFF09"));
+    } catch (error) {
+      spinner2.stop(pc.red("OpenCode \u914D\u7F6E\u5931\u8D25"));
+      console.error(formatConfigError(error));
       return 1;
     }
+  } else {
+    spinner2.start("\u914D\u7F6E OpenClaw\u2026");
+    try {
+      const backupDir = await configureOpenClaw(
+        apiKey,
+        apiBaseUrl,
+        model,
+        verifiedModelIds
+      );
+      const backupHint = backupDir ? `
+\u5907\u4EFD: ${backupDir}` : "";
+      spinner2.stop(
+        `OpenClaw \u914D\u7F6E\u5DF2\u5199\u5165 ~/.openclaw/openclaw.json${backupHint}`
+      );
+    } catch (error) {
+      spinner2.stop(pc.red("OpenClaw \u914D\u7F6E\u5931\u8D25"));
+      console.error(formatConfigError(error));
+      return 1;
+    }
+  }
+  if (!opts.skipVerify && verifiedModelIds === void 0) {
+    p.outro(pc.yellow("\u914D\u7F6E\u5B8C\u6210\uFF08\u9A8C\u8BC1\u672A\u901A\u8FC7\uFF09"));
+    return 1;
+  }
+  const nextSteps = [
+    `\u8FD0\u884C ${launchCommand(toolType)} \u542F\u52A8 ${toolLabel(toolType)}`
+  ];
+  if (toolType === "opencode") {
+    nextSteps.push("\u5728 OpenCode \u5185\u7528 /models \u9009\u62E9 trinity/<model_code>");
+  } else if (toolType === "openclaw") {
+    nextSteps.push("\u9ED8\u8BA4\u6A21\u578B\u4E3A trinity/<model_code>\uFF1B\u6539\u5B8C\u914D\u7F6E\u540E\u8BF7\u91CD\u542F Gateway");
+  } else {
+    nextSteps.push("\u5728\u5DE5\u5177\u5185\u7528 /model \u5207\u6362\u4E3A Trinity \u5DF2\u4E0A\u67B6\u7684 model_code");
   }
-  const launchCmd = toolType === "claude" ? "claude" : "codex";
-  p.note(
-    [
-      `\u8FD0\u884C ${launchCmd} \u542F\u52A8 ${toolLabel(toolType)}`,
-      "\u5728\u5DE5\u5177\u5185\u7528 /model \u5207\u6362\u4E3A Trinity \u5DF2\u4E0A\u67B6\u7684 model_code",
-      "\u914D\u7F6E\u540E\u8BF7\u6C42\u8D70 Trinity \u8BA1\u8D39\uFF0C\u4E0D\u518D\u4F7F\u7528 Anthropic/OpenAI \u5B98\u65B9\u989D\u5EA6"
-    ].join("\n"),
-    "\u4E0B\u4E00\u6B65"
-  );
+  nextSteps.push("\u914D\u7F6E\u540E\u8BF7\u6C42\u8D70 Trinity \u8BA1\u8D39\uFF0C\u4E0D\u518D\u4F7F\u7528\u5B98\u65B9\u989D\u5EA6");
+  p.note(nextSteps.join("\n"), "\u4E0B\u4E00\u6B65");
   p.outro(pc.green("\u5B8C\u6210"));
   return 0;
 }
-function formatZcfError(error) {
+function formatConfigError(error) {
   if (error instanceof Error && "timed out" in error) {
     return "zcf \u6267\u884C\u8D85\u65F6\uFF08>3 \u5206\u949F\uFF09\u3002\u8BF7\u68C0\u67E5\u7F51\u7EDC\u6216\u7A0D\u540E\u91CD\u8BD5\u3002";
   }

package/dist/merge-codex-config-GC7ZDP7R.js

@@ -0,0 +1,107 @@
+// src/merge-codex-config.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { parse, stringify } from "smol-toml";
+var TRINITY_CODEX_PROVIDER = "trinity";
+var TRINITY_CODEX_TEMP_ENV_KEY = "TRINITY_API_KEY";
+function codexHome() {
+  return process.env.CODEX_HOME?.trim() || path.join(os.homedir(), ".codex");
+}
+function codexConfigPath() {
+  return path.join(codexHome(), "config.toml");
+}
+function codexAuthPath() {
+  return path.join(codexHome(), "auth.json");
+}
+function timestampLabel() {
+  const now = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}_${pad(now.getHours())}-${pad(now.getMinutes())}-${pad(now.getSeconds())}`;
+}
+function backupCodexFiles() {
+  const home = codexHome();
+  const configPath = codexConfigPath();
+  const authPath = codexAuthPath();
+  if (!fs.existsSync(configPath) && !fs.existsSync(authPath)) {
+    return null;
+  }
+  const backupDir = path.join(home, "backup", `trinity-config-${timestampLabel()}`);
+  fs.mkdirSync(backupDir, { recursive: true });
+  for (const src of [configPath, authPath]) {
+    if (fs.existsSync(src)) {
+      fs.copyFileSync(src, path.join(backupDir, path.basename(src)));
+    }
+  }
+  return backupDir;
+}
+function readCodexConfigDoc() {
+  const configPath = codexConfigPath();
+  if (!fs.existsSync(configPath)) {
+    return {};
+  }
+  const raw = fs.readFileSync(configPath, "utf8");
+  if (!raw.trim()) {
+    return {};
+  }
+  try {
+    return parse(raw);
+  } catch {
+    throw new Error(`\u65E0\u6CD5\u89E3\u6790 ${configPath}\uFF0C\u8BF7\u68C0\u67E5 TOML \u8BED\u6CD5\u540E\u91CD\u8BD5\u3002`);
+  }
+}
+function buildTrinityProvider(baseUrl) {
+  return {
+    name: "Trinity API",
+    base_url: baseUrl.replace(/\/+$/, ""),
+    wire_api: "responses",
+    temp_env_key: TRINITY_CODEX_TEMP_ENV_KEY,
+    requires_openai_auth: false
+  };
+}
+function mergeCodexConfig(model, baseUrl) {
+  const configPath = codexConfigPath();
+  const doc = readCodexConfigDoc();
+  doc.model = model;
+  doc.model_provider = TRINITY_CODEX_PROVIDER;
+  doc.disable_response_storage = true;
+  const providers = doc.model_providers && typeof doc.model_providers === "object" ? { ...doc.model_providers } : {};
+  providers[TRINITY_CODEX_PROVIDER] = buildTrinityProvider(baseUrl);
+  doc.model_providers = providers;
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, `${stringify(doc)}
+`, "utf8");
+}
+function mergeCodexAuth(apiKey) {
+  const authPath = codexAuthPath();
+  let auth = {};
+  if (fs.existsSync(authPath)) {
+    try {
+      auth = JSON.parse(fs.readFileSync(authPath, "utf8"));
+    } catch {
+      auth = {};
+    }
+  }
+  auth[TRINITY_CODEX_TEMP_ENV_KEY] = apiKey;
+  auth.OPENAI_API_KEY = apiKey;
+  fs.mkdirSync(path.dirname(authPath), { recursive: true });
+  fs.writeFileSync(authPath, `${JSON.stringify(auth, null, 2)}
+`, "utf8");
+}
+function configureCodexDirect(apiKey, codexBaseUrl, model) {
+  const backupDir = backupCodexFiles();
+  mergeCodexConfig(model, codexBaseUrl);
+  mergeCodexAuth(apiKey);
+  return backupDir;
+}
+export {
+  TRINITY_CODEX_PROVIDER,
+  TRINITY_CODEX_TEMP_ENV_KEY,
+  backupCodexFiles,
+  codexAuthPath,
+  codexConfigPath,
+  codexHome,
+  configureCodexDirect,
+  mergeCodexAuth,
+  mergeCodexConfig
+};

package/dist/merge-openclaw-config-XV25MSSC.js

@@ -0,0 +1,126 @@
+// src/merge-openclaw-config.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+var TRINITY_OPENCLAW_PROVIDER = "trinity";
+function openclawHome() {
+  if (process.env.OPENCLAW_HOME?.trim()) {
+    return process.env.OPENCLAW_HOME.trim();
+  }
+  return path.join(os.homedir(), ".openclaw");
+}
+function openclawConfigPath() {
+  if (process.env.OPENCLAW_CONFIG?.trim()) {
+    return process.env.OPENCLAW_CONFIG.trim();
+  }
+  return path.join(openclawHome(), "openclaw.json");
+}
+function timestampLabel() {
+  const now = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}_${pad(now.getHours())}-${pad(now.getMinutes())}-${pad(now.getSeconds())}`;
+}
+function backupOpenClawConfig() {
+  const configPath = openclawConfigPath();
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+  const backupDir = path.join(openclawHome(), "backup", `trinity-config-${timestampLabel()}`);
+  fs.mkdirSync(backupDir, { recursive: true });
+  fs.copyFileSync(configPath, path.join(backupDir, path.basename(configPath)));
+  return backupDir;
+}
+function readOpenClawConfig() {
+  const configPath = openclawConfigPath();
+  if (!fs.existsSync(configPath)) {
+    return {};
+  }
+  const raw = fs.readFileSync(configPath, "utf8");
+  if (!raw.trim()) {
+    return {};
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error(
+      `\u65E0\u6CD5\u89E3\u6790 ${configPath}\u3002\u82E5\u6587\u4EF6\u4E3A JSON5\uFF0C\u8BF7\u5148\u6539\u4E3A\u6807\u51C6 JSON\uFF0C\u6216\u5907\u4EFD\u540E\u5220\u9664\u518D\u91CD\u8DD1\u3002`
+    );
+  }
+}
+function isLikelyNonTextModel(id) {
+  const lower = id.toLowerCase();
+  return lower.includes("image") || lower.includes("video") || lower.includes("seedance") || lower.includes("wan-") || lower.includes("kling");
+}
+function buildModelEntries(primaryModel, modelIds) {
+  const ids = [primaryModel];
+  const seen = new Set(ids);
+  for (const id of modelIds ?? []) {
+    const trimmed = id?.trim();
+    if (!trimmed || seen.has(trimmed) || isLikelyNonTextModel(trimmed)) continue;
+    seen.add(trimmed);
+    ids.push(trimmed);
+    if (ids.length >= 80) break;
+  }
+  return ids.map((id) => ({
+    id,
+    name: id,
+    reasoning: false,
+    input: ["text"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 128e3,
+    maxTokens: 8192
+  }));
+}
+function mergeOpenClawConfig(options) {
+  const configPath = openclawConfigPath();
+  const doc = readOpenClawConfig();
+  const modelsBlock = doc.models && typeof doc.models === "object" ? { ...doc.models } : {};
+  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 });
+  }
+  providers[TRINITY_OPENCLAW_PROVIDER] = {
+    ...existing,
+    baseUrl: options.baseUrl.replace(/\/+$/, ""),
+    apiKey: options.apiKey,
+    api: "openai-completions",
+    models: [...byId.values()]
+  };
+  modelsBlock.providers = providers;
+  doc.models = modelsBlock;
+  const agents = doc.agents && typeof doc.agents === "object" ? { ...doc.agents } : {};
+  const defaults = agents.defaults && typeof agents.defaults === "object" ? { ...agents.defaults } : {};
+  const modelCfg = defaults.model && typeof defaults.model === "object" ? { ...defaults.model } : {};
+  modelCfg.primary = `${TRINITY_OPENCLAW_PROVIDER}/${options.model}`;
+  defaults.model = modelCfg;
+  const allow = defaults.models && typeof defaults.models === "object" ? { ...defaults.models } : {};
+  allow[`${TRINITY_OPENCLAW_PROVIDER}/*`] = allow[`${TRINITY_OPENCLAW_PROVIDER}/*`] ?? {};
+  defaults.models = allow;
+  agents.defaults = defaults;
+  doc.agents = agents;
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, `${JSON.stringify(doc, null, 2)}
+`, "utf8");
+}
+function configureOpenClawDirect(options) {
+  const backupDir = backupOpenClawConfig();
+  mergeOpenClawConfig(options);
+  return backupDir;
+}
+export {
+  TRINITY_OPENCLAW_PROVIDER,
+  backupOpenClawConfig,
+  configureOpenClawDirect,
+  mergeOpenClawConfig,
+  openclawConfigPath,
+  openclawHome
+};

package/dist/merge-opencode-config-P4QJ63DF.js

@@ -0,0 +1,107 @@
+// src/merge-opencode-config.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+var TRINITY_OPENCODE_PROVIDER = "trinity";
+function opencodeConfigDir() {
+  if (process.env.OPENCODE_CONFIG_DIR?.trim()) {
+    return process.env.OPENCODE_CONFIG_DIR.trim();
+  }
+  return path.join(os.homedir(), ".config", "opencode");
+}
+function opencodeConfigPath() {
+  if (process.env.OPENCODE_CONFIG?.trim()) {
+    return process.env.OPENCODE_CONFIG.trim();
+  }
+  return path.join(opencodeConfigDir(), "opencode.json");
+}
+function timestampLabel() {
+  const now = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}_${pad(now.getHours())}-${pad(now.getMinutes())}-${pad(now.getSeconds())}`;
+}
+function backupOpenCodeConfig() {
+  const configPath = opencodeConfigPath();
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+  const backupDir = path.join(opencodeConfigDir(), "backup", `trinity-config-${timestampLabel()}`);
+  fs.mkdirSync(backupDir, { recursive: true });
+  fs.copyFileSync(configPath, path.join(backupDir, path.basename(configPath)));
+  return backupDir;
+}
+function readOpenCodeConfig() {
+  const configPath = opencodeConfigPath();
+  if (!fs.existsSync(configPath)) {
+    return {};
+  }
+  const raw = fs.readFileSync(configPath, "utf8");
+  if (!raw.trim()) {
+    return {};
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error(`\u65E0\u6CD5\u89E3\u6790 ${configPath}\uFF0C\u8BF7\u68C0\u67E5 JSON \u8BED\u6CD5\u540E\u91CD\u8BD5\u3002`);
+  }
+}
+function buildModelMap(primaryModel, modelIds) {
+  const ids = [primaryModel];
+  const seen = new Set(ids);
+  for (const id of modelIds ?? []) {
+    const trimmed = id?.trim();
+    if (!trimmed || seen.has(trimmed)) continue;
+    const lower = trimmed.toLowerCase();
+    if (lower.includes("image") || lower.includes("video") || lower.includes("seedance") || lower.includes("wan-") || lower.includes("kling")) {
+      continue;
+    }
+    seen.add(trimmed);
+    ids.push(trimmed);
+    if (ids.length >= 80) break;
+  }
+  const models = {};
+  for (const id of ids) {
+    models[id] = { name: id };
+  }
+  return models;
+}
+function mergeOpenCodeConfig(options) {
+  const configPath = opencodeConfigPath();
+  const doc = readOpenCodeConfig();
+  doc.$schema = doc.$schema ?? "https://opencode.ai/config.json";
+  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 : {};
+  providers[TRINITY_OPENCODE_PROVIDER] = {
+    ...existing,
+    npm: "@ai-sdk/openai-compatible",
+    name: "Trinity",
+    options: {
+      ...existing.options ?? {},
+      baseURL: options.baseUrl.replace(/\/+$/, ""),
+      apiKey: options.apiKey
+    },
+    models: {
+      ...existingModels,
+      ...buildModelMap(options.model, options.modelIds)
+    }
+  };
+  doc.provider = providers;
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, `${JSON.stringify(doc, null, 2)}
+`, "utf8");
+}
+function configureOpenCodeDirect(options) {
+  const backupDir = backupOpenCodeConfig();
+  mergeOpenCodeConfig(options);
+  return backupDir;
+}
+export {
+  TRINITY_OPENCODE_PROVIDER,
+  backupOpenCodeConfig,
+  configureOpenCodeDirect,
+  mergeOpenCodeConfig,
+  opencodeConfigDir,
+  opencodeConfigPath
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "trinity-config",
-  "version": "1.1.0",
-  "description": "一键把 Trinity API 接入 Claude Code 与 Codex CLI",
+  "version": "1.2.1",
+  "description": "一键把 Trinity API 接入 Claude Code、Codex、OpenCode、OpenClaw",
   "license": "MIT",
   "type": "module",
   "bin": {
@@ -29,6 +29,8 @@
     "trinitydesk",
     "claude-code",
     "codex",
+    "opencode",
+    "openclaw",
     "cli",
     "ai-gateway",
     "zcf"
@@ -42,7 +44,8 @@
   "dependencies": {
     "@clack/prompts": "^0.11.0",
     "execa": "^9.5.2",
-    "picocolors": "^1.1.1"
+    "picocolors": "^1.1.1",
+    "smol-toml": "^1.3.1"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",