@yunzhi519/maas-helper 0.1.1

package/README.md

@@ -0,0 +1,65 @@
+# yunzhi-maas-helper
+
+> **Powered by MiniRelax** · 苏州云养智健人工智能科技有限公司
+
+云智 Token Hub（MaaS）编码工具配置助手。运行不带参数的 `yunzhi-helper`进入交互菜单，完成 API Key 配置与验证（自动调用 `/v1/models`）、模型列表自动获取、OpenCode / Claude Code / Codex 一键配置。
+
+- 平台：云智 Token Hub — https://maas.piteyun.com/
+- OpenAI 兼容端点：`https://maas.piteyun.com/v1`
+- 要求：Node.js >= 18
+
+## 安装
+
+```bash
+# 发布后（暂未发布）
+npm install -g @yunzhi519/maas-helper@latest
+
+# 当前内部阶段：从源码安装
+cd yunzhi-maas-helper
+npm install -g .
+```
+
+## 使用
+
+```bash
+yunzhi-helper              # 交互菜单
+yunzhi-helper --version    # 版本
+yunzhi-helper --help       # 帮助
+```
+```bash
+yunzhi-helper
+```
+
+主菜单：
+
+1. **输入/配置 API Key** — 隐藏输入，调用 `GET /v1/models` 实时验证
+2. **配置编码工具** — 两个工具的管理菜单：
+   - **OpenCode**：配置模型（主模型/小模型，列表自动获取）、刷新模型列表、配置装载/配置刷新
+   - **Claude Code**：配置模型（Haiku/Sonnet/Opus/Fable 四角色）、配置装载/配置刷新、清除网关配置（恢复官方登录）
+   - **Codex**：内置 Responses API 支持探测；平台上线 `/v1/responses` 后即可一键写入 `config.toml` + `auth.json`（当前 Codex 0.154+ 已移除 `wire_api = "chat"`，云智尚未提供 Responses API，详见教程）
+3. **测试真实请求** — 向 `/v1/chat/completions` 发起一次真实调用
+4. **查看当前配置**
+
+推荐模型：OpenCode 主模型 `glm-5.3` / 小模型 `glm-5.3-flash`；Claude Code 四角色 Haiku `glm-5.3-flash`、Sonnet `glm-5.3`、Opus `kimi-k2.7`、Fable `qwen3.7-max`（均可在实时列表中改选）。
+
+## 配置文件位置
+
+| 内容 | 位置 |
+| --- | --- |
+| Helper 自身配置（含明文 Key，勿提交仓库） | `~/.yunzhi-maas-helper/config.json` |
+| OpenCode 公开配置（Provider/端点/模型） | `~/.config/opencode/opencode.jsonc` |
+| OpenCode 凭据（权限 0600） | `~/.local/share/opencode/auth.json` |
+| Claude Code 环境变量（端点/密钥/四模型） | `~/.claude/settings.json` |
+| Claude Code onboarding 标记 | `~/.claude.json` |
+
+## 教程
+
+- OpenCode：[`docs/yunzhi-maas-helper-opencode-tutorial.md`](../docs/yunzhi-maas-helper-opencode-tutorial.md)
+- Claude Code：[`docs/yunzhi-maas-helper-claude-code-tutorial.md`](../docs/yunzhi-maas-helper-claude-code-tutorial.md)
+- Codex：[`docs/yunzhi-maas-helper-codex-tutorial.md`](../docs/yunzhi-maas-helper-codex-tutorial.md)（⚠️ 当前需平台上线 Responses API）
+
+> 端点区分：OpenCode 用 OpenAI 兼容端点 `https://maas.piteyun.com/v1`；Claude Code 用 Anthropic 根端点 `https://maas.piteyun.com`（Claude Code 自动拼接 `/v1/messages`）；Codex 需要 OpenAI Responses API（`/v1/responses`，暂未上线）。三枚端点共用同一枚 API Key。
+
+## 密钥安全
+
+不要把完整 API Key 粘贴到 Markdown、截图、终端录屏、Git 仓库或公共聊天中。密钥泄露后请立即到控制台删除并重新创建。

package/bin/yunzhi-maas-helper.js

