claude360 0.1.0

package/src/config-store.js

@@ -0,0 +1,69 @@
+import { constants } from "node:fs";
+import { access, chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+export function resolveConfigPath({
+  platform = process.platform,
+  env = process.env,
+  homedir = os.homedir,
+} = {}) {
+  if (platform === "win32") {
+    const home = env.USERPROFILE || homedir();
+    return path.win32.join(home, ".claude360", "config.json");
+  }
+
+  return path.posix.join(homedir(), ".claude360", "config.json");
+}
+
+export function createConfigStore({ configPath = resolveConfigPath() } = {}) {
+  return {
+    path: configPath,
+    async load() {
+      try {
+        await access(configPath, constants.F_OK);
+      } catch {
+        return {};
+      }
+
+      const content = await readFile(configPath, "utf8");
+      if (content.trim() === "") {
+        return {};
+      }
+      return JSON.parse(content);
+    },
+    async save(config) {
+      const configDir = path.dirname(configPath);
+      await mkdir(configDir, { recursive: true, mode: 0o700 });
+      await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, {
+        encoding: "utf8",
+        mode: 0o600,
+      });
+      if (process.platform !== "win32") {
+        await chmod(configDir, 0o700);
+        await chmod(configPath, 0o600);
+      }
+    },
+  };
+}
+
+export function maskSecret(value) {
+  if (!value) {
+    return "";
+  }
+  if (value.length <= 4) {
+    return "*".repeat(value.length);
+  }
+  if (value.length <= 8) {
+    return `${value.slice(0, 2)}****${value.slice(-2)}`;
+  }
+  return `${value.slice(0, 4)}**********${value.slice(-4)}`;
+}
+
+export function toDiagnosticConfig(config) {
+  return {
+    ...config,
+    apiKey: maskSecret(config.apiKey),
+    cliToken: maskSecret(config.cliToken),
+  };
+}

package/src/diagnostics.js

