claude360 0.1.1 → 0.2.1

package/src/token-manager.js

@@ -24,10 +24,44 @@ function formatTokenKey(key) {
   return key.includes("*") ? key : maskSecret(key);
 }
 
+export const TOKEN_PURPOSES = [
+  { label: "Claude Code 默认 Key", value: "claude-code-default" },
+  { label: "Codex 默认 Key", value: "codex-default" },
+  { label: "通用 Key", value: "claude360-cli" },
+];
+
+// 创建新 API Key：选择用途（决定默认名）→ 选择分组（来自后端）→ 创建并返回明文
+export async function createNewToken({ api, promptSelect, promptInput = async (_m, d) => d } = {}) {
+  if (!api) {
+    throw new Error("缺少 API client");
+  }
+  if (typeof promptSelect !== "function") {
+    throw new Error("缺少选择输入");
+  }
+  const purpose = await promptSelect("请选择 Key 用途：", TOKEN_PURPOSES);
+  const groups = await loadGroups(api);
+  const group = await selectGroup({ groups, promptSelect });
+  const name = await promptInput("新 API Key 名称", purpose);
+  const created = await api.post("/api/cli/tokens", {
+    name,
+    group: group.name,
+  });
+  if (!created?.key) {
+    throw new Error("创建 API Key 失败");
+  }
+  return {
+    tokenId: created.id,
+    tokenName: created.name || name,
+    apiKey: created.key,
+    group: created.group || group.name,
+    created: true,
+  };
+}
+
 export async function chooseOrCreateToken({
   api,
   promptSelect,
-  promptInput = async () => "Claude360 CLI",
+  promptInput = async (_message, defaultValue = "Claude360 CLI") => defaultValue,
 } = {}) {
   if (!api) {
     throw new Error("缺少 API client");
@@ -39,11 +73,17 @@ export async function chooseOrCreateToken({
     if (typeof promptSelect !== "function") {
       throw new Error("缺少 Token 选择输入");
     }
-    const choices = tokens.map((token) => ({
-      label: formatTokenOption(token),
-      value: token.id,
-    }));
+    const choices = [
+      ...tokens.map((token) => ({
+        label: formatTokenOption(token),
+        value: token.id,
+      })),
+      { label: "创建新的 API Key", value: "__create__" },
+    ];
     const tokenId = await promptSelect("选择 API Key", choices);
+    if (tokenId === "__create__") {
+      return createNewToken({ api, promptSelect, promptInput });
+    }
     const selected = tokens.find((token) => token.id === tokenId);
     if (!selected) {
       throw new Error("选择的 API Key 无效");
@@ -61,23 +101,7 @@ export async function chooseOrCreateToken({
     };
   }
 
-  const groups = await loadGroups(api);
-  const group = await selectGroup({ groups, promptSelect });
-  const name = await promptInput("新 API Key 名称", "Claude360 CLI");
-  const created = await api.post("/api/cli/tokens", {
-    name,
-    group: group.name,
-  });
-  if (!created?.key) {
-    throw new Error("创建 API Key 失败");
-  }
-  return {
-    tokenId: created.id,
-    tokenName: created.name || name,
-    apiKey: created.key,
-    group: created.group || group.name,
-    created: true,
-  };
+  return createNewToken({ api, promptSelect, promptInput });
 }
 
 function formatStatus(status) {

package/src/tool-installer.js

@@ -1,3 +1,4 @@
+import { sanitizeText } from "./sanitize.js";
 import { spawn } from "node:child_process";
 
 const TOOL_COMMANDS = {
@@ -31,6 +32,8 @@ export function buildInstallCommand(target) {
   };
 }
 
+export const NPM_MIRROR_REGISTRY = "https://registry.npmmirror.com";
+
 export async function installOrUpdateTools({
   targets,
   confirm,
@@ -55,17 +58,33 @@ export async function installOrUpdateTools({
       continue;
     }
 
-    const result = await execCommand(install.command, install.args);
+    let result = await execCommand(install.command, install.args);
+    let usedMirror = false;
+    // 官方源失败时支持国内镜像回退：一次性 --registry 参数重试，不修改用户全局 npm 配置
+    if (!result.ok) {
+      const retryWithMirror = await confirm(
+        `安装失败：${sanitizeText(result.stderr || result.error || "npm install failed")}\n是否使用国内镜像（${NPM_MIRROR_REGISTRY}）重试？仅本次安装生效，不修改全局 npm 配置。`,
+      );
+      if (retryWithMirror) {
+        usedMirror = true;
+        result = await execCommand(install.command, [
+          ...install.args,
+          `--registry=${NPM_MIRROR_REGISTRY}`,
+        ]);
+      }
+    }
+
     if (!result.ok) {
       results.push({
         target,
         ok: false,
-        error: result.stderr || result.error || "npm install failed",
+        usedMirror,
+        error: sanitizeText(result.stderr || result.error || "npm install failed"),
         remediation: "请检查 Node/npm 是否可用，并修复 npm 全局目录权限后重试。",
       });
       continue;
     }
-    results.push({ target, ok: true, output: result.stdout || "" });
+    results.push({ target, ok: true, usedMirror, output: result.stdout || "" });
   }
   return results;
 }

package/src/tool-launcher.js

@@ -1,8 +1,29 @@
 import { spawn } from "node:child_process";
-import { mkdir as fsMkdir, readFile as fsReadFile, writeFile as fsWriteFile } from "node:fs/promises";
+
+import { parse as parseToml } from "smol-toml";
+
+import { safeErrorMessage } from "./sanitize.js";
+import { copyFile as fsCopyFile, mkdir as fsMkdir, readFile as fsReadFile, writeFile as fsWriteFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
+// Codex 协议兼容性检测：以后端上报为准，CLI 不内置协议判断逻辑
+export async function checkCodexCompat(api) {
+  if (!api || typeof api.get !== "function") {
+    return { supported: false, detail: "API client 不可用" };
+  }
+  try {
+    const data = await api.get("/api/cli/codex/compat");
+    return {
+      supported: Boolean(data?.supported),
+      wireApi: data?.wire_api || "responses",
+      detail: data?.supported ? "Claude360 已支持 Codex 所需协议" : "Claude360 暂不支持 Codex 所需协议",
+    };
+  } catch (error) {
+    return { supported: false, detail: `协议兼容性检测失败：${safeErrorMessage(error)}` };
+  }
+}
+
 export async function launchClaudeCode({
   config,
   spawnCommand = spawnInherited,
@@ -29,12 +50,14 @@ export async function launchCodex({
   readFile = fsReadFile,
   writeFile = fsWriteFile,
   mkdir = fsMkdir,
+  copyFile = fsCopyFile,
   confirmConflict,
   spawnCommand = spawnInherited,
   env = process.env,
+  writeLine = () => {},
 } = {}) {
   assertApiKey(config);
-  await configureCodexProvider({ config, configPath, readFile, writeFile, mkdir, confirmConflict });
+  await configureCodexProvider({ config, configPath, readFile, writeFile, mkdir, copyFile, confirmConflict, writeLine });
   return spawnCommand("codex", ["--profile", "claude360"], {
     stdio: "inherit",
     env: {
@@ -50,7 +73,9 @@ export async function configureCodexProvider({
   readFile = fsReadFile,
   writeFile = fsWriteFile,
   mkdir = fsMkdir,
+  copyFile = fsCopyFile,
   confirmConflict,
+  writeLine = () => {},
 } = {}) {
   const current = await readConfigIfExists(readFile, configPath);
   const desired = {
@@ -59,50 +84,86 @@ export async function configureCodexProvider({
     envKey: "CLAUDE360_API_KEY",
     wireApi: "responses",
   };
-  await confirmCodexProviderConflict(current, desired, confirmConflict);
+  await confirmCodexConfigConflict(current, desired, confirmConflict);
   const content = buildCodexConfig(current, {
     providerId: desired.providerId,
     baseUrl: desired.baseUrl,
     envKey: desired.envKey,
   });
+  const tomlError = validateBasicToml(content);
+  if (tomlError) {
+    throw new Error(`生成的 Codex 配置 TOML 校验失败：${tomlError}`);
+  }
   await mkdir(path.dirname(configPath), { recursive: true });
+  // 写入前备份原配置（PRD 安全要求）
+  let backupPath = null;
+  if (current !== "") {
+    backupPath = `${configPath}.claude360.bak`;
+    await copyFile(configPath, backupPath);
+    writeLine(`已备份原 Codex 配置到：${backupPath}`);
+  }
   await writeFile(configPath, content, "utf8");
-  return content;
+  return { content, backupPath };
 }
 
-async function confirmCodexProviderConflict(content, desired, confirmConflict) {
-  const existing = extractProviderBlock(content, desired.providerId);
-  if (!existing) {
-    return;
+// 真实 TOML 校验（验收 P0-2）：写入 ~/.codex/config.toml 前对合并产物完整 parse，
+// 未闭合字符串、重复表等真实语法错误必须被检出；旧的行级形状检查既漏报也会
+// 误报用户配置中的合法多行结构。返回 null 表示通过，否则返回用户可读错误。
+export function validateBasicToml(content) {
+  try {
+    parseToml(String(content));
+    return null;
+  } catch (error) {
+    const line = error?.line ? `第 ${error.line} 行` : "";
+    const message = error?.message ? error.message.split("\n")[0] : "TOML 语法错误";
+    return `${line}${line ? "：" : ""}${message}`;
   }
-  const values = parseTomlStringAssignments(existing);
+}
+
+// 验收 P0-3：provider 与 profile 两类 claude360 块的冲突都必须二次确认，
+// 拒绝时在 mkdir / 备份 / 写入之前抛错，磁盘零改动
+async function confirmCodexConfigConflict(content, desired, confirmConflict) {
   const conflicts = [];
-  if (values.base_url && values.base_url !== desired.baseUrl) {
-    conflicts.push(`base_url: ${values.base_url} -> ${desired.baseUrl}`);
-  }
-  if (values.env_key && values.env_key !== desired.envKey) {
-    conflicts.push(`env_key: ${values.env_key} -> ${desired.envKey}`);
+
+  const providerBlock = extractTableBlock(content, `model_providers.${desired.providerId}`);
+  if (providerBlock) {
+    const values = parseTomlStringAssignments(providerBlock);
+    if (values.base_url && values.base_url !== desired.baseUrl) {
+      conflicts.push(`base_url: ${values.base_url} -> ${desired.baseUrl}`);
+    }
+    if (values.env_key && values.env_key !== desired.envKey) {
+      conflicts.push(`env_key: ${values.env_key} -> ${desired.envKey}`);
+    }
+    if (values.wire_api && values.wire_api !== desired.wireApi) {
+      conflicts.push(`wire_api: ${values.wire_api} -> ${desired.wireApi}`);
+    }
   }
-  if (values.wire_api && values.wire_api !== desired.wireApi) {
-    conflicts.push(`wire_api: ${values.wire_api} -> ${desired.wireApi}`);
+
+  const profileBlock = extractTableBlock(content, `profiles.${desired.providerId}`);
+  if (profileBlock) {
+    const values = parseTomlStringAssignments(profileBlock);
+    if (values.model_provider && values.model_provider !== desired.providerId) {
+      conflicts.push(`profiles.${desired.providerId}.model_provider: ${values.model_provider} -> ${desired.providerId}`);
+    }
   }
+
   if (conflicts.length === 0) {
     return;
   }
   if (typeof confirmConflict !== "function") {
-    throw new Error(`Codex Claude360 provider 配置存在冲突：${conflicts.join("; ")}`);
+    throw new Error(`Codex Claude360 配置存在冲突：${conflicts.join("; ")}`);
   }
   const approved = await confirmConflict(
-    `Codex Claude360 provider 配置存在冲突，将覆盖以下字段：\n${conflicts.join("\n")}\n是否继续？`,
+    `Codex Claude360 配置存在冲突，将覆盖以下字段：\n${conflicts.join("\n")}\n是否继续？`,
   );
   if (!approved) {
-    throw new Error(`Codex Claude360 provider 配置存在冲突：${conflicts.join("; ")}`);
+    throw new Error(`Codex Claude360 配置存在冲突：${conflicts.join("; ")}`);
   }
 }
 
-function extractProviderBlock(content, providerId) {
+function extractTableBlock(content, tableName) {
   const lines = content.split(/\r?\n/);
-  const header = `[model_providers.${providerId}]`;
+  const header = `[${tableName}]`;
   const start = lines.findIndex((line) => line.trim() === header);
   if (start === -1) {
     return null;

package/src/topup.js

@@ -20,13 +20,20 @@ export async function runWechatTopUp({
   }
 
   const options = await loadTopUpOptions(api);
+  // 后端口径前置拦截（验收 P1-2）：禁用时不进金额选择、不创建订单
+  if (options?.wechat_enabled === false) {
+    throw new Error("微信支付未启用，请使用网页充值。");
+  }
   const amount = await chooseTopUpAmount({ options, promptSelect, promptInput });
   const order = await api.post("/api/cli/topup/wechat", { amount });
   if (!order?.order_id || !order?.code_url) {
     throw new Error("创建微信充值订单失败");
   }
 
+  writeLine("请使用微信扫码支付");
   await printQrOrCodeUrl({ codeUrl: order.code_url, renderQr, writeLine });
+  writeLine(`订单金额：${order.money_display || order.money || amount}`);
+  writeLine("订单状态：等待支付...");
   const status = await waitTopUpPaid({
     api,
     orderId: order.order_id,
@@ -83,7 +90,7 @@ async function printQrOrCodeUrl({ codeUrl, renderQr, writeLine }) {
 
 async function waitTopUpPaid({ api, orderId, sleep, pollIntervalMs, maxPolls }) {
   for (let attempt = 0; attempt < maxPolls; attempt += 1) {
-    const status = await api.get(`/api/cli/topup/${encodeURIComponent(orderId)}`);
+    const status = await api.get(`/api/cli/topup/order?order_id=${encodeURIComponent(orderId)}`);
     if (status?.status === "success") {
       return status;
     }