@@ -0,0 +1,522 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * yunzhi-maas-helper - 云智 Token Hub (MaaS) 编码工具配置助手
+ * Powered by MiniRelax · 苏州云养智健人工智能科技有限公司
+ *
+ * 用法：不带参数运行 `yunzhi-helper` 进入交互菜单。
+ * 本教程中的密钥、模型和工具配置都从该菜单完成。
+ */
+
+const readline = require('readline');
+const path = require('path');
+
+const { BASE_URL, MODEL_META, RECOMMENDED, maskKey, fetchModels, testChat } = require('../lib/api');
+const store = require('../lib/store');
+const opencode = require('../lib/opencode');
+const claudecode = require('../lib/claude');
+const codexcli = require('../lib/codex');
+
+const VERSION = require('../package.json').version;
+
+/** 企业品牌信息（MiniRelax · 苏州云养智健） */
+const BRAND = {
+  name: 'MiniRelax',
+  vendor: '苏州云养智健人工智能科技有限公司',
+  product: 'yunzhi-maas-helper',
+  banner: [
+    '███╗   ███╗██╗███╗   ██╗██╗    ██████╗ ███████╗██╗      █████╗ ██╗  ██╗',
+    '████╗ ████║██║████╗  ██║██║    ██╔══██╗██╔════╝██║     ██╔══██╗╚██╗██╔╝',
+    '██╔████╔██║██║██╔██╗ ██║██║    ██████╔╝█████╗  ██║     ███████║ ╚███╔╝ ',
+    '██║╚██╔╝██║██║██║╚██╗██║██║    ██╔══██╗██╔══╝  ██║     ██╔══██║ ██╔██╗ ',
+    '██║ ╚═╝ ██║██║██║ ╚████║██║    ██║  ██║███████╗███████╗██║  ██║██╔╝ ██╗',
+    '╚═╝     ╚═╝╚═╝╚═╝  ╚═══╝╚═╝    ╚═╝  ╚═╝╚══════╝╚══════╝╚═╝  ╚═╝╚═╝  ╚═╝',
+  ],
+};
+
+function printBanner() {
+  const wide = process.stdout.columns || 80;
+  console.log('');
+  if (wide >= 78) {
+    for (const line of BRAND.banner) console.log('\x1b[36m' + line + '\x1b[0m');
+  } else {
+    console.log('\x1b[36m' + C.bold(BRAND.name) + '\x1b[0m');
+  }
+  console.log(C.dim(`  ${BRAND.product} v${VERSION}  ·  云智 Token Hub  ·  ${BASE_URL}`));
+  console.log(C.dim(`  Powered by ${BRAND.name} · ${BRAND.vendor}`));
+  console.log('');
+}
+
+const C = {
+  dim: (s) => `\x1b[2m${s}\x1b[0m`,
+  bold: (s) => `\x1b[1m${s}\x1b[0m`,
+  green: (s) => `\x1b[32m${s}\x1b[0m`,
+  yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+  red: (s) => `\x1b[31m${s}\x1b[0m`,
+  cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+};
+
+function makeRl() {
+  return readline.createInterface({ input: process.stdin, output: process.stdout });
+}
+
+function ask(rl, prompt) {
+  return new Promise((resolve) => rl.question(prompt, (a) => resolve(a.trim())));
+}
+
+/** 隐藏输入（不回显），跨平台：逐 keypress 收集 */
+function hiddenInput(promptText) {
+  return new Promise((resolve) => {
+    process.stdout.write(promptText);
+    readline.emitKeypressEvents(process.stdin);
+    const isTTY = process.stdin.isTTY;
+    if (isTTY) process.stdin.setRawMode(true);
+    let value = '';
+    const onKeypress = (str, key) => {
+      if (!key) return;
+      if (key.name === 'return' || key.name === 'enter') {
+        cleanup();
+        process.stdout.write('\n');
+        resolve(value);
+        return;
+      }
+      if (key.name === 'backspace') {
+        value = value.slice(0, -1);
+        return;
+      }
+      if (key.ctrl && (key.name === 'c' || key.name === 'd')) {
+        cleanup();
+        process.stdout.write('\n');
+        process.exit(130);
+      }
+      if (!key.ctrl && !key.meta && str && str >= ' ') {
+        value += str;
+      }
+    };
+    function cleanup() {
+      process.stdin.removeListener('keypress', onKeypress);
+      if (isTTY) process.stdin.setRawMode(false);
+      process.stdin.pause();
+    }
+    process.stdin.on('keypress', onKeypress);
+    if (isTTY) process.stdin.resume();
+  });
+}
+
+/** 通用编号菜单；返回选中的 key */
+async function pick(rl, title, options) {
+  console.log('\n' + C.bold(title));
+  options.forEach((o, i) => {
+    const meta = o.meta ? C.dim('  —  ' + o.meta) : '';
+    console.log(`  ${i + 1}. ${o.label}${meta}`);
+  });
+  const ans = await ask(rl, `\n请输入编号 (1-${options.length}, q 返回): `);
+  if (ans.toLowerCase() === 'q' || ans === '') return null;
+  const idx = parseInt(ans, 10) - 1;
+  if (Number.isNaN(idx) || idx < 0 || idx >= options.length) {
+    console.log(C.yellow('无效输入，请重试。'));
+    return await pick(rl, title, options);
+  }
+  return options[idx];
+}
+
+/* ---------- 主流程 ---------- */
+
+async function configureApiKey(rl) {
+  const cfg = store.read();
+  const isUpdate = Boolean(cfg.apiKey);
+  console.log('');
+  console.log(
+    isUpdate
+      ? `当前 API Key: ${C.green(maskKey(cfg.apiKey))}`
+      : '尚未保存 API Key。'
+  );
+  console.log(`请先登录云智 Token Hub 控制台，在 ${C.cyan('API 密钥管理')} 创建并复制密钥。`);
+  console.log(C.dim(`密钥用途可填写 "Coding Helper - OpenCode 教程"。端点：${BASE_URL}`));
+  const key = await hiddenInput('\n请在这里输入您的 API key, 回车键确认: ');
+  if (!key) {
+    console.log(C.yellow('未输入任何内容，已取消。'));
+    return;
+  }
+  console.log(C.dim(`正在调用 ${BASE_URL}/models 验证密钥...`));
+  const result = await fetchModels(key);
+  if (!result.ok) {
+    console.log(C.red(`✗ 验证失败：${result.message}`));
+    console.log(C.dim('常见原因：复制了遮罩文本、密钥已过期、密钥被删除。请回控制台重新复制或创建。'));
+    return;
+  }
+  const next = {
+    ...cfg,
+    apiKey: key,
+    apiKeyMask: maskKey(key),
+    baseURL: BASE_URL,
+    verifiedAt: new Date().toISOString(),
+    modelCount: result.models.length,
+  };
+  store.write(next);
+  console.log(C.green('✓ 设置成功'));
+  console.log(`  API Key 状态: ${C.green('已设置')}  (${maskKey(key)})`);
+  console.log(`  可用模型: ${result.models.length} 个  端点: ${BASE_URL}`);
+  console.log(C.dim(`Helper 配置已保存到 ${store.HELPER_CONFIG}，请勿提交到代码仓库。`));
+}
+
+async function selectModels(rl, models) {
+  const cfg = store.read();
+  const label = (id) => {
+    const meta = MODEL_META[id];
+    return meta ? `${id} ${C.dim(`(${meta.vendor} · ${meta.desc})`)}` : id;
+  };
+
+  const mainOpts = models.map((id) => ({ key: id, label: label(id) }));
+  const mainPick = await pick(
+    rl,
+    '选择主模型（日常编码、推理和复杂任务）',
+    mainOpts
+  );
+  if (!mainPick) return null;
+  const mainModel = mainPick.key;
+
+  const smallOpts = models.map((id) => ({ key: id, label: label(id) }));
+  const smallPick = await pick(rl, '选择小模型 (快速/轻量，辅助任务)', smallOpts);
+  if (!smallPick) return null;
+  const smallModel = smallPick.key;
+
+  console.log('');
+  console.log(`  主模型: ${C.cyan(mainModel)}${mainModel === RECOMMENDED.main ? C.green('  ← 推荐默认') : ''}`);
+  console.log(`  小模型: ${C.cyan(smallModel)}${smallModel === RECOMMENDED.small ? C.green('  ← 推荐默认') : ''}`);
+
+  const ans = await ask(rl, '\n是否立即将配置应用到 OpenCode? (Y/n): ');
+  if (ans && ans.toLowerCase() !== 'y') {
+    console.log(C.yellow('已取消，未写入 OpenCode 配置。'));
+    return { mainModel, smallModel, applied: false };
+  }
+
+  const res = opencode.applyConfig({
+    apiKey: cfg.apiKey,
+    models,
+    mainModel,
+    smallModel,
+  });
+  console.log(C.green('✓ 配置已同步'));
+  console.log(C.dim(`  Provider、端点和模型 → ${res.configFile}`));
+  console.log(C.dim(`  X-AIO 风格凭据分离：API Key → ${res.authFile}`));
+  if (res.legacyKeyRemoved) {
+    console.log(C.yellow('  已从公开配置移除旧版内嵌 apiKey，凭据现在仅保存在 auth.json。'));
+  }
+  return { mainModel, smallModel, applied: true };
+}
+
+async function opencodeMenu(rl) {
+  for (;;) {
+    const cfg = store.read();
+    const st = opencode.status();
+    const keyMatch = cfg.apiKey && st.hasKey;
+
+    console.log('\n' + C.bold('── OpenCode 管理 ──'));
+    console.log(`  API Key:  ${cfg.apiKey ? C.green(maskKey(cfg.apiKey)) : C.red('未设置')}${keyMatch ? C.green('  (与 Helper 一致)') : ''}`);
+    console.log(`  端点:     ${st.baseURL || C.dim('未配置')}`);
+    console.log(`  主模型:   ${st.mainModel || C.dim('未配置')}`);
+    console.log(`  小模型:   ${st.smallModel || C.dim('未配置')}`);
+    console.log(`  模型目录: ${st.modelCount ? C.green(st.modelCount + ' 个') : C.dim('空')}`);
+    console.log(`  状态:     ${st.hasProvider && keyMatch ? C.green('配置已同步') : C.yellow('待配置/不一致')}`);
+
+    const act = await pick(rl, 'OpenCode 管理菜单', [
+      { key: 'models', label: '配置模型 - (选择主模型/小模型)' },
+      { key: 'refresh', label: '刷新模型列表 - (更新可用模型到配置)' },
+      { key: 'reload', label: '配置装载/配置刷新' },
+      { key: 'back', label: '返回主菜单' },
+    ]);
+    if (!act || act.key === 'back') return;
+
+    if (act.key === 'models') {
+      if (!cfg.apiKey) {
+        console.log(C.red('请先在主菜单配置 API Key。'));
+        continue;
+      }
+      const result = await fetchModels(cfg.apiKey);
+      if (!result.ok) {
+        console.log(C.red(`模型列表获取失败：${result.message}`));
+        continue;
+      }
+      await selectModels(rl, result.models);
+    } else if (act.key === 'refresh') {
+      if (!cfg.apiKey) {
+        console.log(C.red('请先在主菜单配置 API Key。'));
+        continue;
+      }
+      const result = await fetchModels(cfg.apiKey);
+      if (!result.ok) {
+        console.log(C.red(`模型列表获取失败：${result.message}`));
+        continue;
+      }
+      const r = opencode.refreshModels(result.models);
+      if (r.ok) {
+        console.log(C.green(`✓ 模型列表已刷新（${result.models.length} 个）→ ${r.file}`));
+        console.log(C.dim('刷新只更新可选模型目录，不改变当前主模型/小模型。'));
+      } else {
+        console.log(C.yellow(r.message));
+      }
+    } else if (act.key === 'reload') {
+      const st2 = opencode.status();
+      if (!st2.hasProvider) {
+        console.log(C.yellow('尚未配置 yunzhi Provider。请先选择“配置模型”完成初始配置。'));
+        continue;
+      }
+      if (st2.baseURL !== BASE_URL) {
+        const r = opencode.normalizeEndpoint();
+        console.log(C.green(`✓ 端点已规范化为 ${BASE_URL} → ${r.file}`));
+      } else {
+        console.log(C.green('✓ 配置装载完成，端点与 Provider 元数据已是最新。'));
+      }
+      console.log(C.dim('请重新启动 OpenCode TUI 以加载最新配置。'));
+    }
+  }
+}
+
+async function claudeMenu(rl) {
+  for (;;) {
+    const cfg = store.read();
+    const st = claudecode.status();
+
+    console.log('\n' + C.bold('── Claude Code 管理 ──'));
+    console.log(`  API Key:    ${cfg.apiKey ? C.green(maskKey(cfg.apiKey)) : C.red('未设置')}`);
+    console.log(`  端点:       ${st.baseURL || C.dim('未配置')}`);
+    for (const role of ['haiku', 'sonnet', 'opus', 'fable']) {
+      console.log(`  ${claudecode.ROLE_LABELS[role].padEnd(16)} ${st.models[role] || C.dim('未配置')}`);
+    }
+    console.log(`  状态:       ${st.hasToken && st.models.haiku && st.models.sonnet ? C.green('配置已同步') : C.yellow('待配置/不一致')}`);
+
+    const act = await pick(rl, 'Claude Code 管理菜单', [
+      { key: 'models', label: '配置模型 - (选择 Haiku/Sonnet/Opus/Fable 模型)' },
+      { key: 'reload', label: '配置装载/配置刷新 - (应用配置并清除旧路径)' },
+      { key: 'clear', label: '清除网关配置 - (恢复 Claude Code 官方登录)' },
+      { key: 'back', label: '返回主菜单' },
+    ]);
+    if (!act || act.key === 'back') return;
+
+    if (act.key === 'models') {
+      if (!cfg.apiKey) {
+        console.log(C.red('请先在主菜单配置 API Key。'));
+        continue;
+      }
+      const result = await fetchModels(cfg.apiKey);
+      if (!result.ok) {
+        console.log(C.red(`模型列表获取失败：${result.message}`));
+        continue;
+      }
+      const label = (id) => {
+        const meta = MODEL_META[id];
+        return meta ? `${id} ${C.dim(`(${meta.vendor} · ${meta.desc})`)}` : id;
+      };
+      const models = {};
+      for (const role of ['haiku', 'sonnet', 'opus', 'fable']) {
+        const opts = result.models.map((id) => ({ key: id, label: label(id) }));
+        const picked = await pick(rl, `选择 ${claudecode.ROLE_LABELS[role]}`, opts);
+        if (!picked) {
+          console.log(C.yellow('已取消，未写入 Claude Code 配置。'));
+          return;
+        }
+        models[role] = picked.key;
+      }
+      console.log('');
+      for (const role of ['haiku', 'sonnet', 'opus', 'fable']) {
+        const rec = claudecode.RECOMMENDED_ROLES[role] === models[role] ? C.green('  ← 推荐默认') : '';
+        console.log(`  ${claudecode.ROLE_LABELS[role].padEnd(16)} ${C.cyan(models[role])}${rec}`);
+      }
+      const ans = await ask(rl, '\n是否立即将配置应用到 Claude Code? (Y/n): ');
+      if (ans && ans.toLowerCase() !== 'y') {
+        console.log(C.yellow('已取消。'));
+        continue;
+      }
+      const r = claudecode.applyConfig({ apiKey: cfg.apiKey, models });
+      console.log(C.green('✓ 配置已同步'));
+      console.log(C.dim(`  环境变量（端点/密钥/四模型） → ${r.settingsFile}`));
+      console.log(C.dim(`  onboarding 标记 → ${r.claudeJsonFile}`));
+    } else if (act.key === 'reload') {
+      const st2 = claudecode.status();
+      if (!st2.hasToken) {
+        console.log(C.yellow('尚未配置 Claude Code。请先选择“配置模型”完成初始配置。'));
+        continue;
+      }
+      if (st2.baseURL === claudecode.ANTHROPIC_BASE_URL) {
+        console.log(C.green(`✓ 配置装载完成，端点已是 ${claudecode.ANTHROPIC_BASE_URL}（根端点，无 /v1 路径）。`));
+      } else {
+        console.log(C.yellow(`当前端点为 ${st2.baseURL}，请通过“配置模型”重新应用以规范化。`));
+      }
+      console.log(C.dim('请完全退出并重新启动 Claude Code 后运行 /status 核对。'));
+    } else if (act.key === 'clear') {
+      const r = claudecode.clearGatewayEnv();
+      if (r.ok) {
+        console.log(C.green(`✓ 已移除 ${r.removed.length} 个 ANTHROPIC_* 环境变量，Claude Code 将恢复官方登录。`));
+      } else {
+        console.log(C.yellow('未找到可清除的配置。'));
+      }
+    }
+  }
+}
+
+async function codexMenu(rl) {
+  const cfg = store.read();
+  const st = codexcli.status();
+
+  console.log('\n' + C.bold('── Codex 管理 ──'));
+  console.log(`  CODEX_HOME: ${C.dim(codexcli.codexHome())}`);
+  console.log(`  Provider:   ${st.hasProvider ? C.green(codexcli.PROVIDER_ID) : C.dim('未配置')}`);
+  console.log(`  API 端点:   ${st.baseUrl || C.dim('未配置')}`);
+  console.log(`  请求协议:   ${st.wireApi ? C.cyan(st.wireApi) : C.dim('未配置')}`);
+  console.log(`  模型:       ${st.model || C.dim('未配置')}`);
+  console.log(`  API Key:    ${st.hasKey ? C.green(st.keyMask) : C.red('未设置')}`);
+
+  const probe = await codexcli.probeResponsesSupport(cfg.apiKey);
+  if (!probe.supported) {
+    console.log('');
+    console.log(C.red('⚠ 平台暂不支持 OpenAI Responses API（Codex 必需）：' + probe.detail));
+    console.log(C.yellow('  Codex CLI 0.15x 已移除 wire_api = "chat"，当前无法接入云智。'));
+    console.log(C.dim('  待平台上线 /v1/responses 后，本菜单的配置功能即可使用。'));
+    return;
+  }
+  if (!probe.usable) {
+    console.log('');
+    console.log(C.yellow('⚠ Responses API 已上线，但 Codex 关键路径暂不可用：' + probe.detail));
+    console.log(C.dim('  Codex 始终以「数组 input + 流式」请求，该组合当前被网关上游拒绝（upstream_error）。'));
+    console.log(C.dim('  修复后重新进入本菜单即可配置；也可先用「测试真实请求」验证网关状态。'));
+    return;
+  }
+  console.log(C.green(`✓ 平台 Responses API 可用（${probe.detail}）`));
+
+  const act = await pick(rl, 'Codex 管理菜单', [
+    { key: 'models', label: '配置模型 - (选择模型)' },
+    { key: 'back', label: '返回主菜单' },
+  ]);
+  if (!act || act.key === 'back') return;
+
+  if (act.key === 'models') {
+    if (!cfg.apiKey) {
+      console.log(C.red('请先在主菜单配置 API Key。'));
+      return;
+    }
+    const result = await fetchModels(cfg.apiKey);
+    if (!result.ok) {
+      console.log(C.red(`模型列表获取失败：${result.message}`));
+      return;
+    }
+    const label = (id) => {
+      const meta = MODEL_META[id];
+      return meta ? `${id} ${C.dim(`(${meta.vendor} · ${meta.desc})`)}` : id;
+    };
+    const picked = await pick(rl, '选择模型（推荐 glm-5.3）', result.models.map((id) => ({ key: id, label: label(id) })));
+    if (!picked) {
+      console.log(C.yellow('已取消。'));
+      return;
+    }
+    const ans = await ask(rl, '\n是否立即将配置应用到 Codex? (Y/n): ');
+    if (ans && ans.toLowerCase() !== 'y') {
+      console.log(C.yellow('已取消。'));
+      return;
+    }
+    const r = codexcli.applyConfig({ apiKey: cfg.apiKey, model: picked.key });
+    console.log(C.green('✓ 配置已同步'));
+    console.log(C.dim(`  Provider、端点和模型 → ${r.configFile} (wire_api = "responses")`));
+    console.log(C.dim(`  凭据 → ${r.authFile} (0600, cli_auth_credentials_store = "file")`));
+  }
+}
+
+async function testRequest(rl) {
+  const cfg = store.read();
+  const st = opencode.status();
+  const model = st.mainModel && st.mainModel.split('/')[1];
+  if (!cfg.apiKey) {
+    console.log(C.red('请先在主菜单配置 API Key。'));
+    return;
+  }
+  const useModel = model || (await ask(rl, '请输入要测试的模型 ID: '));
+  if (!useModel) return;
+  console.log(C.dim(`正在向 ${BASE_URL}/chat/completions 发起真实请求 (model: ${useModel})...`));
+  const r = await testChat(cfg.apiKey, useModel);
+  if (r.ok) {
+    console.log(C.green('✓ 真实请求成功，模型回复：') + r.reply);
+  } else {
+    console.log(C.red(`✗ 请求失败：${r.message}`));
+  }
+}
+
+function showStatus() {
+  const cfg = store.read();
+  const st = opencode.status();
+  const cs = claudecode.status();
+  const cx = codexcli.status();
+  console.log('\n' + C.bold('── 当前配置 ──'));
+  console.log(`Helper 配置文件:  ${store.HELPER_CONFIG}`);
+  console.log(`API Key:          ${cfg.apiKey ? C.green('已设置 ' + maskKey(cfg.apiKey)) : C.red('未设置')}`);
+  console.log(`端点:             ${cfg.baseURL || C.dim('未记录')}`);
+  console.log(`OpenCode 配置:    ${st.configFile}`);
+  console.log(`OpenCode 主模型:  ${st.mainModel || C.dim('未配置')}`);
+  console.log(`OpenCode 小模型:  ${st.smallModel || C.dim('未配置')}`);
+  console.log(`Claude Code 配置: ${cs.settingsFile} ${cs.hasToken ? C.green('(已配置)') : C.dim('(未配置)')}`);
+  console.log(`Codex 配置:       ${cx.configFile} ${cx.hasProvider ? C.green('(已配置)') : C.dim('(未配置)')}`);
+  console.log(C.dim(`Powered by ${BRAND.name} · ${BRAND.vendor}`));
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  if (argv.includes('--version') || argv.includes('-v')) {
+    console.log(`${BRAND.product} v${VERSION}  ·  Powered by ${BRAND.name}`);
+    return;
+  }
+  if (argv.includes('--help') || argv.includes('-h')) {
+    printBanner();
+    console.log('用法: yunzhi-helper            不带参数，进入交互配置菜单');
+    console.log('      yunzhi-helper --version  查看版本');
+    console.log('      yunzhi-helper --help     显示本帮助');
+    console.log('');
+    console.log('配置编码工具: OpenCode / Claude Code / Codex（菜单内完成）');
+    console.log(C.dim(`Powered by ${BRAND.name} · ${BRAND.vendor}`));
+    return;
+  }
+  if (!process.stdin.isTTY) {
+    console.error('请在交互式终端中运行: yunzhi-helper');
+    process.exit(1);
+  }
+  printBanner();
+  const rl = makeRl();
+  try {
+    for (;;) {
+      const cfg = store.read();
+      const act = await pick(rl, `── ${BRAND.product} 主菜单 ──`, [
+        {
+          key: 'key',
+          label: cfg.apiKey ? '配置 API Key' : '输入 API Key',
+          meta: cfg.apiKey ? maskKey(cfg.apiKey) : '尚未保存密钥',
+        },
+        { key: 'tool', label: '配置编码工具', meta: 'OpenCode / Claude Code / Codex' },
+        { key: 'test', label: '测试真实请求', meta: 'chat/completions' },
+        { key: 'status', label: '查看当前配置' },
+        { key: 'exit', label: '退出' },
+      ]);
+      if (!act || act.key === 'exit') break;
+      if (act.key === 'key') await configureApiKey(rl);
+      if (act.key === 'tool') {
+        const tool = await pick(rl, '选择编码工具', [
+          { key: 'opencode', label: 'OpenCode' },
+          { key: 'claude', label: 'Claude Code' },
+          { key: 'codex', label: 'Codex', meta: '需平台 Responses API' },
+        ]);
+        if (tool && tool.key === 'opencode') await opencodeMenu(rl);
+        if (tool && tool.key === 'claude') await claudeMenu(rl);
+        if (tool && tool.key === 'codex') await codexMenu(rl);
+      }
+      if (act.key === 'test') await testRequest(rl);
+      if (act.key === 'status') showStatus();
+    }
+  } finally {
+    rl.close();
+  }
+  console.log(C.dim(`\nPowered by ${BRAND.name} · ${BRAND.vendor}`));
+  console.log(C.dim('再见。'));
+}
+
+main().catch((err) => {
+  console.error(C.red(`发生错误：${err && err.stack ? err.stack : err}`));
+  process.exit(1);
+});