@@ -0,0 +1,206 @@
+import { spawn } from "node:child_process";
+import { access } from "node:fs/promises";
+import { constants } from "node:fs";
+import os from "node:os";
+
+export async function runDiagnostics({
+  config = {},
+  platform = defaultPlatform(),
+  execCommand = defaultExecCommand,
+  checkPathWritable = defaultCheckPathWritable,
+  api,
+} = {}) {
+  const node = await commandVersion(execCommand, "node", ["--version"]);
+  const npm = await commandVersion(execCommand, "npm", ["--version"]);
+  const npmPrefix = await execCommand("npm", ["prefix", "-g"]);
+  const globalNpmPermission = npmPrefix.ok
+    ? {
+      ok: await checkPathWritable(npmPrefix.stdout.trim()),
+      detail: npmPrefix.stdout.trim(),
+    }
+    : { ok: false, detail: npmPrefix.stderr || npmPrefix.error || "npm prefix failed" };
+  const claudeCode = await commandVersion(execCommand, "claude", ["--version"]);
+  const codex = await commandVersion(execCommand, "codex", ["--version"]);
+
+  const me = await safeApiGet(api, "/api/cli/me");
+  const tokens = await safeApiGet(api, "/api/cli/tokens");
+  const topUpOptions = await safeApiGet(api, "/api/cli/topup/options");
+
+  return {
+    platform: {
+      os: platform.platform,
+      arch: platform.arch,
+      terminalQr: detectTerminalQr(platform),
+    },
+    runtime: {
+      node,
+      npm,
+      globalNpmPermission,
+    },
+    tools: {
+      claudeCode,
+      codex,
+    },
+    api: {
+      connectivity: {
+        ok: me.ok,
+        detail: me.ok ? (config.baseUrl || "connected") : me.detail,
+      },
+    },
+    auth: {
+      ok: Boolean(config.cliToken) && me.ok,
+      detail: config.cliToken ? "已授权" : "未授权",
+    },
+    balance: {
+      ok: me.ok,
+      detail: me.ok ? String(me.data?.quota ?? "-") : me.detail,
+    },
+    token: buildTokenStatus({ config, tokens }),
+    topUp: buildTopUpStatus({ topUpOptions }),
+  };
+}
+
+function buildTopUpStatus({ topUpOptions }) {
+  if (!topUpOptions.ok) {
+    return { ok: false, detail: topUpOptions.detail };
+  }
+  if (!topUpOptions.data?.wechat_enabled) {
+    return { ok: false, detail: "微信支付未启用" };
+  }
+  return { ok: true, detail: "可用" };
+}
+
+export function formatDiagnosticsSummary(report) {
+  return [
+    `OS: ${report.platform.os} ${report.platform.arch}`,
+    formatLine("Terminal QR", report.platform.terminalQr, "检查终端是否支持 TTY 输出，无法渲染时复制 code_url 支付"),
+    formatLine("Node", report.runtime.node, "安装 Node.js 18+ 后重新运行 claude360", "version"),
+    formatLine("npm", report.runtime.npm, "安装 npm 或修复 Node.js 安装", "version"),
+    formatLine("Global npm permission", report.runtime.globalNpmPermission, "修复 npm 全局目录权限，或切换到用户级 npm prefix"),
+    formatLine("Claude Code", report.tools.claudeCode, "安装或更新 Claude Code", "version"),
+    formatLine("Codex", report.tools.codex, "安装或更新 Codex", "version"),
+    formatLine("Claude360 API", report.api.connectivity, "检查网络连接和 Claude360 站点可用性"),
+    formatLine("Auth", report.auth, "重新执行浏览器授权"),
+    formatLine("Balance", report.balance, "授权后重试，或登录网站检查账户状态"),
+    formatLine("Token", report.token, "在菜单中切换或创建 API Key"),
+    formatLine("WeChat top-up", report.topUp, "检查后端微信支付配置或稍后重试"),
+  ].join("\n");
+}
+
+function formatLine(label, check, fix, valueKey = "detail") {
+  const line = `${label}: ${formatCheck(check, valueKey)}`;
+  if (check.ok) {
+    return line;
+  }
+  return `${line} | Fix: ${fix}`;
+}
+
+function formatCheck(check, valueKey = "detail") {
+  const status = check.ok ? "OK" : "FAIL";
+  const value = check[valueKey] || check.detail || "";
+  return `${status}${value ? ` ${value}` : ""}`;
+}
+
+function defaultPlatform() {
+  return {
+    platform: process.platform,
+    arch: process.arch,
+    isTTY: Boolean(process.stdout.isTTY),
+    env: process.env,
+  };
+}
+
+function detectTerminalQr(platform) {
+  if (!platform.isTTY) {
+    return { ok: false, detail: "stdout is not TTY" };
+  }
+  const term = platform.env?.TERM || "";
+  if (term === "dumb") {
+    return { ok: false, detail: "TERM=dumb" };
+  }
+  return { ok: true, detail: `TTY ${term || "unknown"}` };
+}
+
+async function commandVersion(execCommand, command, args) {
+  const result = await execCommand(command, args);
+  if (!result.ok) {
+    return { ok: false, detail: result.stderr || result.error || "not found" };
+  }
+  return {
+    ok: true,
+    version: result.stdout.trim(),
+  };
+}
+
+async function safeApiGet(api, path) {
+  if (!api || typeof api.get !== "function") {
+    return { ok: false, detail: "API client unavailable" };
+  }
+  try {
+    return { ok: true, data: await api.get(path) };
+  } catch (error) {
+    return { ok: false, detail: error?.message || String(error) };
+  }
+}
+
+function buildTokenStatus({ config, tokens }) {
+  if (!tokens.ok) {
+    return { ok: false, detail: tokens.detail };
+  }
+  const items = Array.isArray(tokens.data?.items) ? tokens.data.items : [];
+  if (items.length === 0) {
+    return { ok: false, detail: "无 API Key" };
+  }
+  const selected = items.find((token) => token.id === config.selectedTokenId) || items[0];
+  return { ok: true, detail: selected.name || `Token #${selected.id}` };
+}
+
+export function defaultExecCommand(command, args, { timeoutMs = 5000 } = {}) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const child = spawn(command, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    const timer = setTimeout(() => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      child.kill("SIGTERM");
+      resolve({ ok: false, stdout, stderr, error: "timeout" });
+    }, timeoutMs);
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      resolve({ ok: false, stdout, stderr, error: error.message });
+    });
+    child.on("close", (code) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      resolve({ ok: code === 0, stdout, stderr });
+    });
+  });
+}
+
+async function defaultCheckPathWritable(path) {
+  try {
+    await access(path || os.homedir(), constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/group-manager.js

@@ -0,0 +1,36 @@
+export function formatGroupOption(group) {
+  const name = group?.name || "";
+  const displayName = group?.display_name || name;
+  const ratio = Number(group?.ratio);
+  const ratioText = Number.isFinite(ratio) ? `（倍率 ${formatRatio(ratio)}x）` : "";
+  return `${displayName} / ${name}${ratioText}`;
+}
+
+export async function loadGroups(api) {
+  const groups = await api.get("/api/cli/groups");
+  return Array.isArray(groups) ? groups : [];
+}
+
+export async function selectGroup({ groups, promptSelect }) {
+  if (!Array.isArray(groups) || groups.length === 0) {
+    throw new Error("没有可用分组");
+  }
+  if (typeof promptSelect !== "function") {
+    throw new Error("缺少分组选择输入");
+  }
+
+  const choices = groups.map((group) => ({
+    label: formatGroupOption(group),
+    value: group.name,
+  }));
+  const selectedName = await promptSelect("选择 API 分组", choices);
+  const selected = groups.find((group) => group.name === selectedName);
+  if (!selected) {
+    throw new Error("选择的分组无效");
+  }
+  return selected;
+}
+
+function formatRatio(ratio) {
+  return Number.isInteger(ratio) ? ratio.toFixed(1) : String(ratio);
+}

package/src/index.js

@@ -0,0 +1,160 @@
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { execFile } from "node:child_process";
+
+import { ApiClient } from "./api-client.js";
+import { authenticateWithBrowser } from "./auth.js";
+import { createConfigStore } from "./config-store.js";
+import { formatDiagnosticsSummary, runDiagnostics as collectDiagnostics } from "./diagnostics.js";
+import { runMainMenu } from "./menu.js";
+import { installOrUpdateTools as installTools } from "./tool-installer.js";
+import { launchClaudeCode as startClaudeCode, launchCodex as startCodex } from "./tool-launcher.js";
+import { runWechatTopUp } from "./topup.js";
+import { chooseOrCreateToken, loadBalance } from "./token-manager.js";
+
+export async function runCli({
+  configStore = createConfigStore(),
+  createApiClient = (config) => new ApiClient(config),
+  authenticateWithBrowser: authWithBrowser = authenticateWithBrowser,
+  chooseOrCreateToken: chooseToken = chooseOrCreateToken,
+  promptSelect = defaultPromptSelect,
+  promptInput = defaultPromptInput,
+  confirm = defaultConfirm,
+  openBrowser = defaultOpenBrowser,
+  installOrUpdateTools = installTools,
+  launchClaudeCode = startClaudeCode,
+  launchCodex = startCodex,
+  sleep,
+  writeLine = console.log,
+} = {}) {
+  let config = await configStore.load();
+  const baseUrl = config.baseUrl || "https://claude360.xyz";
+  let api = createApiClient({ baseUrl, cliToken: config.cliToken || "" });
+
+  if (!config.cliToken) {
+    const cliToken = await authWithBrowser({ api, openBrowser, sleep });
+    config = { ...config, baseUrl, cliToken };
+    await configStore.save(config);
+    api = createApiClient({ baseUrl, cliToken });
+  }
+
+  if (!config.apiKey) {
+    const token = await chooseToken({ api, promptSelect, promptInput });
+    config = {
+      ...config,
+      apiKey: token.apiKey,
+      selectedTokenId: token.tokenId,
+      tokenName: token.tokenName,
+      group: token.group,
+    };
+    await configStore.save(config);
+  }
+
+  return runMainMenu({
+    promptSelect,
+    config,
+    writeLine,
+    actions: {
+      loadBalance: () => loadBalance(api),
+      runWechatTopUp: () => runWechatTopUp({ api, promptSelect, promptInput, writeLine, sleep }),
+      launchClaudeCode: () => launchClaudeCode({ config }),
+      launchCodex: () => launchCodex({ config, confirmConflict: confirm }),
+      installOrUpdateTools: async () => installOrUpdateTools({
+        targets: await selectToolTargets(promptSelect),
+        confirm,
+      }),
+      switchToken: async () => {
+        const token = await chooseToken({ api, promptSelect, promptInput });
+        config = {
+          ...config,
+          apiKey: token.apiKey,
+          selectedTokenId: token.tokenId,
+          tokenName: token.tokenName,
+          group: token.group,
+        };
+        await configStore.save(config);
+      },
+      runDiagnostics: async () => {
+        const report = await collectDiagnostics({ config, api });
+        writeLine(formatDiagnosticsSummary(report));
+      },
+    },
+  });
+}
+
+async function defaultPromptSelect(message, choices) {
+  const rl = readline.createInterface({ input, output });
+  try {
+    writeChoices(message, choices);
+    const answer = await rl.question("> ");
+    const index = Number(answer) - 1;
+    if (Number.isInteger(index) && choices[index]) {
+      return choices[index].value;
+    }
+    const matched = choices.find((choice) => choice.value === answer);
+    if (matched) {
+      return matched.value;
+    }
+    throw new Error("选择无效");
+  } finally {
+    rl.close();
+  }
+}
+
+async function defaultPromptInput(message, defaultValue = "") {
+  const rl = readline.createInterface({ input, output });
+  try {
+    const suffix = defaultValue ? ` (${defaultValue})` : "";
+    const answer = await rl.question(`${message}${suffix}: `);
+    return answer.trim() || defaultValue;
+  } finally {
+    rl.close();
+  }
+}
+
+async function defaultConfirm(message) {
+  const answer = await defaultPromptInput(`${message}\n输入 yes 确认`, "no");
+  return ["yes", "y", "确认", "是", "继续"].includes(answer.trim().toLowerCase());
+}
+
+function writeChoices(message, choices) {
+  console.log(message);
+  choices.forEach((choice, index) => {
+    console.log(`${index + 1}. ${choice.label}`);
+  });
+}
+
+async function selectToolTargets(promptSelect) {
+  const selected = await promptSelect("选择安装或更新目标", [
+    { label: "仅 Claude Code", value: "claude" },
+    { label: "仅 Codex", value: "codex" },
+    { label: "Claude Code 和 Codex", value: "all" },
+  ]);
+  if (selected === "claude") {
+    return ["claude360", "claude"];
+  }
+  if (selected === "codex") {
+    return ["claude360", "codex"];
+  }
+  if (selected === "all") {
+    return ["claude360", "claude", "codex"];
+  }
+  throw new Error("安装或更新目标无效");
+}
+
+function defaultOpenBrowser(url) {
+  const commands = {
+    win32: ["cmd", ["/c", "start", "", url]],
+    darwin: ["open", [url]],
+    linux: ["xdg-open", [url]],
+  };
+  const [command, args] = commands[process.platform] || commands.linux;
+  return new Promise((resolve) => {
+    const child = execFile(command, args, { stdio: "ignore" });
+    child.on("error", () => {
+      console.log(`无法自动打开浏览器，请访问：${url}`);
+      resolve();
+    });
+    child.on("close", () => resolve());
+  });
+}

package/src/menu.js

@@ -0,0 +1,72 @@
+export function createMainMenuChoices() {
+  return [
+    { label: "查看余额", value: "balance" },
+    { label: "微信扫码充值", value: "topup" },
+    { label: "启动 Claude Code", value: "launch_claude" },
+    { label: "启动 Codex", value: "launch_codex" },
+    { label: "安装或更新工具", value: "install_tools" },
+    { label: "切换 API Key / 分组", value: "switch_token" },
+    { label: "诊断", value: "diagnostics" },
+    { label: "退出", value: "exit" },
+  ];
+}
+
+export async function runMainMenu({
+  promptSelect,
+  actions = {},
+  config = {},
+  writeLine = console.log,
+} = {}) {
+  if (typeof promptSelect !== "function") {
+    throw new Error("缺少菜单选择输入");
+  }
+
+  const selected = await promptSelect("Claude360", createMainMenuChoices());
+  switch (selected) {
+  case "balance": {
+    const balance = await requireAction(actions, "loadBalance")();
+    writeLine(formatBalance(balance, config));
+    break;
+  }
+  case "topup":
+    await requireAction(actions, "runWechatTopUp")();
+    break;
+  case "launch_claude":
+    await requireAction(actions, "launchClaudeCode")();
+    break;
+  case "launch_codex":
+    await requireAction(actions, "launchCodex")();
+    break;
+  case "install_tools":
+    await requireAction(actions, "installOrUpdateTools")();
+    break;
+  case "switch_token":
+    await requireAction(actions, "switchToken")();
+    break;
+  case "diagnostics":
+    await requireAction(actions, "runDiagnostics")();
+    break;
+  case "exit":
+    break;
+  default:
+    throw new Error("未知菜单选项");
+  }
+  return selected;
+}
+
+function requireAction(actions, name) {
+  if (typeof actions[name] !== "function") {
+    throw new Error(`缺少菜单动作：${name}`);
+  }
+  return actions[name];
+}
+
+function formatBalance(balance, config) {
+  return [
+    `账号：${balance?.username || "-"}`,
+    `余额：${balance?.quota ?? "-"} ${balance?.display_unit || ""}`.trim(),
+    `已用：${balance?.used_quota ?? "-"}`,
+    `当前 Key：${config.tokenName || config.selectedTokenId || "-"}`,
+    `当前分组：${config.group || "-"}`,
+  ].join("\n");
+}

package/src/platform.js

@@ -0,0 +1,9 @@
+import os from "node:os";
+
+export function getPlatform() {
+  return process.platform;
+}
+
+export function getHomeDir() {
+  return os.homedir();
+}

package/src/token-manager.js

@@ -0,0 +1,99 @@
+import { loadGroups, selectGroup } from "./group-manager.js";
+import { maskSecret } from "./config-store.js";
+
+export async function loadBalance(api) {
+  return api.get("/api/cli/me");
+}
+
+export function formatTokenOption(token) {
+  const key = formatTokenKey(token.masked_key || token.key);
+  return [
+    token.name || `Token #${token.id}`,
+    key,
+    `group=${token.group || "-"}`,
+    `status=${formatStatus(token.status)}`,
+    `quota=${formatQuota(token)}`,
+    `expires=${formatExpiry(token.expired_time)}`,
+  ].filter(Boolean).join(" | ");
+}
+
+function formatTokenKey(key) {
+  if (!key) {
+    return "";
+  }
+  return key.includes("*") ? key : maskSecret(key);
+}
+
+export async function chooseOrCreateToken({
+  api,
+  promptSelect,
+  promptInput = async () => "Claude360 CLI",
+} = {}) {
+  if (!api) {
+    throw new Error("缺少 API client");
+  }
+
+  const page = await api.get("/api/cli/tokens");
+  const tokens = Array.isArray(page?.items) ? page.items : [];
+  if (tokens.length > 0) {
+    if (typeof promptSelect !== "function") {
+      throw new Error("缺少 Token 选择输入");
+    }
+    const choices = tokens.map((token) => ({
+      label: formatTokenOption(token),
+      value: token.id,
+    }));
+    const tokenId = await promptSelect("选择 API Key", choices);
+    const selected = tokens.find((token) => token.id === tokenId);
+    if (!selected) {
+      throw new Error("选择的 API Key 无效");
+    }
+    const revealed = await api.post(`/api/cli/tokens/${selected.id}/reveal`);
+    if (!revealed?.key) {
+      throw new Error("未返回 API Key");
+    }
+    return {
+      tokenId: selected.id,
+      tokenName: selected.name || `Token #${selected.id}`,
+      apiKey: revealed.key,
+      group: selected.group,
+      created: false,
+    };
+  }
+
+  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,
+  };
+}
+
+function formatStatus(status) {
+  return status === 1 ? "enabled" : "disabled";
+}
+
+function formatQuota(token) {
+  if (token.unlimited_quota) {
+    return "unlimited";
+  }
+  return String(token.remain_quota ?? 0);
+}
+
+function formatExpiry(expiredTime) {
+  if (expiredTime === -1 || expiredTime === 0 || expiredTime === undefined || expiredTime === null) {
+    return "never";
+  }
+  return String(expiredTime);
+}