package/lib/api.js

@@ -0,0 +1,114 @@
+'use strict';
+
+/**
+ * lib/api.js - 云智 Token Hub API 访问层
+ * 端点：https://maas.piteyun.com/v1（OpenAI 兼容）
+ */
+
+const BASE_URL = 'https://maas.piteyun.com/v1';
+
+/** 内置模型元数据（来自模型广场，用于菜单展示；未收录模型将回退为通用展示） */
+const MODEL_META = {
+  'glm-5.3': { vendor: '智谱 AI', desc: '旗舰模型，编码/推理能力强' },
+  'glm-5.3-flash': { vendor: '智谱 AI', desc: '快速轻量，适合辅助任务' },
+  'kimi-k2.7': { vendor: '月之暗面 Kimi', desc: '长上下文通用模型' },
+  'qwen3.7-max': { vendor: '阿里通义千问', desc: '通义旗舰' },
+  'qwen3.8-flash-free': { vendor: '阿里通义千问', desc: '无限火力可用' },
+  'deepseek-v4-flash-0731': { vendor: 'DeepSeek', desc: '快速，支持缓存计价' },
+  'deepseek-v4-flash-free': { vendor: 'DeepSeek', desc: '无限火力可用' },
+};
+
+/** 教程推荐默认模型（非强制） */
+const RECOMMENDED = {
+  main: 'glm-5.3',
+  small: 'glm-5.3-flash',
+};
+
+function maskKey(key) {
+  if (!key || key.length < 12) return '••••••••';
+  return key.slice(0, 6) + '••••...' + key.slice(-4);
+}
+
+/**
+ * 用 API Key 请求模型列表，同时完成密钥验证。
+ * @returns {Promise<{ok: true, models: string[]} | {ok: false, status?: number, message: string}>}
+ */
+async function fetchModels(apiKey, { timeoutMs = 15000 } = {}) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const resp = await fetch(`${BASE_URL}/models`, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal: controller.signal,
+    });
+    if (resp.status === 401 || resp.status === 403) {
+      return { ok: false, status: resp.status, message: 'API Key 无效或已过期' };
+    }
+    if (!resp.ok) {
+      return { ok: false, status: resp.status, message: `服务返回 HTTP ${resp.status}` };
+    }
+    const body = await resp.json();
+    const ids = Array.isArray(body && body.data)
+      ? body.data.map((m) => (typeof m === 'string' ? m : m && m.id)).filter(Boolean)
+      : [];
+    if (!ids.length) {
+      return { ok: false, status: resp.status, message: '密钥有效，但模型列表为空' };
+    }
+    return { ok: true, models: ids.sort() };
+  } catch (err) {
+    if (err && err.name === 'AbortError') {
+      return { ok: false, message: `请求超时（${timeoutMs / 1000}s），请检查网络` };
+    }
+    return { ok: false, message: `无法连接 ${BASE_URL}：${err && err.message}` };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * 发起一次真实 chat 请求验证端到端可用。
+ * @returns {Promise<{ok: true, reply: string} | {ok: false, message: string}>}
+ */
+async function testChat(apiKey, model, { timeoutMs = 60000 } = {}) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const resp = await fetch(`${BASE_URL}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        model,
+        messages: [
+          { role: 'user', content: '只回复"配置成功"，不要创建、修改或删除任何文件。' },
+        ],
+        stream: false,
+      }),
+      signal: controller.signal,
+    });
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => '');
+      return { ok: false, message: `HTTP ${resp.status} ${text.slice(0, 200)}`.trim() };
+    }
+    const body = await resp.json();
+    // 云智网关非流式响应为包裹结构 {code, message, data:{choices:[...]}}，标准结构则直接使用
+    const payload = body && body.data && body.data.choices ? body.data : body;
+    const message = payload && payload.choices && payload.choices[0] && payload.choices[0].message;
+    const reply = message ? String(message.content || '').trim() : '';
+    if (!reply && message && message.reasoning_content) {
+      return { ok: true, reply: '(模型仅输出推理内容，未给出最终文本)' };
+    }
+    return { ok: true, reply };
+  } catch (err) {
+    if (err && err.name === 'AbortError') {
+      return { ok: false, message: `请求超时（${timeoutMs / 1000}s）` };
+    }
+    return { ok: false, message: `请求失败：${err && err.message}` };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+module.exports = { BASE_URL, MODEL_META, RECOMMENDED, maskKey, fetchModels, testChat };

package/lib/claude.js

@@ -0,0 +1,120 @@
+'use strict';
+
+/**
+ * lib/claude.js - Claude Code 配置读写
+ * Claude Code 通过环境变量接入网关：
+ *   ANTHROPIC_BASE_URL       = Anthropic 根端点（不带 /v1，Claude Code 自行拼接 /v1/messages）
+ *   ANTHROPIC_AUTH_TOKEN     = 云智 API Key
+ *   ANTHROPIC_MODEL          = 默认（Sonnet 槽位）模型
+ *   ANTHROPIC_SMALL_FAST_MODEL = 小模型（Haiku 槽位）
+ *   ANTHROPIC_DEFAULT_HAIKU/SONNET/OPUS/FABLE_MODEL = 四角色显式映射
+ * 配置写入 ~/.claude/settings.json（保留其他字段），并在 ~/.claude.json 中完成 onboarding 标记。
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const ANTHROPIC_BASE_URL = 'https://maas.piteyun.com';
+
+const CLAUDE_DIR = path.join(os.homedir(), '.claude');
+const CLAUDE_SETTINGS = path.join(CLAUDE_DIR, 'settings.json');
+const CLAUDE_JSON = path.join(os.homedir(), '.claude.json');
+
+/** 教程推荐默认四角色映射（可从实时列表改选其他模型） */
+const RECOMMENDED_ROLES = {
+  haiku: 'glm-5.3-flash',
+  sonnet: 'glm-5.3',
+  opus: 'kimi-k2.7',
+  fable: 'qwen3.7-max',
+};
+
+const ROLE_LABELS = {
+  haiku: 'Haiku (快速/轻量)',
+  sonnet: 'Sonnet (日常主力)',
+  opus: 'Opus (复杂任务)',
+  fable: 'Fable (长程/规划)',
+};
+
+function readJsonSafe(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeJson(file, obj) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(obj, null, 2) + '\n', 'utf8');
+}
+
+/**
+ * 应用配置到 Claude Code。
+ * @returns {{settingsFile: string, claudeJsonFile: string}}
+ */
+function applyConfig({ apiKey, models }) {
+  // models: { haiku, sonnet, opus, fable }
+  const settings = readJsonSafe(CLAUDE_SETTINGS) || {};
+  settings.env = Object.assign({}, settings.env, {
+    ANTHROPIC_BASE_URL,
+    ANTHROPIC_AUTH_TOKEN: apiKey,
+    ANTHROPIC_MODEL: models.sonnet,
+    ANTHROPIC_SMALL_FAST_MODEL: models.haiku,
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: models.haiku,
+    ANTHROPIC_DEFAULT_SONNET_MODEL: models.sonnet,
+    ANTHROPIC_DEFAULT_OPUS_MODEL: models.opus,
+    ANTHROPIC_DEFAULT_FABLE_MODEL: models.fable,
+  });
+  writeJson(CLAUDE_SETTINGS, settings);
+
+  // onboarding 标记（合并写入，不覆盖其他字段）
+  const claudeJson = readJsonSafe(CLAUDE_JSON) || {};
+  claudeJson.hasCompletedOnboarding = true;
+  writeJson(CLAUDE_JSON, claudeJson);
+
+  return { settingsFile: CLAUDE_SETTINGS, claudeJsonFile: CLAUDE_JSON };
+}
+
+/** 清除网关 env（恢复官方登录方式时使用） */
+function clearGatewayEnv() {
+  const settings = readJsonSafe(CLAUDE_SETTINGS);
+  if (!settings || !settings.env) return { ok: false };
+  const keys = Object.keys(settings.env).filter((k) => k.startsWith('ANTHROPIC_'));
+  for (const k of keys) delete settings.env[k];
+  writeJson(CLAUDE_SETTINGS, settings);
+  return { ok: true, removed: keys };
+}
+
+function status() {
+  const settings = readJsonSafe(CLAUDE_SETTINGS) || {};
+  const env = settings.env || {};
+  const claudeJson = readJsonSafe(CLAUDE_JSON) || {};
+  return {
+    baseURL: env.ANTHROPIC_BASE_URL || null,
+    hasToken: Boolean(env.ANTHROPIC_AUTH_TOKEN),
+    tokenMask: env.ANTHROPIC_AUTH_TOKEN
+      ? env.ANTHROPIC_AUTH_TOKEN.slice(0, 6) + '••••...' + env.ANTHROPIC_AUTH_TOKEN.slice(-4)
+      : null,
+    models: {
+      haiku: env.ANTHROPIC_DEFAULT_HAIKU_MODEL || env.ANTHROPIC_SMALL_FAST_MODEL || null,
+      sonnet: env.ANTHROPIC_DEFAULT_SONNET_MODEL || env.ANTHROPIC_MODEL || null,
+      opus: env.ANTHROPIC_DEFAULT_OPUS_MODEL || null,
+      fable: env.ANTHROPIC_DEFAULT_FABLE_MODEL || null,
+    },
+    onboarding: claudeJson.hasCompletedOnboarding === true,
+    settingsFile: CLAUDE_SETTINGS,
+    claudeJsonFile: CLAUDE_JSON,
+  };
+}
+
+module.exports = {
+  ANTHROPIC_BASE_URL,
+  CLAUDE_SETTINGS,
+  CLAUDE_JSON,
+  RECOMMENDED_ROLES,
+  ROLE_LABELS,
+  applyConfig,
+  clearGatewayEnv,
+  status,
+};

package/lib/codex.js

@@ -0,0 +1,239 @@
+'use strict';
+
+/**
+ * lib/codex.js - Codex CLI 配置读写
+ *
+ * Codex 自定义 Provider 走 $CODEX_HOME/config.toml（TOML）+ auth.json（凭据）。
+ * ⚠️ 平台现状（2026-09-13 实测）：云智 Token Hub 当前仅提供 OpenAI Chat Completions
+ * （/v1/chat/completions）；OpenAI Responses API（/v1/responses）返回 404。
+ * 而 Codex CLI 0.154.0 起已移除 wire_api = "chat"（报错 "chat is no longer supported"，
+ * 参见 github.com/openai/codex/discussions/7782），自定义 Provider 强制 wire_api = "responses"。
+ * 因此本模块提供：
+ *   - probeResponsesSupport(): 探测平台是否已上线 Responses API
+ *   - applyConfig(): 平台支持时写入完整 Provider（wire_api = "responses"）
+ * 配置分离：公开配置 → config.toml；凭据 → auth.json（0600）；并设置
+ * cli_auth_credentials_store = "file"，确保 Codex 读取 auth.json 而不是 keyring。
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const { BASE_URL } = require('./api');
+
+const PROVIDER_ID = 'yunzhi';
+
+function codexHome() {
+  return process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+}
+
+function configPath() {
+  return path.join(codexHome(), 'config.toml');
+}
+
+function authPath() {
+  return path.join(codexHome(), 'auth.json');
+}
+
+/**
+ * 探测平台 Responses API 支持情况（两级）：
+ *  1. 路由是否存在（JSON 响应 vs HTML 兜底页 —— 云智 404 是 200+text/html，必须查 content-type）
+ *  2. Codex 关键路径是否可用：数组 input + stream:true（Codex 始终发此组合；
+ *     2026-09-13 实测网关对该组合返回 upstream_error，字符串 input 则正常）
+ * @returns {Promise<{supported: boolean, usable: boolean, detail: string}>}
+ */
+async function probeResponsesSupport(apiKey) {
+  const post = (body) => fetch(`${BASE_URL}/responses`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      ...(apiKey ? { Authorization: `Bearer ${apiKey}` } : {}),
+    },
+    body: JSON.stringify(body),
+  });
+  try {
+    // 第一级：路由探测（非流式，最小请求）
+    const r1 = await post({ model: 'glm-5.3-flash', input: 'ping', stream: false });
+    const ct1 = (r1.headers.get('content-type') || '').toLowerCase();
+    if (ct1.includes('text/html') || r1.status === 404) {
+      return { supported: false, usable: false, detail: `${BASE_URL}/responses 返回 HTML 兜底页，平台尚未提供 OpenAI Responses API` };
+    }
+    if (!ct1.includes('json')) {
+      return { supported: false, usable: false, detail: `探测响应异常（${ct1}）` };
+    }
+    // 第二级：Codex 关键路径（数组 input + 流式）
+    let usable = true;
+    let flowDetail = '';
+    try {
+      const r2 = await post({
+        model: 'glm-5.3-flash',
+        input: [{ role: 'user', content: [{ type: 'input_text', text: 'ping' }] }],
+        stream: true,
+      });
+      const ct2 = (r2.headers.get('content-type') || '').toLowerCase();
+      const text2 = await r2.text();
+      if (ct2.includes('text/html')) {
+        usable = false; flowDetail = '流式返回 HTML 兜底页';
+      } else if (text2.includes('upstream_error') || text2.includes('"type":"error"')) {
+        usable = false; flowDetail = '数组 input + 流式返回 upstream_error';
+      }
+    } catch (e2) {
+      usable = false; flowDetail = `流式探测请求失败：${e2 && e2.message}`;
+    }
+    if (!usable) {
+      return {
+        supported: true, usable: false,
+        detail: `Responses API 已上线，但 Codex 关键路径不可用（${flowDetail}）——待网关修复数组 input + 流式组合`,
+      };
+    }
+    return { supported: true, usable: true, detail: '端点与 Codex 关键路径（数组 input + 流式）均正常' };
+  } catch (err) {
+    return { supported: false, usable: false, detail: `探测请求失败：${err && err.message}` };
+  }
+}
+
+/* ---------- TOML 读写 ---------- */
+
+/** 读取顶层简单键值（key = "value"） */
+function readTopLevelScalar(text, key) {
+  const re = new RegExp(`^\\s*${key}\\s*=\\s*"([^"]*)"`, 'm');
+  const m = text.match(re);
+  return m ? m[1] : null;
+}
+
+/**
+ * 替换或追加一个 [[section]] 块。
+ * sectionHeader 形如 "[model_providers.yunzhi]"；
+ * blockText 为完整块文本（含 header 行）。
+ */
+function upsertSection(text, sectionHeader, blockText) {
+  const escaped = sectionHeader.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const re = new RegExp(`(^|\\n)\\s*${escaped}\\s*\\n[\\s\\S]*?(?=\\n\\s*\\[|\\n*$)`, '');
+  const m = text.match(re);
+  if (m) {
+    return text.replace(re, `$1${blockText}\n`);
+  }
+  const sep = text.trim().length ? '\n\n' : '';
+  return text.trimEnd() + sep + blockText + '\n';
+}
+
+/** 设置/替换顶层字符串键（插入到文件最前，或替换已有行） */
+function setTopLevelString(text, key, value) {
+  const re = new RegExp(`^\\s*${key}\\s*=\\s*"[^"]*"\\s*$`, 'm');
+  if (re.test(text)) {
+    return text.replace(re, `${key} = "${value}"`);
+  }
+  return `${key} = "${value}"\n` + text;
+}
+
+function writeAtomic(file, content) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = file + '.tmp-' + process.pid;
+  fs.writeFileSync(tmp, content, 'utf8');
+  fs.renameSync(tmp, file);
+}
+
+/**
+ * 应用 Codex 配置（要求平台 Responses API 已上线且关键路径可用）。
+ * 认证：Codex 自定义 Provider 通过 env_key 指定的环境变量读取密钥
+ * （实测 auth.json 的 OPENAI_API_KEY 对自定义 Provider 不生效，返回 401 missing API key）。
+ * @param {{apiKey: string, model: string}} p
+ */
+function applyConfig({ apiKey, model }) {
+  const home = codexHome();
+  const cfgFile = configPath();
+  const authFile = authPath();
+  let toml = '';
+  try {
+    toml = fs.readFileSync(cfgFile, 'utf8');
+  } catch {
+    /* 新建 */
+  }
+
+  toml = setTopLevelString(toml, 'model', model);
+  toml = setTopLevelString(toml, 'model_provider', PROVIDER_ID);
+  toml = setTopLevelString(toml, 'cli_auth_credentials_store', 'file');
+
+  const block = [
+    `[model_providers.${PROVIDER_ID}]`,
+    `name = "Yunzhi Token Hub (MaaS)"`,
+    `base_url = "${BASE_URL}"`,
+    `wire_api = "responses"`,
+    `env_key = "YUNZHI_API_KEY"`,
+  ].join('\n');
+  toml = upsertSection(toml, `[model_providers.${PROVIDER_ID}]`, block);
+  writeAtomic(cfgFile, toml);
+
+  // auth.json 同步保存（部分工具读取），并提示设置环境变量
+  let auth = {};
+  try {
+    auth = JSON.parse(fs.readFileSync(authFile, 'utf8')) || {};
+  } catch {
+    /* 新建 */
+  }
+  auth.OPENAI_API_KEY = apiKey;
+  writeAtomic(authFile, JSON.stringify(auth, null, 2) + '\n');
+  try {
+    fs.chmodSync(authFile, 0o600);
+  } catch {
+    /* noop on Windows */
+  }
+
+  return {
+    configFile: cfgFile,
+    authFile,
+    envHint: `Codex 通过环境变量 YUNZHI_API_KEY 读取密钥（env_key 已写入配置），请将其加入 shell 配置或系统环境变量`,
+  };
+}
+
+function status() {
+  const cfgFile = configPath();
+  const authFile = authPath();
+  let toml = '';
+  try {
+    toml = fs.readFileSync(cfgFile, 'utf8');
+  } catch {
+    toml = '';
+  }
+  let auth = {};
+  try {
+    auth = JSON.parse(fs.readFileSync(authFile, 'utf8')) || {};
+  } catch {
+    /* 无凭据 */
+  }
+  const providerBlock = toml.includes(`[model_providers.${PROVIDER_ID}]`);
+  // 只在 yunzhi 块内读取 base_url / wire_api，避免误读其他 Provider 的同名键
+  let blockText = '';
+  if (providerBlock) {
+    const blockRe = new RegExp(`\\[model_providers\\.${PROVIDER_ID}\\][\\s\\S]*?(?=\\n\\s*\\[|$)`);
+    blockText = (toml.match(blockRe) || [''])[0];
+  }
+  const baseUrlMatch = blockText.match(/^base_url\s*=\s*"([^"]*)"\s*$/m);
+  const wireApiMatch = blockText.match(/^wire_api\s*=\s*"([^"]*)"\s*$/m);
+  return {
+    hasProvider: providerBlock,
+    wireApi: wireApiMatch ? wireApiMatch[1] : null,
+    baseUrl: providerBlock && baseUrlMatch ? baseUrlMatch[1] : null,
+    model: readTopLevelScalar(toml, 'model'),
+    modelProvider: readTopLevelScalar(toml, 'model_provider'),
+    hasKey: Boolean(auth.OPENAI_API_KEY),
+    keyMask: auth.OPENAI_API_KEY
+      ? auth.OPENAI_API_KEY.slice(0, 6) + '••••...' + auth.OPENAI_API_KEY.slice(-4)
+      : null,
+    configFile: cfgFile,
+    authFile,
+  };
+}
+
+module.exports = {
+  PROVIDER_ID,
+  codexHome,
+  configPath,
+  authPath,
+  probeResponsesSupport,
+  applyConfig,
+  status,
+  readTopLevelScalar,
+  upsertSection,
+  setTopLevelString,
+};

package/lib/opencode.js

@@ -0,0 +1,214 @@
+'use strict';
+
+/**
+ * lib/opencode.js - OpenCode 配置读写
+ * 公开配置（Provider、端点、模型）：~/.config/opencode/opencode.jsonc
+ * 凭据（API Key）：            ~/.local/share/opencode/auth.json
+ * 两者分开保存，凭据文件权限应为 0600（POSIX）。
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const { BASE_URL } = require('./api');
+
+const PROVIDER_ID = 'yunzhi';
+const OPENCODE_DIR = path.join(os.homedir(), '.config', 'opencode');
+const OPENCODE_CONFIG = path.join(OPENCODE_DIR, 'opencode.jsonc');
+const OPENCODE_AUTH_DIR = path.join(os.homedir(), '.local', 'share', 'opencode');
+const OPENCODE_AUTH = path.join(OPENCODE_AUTH_DIR, 'auth.json');
+
+/* ---------- 简易 JSONC 解析（跳过字符串内的 // 与 /* *​/，容忍尾逗号） ---------- */
+
+function stripJsonComments(text) {
+  let out = '';
+  let i = 0;
+  let inStr = false;
+  let strCh = '';
+  while (i < text.length) {
+    const c = text[i];
+    const next = text[i + 1];
+    if (inStr) {
+      out += c;
+      if (c === '\\') {
+        out += next || '';
+        i += 2;
+        continue;
+      }
+      if (c === strCh) inStr = false;
+      i += 1;
+      continue;
+    }
+    if (c === '"' || c === "'") {
+      inStr = true;
+      strCh = c;
+      out += c;
+      i += 1;
+      continue;
+    }
+    if (c === '/' && next === '/') {
+      while (i < text.length && text[i] !== '\n') i += 1;
+      continue;
+    }
+    if (c === '/' && next === '*') {
+      i += 2;
+      while (i < text.length && !(text[i] === '*' && text[i + 1] === '/')) i += 1;
+      i += 2;
+      continue;
+    }
+    out += c;
+    i += 1;
+  }
+  // 去尾逗号
+  return out.replace(/,(\s*[}\]])/g, '$1');
+}
+
+function readJsonc(file) {
+  try {
+    const raw = fs.readFileSync(file, 'utf8');
+    return JSON.parse(stripJsonComments(raw));
+  } catch {
+    return null;
+  }
+}
+
+function readOpenCodeConfig() {
+  // 优先 opencode.jsonc，其次旧版 opencode.json
+  const jsonc = readJsonc(OPENCODE_CONFIG);
+  if (jsonc) return { config: jsonc, file: OPENCODE_CONFIG };
+  const legacy = readJsonc(path.join(OPENCODE_DIR, 'opencode.json'));
+  if (legacy) return { config: legacy, file: path.join(OPENCODE_DIR, 'opencode.json') };
+  return { config: {}, file: OPENCODE_CONFIG };
+}
+
+function readAuth() {
+  try {
+    const raw = fs.readFileSync(OPENCODE_AUTH, 'utf8');
+    const obj = JSON.parse(raw);
+    return obj && typeof obj === 'object' ? obj : {};
+  } catch {
+    return {};
+  }
+}
+
+/* ---------- 写入 ---------- */
+
+function writeOpenCodeConfig(cfg, file) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  // 注意：重写会丢失原有 JSONC 注释（与 xaio-chelper 行为一致）
+  fs.writeFileSync(file, JSON.stringify(cfg, null, 2) + '\n', 'utf8');
+}
+
+function writeAuth(auth) {
+  fs.mkdirSync(OPENCODE_AUTH_DIR, { recursive: true });
+  fs.writeFileSync(OPENCODE_AUTH, JSON.stringify(auth, null, 2) + '\n', 'utf8');
+  try {
+    fs.chmodSync(OPENCODE_AUTH, 0o600);
+  } catch {
+    /* noop on Windows */
+  }
+}
+
+/** 构造 yunzhi provider 块 */
+function buildProvider(models, mainModel, smallModel) {
+  const modelsBlock = {};
+  for (const id of models) {
+    modelsBlock[id] = { name: id };
+  }
+  return {
+    npm: '@ai-sdk/openai-compatible',
+    name: 'Yunzhi Token Hub (MaaS)',
+    options: { baseURL: BASE_URL },
+    models: modelsBlock,
+  };
+}
+
+/**
+ * 应用配置：写入 provider + 主/小模型到 opencode 配置，写入凭据到 auth.json。
+ * 返回实际写入的文件路径与是否发生旧 key 清理。
+ */
+function applyConfig({ apiKey, models, mainModel, smallModel }) {
+  const { config, file } = readOpenCodeConfig();
+
+  // 清理旧版把 apiKey 放在公开配置里的写法
+  let legacyKeyRemoved = false;
+  if (
+    config.provider &&
+    config.provider[PROVIDER_ID] &&
+    config.provider[PROVIDER_ID].options &&
+    'apiKey' in config.provider[PROVIDER_ID].options
+  ) {
+    delete config.provider[PROVIDER_ID].options.apiKey;
+    legacyKeyRemoved = true;
+  }
+
+  config.$schema = config.$schema || 'https://opencode.ai/config.json';
+  config.provider = config.provider || {};
+  config.provider[PROVIDER_ID] = buildProvider(models);
+  config.model = `${PROVIDER_ID}/${mainModel}`;
+  if (smallModel) config.small_model = `${PROVIDER_ID}/${smallModel}`;
+
+  writeOpenCodeConfig(config, file);
+
+  const auth = readAuth();
+  auth[PROVIDER_ID] = { type: 'api', key: apiKey };
+  writeAuth(auth);
+
+  return { configFile: file, authFile: OPENCODE_AUTH, legacyKeyRemoved };
+}
+
+/** 仅刷新模型目录，不改动当前主/小模型 */
+function refreshModels(models) {
+  const { config, file } = readOpenCodeConfig();
+  if (!config.provider || !config.provider[PROVIDER_ID]) {
+    return { ok: false, message: '尚未配置 yunzhi Provider，请先在“配置模型”中完成初始配置' };
+  }
+  config.provider[PROVIDER_ID].models = buildProvider(models).models;
+  writeOpenCodeConfig(config, file);
+  return { ok: true, file };
+}
+
+/** 仅规范化端点与 Provider 元数据，不触碰凭据与模型选择 */
+function normalizeEndpoint() {
+  const { config, file } = readOpenCodeConfig();
+  if (!config.provider || !config.provider[PROVIDER_ID]) {
+    return { ok: false };
+  }
+  config.provider[PROVIDER_ID].options = config.provider[PROVIDER_ID].options || {};
+  config.provider[PROVIDER_ID].options.baseURL = BASE_URL;
+  config.provider[PROVIDER_ID].name = 'Yunzhi Token Hub (MaaS)';
+  writeOpenCodeConfig(config, file);
+  return { ok: true, file };
+}
+
+/** 读取当前配置状态，用于菜单展示 */
+function status() {
+  const { config, file } = readOpenCodeConfig();
+  const auth = readAuth();
+  const provider = config.provider && config.provider[PROVIDER_ID];
+  const hasKey = Boolean(auth[PROVIDER_ID] && auth[PROVIDER_ID].key);
+  return {
+    hasProvider: Boolean(provider),
+    baseURL: provider && provider.options ? provider.options.baseURL : null,
+    modelCount: provider && provider.models ? Object.keys(provider.models).length : 0,
+    mainModel: config.model || null,
+    smallModel: config.small_model || null,
+    hasKey,
+    configFile: file,
+    authFile: OPENCODE_AUTH,
+  };
+}
+
+module.exports = {
+  PROVIDER_ID,
+  OPENCODE_CONFIG,
+  OPENCODE_AUTH,
+  readOpenCodeConfig,
+  readAuth,
+  applyConfig,
+  refreshModels,
+  normalizeEndpoint,
+  status,
+  stripJsonComments,
+};

package/lib/store.js

@@ -0,0 +1,37 @@
+'use strict';
+
+/**
+ * lib/store.js - Helper 自身配置读写
+ * 位置：~/.yunzhi-maas-helper/config.json
+ * 注意：该文件包含明文 API Key，不要提交到代码仓库。
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const HELPER_DIR = path.join(os.homedir(), '.yunzhi-maas-helper');
+const HELPER_CONFIG = path.join(HELPER_DIR, 'config.json');
+
+function read() {
+  try {
+    const raw = fs.readFileSync(HELPER_CONFIG, 'utf8');
+    const obj = JSON.parse(raw);
+    return obj && typeof obj === 'object' ? obj : {};
+  } catch {
+    return {};
+  }
+}
+
+function write(cfg) {
+  fs.mkdirSync(HELPER_DIR, { recursive: true });
+  fs.writeFileSync(HELPER_CONFIG, JSON.stringify(cfg, null, 2) + '\n', 'utf8');
+  // 仅 POSIX 生效；Windows 上忽略失败
+  try {
+    fs.chmodSync(HELPER_CONFIG, 0o600);
+  } catch {
+    /* noop on Windows */
+  }
+}
+
+module.exports = { HELPER_DIR, HELPER_CONFIG, read, write };

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@yunzhi519/maas-helper",
+  "version": "0.1.1",
+  "description": "yunzhi-maas-helper - 云智 Token Hub (MaaS) 编码工具配置助手，一键配置 OpenCode / Claude Code / Codex 的 API Key、端点与模型。Powered by MiniRelax",
+  "bin": {
+    "yunzhi-helper": "bin/yunzhi-maas-helper.js"
+  },
+  "main": "bin/yunzhi-maas-helper.js",
+  "type": "commonjs",
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "yunzhi",
+    "maas",
+    "token-hub",
+    "opencode",
+    "claude-code",
+    "codex",
+    "minirelax",
+    "cli"
+  ],
+  "author": "MiniRelax (苏州云养智健人工智能科技有限公司)",
+  "license": "MIT",
+  "files": [
+    "bin",
+    "lib",
+    "README.md"
+  ]
+}