@shi_zhen/code-helper 0.1.0

package/dist/cli/index.mjs

@@ -0,0 +1,3680 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports, module) {
+    module.exports = {
+      name: "@shi_zhen/code-helper",
+      version: "0.1.0",
+      description: "Code Helper - A unified tool to manage your Claude Code",
+      repository: {
+        type: "git",
+        url: "https://github.com/shirenchuang/code-helper.git"
+      },
+      author: "shirenchuang",
+      module: "dist/index.js",
+      typings: "dist/index.d.ts",
+      bin: {
+        ch: "./bin/code-helper.js",
+        "code-helper": "./bin/code-helper.js"
+      },
+      files: [
+        "bin",
+        "dist",
+        "LEGAL.md"
+      ],
+      scripts: {
+        build: "tsup",
+        "build:watch": "tsup --watch",
+        dev: "tsup --watch",
+        lint: "eslint src --ext .ts",
+        test: "jest",
+        prepublishOnly: "npm run build"
+      },
+      dependencies: {
+        "@babel/runtime": "^7.18.0",
+        boxen: "^5.1.2",
+        chalk: "^4.1.2",
+        execa: "^5.1.1",
+        figlet: "^1.7.0",
+        inquirer: "^8.2.6",
+        ora: "^5.4.1"
+      },
+      devDependencies: {
+        "@types/figlet": "^1.5.8",
+        "@types/inquirer": "^8.2.10",
+        "@types/node": "^20.0.0",
+        "@typescript-eslint/eslint-plugin": "^6.0.0",
+        "@typescript-eslint/parser": "^6.0.0",
+        eslint: "^8.0.0",
+        tsup: "^8.0.0",
+        typescript: "^5.0.0"
+      },
+      engines: {
+        node: ">=20"
+      },
+      keywords: [
+        "claude",
+        "claude-code",
+        "mcp",
+        "ai",
+        "cli",
+        "tools"
+      ],
+      license: "MIT"
+    };
+  }
+});
+
+// src/cli/utils/exec.ts
+import execa from "execa";
+async function executeCommand(command, envVars) {
+  try {
+    let finalCommand = command;
+    if (command.includes("|")) {
+      finalCommand = `set -o pipefail && ${command}`;
+    }
+    const { stdout } = await execa.command(finalCommand, {
+      shell: true,
+      stdio: "inherit",
+      env: envVars ? { ...process.env, ...envVars } : void 0
+    });
+    return stdout || "";
+  } catch (error) {
+    const execError = error;
+    throw new Error(execError.stderr || execError.message || "\u547D\u4EE4\u6267\u884C\u5931\u8D25");
+  }
+}
+async function executeCommandQuiet(command) {
+  try {
+    const { stdout } = await execa.command(command, {
+      shell: true
+    });
+    return stdout || "";
+  } catch (error) {
+    const execError = error;
+    throw new Error(execError.stderr || execError.message || "\u547D\u4EE4\u6267\u884C\u5931\u8D25");
+  }
+}
+async function commandExists(command) {
+  try {
+    await execa.command(`which ${command}`, { shell: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var init_exec = __esm({
+  "src/cli/utils/exec.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/utils/webui.ts
+var webui_exports = {};
+__export(webui_exports, {
+  launchWebUI: () => launchWebUI
+});
+import chalk2 from "chalk";
+import inquirer8 from "inquirer";
+async function launchWebUI() {
+  console.log(chalk2.cyan("\n\u{1F680} ClaudeCode UI \u542F\u52A8\u6307\u5357\n"));
+  console.log(chalk2.yellow("\u8BF7\u5728\u7EC8\u7AEF\u4E2D\u624B\u52A8\u6267\u884C\u4EE5\u4E0B\u547D\u4EE4\u6765\u542F\u52A8 Web UI\uFF1A\n"));
+  console.log(chalk2.green.bold("  npx @siteboon/claude-code-ui\n"));
+  console.log(
+    chalk2.dim("\u8BF4\u660E: \u4F7F\u7528\u5F00\u6E90\u7248\u672C\u7684 Claude Code UI")
+  );
+  console.log(chalk2.dim("      \u8FD9\u6837\u53EF\u4EE5\u786E\u4FDD\u4F7F\u7528\u6B63\u786E\u7684 Node.js \u7248\u672C\u548C\u4F9D\u8D56"));
+  console.log();
+  await inquirer8.prompt([
+    {
+      type: "input",
+      name: "confirm",
+      message: "\u6309 Enter \u952E\u8FD4\u56DE\u4E3B\u83DC\u5355"
+    }
+  ]);
+}
+var init_webui = __esm({
+  "src/cli/utils/webui.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/utils/version.ts
+var version_exports = {};
+__export(version_exports, {
+  checkAndUpdate: () => checkAndUpdate,
+  testUpdate: () => testUpdate
+});
+import chalk3 from "chalk";
+import ora7 from "ora";
+function getLocalVersion() {
+  const pkg3 = require_package();
+  return pkg3.version;
+}
+async function getRemoteVersion() {
+  try {
+    const result = await executeCommandQuiet(
+      "npm view code-helper version"
+    );
+    return result.trim();
+  } catch (error) {
+    console.error(chalk3.yellow("\u26A0\uFE0F  \u65E0\u6CD5\u68C0\u67E5\u7248\u672C\u66F4\u65B0"));
+    return null;
+  }
+}
+function readCache() {
+  try {
+    if (!fs9.existsSync(CACHE_FILE)) {
+      return null;
+    }
+    const content = fs9.readFileSync(CACHE_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function writeCache(data) {
+  try {
+    if (!fs9.existsSync(CACHE_DIR)) {
+      fs9.mkdirSync(CACHE_DIR, { recursive: true });
+    }
+    fs9.writeFileSync(CACHE_FILE, JSON.stringify(data, null, 2));
+  } catch (error) {
+  }
+}
+function compareVersions(v1, v2) {
+  const parts1 = v1.split(".").map(Number);
+  const parts2 = v2.split(".").map(Number);
+  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+    const part1 = parts1[i] || 0;
+    const part2 = parts2[i] || 0;
+    if (part1 > part2) return 1;
+    if (part1 < part2) return -1;
+  }
+  return 0;
+}
+async function updateToLatest() {
+  const spinner = ora7("\u6B63\u5728\u66F4\u65B0\u5230\u6700\u65B0\u7248\u672C...").start();
+  try {
+    await executeCommand("npm install -g code-helper@latest");
+    spinner.succeed(chalk3.green("\u2705 \u66F4\u65B0\u6210\u529F\uFF01"));
+    return true;
+  } catch (error) {
+    spinner.fail(chalk3.red("\u274C \u66F4\u65B0\u5931\u8D25"));
+    console.error(chalk3.red(`\u9519\u8BEF: ${error}`));
+    return false;
+  }
+}
+async function checkAndUpdate(forceCheck = false) {
+  const localVersion = getLocalVersion();
+  const cache = readCache();
+  const now = Date.now();
+  if (!forceCheck && cache && now - cache.lastCheck < CHECK_INTERVAL) {
+    if (compareVersions(cache.latestVersion, localVersion) > 0) {
+      console.log(
+        chalk3.yellow(
+          `
+\u{1F4A1} \u63D0\u793A: \u6709\u65B0\u7248\u672C ${cache.latestVersion} \u53EF\u7528 (\u5F53\u524D\u7248\u672C: ${localVersion})`
+        )
+      );
+      console.log(chalk3.gray("   \u4E0B\u6B21\u542F\u52A8\u65F6\u5C06\u81EA\u52A8\u66F4\u65B0...\n"));
+    }
+    return;
+  }
+  const spinner = ora7("\u6B63\u5728\u68C0\u67E5\u7248\u672C\u66F4\u65B0...").start();
+  const remoteVersion = await getRemoteVersion();
+  if (!remoteVersion) {
+    spinner.stop();
+    return;
+  }
+  writeCache({
+    lastCheck: now,
+    latestVersion: remoteVersion
+  });
+  if (compareVersions(remoteVersion, localVersion) > 0) {
+    spinner.succeed(
+      chalk3.cyan(`\u53D1\u73B0\u65B0\u7248\u672C: ${remoteVersion} (\u5F53\u524D\u7248\u672C: ${localVersion})`)
+    );
+    console.log(chalk3.gray("\u6B63\u5728\u81EA\u52A8\u66F4\u65B0...\n"));
+    const success = await updateToLatest();
+    if (success) {
+      console.log(
+        chalk3.green("\n\u2728 \u66F4\u65B0\u5B8C\u6210\uFF01\u8BF7\u91CD\u65B0\u8FD0\u884C\u547D\u4EE4\u4EE5\u4F7F\u7528\u6700\u65B0\u7248\u672C\u3002\n")
+      );
+      process.exit(0);
+    } else {
+      console.log(
+        chalk3.yellow(
+          "\n\u26A0\uFE0F  \u81EA\u52A8\u66F4\u65B0\u5931\u8D25\uFF0C\u4F60\u53EF\u4EE5\u624B\u52A8\u8FD0\u884C: npm install -g code-helper@latest\n"
+        )
+      );
+    }
+  } else {
+    spinner.succeed(chalk3.green(`\u5F53\u524D\u5DF2\u662F\u6700\u65B0\u7248\u672C v${localVersion}`));
+  }
+}
+async function testUpdate() {
+  const localVersion = getLocalVersion();
+  console.log(chalk3.cyan("\n\u{1F9EA} \u6D4B\u8BD5\u6A21\u5F0F: \u6A21\u62DF\u7248\u672C\u66F4\u65B0\u6D41\u7A0B\n"));
+  console.log(chalk3.gray(`\u5F53\u524D\u7248\u672C: ${localVersion}`));
+  console.log(chalk3.gray("\u6B63\u5728\u68C0\u67E5\u8FDC\u7A0B\u7248\u672C...\n"));
+  const remoteVersion = await getRemoteVersion();
+  if (!remoteVersion) {
+    console.log(chalk3.red("\u274C \u65E0\u6CD5\u83B7\u53D6\u8FDC\u7A0B\u7248\u672C"));
+    return;
+  }
+  console.log(chalk3.gray(`\u8FDC\u7A0B\u7248\u672C: ${remoteVersion}
+`));
+  if (compareVersions(remoteVersion, localVersion) > 0) {
+    console.log(chalk3.green("\u2705 \u8FDC\u7A0B\u7248\u672C\u66F4\u65B0\uFF0C\u4F1A\u89E6\u53D1\u81EA\u52A8\u66F4\u65B0"));
+  } else if (compareVersions(remoteVersion, localVersion) === 0) {
+    console.log(chalk3.yellow("\u26A0\uFE0F  \u8FDC\u7A0B\u7248\u672C\u4E0E\u672C\u5730\u7248\u672C\u76F8\u540C"));
+    console.log(chalk3.gray("   \u771F\u5B9E\u4F7F\u7528\u65F6\u4E0D\u4F1A\u89E6\u53D1\u66F4\u65B0"));
+  } else {
+    console.log(chalk3.yellow("\u26A0\uFE0F  \u672C\u5730\u7248\u672C\u9AD8\u4E8E\u8FDC\u7A0B\u7248\u672C"));
+    console.log(chalk3.gray("   \u8FD9\u901A\u5E38\u53D1\u751F\u5728\u672C\u5730\u5F00\u53D1\u65F6"));
+  }
+  console.log(
+    chalk3.cyan("\n\u{1F4A1} \u63D0\u793A: \u53D1\u5E03\u65B0\u7248\u672C\u540E\uFF0C\u7528\u6237\u9996\u6B21\u542F\u52A8\u65F6\u4F1A\u81EA\u52A8\u66F4\u65B0\n")
+  );
+}
+var os10, path10, fs9, CACHE_DIR, CACHE_FILE, CHECK_INTERVAL;
+var init_version = __esm({
+  "src/cli/utils/version.ts"() {
+    "use strict";
+    init_exec();
+    os10 = __require("os");
+    path10 = __require("path");
+    fs9 = __require("fs");
+    CACHE_DIR = path10.join(os10.homedir(), ".code-helper");
+    CACHE_FILE = path10.join(CACHE_DIR, "version-check.json");
+    CHECK_INTERVAL = 24 * 60 * 60 * 1e3;
+  }
+});
+
+// src/cli/menus/main.ts
+import inquirer9 from "inquirer";
+
+// src/cli/ui.ts
+import boxen from "boxen";
+import chalk from "chalk";
+import figlet from "figlet";
+var pkg = require_package();
+var VERSION = pkg.version;
+var theme = {
+  primary: chalk.hex("#FF8C00"),
+  // 深橙色
+  secondary: chalk.hex("#FFA500"),
+  // 橙色
+  success: chalk.green,
+  error: chalk.red,
+  warning: chalk.yellow,
+  info: chalk.cyan,
+  dim: chalk.gray
+};
+function generateTitle() {
+  try {
+    const title = figlet.textSync("CODE HELPER", {
+      font: "Standard",
+      horizontalLayout: "default"
+    });
+    return theme.primary(title);
+  } catch {
+    return theme.primary("CODE HELPER");
+  }
+}
+function showHeader() {
+  console.clear();
+  const title = generateTitle();
+  const subtitle = `Code Helper v${VERSION}
+A unified tool to manage your Claude Code`;
+  const header = boxen(
+    `${title}
+
+${theme.secondary(subtitle)}`,
+    {
+      padding: 1,
+      margin: 1,
+      borderStyle: "round",
+      borderColor: "yellow",
+      textAlignment: "center"
+    }
+  );
+  console.log(header);
+}
+function showSuccess(message) {
+  console.log(theme.success(`\u2713 ${message}`));
+}
+function showError(message) {
+  console.log(theme.error(`\u2717 ${message}`));
+}
+function showWarning(message) {
+  console.log(theme.warning(`\u26A0 ${message}`));
+}
+function showInfo(message) {
+  console.log(theme.info(`\u2139 ${message}`));
+}
+function createBoxTitle(title) {
+  return boxen(theme.primary(title), {
+    padding: { left: 2, right: 2, top: 0, bottom: 0 },
+    borderStyle: "round",
+    borderColor: "yellow",
+    textAlignment: "center"
+  });
+}
+
+// src/cli/utils/claude.ts
+import { execSync } from "child_process";
+import fs from "fs";
+import os from "os";
+import path from "path";
+var cachedInfo = null;
+var lastCheckTime = 0;
+var CACHE_DURATION = 5e3;
+function execSyncWithTimeout(command, timeoutMs = 2e3) {
+  try {
+    return execSync(command, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "ignore"],
+      timeout: timeoutMs
+    }).trim();
+  } catch {
+    return "";
+  }
+}
+function detectClaudeInstallationSync() {
+  try {
+    const whichResult = execSyncWithTimeout("which claude", 1e3);
+    if (!whichResult) {
+      return { installed: false };
+    }
+    let installMethod = "unknown";
+    const officialPaths = [
+      path.join(os.homedir(), ".local/bin/claude"),
+      path.join(os.homedir(), ".claude/bin/claude")
+    ];
+    for (const officialPath of officialPaths) {
+      if (whichResult === officialPath || fs.existsSync(officialPath)) {
+        installMethod = "official";
+        break;
+      }
+    }
+    if (installMethod === "unknown" && whichResult.includes("node_modules")) {
+      installMethod = "npm";
+    }
+    if (installMethod === "unknown" && process.platform === "darwin" && whichResult.includes("homebrew")) {
+      installMethod = "homebrew";
+    }
+    let version;
+    try {
+      const versionOutput = execSyncWithTimeout("claude --version", 1500);
+      if (versionOutput) {
+        const versionMatch = versionOutput.match(/(\d+\.\d+\.\d+)/);
+        version = versionMatch ? versionMatch[1] : versionOutput;
+      }
+    } catch {
+      version = void 0;
+    }
+    return {
+      installed: true,
+      version,
+      installMethod,
+      binaryPath: whichResult
+    };
+  } catch {
+    return { installed: false };
+  }
+}
+function formatInstallMethod(method) {
+  switch (method) {
+    case "npm":
+      return "npm \u5168\u5C40\u5B89\u88C5";
+    case "official":
+      return "\u5B98\u65B9\u811A\u672C\u5B89\u88C5";
+    case "homebrew":
+      return "Homebrew \u5B89\u88C5";
+    case "unknown":
+    default:
+      return "\u672A\u77E5\u65B9\u5F0F";
+  }
+}
+function detectClaudeInstallation() {
+  const now = Date.now();
+  if (cachedInfo && now - lastCheckTime < CACHE_DURATION) {
+    return cachedInfo;
+  }
+  cachedInfo = detectClaudeInstallationSync();
+  lastCheckTime = now;
+  return cachedInfo;
+}
+function getCachedClaudeInfo() {
+  return cachedInfo;
+}
+function clearClaudeCache() {
+  cachedInfo = null;
+  lastCheckTime = 0;
+}
+function formatClaudeStatus(info) {
+  if (!info.installed) {
+    return "\u672A\u5B89\u88C5";
+  }
+  const parts = ["\u5DF2\u5B89\u88C5"];
+  if (info.version) {
+    parts.push(`v${info.version}`);
+  }
+  if (info.installMethod) {
+    parts.push(`(${formatInstallMethod(info.installMethod)})`);
+  }
+  return parts.join(" ");
+}
+
+// src/cli/utils/config.ts
+import fs2 from "fs";
+import os2 from "os";
+import path2 from "path";
+var CLAUDE_DIR = path2.join(os2.homedir(), ".claude");
+var SETTINGS_FILE = path2.join(CLAUDE_DIR, "settings.json");
+var CODE_HELPER_CONFIG_FILE = path2.join(CLAUDE_DIR, "code-helper.json");
+var CODE_HELPER_DIR = path2.join(os2.homedir(), ".code-helper");
+var PROFILES_FILE = path2.join(CODE_HELPER_DIR, "profiles.json");
+var GLM_BASE_URL = "https://open.bigmodel.cn/api/anthropic";
+var KIMI_BASE_URL = "https://api.kimi.com/coding";
+var DEFAULT_BASE_URL = "https://api.anthropic.com";
+function ensureClaudeDir() {
+  if (!fs2.existsSync(CLAUDE_DIR)) {
+    fs2.mkdirSync(CLAUDE_DIR, { recursive: true });
+  }
+}
+function readClaudeSettings() {
+  try {
+    if (fs2.existsSync(SETTINGS_FILE)) {
+      const content = fs2.readFileSync(SETTINGS_FILE, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch {
+  }
+  return {};
+}
+function writeClaudeSettings(settings) {
+  ensureClaudeDir();
+  fs2.writeFileSync(SETTINGS_FILE, JSON.stringify(settings, null, 2), "utf-8");
+}
+function readCodeHelperConfig() {
+  try {
+    if (fs2.existsSync(CODE_HELPER_CONFIG_FILE)) {
+      const content = fs2.readFileSync(CODE_HELPER_CONFIG_FILE, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch {
+  }
+  return {
+    version: "0.1.0",
+    installedMcps: [],
+    installedPlugins: [],
+    preferences: {
+      defaultBaseUrl: DEFAULT_BASE_URL
+    }
+  };
+}
+function writeCodeHelperConfig(config) {
+  ensureClaudeDir();
+  fs2.writeFileSync(CODE_HELPER_CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+}
+function getApiKeyStatus() {
+  const settings = readClaudeSettings();
+  const apiKey = settings.env?.ANTHROPIC_AUTH_TOKEN;
+  if (apiKey && apiKey.length > 0) {
+    const masked = apiKey.substring(0, 4) + "****";
+    return theme.success(`\u5DF2\u8BBE\u7F6E (${masked})`);
+  }
+  return theme.dim("\u672A\u8BBE\u7F6E");
+}
+function getBaseUrlStatus() {
+  const settings = readClaudeSettings();
+  const baseUrl = settings.env?.ANTHROPIC_BASE_URL;
+  if (baseUrl && baseUrl.length > 0) {
+    try {
+      const url = new URL(baseUrl);
+      return theme.success(url.host);
+    } catch {
+      return theme.success(baseUrl);
+    }
+  }
+  return theme.dim("\u672A\u8BBE\u7F6E");
+}
+async function saveApiConfig(baseUrl, apiKey, options) {
+  const settings = readClaudeSettings();
+  if (!settings.env) {
+    settings.env = {};
+  }
+  delete settings.env.ANTHROPIC_MODEL;
+  delete settings.env.ANTHROPIC_SMALL_FAST_MODEL;
+  delete settings.env.ANTHROPIC_DEFAULT_HAIKU_MODEL;
+  delete settings.env.ANTHROPIC_DEFAULT_OPUS_MODEL;
+  delete settings.env.ANTHROPIC_DEFAULT_SONNET_MODEL;
+  delete settings.env.API_TIMEOUT_MS;
+  delete settings.skipWebFetchPreflight;
+  settings.env.ANTHROPIC_AUTH_TOKEN = apiKey;
+  settings.env.ANTHROPIC_BASE_URL = baseUrl;
+  settings.env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = "1";
+  if (options?.model) {
+    settings.env.ANTHROPIC_MODEL = options.model;
+  }
+  if (options?.smallFastModel) {
+    settings.env.ANTHROPIC_SMALL_FAST_MODEL = options.smallFastModel;
+  }
+  if (options?.haikuModel) {
+    settings.env.ANTHROPIC_DEFAULT_HAIKU_MODEL = options.haikuModel;
+  }
+  if (options?.opusModel) {
+    settings.env.ANTHROPIC_DEFAULT_OPUS_MODEL = options.opusModel;
+  }
+  if (options?.sonnetModel) {
+    settings.env.ANTHROPIC_DEFAULT_SONNET_MODEL = options.sonnetModel;
+  }
+  if (options?.skipWebFetchPreflight) {
+    settings.skipWebFetchPreflight = true;
+  }
+  if (options?.timeout) {
+    settings.env.API_TIMEOUT_MS = options.timeout;
+  }
+  writeClaudeSettings(settings);
+  const helperConfig = readCodeHelperConfig();
+  helperConfig.preferences.defaultBaseUrl = baseUrl;
+  writeCodeHelperConfig(helperConfig);
+}
+function ensureCodeHelperDir() {
+  if (!fs2.existsSync(CODE_HELPER_DIR)) {
+    fs2.mkdirSync(CODE_HELPER_DIR, { recursive: true });
+  }
+}
+function readProfiles() {
+  try {
+    if (fs2.existsSync(PROFILES_FILE)) {
+      const content = fs2.readFileSync(PROFILES_FILE, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch {
+  }
+  return {
+    version: "1.0.0",
+    currentProfileId: null,
+    profiles: []
+  };
+}
+function writeProfiles(config) {
+  ensureCodeHelperDir();
+  fs2.writeFileSync(PROFILES_FILE, JSON.stringify(config, null, 2), "utf-8");
+}
+function getAllProfiles() {
+  return readProfiles().profiles;
+}
+function getCurrentProfile() {
+  const config = readProfiles();
+  if (!config.currentProfileId) return null;
+  return config.profiles.find((p) => p.id === config.currentProfileId) || null;
+}
+function addProfile(profile) {
+  const config = readProfiles();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const newProfile = {
+    ...profile,
+    id: `profile_${Date.now()}`,
+    createdAt: now,
+    updatedAt: now
+  };
+  config.profiles.push(newProfile);
+  writeProfiles(config);
+  return newProfile;
+}
+function deleteProfile(id) {
+  const config = readProfiles();
+  const index = config.profiles.findIndex((p) => p.id === id);
+  if (index === -1) return false;
+  config.profiles.splice(index, 1);
+  if (config.currentProfileId === id) {
+    config.currentProfileId = null;
+  }
+  writeProfiles(config);
+  return true;
+}
+function switchProfile(id) {
+  const config = readProfiles();
+  const profile = config.profiles.find((p) => p.id === id);
+  if (!profile) return false;
+  const settings = readClaudeSettings();
+  if (!settings.env) {
+    settings.env = {};
+  }
+  delete settings.env.ANTHROPIC_MODEL;
+  delete settings.env.ANTHROPIC_SMALL_FAST_MODEL;
+  delete settings.env.ANTHROPIC_DEFAULT_HAIKU_MODEL;
+  delete settings.env.ANTHROPIC_DEFAULT_OPUS_MODEL;
+  delete settings.env.ANTHROPIC_DEFAULT_SONNET_MODEL;
+  delete settings.env.API_TIMEOUT_MS;
+  delete settings.skipWebFetchPreflight;
+  settings.env.ANTHROPIC_AUTH_TOKEN = profile.apiKey;
+  settings.env.ANTHROPIC_BASE_URL = profile.baseUrl;
+  settings.env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC = "1";
+  if (profile.model) {
+    settings.env.ANTHROPIC_MODEL = profile.model;
+  }
+  if (profile.timeout) {
+    settings.env.API_TIMEOUT_MS = profile.timeout;
+  }
+  writeClaudeSettings(settings);
+  config.currentProfileId = id;
+  writeProfiles(config);
+  return true;
+}
+function getCurrentProfileStatus() {
+  const current = getCurrentProfile();
+  if (current) {
+    return theme.success(`${current.name}`);
+  }
+  return theme.dim("\u672A\u9009\u62E9\u914D\u7F6E");
+}
+
+// src/cli/menus/auth.ts
+import inquirer from "inquirer";
+import ora from "ora";
+
+// src/cli/utils/api.ts
+import http from "http";
+import https from "https";
+async function verifyApiKey(baseUrl, apiKey) {
+  return new Promise((resolve) => {
+    try {
+      const url = new URL(baseUrl);
+      const isHttps = url.protocol === "https:";
+      const client = isHttps ? https : http;
+      const testPayload = JSON.stringify({
+        model: "claude-3-5-sonnet-20241022",
+        max_tokens: 1,
+        messages: [{ role: "user", content: "test" }]
+      });
+      const requestOptions = {
+        hostname: url.hostname,
+        port: url.port || (isHttps ? 443 : 80),
+        path: `${url.pathname}/v1/messages`.replace(/\/+/g, "/"),
+        method: "POST",
+        headers: {
+          "x-api-key": apiKey,
+          "anthropic-version": "2023-06-01",
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(testPayload)
+        },
+        timeout: 15e3
+        // 15秒超时
+      };
+      const req = client.request(requestOptions, (res) => {
+        let responseData = "";
+        res.on("data", (chunk) => {
+          responseData += chunk;
+        });
+        res.on("end", () => {
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            resolve({ valid: true });
+          } else if (res.statusCode === 401 || res.statusCode === 403) {
+            resolve({ valid: false, error: "API Key \u65E0\u6548\u6216\u672A\u6388\u6743" });
+          } else if (res.statusCode === 400) {
+            try {
+              const errorData = JSON.parse(responseData);
+              if (errorData.error?.message) {
+                if (errorData.error.message.includes("model") || errorData.error.message.includes("\u4E0D\u652F\u6301")) {
+                  resolve({ valid: true });
+                  return;
+                }
+              }
+            } catch {
+            }
+            resolve({ valid: true });
+          } else {
+            resolve({
+              valid: false,
+              error: `\u670D\u52A1\u5668\u8FD4\u56DE\u9519\u8BEF (${res.statusCode})`
+            });
+          }
+        });
+      });
+      req.on("error", (error) => {
+        if (error.message.includes("ENOTFOUND")) {
+          resolve({
+            valid: false,
+            error: "Base URL \u65E0\u6CD5\u8BBF\u95EE\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u6216 URL \u662F\u5426\u6B63\u786E"
+          });
+        } else if (error.message.includes("ETIMEDOUT") || error.message.includes("ECONNREFUSED")) {
+          resolve({ valid: false, error: "\u8FDE\u63A5\u8D85\u65F6\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u6216\u4EE3\u7406\u8BBE\u7F6E" });
+        } else {
+          resolve({ valid: false, error: `\u7F51\u7EDC\u9519\u8BEF: ${error.message}` });
+        }
+      });
+      req.on("timeout", () => {
+        req.destroy();
+        resolve({ valid: false, error: "\u8BF7\u6C42\u8D85\u65F6\uFF0C\u8BF7\u68C0\u67E5\u7F51\u7EDC\u8FDE\u63A5" });
+      });
+      req.write(testPayload);
+      req.end();
+    } catch (error) {
+      resolve({
+        valid: false,
+        error: `\u9A8C\u8BC1\u5931\u8D25: ${error.message}`
+      });
+    }
+  });
+}
+
+// src/cli/menus/auth.ts
+async function showAuthMenu() {
+  while (true) {
+    showHeader();
+    console.log(createBoxTitle("\u6388\u6743\u767B\u5F55"));
+    console.log();
+    const currentProfile = getCurrentProfile();
+    if (currentProfile) {
+      console.log(
+        `${theme.primary("\u5F53\u524D\u914D\u7F6E\uFF1A")} ${theme.success(currentProfile.name)}`
+      );
+      console.log(`${theme.dim("  Base URL:")} ${currentProfile.baseUrl}`);
+      console.log(
+        `${theme.dim("  API Key:")} ${maskApiKey(currentProfile.apiKey)}`
+      );
+      console.log();
+    }
+    const savedProfiles = getAllProfiles();
+    const choices = [
+      {
+        name: `Claude API ${theme.dim("(\u63A8\u8350 - \u5B98\u65B9 API)")}`,
+        value: { type: "claude" }
+      },
+      {
+        name: `\u667A\u8C31 GLM AI ${theme.dim("(\u5F00\u653E\u5E73\u53F0)")}`,
+        value: { type: "glm" }
+      },
+      {
+        name: `Kimi AI ${theme.dim("(\u6708\u4E4B\u6697\u9762)")}`,
+        value: { type: "kimi" }
+      },
+      {
+        name: `\u624B\u52A8\u8F93\u5165\u5BC6\u94A5 ${theme.dim("(\u81EA\u5B9A\u4E49 Base URL)")}`,
+        value: { type: "manual" }
+      }
+    ];
+    if (savedProfiles.length > 0) {
+      choices.push(new inquirer.Separator());
+      choices.push(new inquirer.Separator(theme.dim("\u2500\u2500 \u5DF2\u4FDD\u5B58\u7684\u914D\u7F6E \u2500\u2500")));
+      for (const profile of savedProfiles) {
+        const isCurrent = currentProfile?.id === profile.id;
+        if (isCurrent) {
+          choices.push({
+            name: `${theme.success("\u2713")} ${theme.info("\u6062\u590D")} ${profile.name} ${theme.dim("(\u5F53\u524D)")}`,
+            value: { type: "restore", profile }
+          });
+        } else {
+          choices.push({
+            name: `  ${theme.info("\u6062\u590D")} ${profile.name}`,
+            value: { type: "restore", profile }
+          });
+        }
+      }
+      choices.push({
+        name: `  ${theme.error("\u2715")} \u7BA1\u7406\u5DF2\u4FDD\u5B58\u7684\u914D\u7F6E`,
+        value: { type: "manage" }
+      });
+    }
+    choices.push(
+      new inquirer.Separator(),
+      {
+        name: `${theme.dim("<-")} \u8FD4\u56DE`,
+        value: { type: "back" }
+      },
+      {
+        name: `${theme.dim("X")}  \u9000\u51FA`,
+        value: { type: "exit" }
+      }
+    );
+    const { choice } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "choice",
+        message: "\u8BF7\u9009\u62E9\u6388\u6743\u65B9\u5F0F\uFF1A",
+        pageSize: 15,
+        choices
+      }
+    ]);
+    switch (choice.type) {
+      case "claude":
+        await handleClaudeAuth();
+        break;
+      case "glm":
+        await handleGlmAuth();
+        break;
+      case "kimi":
+        await handleKimiAuth();
+        break;
+      case "manual":
+        await handleManualAuth();
+        break;
+      case "restore":
+        await handleRestoreProfile(choice.profile);
+        break;
+      case "manage":
+        await handleManageProfiles();
+        break;
+      case "back":
+        return;
+      case "exit":
+        process.exit(0);
+    }
+  }
+}
+async function handleClaudeAuth() {
+  console.log();
+  console.log(theme.primary("Claude API \u6388\u6743"));
+  console.log();
+  console.log(theme.dim("Base URL: ") + DEFAULT_BASE_URL);
+  console.log();
+  showInfo("\u83B7\u53D6 API Key \u65B9\u5F0F\uFF1A");
+  console.log(
+    theme.dim("  1. \u8BBF\u95EE https://console.anthropic.com/settings/keys")
+  );
+  console.log(theme.dim("  2. \u521B\u5EFA\u6216\u590D\u5236 API Key"));
+  console.log(theme.dim("  3. \u7C98\u8D34\u5230\u4E0B\u65B9"));
+  console.log();
+  console.log(theme.dim("  (\u76F4\u63A5\u6309\u56DE\u8F66\u53EF\u8FD4\u56DE)"));
+  console.log();
+  const { apiKey } = await inquirer.prompt([
+    {
+      type: "password",
+      name: "apiKey",
+      message: "\u8BF7\u8F93\u5165 Claude API Key:",
+      mask: "*"
+    }
+  ]);
+  if (!apiKey || apiKey.trim().length === 0) {
+    return;
+  }
+  console.log();
+  const spinner = ora("\u6B63\u5728\u9A8C\u8BC1 API Key...").start();
+  const verification = await verifyApiKey(DEFAULT_BASE_URL, apiKey.trim());
+  if (!verification.valid) {
+    spinner.fail("API Key \u9A8C\u8BC1\u5931\u8D25");
+    console.log();
+    showError(verification.error || "\u672A\u77E5\u9519\u8BEF");
+    await waitForEnter();
+    return;
+  }
+  spinner.succeed("API Key \u9A8C\u8BC1\u901A\u8FC7");
+  try {
+    await saveApiConfig(DEFAULT_BASE_URL, apiKey.trim());
+    console.log();
+    showSuccess("Claude API \u6388\u6743\u914D\u7F6E\u5DF2\u751F\u6548");
+    displaySavedConfig();
+    await askToSaveProfile(
+      "Claude API",
+      DEFAULT_BASE_URL,
+      apiKey.trim()
+    );
+  } catch (error) {
+    console.log();
+    showError(`\u4FDD\u5B58\u914D\u7F6E\u5931\u8D25: ${error.message}`);
+    await waitForEnter();
+  }
+}
+async function handleGlmAuth() {
+  console.log();
+  console.log(theme.primary("\u667A\u8C31 GLM AI \u6388\u6743"));
+  console.log();
+  console.log(theme.dim("Base URL: ") + GLM_BASE_URL);
+  console.log();
+  showInfo("\u83B7\u53D6 API Key \u65B9\u5F0F\uFF1A");
+  console.log(
+    theme.dim("  1. \u8BBF\u95EE https://bigmodel.cn/usercenter/proj-mgmt/apikeys")
+  );
+  console.log(theme.dim("  2. \u521B\u5EFA\u6216\u590D\u5236 API Key"));
+  console.log(theme.dim("  3. \u7C98\u8D34\u5230\u4E0B\u65B9"));
+  console.log();
+  console.log(theme.dim("  (\u76F4\u63A5\u6309\u56DE\u8F66\u53EF\u8FD4\u56DE)"));
+  console.log();
+  const { apiKey } = await inquirer.prompt([
+    {
+      type: "password",
+      name: "apiKey",
+      message: "\u8BF7\u8F93\u5165\u667A\u8C31 API Key:",
+      mask: "*"
+    }
+  ]);
+  if (!apiKey || apiKey.trim().length === 0) {
+    return;
+  }
+  console.log();
+  const spinner = ora("\u6B63\u5728\u9A8C\u8BC1 API Key...").start();
+  const verification = await verifyApiKey(GLM_BASE_URL, apiKey.trim());
+  if (!verification.valid) {
+    spinner.fail("API Key \u9A8C\u8BC1\u5931\u8D25");
+    console.log();
+    showError(verification.error || "\u672A\u77E5\u9519\u8BEF");
+    await waitForEnter();
+    return;
+  }
+  spinner.succeed("API Key \u9A8C\u8BC1\u901A\u8FC7");
+  try {
+    await saveApiConfig(GLM_BASE_URL, apiKey.trim(), {
+      timeout: "3000000"
+    });
+    console.log();
+    showSuccess("\u667A\u8C31 GLM AI \u6388\u6743\u914D\u7F6E\u5DF2\u751F\u6548");
+    displaySavedConfig();
+    await askToSaveProfile(
+      "\u667A\u8C31 GLM",
+      GLM_BASE_URL,
+      apiKey.trim(),
+      void 0,
+      "3000000"
+    );
+  } catch (error) {
+    console.log();
+    showError(`\u4FDD\u5B58\u914D\u7F6E\u5931\u8D25: ${error.message}`);
+    await waitForEnter();
+  }
+}
+async function handleKimiAuth() {
+  console.log();
+  console.log(theme.primary("Kimi AI \u6388\u6743"));
+  console.log();
+  console.log(theme.dim("Base URL: ") + KIMI_BASE_URL);
+  console.log();
+  showInfo("\u83B7\u53D6 API Key \u65B9\u5F0F\uFF1A");
+  console.log(theme.dim("  1. \u8BBF\u95EE Kimi AI \u5B98\u7F51\u83B7\u53D6 API Key"));
+  console.log(theme.dim("  2. \u521B\u5EFA\u6216\u590D\u5236 API Key"));
+  console.log(theme.dim("  3. \u7C98\u8D34\u5230\u4E0B\u65B9"));
+  console.log();
+  console.log(theme.dim("  (\u76F4\u63A5\u6309\u56DE\u8F66\u53EF\u8FD4\u56DE)"));
+  console.log();
+  const { apiKey } = await inquirer.prompt([
+    {
+      type: "password",
+      name: "apiKey",
+      message: "\u8BF7\u8F93\u5165 Kimi API Key:",
+      mask: "*"
+    }
+  ]);
+  if (!apiKey || apiKey.trim().length === 0) {
+    return;
+  }
+  console.log();
+  const spinner = ora("\u6B63\u5728\u9A8C\u8BC1 API Key...").start();
+  const verification = await verifyApiKey(KIMI_BASE_URL, apiKey.trim());
+  if (!verification.valid) {
+    spinner.fail("API Key \u9A8C\u8BC1\u5931\u8D25");
+    console.log();
+    showError(verification.error || "\u672A\u77E5\u9519\u8BEF");
+    await waitForEnter();
+    return;
+  }
+  spinner.succeed("API Key \u9A8C\u8BC1\u901A\u8FC7");
+  try {
+    await saveApiConfig(KIMI_BASE_URL, apiKey.trim(), {
+      timeout: "3000000"
+    });
+    console.log();
+    showSuccess("Kimi AI \u6388\u6743\u914D\u7F6E\u5DF2\u751F\u6548");
+    displaySavedConfig();
+    await askToSaveProfile(
+      "Kimi AI",
+      KIMI_BASE_URL,
+      apiKey.trim(),
+      void 0,
+      "3000000"
+    );
+  } catch (error) {
+    console.log();
+    showError(`\u4FDD\u5B58\u914D\u7F6E\u5931\u8D25: ${error.message}`);
+    await waitForEnter();
+  }
+}
+async function handleManualAuth() {
+  console.log();
+  console.log(theme.primary("\u624B\u52A8\u8F93\u5165\u914D\u7F6E"));
+  console.log();
+  console.log(theme.dim("\u53EA\u9700\u914D\u7F6E\u4EE5\u4E0B\u5FC5\u8981\u5B57\u6BB5\uFF1A"));
+  console.log(theme.dim("  - ANTHROPIC_AUTH_TOKEN"));
+  console.log(theme.dim("  - ANTHROPIC_BASE_URL"));
+  console.log(theme.dim("  - API_TIMEOUT_MS (\u53EF\u9009)"));
+  console.log(
+    theme.dim("  - CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC (\u9ED8\u8BA4\u7981\u7528)")
+  );
+  console.log();
+  console.log(theme.dim("(\u4EFB\u610F\u6B65\u9AA4\u76F4\u63A5\u6309\u56DE\u8F66\u53EF\u8FD4\u56DE)"));
+  console.log();
+  const { baseUrl } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "baseUrl",
+      message: "\u8BF7\u8F93\u5165 ANTHROPIC_BASE_URL:",
+      default: DEFAULT_BASE_URL
+    }
+  ]);
+  if (!baseUrl || baseUrl.trim().length === 0) {
+    return;
+  }
+  const { apiKey } = await inquirer.prompt([
+    {
+      type: "password",
+      name: "apiKey",
+      message: "\u8BF7\u8F93\u5165 ANTHROPIC_AUTH_TOKEN:",
+      mask: "*"
+    }
+  ]);
+  if (!apiKey || apiKey.trim().length === 0) {
+    return;
+  }
+  const { timeout } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "timeout",
+      message: "\u8BF7\u8F93\u5165 API_TIMEOUT_MS\uFF08\u6BEB\u79D2\uFF0C\u76F4\u63A5\u56DE\u8F66\u8DF3\u8FC7\uFF09:",
+      default: "",
+      validate: (input) => {
+        if (!input || input.trim() === "") return true;
+        const num = parseInt(input.trim(), 10);
+        return !isNaN(num) && num > 0 || "\u8BF7\u8F93\u5165\u6709\u6548\u7684\u6570\u5B57";
+      }
+    }
+  ]);
+  console.log();
+  const spinner = ora("\u6B63\u5728\u9A8C\u8BC1 API Key...").start();
+  const verification = await verifyApiKey(baseUrl.trim(), apiKey.trim());
+  if (!verification.valid) {
+    spinner.fail("API Key \u9A8C\u8BC1\u5931\u8D25");
+    console.log();
+    showError(verification.error || "\u672A\u77E5\u9519\u8BEF");
+    await waitForEnter();
+    return;
+  }
+  spinner.succeed("API Key \u9A8C\u8BC1\u901A\u8FC7");
+  try {
+    const options = {};
+    if (timeout && timeout.trim()) {
+      options.timeout = timeout.trim();
+    }
+    await saveApiConfig(baseUrl.trim(), apiKey.trim(), options);
+    console.log();
+    showSuccess("\u914D\u7F6E\u5DF2\u751F\u6548");
+    displaySavedConfig();
+    await askToSaveProfile(
+      "\u81EA\u5B9A\u4E49\u914D\u7F6E",
+      baseUrl.trim(),
+      apiKey.trim(),
+      void 0,
+      timeout && timeout.trim() ? timeout.trim() : void 0
+    );
+  } catch (error) {
+    console.log();
+    showError(`\u4FDD\u5B58\u914D\u7F6E\u5931\u8D25: ${error.message}`);
+    await waitForEnter();
+  }
+}
+async function askToSaveProfile(defaultName, baseUrl, apiKey, model, timeout) {
+  console.log();
+  const { save } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "save",
+      message: "\u662F\u5426\u4FDD\u5B58\u6B64\u914D\u7F6E\u4EE5\u4FBF\u4E0B\u6B21\u5FEB\u901F\u6062\u590D\uFF1F",
+      default: true
+    }
+  ]);
+  if (!save) {
+    await waitForEnter();
+    return;
+  }
+  const { name } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "name",
+      message: "\u8BF7\u8F93\u5165\u914D\u7F6E\u540D\u79F0\uFF1A",
+      default: defaultName,
+      validate: (input) => input.trim() !== "" || "\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A"
+    }
+  ]);
+  try {
+    const newProfile = addProfile({
+      name: name.trim(),
+      baseUrl,
+      apiKey,
+      model,
+      timeout
+    });
+    switchProfile(newProfile.id);
+    showSuccess(`\u914D\u7F6E "${name.trim()}" \u5DF2\u4FDD\u5B58`);
+    showInfo('\u4E0B\u6B21\u53EF\u4EE5\u76F4\u63A5\u9009\u62E9"\u6062\u590D"\u6765\u5FEB\u901F\u5207\u6362');
+  } catch (error) {
+    showError(`\u4FDD\u5B58\u5931\u8D25: ${error.message}`);
+  }
+  await waitForEnter();
+}
+async function handleRestoreProfile(profile) {
+  console.log();
+  try {
+    const success = switchProfile(profile.id);
+    if (success) {
+      showSuccess(`\u5DF2\u5207\u6362\u5230\uFF1A${profile.name}`);
+      showInfo("\u914D\u7F6E\u5DF2\u751F\u6548");
+    } else {
+      showError("\u5207\u6362\u5931\u8D25");
+    }
+  } catch (error) {
+    showError(`\u5207\u6362\u5931\u8D25: ${error.message}`);
+  }
+  await waitForEnter();
+}
+async function handleManageProfiles() {
+  while (true) {
+    const profiles = getAllProfiles();
+    const currentProfile = getCurrentProfile();
+    if (profiles.length === 0) {
+      console.log();
+      showWarning("\u6CA1\u6709\u5DF2\u4FDD\u5B58\u7684\u914D\u7F6E");
+      await waitForEnter();
+      return;
+    }
+    showHeader();
+    console.log(createBoxTitle("\u7BA1\u7406\u5DF2\u4FDD\u5B58\u7684\u914D\u7F6E"));
+    console.log();
+    const choices = profiles.map((p) => {
+      const isCurrent = currentProfile?.id === p.id;
+      const suffix = isCurrent ? theme.warning(" (\u5F53\u524D\u4F7F\u7528\u4E2D)") : "";
+      return {
+        name: `${theme.error("\u2715")} \u5220\u9664 ${p.name}${suffix} ${theme.dim(
+          `- ${p.baseUrl}`
+        )}`,
+        value: p
+      };
+    });
+    choices.push(new inquirer.Separator(), {
+      name: `${theme.dim("<-")} \u8FD4\u56DE`,
+      value: null
+    });
+    const { profile } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "profile",
+        message: "\u8BF7\u9009\u62E9\u8981\u5220\u9664\u7684\u914D\u7F6E\uFF1A",
+        pageSize: 10,
+        choices
+      }
+    ]);
+    if (!profile) return;
+    const { confirm } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: `\u786E\u5B9A\u8981\u5220\u9664\u914D\u7F6E "${profile.name}" \u5417\uFF1F`,
+        default: false
+      }
+    ]);
+    if (!confirm) {
+      continue;
+    }
+    try {
+      deleteProfile(profile.id);
+      showSuccess(`\u914D\u7F6E "${profile.name}" \u5DF2\u5220\u9664`);
+    } catch (error) {
+      showError(`\u5220\u9664\u5931\u8D25: ${error.message}`);
+    }
+    await waitForEnter();
+  }
+}
+function maskApiKey(apiKey) {
+  if (apiKey.length <= 8) {
+    return "*".repeat(apiKey.length);
+  }
+  return apiKey.substring(0, 4) + "****" + apiKey.substring(apiKey.length - 4);
+}
+function displaySavedConfig() {
+  const settings = readClaudeSettings();
+  console.log();
+  console.log(theme.dim("\u914D\u7F6E\u5DF2\u540C\u6B65\uFF1A"));
+  console.log(JSON.stringify(settings, null, 2));
+}
+async function waitForEnter() {
+  console.log();
+  await inquirer.prompt([
+    { type: "input", name: "continue", message: "\u6309\u56DE\u8F66\u952E\u7EE7\u7EED..." }
+  ]);
+}
+
+// src/cli/menus/manage.ts
+import inquirer4 from "inquirer";
+import ora4 from "ora";
+
+// src/cli/menus/install.ts
+import { execSync as execSync2 } from "child_process";
+import inquirer2 from "inquirer";
+import net from "net";
+import ora2 from "ora";
+init_exec();
+
+// src/cli/utils/platform.ts
+import os3 from "os";
+function getOsName(platform) {
+  switch (platform) {
+    case "darwin":
+      return "macOS";
+    case "win32":
+      return "Windows";
+    case "linux":
+      return "Linux";
+    default:
+      return platform;
+  }
+}
+function getArchName(arch) {
+  switch (arch) {
+    case "x64":
+      return "x64";
+    case "arm64":
+      return "arm64";
+    case "ia32":
+      return "x86";
+    default:
+      return arch;
+  }
+}
+function detectPlatform() {
+  const platform = os3.platform();
+  const arch = os3.arch();
+  return {
+    os: platform,
+    osName: getOsName(platform),
+    arch: getArchName(arch),
+    isWindows: platform === "win32",
+    isMac: platform === "darwin",
+    isLinux: platform === "linux"
+  };
+}
+
+// src/cli/menus/install.ts
+var COMMON_PROXY_PORTS = [
+  { port: 7890, name: "Clash" },
+  { port: 7891, name: "Clash (SOCKS)" },
+  { port: 1087, name: "V2RayU" },
+  { port: 1086, name: "V2RayU (SOCKS)" },
+  { port: 8118, name: "Privoxy" },
+  { port: 1080, name: "SOCKS5" },
+  { port: 8080, name: "HTTP Proxy" },
+  { port: 9090, name: "Clash Dashboard" }
+];
+var INSTALL_METHODS = [
+  {
+    name: "\u5B98\u65B9\u811A\u672C\u5B89\u88C5",
+    command: "curl -fsSL https://claude.ai/install.sh | bash",
+    description: "\u9700\u8981\u4EE3\u7406\u6216\u5916\u7F51\u8BBF\u95EE",
+    platforms: ["darwin", "linux"],
+    recommended: true
+  },
+  {
+    name: "npm \u5B89\u88C5",
+    command: "npm install -g @anthropic-ai/claude-code",
+    description: "\u65E0\u9700\u7FFB\u5899",
+    platforms: ["darwin", "linux", "win32"]
+  },
+  {
+    name: "\u5B98\u65B9\u811A\u672C\u5B89\u88C5 (Windows)",
+    command: "irm https://claude.ai/install.ps1 | iex",
+    description: "\u9700\u8981\u4EE3\u7406\u6216\u5916\u7F51\u8BBF\u95EE",
+    platforms: ["win32"],
+    recommended: true
+  },
+  {
+    name: "WinGet \u5B89\u88C5",
+    command: "winget install Anthropic.ClaudeCode",
+    description: "\u9002\u7528\u4E8E Windows",
+    platforms: ["win32"]
+  }
+];
+function getAvailableMethods(platform) {
+  return INSTALL_METHODS.filter(
+    (method) => method.platforms.includes(platform.os)
+  );
+}
+function checkPort(port, host = "127.0.0.1") {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    socket.setTimeout(500);
+    socket.on("connect", () => {
+      socket.destroy();
+      resolve(true);
+    });
+    socket.on("timeout", () => {
+      socket.destroy();
+      resolve(false);
+    });
+    socket.on("error", () => {
+      socket.destroy();
+      resolve(false);
+    });
+    socket.connect(port, host);
+  });
+}
+function getSystemProxy() {
+  const httpProxy = process.env.http_proxy || process.env.HTTP_PROXY;
+  const httpsProxy = process.env.https_proxy || process.env.HTTPS_PROXY;
+  const proxy = httpsProxy || httpProxy;
+  if (proxy) {
+    try {
+      const url = new URL(proxy);
+      return { host: url.hostname, port: parseInt(url.port) || 80 };
+    } catch {
+    }
+  }
+  if (process.platform === "darwin") {
+    try {
+      const output = execSync2('networksetup -getwebproxy "Wi-Fi"', {
+        encoding: "utf-8",
+        timeout: 3e3
+      });
+      const enabledMatch = output.match(/Enabled:\s*(Yes|No)/i);
+      const serverMatch = output.match(/Server:\s*(\S+)/);
+      const portMatch = output.match(/Port:\s*(\d+)/);
+      if (enabledMatch?.[1].toLowerCase() === "yes" && serverMatch && portMatch) {
+        return { host: serverMatch[1], port: parseInt(portMatch[1]) };
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function detectProxyPorts() {
+  const availablePorts = [];
+  const results = await Promise.all(
+    COMMON_PROXY_PORTS.map(async ({ port, name }) => {
+      const isOpen = await checkPort(port);
+      return { port, name, isOpen };
+    })
+  );
+  for (const result of results) {
+    if (result.isOpen) {
+      availablePorts.push({ port: result.port, name: result.name });
+    }
+  }
+  return availablePorts;
+}
+function isNetworkError(errorMessage) {
+  const networkErrorPatterns = [
+    "syntax error",
+    "<!DOCTYPE",
+    "<html",
+    "Could not resolve host",
+    "Connection refused",
+    "Network is unreachable",
+    "Operation timed out",
+    "SSL",
+    "SSL_connect",
+    "SSL_ERROR",
+    "LibreSSL",
+    "certificate",
+    "ENOTFOUND",
+    "ECONNREFUSED",
+    "ETIMEDOUT",
+    "ECONNRESET"
+  ];
+  return networkErrorPatterns.some(
+    (pattern) => errorMessage.toLowerCase().includes(pattern.toLowerCase())
+  );
+}
+function formatErrorMessage(error) {
+  const errorMsg = error.message;
+  if (isNetworkError(errorMsg)) {
+    return "\u7F51\u7EDC\u8FDE\u63A5\u5931\u8D25\uFF0C\u8BE5\u5B89\u88C5\u65B9\u5F0F\u9700\u8981\u80FD\u591F\u8BBF\u95EE\u5916\u7F51";
+  }
+  const lines = errorMsg.split("\n").filter((line) => line.trim());
+  if (lines.length > 2) {
+    return lines.slice(0, 2).join("\n") + `
+${theme.dim(`... \u7701\u7565 ${lines.length - 2} \u884C`)}`;
+  }
+  return errorMsg;
+}
+function needsExternalNetwork(command) {
+  return command.includes("claude.ai");
+}
+async function showInstallMenu() {
+  showHeader();
+  const platform = detectPlatform();
+  console.log(createBoxTitle("\u5B89\u88C5 Claude Code"));
+  console.log();
+  showInfo(`\u68C0\u6D4B\u5230\u60A8\u7684\u7CFB\u7EDF\uFF1A${platform.osName} ${platform.arch}`);
+  console.log();
+  const availableMethods = getAvailableMethods(platform);
+  const choices = availableMethods.map((method2) => ({
+    name: `${method2.name}${method2.recommended ? theme.success(" (\u63A8\u8350)") : ""} - ${theme.dim(method2.description)}`,
+    value: method2
+  }));
+  choices.push(new inquirer2.Separator());
+  choices.push({
+    name: `${theme.dim("<-")} \u8FD4\u56DE`,
+    value: null
+  });
+  choices.push({
+    name: `${theme.dim("X")}  \u9000\u51FA`,
+    value: "exit"
+  });
+  const { method } = await inquirer2.prompt([
+    {
+      type: "list",
+      name: "method",
+      message: "\u8BF7\u9009\u62E9\u5B89\u88C5\u65B9\u5F0F\uFF1A",
+      choices
+    }
+  ]);
+  if (!method) {
+    return;
+  }
+  if (method === "exit") {
+    process.exit(0);
+  }
+  let proxyUrl = null;
+  let finalMethod = method;
+  if (needsExternalNetwork(method.command)) {
+    console.log();
+    const spinner2 = ora2("\u68C0\u6D4B\u672C\u673A\u4EE3\u7406...").start();
+    const systemProxy = getSystemProxy();
+    const detectedPorts = await detectProxyPorts();
+    spinner2.stop();
+    const proxyChoices = [];
+    if (systemProxy) {
+      proxyChoices.push({
+        name: `${theme.success("\u2713")} \u7CFB\u7EDF\u4EE3\u7406 ${theme.dim(
+          `(${systemProxy.host}:${systemProxy.port})`
+        )}`,
+        value: `http://${systemProxy.host}:${systemProxy.port}`
+      });
+    }
+    for (const { port, name } of detectedPorts) {
+      if (systemProxy && systemProxy.port === port) continue;
+      proxyChoices.push({
+        name: `${theme.success("\u2713")} ${name} ${theme.dim(
+          `(127.0.0.1:${port})`
+        )}`,
+        value: `http://127.0.0.1:${port}`
+      });
+    }
+    const hasDetectedProxy = proxyChoices.length > 0;
+    if (hasDetectedProxy) {
+      showInfo("\u68C0\u6D4B\u5230\u672C\u673A\u4EE3\u7406\uFF1A");
+      for (const choice of proxyChoices) {
+        console.log(`  ${choice.name}`);
+      }
+      console.log();
+      const { useProxy } = await inquirer2.prompt([
+        {
+          type: "confirm",
+          name: "useProxy",
+          message: "\u662F\u5426\u4F7F\u7528\u4EE3\u7406\uFF1F\uFF08\u5EFA\u8BAE\u5F00\u542F\uFF09",
+          default: true
+        }
+      ]);
+      if (useProxy) {
+        if (proxyChoices.length === 1) {
+          proxyUrl = proxyChoices[0].value;
+        } else {
+          proxyChoices.push(new inquirer2.Separator());
+          proxyChoices.push({
+            name: `${theme.dim("\u2715")} \u4E0D\u4F7F\u7528\u4EE3\u7406`,
+            value: null
+          });
+          const { selectedProxy } = await inquirer2.prompt([
+            {
+              type: "list",
+              name: "selectedProxy",
+              message: "\u8BF7\u9009\u62E9\u4EE3\u7406\uFF1A",
+              choices: proxyChoices
+            }
+          ]);
+          if (selectedProxy) {
+            proxyUrl = selectedProxy;
+          }
+        }
+      }
+    } else {
+      showWarning("\u672A\u68C0\u6D4B\u5230\u672C\u673A\u4EE3\u7406");
+      showInfo("\u81EA\u52A8\u5207\u6362\u5230 npm \u5B89\u88C5\u65B9\u5F0F\uFF08\u65E0\u9700\u7FFB\u5899\uFF09");
+      console.log();
+      const npmMethod = availableMethods.find(
+        (m) => m.command.includes("npm install")
+      );
+      if (npmMethod) {
+        finalMethod = npmMethod;
+      }
+    }
+  }
+  let finalCommand = finalMethod.command;
+  let envVars = {};
+  if (proxyUrl) {
+    if (finalCommand.includes("curl")) {
+      finalCommand = finalCommand.replace("curl ", `curl --proxy ${proxyUrl} `);
+    } else {
+      envVars = {
+        http_proxy: proxyUrl,
+        https_proxy: proxyUrl,
+        HTTP_PROXY: proxyUrl,
+        HTTPS_PROXY: proxyUrl
+      };
+    }
+    showInfo(`\u4F7F\u7528\u4EE3\u7406: ${proxyUrl}`);
+  }
+  console.log();
+  showInfo(`\u5C06\u6267\u884C\u547D\u4EE4: ${theme.secondary(finalCommand)}`);
+  console.log();
+  const { confirm } = await inquirer2.prompt([
+    {
+      type: "confirm",
+      name: "confirm",
+      message: "\u786E\u8BA4\u6267\u884C\u5B89\u88C5\uFF1F",
+      default: true
+    }
+  ]);
+  if (!confirm) {
+    return;
+  }
+  const spinner = ora2("\u6B63\u5728\u5B89\u88C5 Claude Code...").start();
+  try {
+    await executeCommand(finalCommand, envVars);
+    spinner.text = "\u9A8C\u8BC1\u5B89\u88C5...";
+    const installed = await commandExists("claude");
+    if (installed) {
+      spinner.succeed("Claude Code \u5B89\u88C5\u6210\u529F\uFF01");
+      showSuccess("\u60A8\u73B0\u5728\u53EF\u4EE5\u5728\u7EC8\u7AEF\u4E2D\u8FD0\u884C claude \u547D\u4EE4");
+      console.log();
+      showInfo("\u4E0B\u4E00\u6B65\uFF1A\u914D\u7F6E API \u5BC6\u94A5");
+      console.log(
+        theme.dim('  \u8FD4\u56DE\u4E3B\u83DC\u5355 -> \u9009\u62E9 "\u6388\u6743\u767B\u5F55" -> \u914D\u7F6E\u60A8\u7684 API Key')
+      );
+      console.log(theme.dim("  \u914D\u7F6E\u5B8C\u6210\u540E\u5373\u53EF\u5F00\u59CB\u4F7F\u7528 Claude Code"));
+    } else {
+      spinner.fail("\u5B89\u88C5\u5931\u8D25");
+      showError("\u5B89\u88C5\u547D\u4EE4\u6267\u884C\u5B8C\u6210\uFF0C\u4F46\u672A\u627E\u5230 claude \u547D\u4EE4");
+      console.log();
+      showInfo("\u53EF\u80FD\u7684\u539F\u56E0\uFF1A");
+      console.log(theme.dim("  1. \u5B89\u88C5\u8FC7\u7A0B\u4E2D\u51FA\u73B0\u7F51\u7EDC\u9519\u8BEF"));
+      console.log(theme.dim("  2. \u9700\u8981\u91CD\u65B0\u6253\u5F00\u7EC8\u7AEF\u624D\u80FD\u4F7F\u7528 claude \u547D\u4EE4"));
+      console.log(theme.dim("  3. \u73AF\u5883\u53D8\u91CF PATH \u672A\u6B63\u786E\u8BBE\u7F6E"));
+      console.log();
+      showInfo("\u5EFA\u8BAE\uFF1A");
+      if (proxyUrl) {
+        console.log(
+          theme.dim(
+            "  1. \u68C0\u67E5\u4EE3\u7406\u8F6F\u4EF6\u662F\u5426\u8BBE\u7F6E\u4E3A\u3010\u5168\u5C40\u6A21\u5F0F\u3011\uFF08\u89C4\u5219\u6A21\u5F0F\u53EF\u80FD\u62E6\u622A claude.ai\uFF09"
+          )
+        );
+        console.log(theme.dim('  2. \u6362\u7528 "npm \u5B89\u88C5" \u65B9\u5F0F\uFF08\u65E0\u9700\u7FFB\u5899\uFF09'));
+      } else {
+        console.log(
+          theme.dim('  1. \u4F7F\u7528\u4EE3\u7406\u91CD\u8BD5\uFF08\u9009\u62E9"\u5B98\u65B9\u811A\u672C\u5B89\u88C5"\u540E\u5F00\u542F\u4EE3\u7406\u9009\u9879\uFF09')
+        );
+        console.log(theme.dim('  2. \u6362\u7528 "npm \u5B89\u88C5" \u65B9\u5F0F\uFF08\u65E0\u9700\u7FFB\u5899\uFF09'));
+      }
+    }
+  } catch (error) {
+    spinner.fail("\u5B89\u88C5\u5931\u8D25");
+    const friendlyError = formatErrorMessage(error);
+    showError(friendlyError);
+    if (isNetworkError(error.message)) {
+      console.log();
+      showInfo("\u5EFA\u8BAE\uFF1A");
+      if (proxyUrl) {
+        console.log(
+          theme.dim(
+            "  1. \u68C0\u67E5\u4EE3\u7406\u8F6F\u4EF6\u662F\u5426\u8BBE\u7F6E\u4E3A\u3010\u5168\u5C40\u6A21\u5F0F\u3011\uFF08\u89C4\u5219\u6A21\u5F0F\u53EF\u80FD\u62E6\u622A claude.ai\uFF09"
+          )
+        );
+        console.log(theme.dim("  2. \u5C1D\u8BD5\u66F4\u6362\u4EE3\u7406\u7AEF\u53E3\u6216\u4EE3\u7406\u8F6F\u4EF6"));
+        console.log(theme.dim('  3. \u6362\u7528 "npm \u5B89\u88C5" \u65B9\u5F0F\uFF08\u65E0\u9700\u7FFB\u5899\uFF09'));
+      } else {
+        console.log(
+          theme.dim('  1. \u4F7F\u7528\u4EE3\u7406\u91CD\u8BD5\uFF08\u9009\u62E9"\u5B98\u65B9\u811A\u672C\u5B89\u88C5"\u540E\u5F00\u542F\u4EE3\u7406\u9009\u9879\uFF09')
+        );
+        console.log(theme.dim('  2. \u6362\u7528 "npm \u5B89\u88C5" \u65B9\u5F0F\uFF08\u65E0\u9700\u7FFB\u5899\uFF09'));
+      }
+    }
+  }
+  await inquirer2.prompt([
+    {
+      type: "input",
+      name: "continue",
+      message: "\u6309\u56DE\u8F66\u952E\u8FD4\u56DE\u4E3B\u83DC\u5355..."
+    }
+  ]);
+}
+
+// src/cli/menus/uninstall.ts
+import fs3 from "fs";
+import inquirer3 from "inquirer";
+import ora3 from "ora";
+import os4 from "os";
+import path3 from "path";
+init_exec();
+async function showUninstallMenu() {
+  showHeader();
+  console.log(createBoxTitle("\u5378\u8F7D Claude Code"));
+  console.log();
+  const { choice } = await inquirer3.prompt([
+    {
+      type: "list",
+      name: "choice",
+      message: "\u8BF7\u9009\u62E9\u5378\u8F7D\u65B9\u5F0F\uFF1A",
+      choices: [
+        {
+          name: `\u4EC5\u5378\u8F7D\u7A0B\u5E8F ${theme.dim("(\u4FDD\u7559\u914D\u7F6E\u3001\u4F1A\u8BDD\u548C\u63D2\u4EF6)")}`,
+          value: "program_only" /* PROGRAM_ONLY */
+        },
+        {
+          name: `${theme.error("\u5B8C\u6574\u5378\u8F7D")} ${theme.dim(
+            "(\u5220\u9664\u7A0B\u5E8F\u3001\u914D\u7F6E\u3001\u4F1A\u8BDD\u548C\u63D2\u4EF6)"
+          )}`,
+          value: "complete" /* COMPLETE */
+        },
+        new inquirer3.Separator(),
+        {
+          name: `${theme.dim("<-")} \u8FD4\u56DE`,
+          value: "back" /* BACK */
+        },
+        {
+          name: `${theme.dim("X")}  \u9000\u51FA`,
+          value: "exit" /* EXIT */
+        }
+      ]
+    }
+  ]);
+  switch (choice) {
+    case "program_only" /* PROGRAM_ONLY */:
+      await handleProgramOnlyUninstall();
+      break;
+    case "complete" /* COMPLETE */:
+      await handleCompleteUninstall();
+      break;
+    case "back" /* BACK */:
+      return;
+    case "exit" /* EXIT */:
+      process.exit(0);
+  }
+}
+async function handleProgramOnlyUninstall() {
+  console.log();
+  showInfo("\u5C06\u4EC5\u5378\u8F7D Claude Code \u7A0B\u5E8F\uFF0C\u4FDD\u7559\u4EE5\u4E0B\u5185\u5BB9\uFF1A");
+  console.log(theme.dim("  - ~/.claude/ \u76EE\u5F55\uFF08\u914D\u7F6E\u548C\u4F1A\u8BDD\uFF09"));
+  console.log(theme.dim("  - ~/.claude.json\uFF08MCP \u914D\u7F6E\uFF09"));
+  console.log(theme.dim("  - \u5DF2\u5B89\u88C5\u7684\u63D2\u4EF6"));
+  console.log();
+  const { confirm } = await inquirer3.prompt([
+    {
+      type: "confirm",
+      name: "confirm",
+      message: "\u786E\u8BA4\u5378\u8F7D Claude Code \u7A0B\u5E8F\uFF1F",
+      default: false
+    }
+  ]);
+  if (!confirm) {
+    return;
+  }
+  const spinner = ora3("\u6B63\u5728\u5378\u8F7D Claude Code...").start();
+  try {
+    const platform = detectPlatform();
+    let uninstalled = false;
+    try {
+      await executeCommand("npm uninstall -g @anthropic-ai/claude-code");
+      uninstalled = true;
+    } catch {
+    }
+    if (platform.isMac && !uninstalled) {
+      try {
+        await executeCommand("brew uninstall --cask claude 2>/dev/null");
+        uninstalled = true;
+      } catch {
+      }
+    }
+    const binaryPaths = [
+      "/usr/local/bin/claude",
+      path3.join(os4.homedir(), ".local/bin/claude"),
+      path3.join(os4.homedir(), ".claude/bin/claude")
+    ];
+    for (const binPath of binaryPaths) {
+      if (fs3.existsSync(binPath)) {
+        try {
+          fs3.unlinkSync(binPath);
+          uninstalled = true;
+        } catch {
+        }
+      }
+    }
+    if (uninstalled) {
+      spinner.succeed("Claude Code \u7A0B\u5E8F\u5DF2\u5378\u8F7D");
+      showSuccess("\u914D\u7F6E\u548C\u4F1A\u8BDD\u5DF2\u4FDD\u7559\uFF0C\u91CD\u65B0\u5B89\u88C5\u540E\u53EF\u7EE7\u7EED\u4F7F\u7528");
+    } else {
+      spinner.warn("\u672A\u627E\u5230\u5DF2\u5B89\u88C5\u7684 Claude Code");
+      showInfo("\u53EF\u80FD\u5DF2\u7ECF\u5378\u8F7D\u6216\u4F7F\u7528\u4E86\u5176\u4ED6\u5B89\u88C5\u65B9\u5F0F");
+    }
+  } catch (error) {
+    spinner.fail("\u5378\u8F7D\u5931\u8D25");
+    showError(error.message);
+  }
+  console.log();
+  await inquirer3.prompt([
+    {
+      type: "input",
+      name: "continue",
+      message: "\u6309\u56DE\u8F66\u952E\u8FD4\u56DE..."
+    }
+  ]);
+}
+async function handleCompleteUninstall() {
+  console.log();
+  showWarning("\u26A0\uFE0F  \u5B8C\u6574\u5378\u8F7D\u5C06\u5220\u9664\u4EE5\u4E0B\u6240\u6709\u5185\u5BB9\uFF1A");
+  console.log(theme.error("  - Claude Code \u7A0B\u5E8F"));
+  console.log(theme.error("  - ~/.claude/ \u76EE\u5F55\uFF08\u914D\u7F6E\u548C\u4F1A\u8BDD\uFF09"));
+  console.log(theme.error("  - ~/.claude.json\uFF08MCP \u914D\u7F6E\uFF09"));
+  console.log(theme.error("  - \u5DF2\u5B89\u88C5\u7684\u63D2\u4EF6"));
+  console.log();
+  showWarning("\u6B64\u64CD\u4F5C\u4E0D\u53EF\u6062\u590D\uFF01");
+  console.log();
+  const { confirmFirst } = await inquirer3.prompt([
+    {
+      type: "confirm",
+      name: "confirmFirst",
+      message: "\u786E\u8BA4\u8981\u5B8C\u6574\u5378\u8F7D Claude Code\uFF1F",
+      default: false
+    }
+  ]);
+  if (!confirmFirst) {
+    return;
+  }
+  const { confirmSecond } = await inquirer3.prompt([
+    {
+      type: "input",
+      name: "confirmSecond",
+      message: '\u8BF7\u8F93\u5165 "DELETE" \u786E\u8BA4\u5220\u9664\uFF1A'
+    }
+  ]);
+  if (confirmSecond !== "DELETE") {
+    showInfo("\u5DF2\u53D6\u6D88\u5378\u8F7D");
+    return;
+  }
+  const spinner = ora3("\u6B63\u5728\u5B8C\u6574\u5378\u8F7D Claude Code...").start();
+  try {
+    const platform = detectPlatform();
+    spinner.text = "\u5378\u8F7D\u7A0B\u5E8F...";
+    try {
+      await executeCommand(
+        "npm uninstall -g @anthropic-ai/claude-code 2>/dev/null || true"
+      );
+    } catch {
+    }
+    if (platform.isMac) {
+      try {
+        await executeCommand(
+          "brew uninstall --cask claude 2>/dev/null || true"
+        );
+      } catch {
+      }
+    }
+    const binaryPaths = [
+      "/usr/local/bin/claude",
+      path3.join(os4.homedir(), ".local/bin/claude"),
+      path3.join(os4.homedir(), ".claude/bin/claude")
+    ];
+    for (const binPath of binaryPaths) {
+      if (fs3.existsSync(binPath)) {
+        try {
+          fs3.unlinkSync(binPath);
+        } catch {
+        }
+      }
+    }
+    spinner.text = "\u5220\u9664\u914D\u7F6E\u548C\u4F1A\u8BDD...";
+    const claudeDir = path3.join(os4.homedir(), ".claude");
+    if (fs3.existsSync(claudeDir)) {
+      fs3.rmSync(claudeDir, { recursive: true, force: true });
+    }
+    spinner.text = "\u5220\u9664 MCP \u914D\u7F6E...";
+    const claudeJson = path3.join(os4.homedir(), ".claude.json");
+    if (fs3.existsSync(claudeJson)) {
+      fs3.unlinkSync(claudeJson);
+    }
+    spinner.succeed("Claude Code \u5DF2\u5B8C\u6574\u5378\u8F7D");
+    showSuccess("\u6240\u6709\u7A0B\u5E8F\u3001\u914D\u7F6E\u548C\u6570\u636E\u5DF2\u5220\u9664");
+  } catch (error) {
+    spinner.fail("\u5378\u8F7D\u8FC7\u7A0B\u4E2D\u51FA\u73B0\u9519\u8BEF");
+    showError(error.message);
+  }
+  console.log();
+  await inquirer3.prompt([
+    {
+      type: "input",
+      name: "continue",
+      message: "\u6309\u56DE\u8F66\u952E\u8FD4\u56DE..."
+    }
+  ]);
+}
+
+// src/cli/menus/manage.ts
+async function showManageMenu() {
+  let claudeInfo = getCachedClaudeInfo();
+  if (!claudeInfo) {
+    const spinner = ora4("\u6B63\u5728\u68C0\u6D4B Claude Code...").start();
+    claudeInfo = detectClaudeInstallation();
+    spinner.stop();
+  }
+  while (true) {
+    showHeader();
+    console.log(createBoxTitle("Claude Code \u7BA1\u7406"));
+    console.log();
+    console.log(theme.primary("\u5F53\u524D\u72B6\u6001\uFF1A"));
+    console.log();
+    if (claudeInfo.installed) {
+      showInfo(`\u2713 \u5DF2\u5B89\u88C5`);
+      if (claudeInfo.version) {
+        console.log(`  \u7248\u672C\uFF1A${theme.success(claudeInfo.version)}`);
+      }
+      if (claudeInfo.installMethod) {
+        console.log(
+          `  \u5B89\u88C5\u65B9\u5F0F\uFF1A${theme.info(
+            formatInstallMethod(claudeInfo.installMethod)
+          )}`
+        );
+      }
+      if (claudeInfo.binaryPath) {
+        console.log(`  \u8DEF\u5F84\uFF1A${theme.dim(claudeInfo.binaryPath)}`);
+      }
+    } else {
+      showInfo(`\u2717 \u672A\u5B89\u88C5`);
+    }
+    console.log();
+    const { choice } = await inquirer4.prompt([
+      {
+        type: "list",
+        name: "choice",
+        message: "\u8BF7\u9009\u62E9\u64CD\u4F5C\uFF1A",
+        choices: [
+          {
+            name: `${theme.primary(">")} \u5B89\u88C5 Claude Code`,
+            value: "install" /* INSTALL */
+          },
+          {
+            name: `${theme.error("*")} \u5378\u8F7D Claude Code`,
+            value: "uninstall" /* UNINSTALL */,
+            disabled: !claudeInfo.installed ? "\u672A\u5B89\u88C5" : false
+          },
+          {
+            name: `${theme.info("\u21BB")} \u5237\u65B0\u72B6\u6001`,
+            value: "refresh" /* REFRESH */
+          },
+          new inquirer4.Separator(),
+          {
+            name: `${theme.dim("<-")} \u8FD4\u56DE`,
+            value: "back" /* BACK */
+          },
+          {
+            name: `${theme.dim("X")}  \u9000\u51FA`,
+            value: "exit" /* EXIT */
+          }
+        ]
+      }
+    ]);
+    switch (choice) {
+      case "install" /* INSTALL */:
+        await showInstallMenu();
+        clearClaudeCache();
+        claudeInfo = detectClaudeInstallation();
+        break;
+      case "uninstall" /* UNINSTALL */:
+        await showUninstallMenu();
+        clearClaudeCache();
+        claudeInfo = detectClaudeInstallation();
+        break;
+      case "refresh" /* REFRESH */: {
+        const spinner = ora4("\u6B63\u5728\u5237\u65B0\u72B6\u6001...").start();
+        clearClaudeCache();
+        claudeInfo = detectClaudeInstallation();
+        spinner.succeed("\u72B6\u6001\u5DF2\u5237\u65B0");
+        await new Promise((resolve) => {
+          setTimeout(resolve, 500);
+        });
+        break;
+      }
+      case "back" /* BACK */:
+        return;
+      case "exit" /* EXIT */:
+        process.exit(0);
+    }
+  }
+}
+
+// src/cli/menus/mcp.ts
+import inquirer5 from "inquirer";
+import ora5 from "ora";
+
+// src/cli/services/mcp.ts
+import fs5 from "fs";
+import os6 from "os";
+import path6 from "path";
+
+// src/cli/config/constants.ts
+import path4 from "path";
+var CONFIG_DIR = path4.resolve(__dirname, "../../../config");
+var MARKETS_CONFIG_FILE = path4.join(CONFIG_DIR, "markets.json");
+var MCP_SERVERS_CONFIG_FILE = path4.join(CONFIG_DIR, "mcpServers.json");
+var CACHE_TTL = 6 * 60 * 60 * 1e3;
+var BUILTIN_DEFAULT_MARKETS = [
+  {
+    name: "macopowers",
+    source: "https://github.com/macopowers-dev/macopowers.git",
+    description: "MacoPowers Official Plugin Marketplace",
+    category: "official",
+    recommended: true,
+    default: true
+  }
+];
+var BUILTIN_DEFAULT_MCPS = [
+  {
+    id: "context7",
+    name: "Context7",
+    description: "Get real-time documentation and code examples for popular libraries like React, Next.js, Node.js",
+    usage: 'Query the latest API docs, usage examples and best practices for any library in Claude. Example: "How to use Next.js 14 Server Actions?", "React useEffect latest usage".',
+    transport: "http",
+    url: "https://mcp.context7.com/mcp",
+    headers: {
+      CONTEXT7_API_KEY: "${CONTEXT7_API_KEY}"
+    },
+    requiredEnv: ["CONTEXT7_API_KEY"],
+    apiKeyUrl: "https://context7.com/dashboard",
+    category: "builtin",
+    recommended: true,
+    source: "local"
+  }
+];
+
+// src/cli/utils/cache.ts
+import fs4 from "fs";
+import os5 from "os";
+import path5 from "path";
+var CacheManager = class {
+  cacheDir;
+  cacheFile;
+  constructor(cacheName) {
+    this.cacheDir = path5.join(os5.homedir(), ".code-helper", "cache");
+    this.cacheFile = path5.join(this.cacheDir, `${cacheName}.json`);
+    this.ensureCacheDir();
+  }
+  /**
+   * 加载缓存
+   */
+  load() {
+    try {
+      if (!fs4.existsSync(this.cacheFile)) {
+        return null;
+      }
+      const content = fs4.readFileSync(this.cacheFile, "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      return null;
+    }
+  }
+  /**
+   * 保存缓存
+   */
+  save(data) {
+    const cacheData = {
+      data,
+      timestamp: Date.now()
+    };
+    fs4.writeFileSync(this.cacheFile, JSON.stringify(cacheData, null, 2));
+  }
+  /**
+   * 检查缓存是否过期
+   */
+  isExpired(ttl) {
+    try {
+      if (!fs4.existsSync(this.cacheFile)) {
+        return true;
+      }
+      const content = fs4.readFileSync(this.cacheFile, "utf-8");
+      const { timestamp } = JSON.parse(content);
+      return Date.now() - timestamp > ttl;
+    } catch (error) {
+      return true;
+    }
+  }
+  /**
+   * 清除缓存
+   */
+  clear() {
+    if (fs4.existsSync(this.cacheFile)) {
+      fs4.unlinkSync(this.cacheFile);
+    }
+  }
+  /**
+   * 确保缓存目录存在
+   */
+  ensureCacheDir() {
+    if (!fs4.existsSync(this.cacheDir)) {
+      fs4.mkdirSync(this.cacheDir, { recursive: true });
+    }
+  }
+};
+
+// src/cli/services/mcp.ts
+var CLAUDE_JSON_FILE = path6.join(os6.homedir(), ".claude.json");
+var McpService = class {
+  cacheManager;
+  constructor() {
+    this.cacheManager = new CacheManager("mcp-servers");
+  }
+  /**
+   * 获取所有 MCP 推荐列表（从本地配置文件读取）
+   */
+  async fetchMcpServers() {
+    try {
+      if (fs5.existsSync(MCP_SERVERS_CONFIG_FILE)) {
+        const content = fs5.readFileSync(MCP_SERVERS_CONFIG_FILE, "utf-8");
+        const data = JSON.parse(content);
+        if (data.mcpServers && Array.isArray(data.mcpServers)) {
+          const mcpServers = this.normalizeServers(data.mcpServers);
+          return this.mergeServers(BUILTIN_DEFAULT_MCPS, mcpServers);
+        }
+      }
+      showWarning("\u4F7F\u7528\u5185\u7F6E\u9ED8\u8BA4 MCP \u914D\u7F6E");
+      return BUILTIN_DEFAULT_MCPS;
+    } catch (error) {
+      showWarning("\u8BFB\u53D6 MCP \u914D\u7F6E\u6587\u4EF6\u5931\u8D25\uFF0C\u4F7F\u7528\u5185\u7F6E\u9ED8\u8BA4\u914D\u7F6E");
+      return BUILTIN_DEFAULT_MCPS;
+    }
+  }
+  /**
+   * 刷新 MCP 列表（清除缓存并重新获取）
+   */
+  async refreshMcpServers() {
+    this.cacheManager.clear();
+    return this.fetchMcpServers();
+  }
+  /**
+   * 标准化 MCP 服务器数据
+   */
+  normalizeServers(rawServers) {
+    return rawServers.map((server) => ({
+      id: server.id,
+      name: server.name,
+      description: server.description,
+      usage: server.usage,
+      transport: server.transport || "stdio",
+      // 默认 stdio 传输
+      package: server.package,
+      command: server.command,
+      args: server.args || [],
+      url: server.url,
+      headers: server.headers,
+      env: server.env,
+      requiredEnv: server.requiredEnv,
+      apiKeyUrl: server.apiKeyUrl,
+      category: server.category || "remote",
+      recommended: server.recommended || false,
+      source: server.source || "marketplace"
+    }));
+  }
+  /**
+   * 合并本地和远程 MCP 列表（去重）
+   */
+  mergeServers(localServers, remoteServers) {
+    const serverMap = /* @__PURE__ */ new Map();
+    for (const server of localServers) {
+      serverMap.set(server.id, server);
+    }
+    for (const server of remoteServers) {
+      if (!serverMap.has(server.id)) {
+        serverMap.set(server.id, server);
+      }
+    }
+    return Array.from(serverMap.values());
+  }
+  /**
+   * 降级处理
+   */
+  handleFallback(cached) {
+    if (cached) {
+      showWarning("\u4F7F\u7528\u7F13\u5B58\u7684 MCP \u5217\u8868\uFF08API \u6682\u65F6\u4E0D\u53EF\u7528\uFF09");
+      return this.mergeServers(BUILTIN_DEFAULT_MCPS, cached.data.mcpServers);
+    }
+    showWarning("\u4F7F\u7528\u5185\u7F6E\u9ED8\u8BA4 MCP \u914D\u7F6E");
+    return BUILTIN_DEFAULT_MCPS;
+  }
+  /**
+   * 读取 MCP 配置
+   */
+  readMcpConfig() {
+    try {
+      if (fs5.existsSync(CLAUDE_JSON_FILE)) {
+        const content = fs5.readFileSync(CLAUDE_JSON_FILE, "utf-8");
+        return JSON.parse(content);
+      }
+    } catch {
+    }
+    return { mcpServers: {} };
+  }
+  /**
+   * 写入 MCP 配置
+   */
+  writeMcpConfig(config) {
+    fs5.writeFileSync(
+      CLAUDE_JSON_FILE,
+      JSON.stringify(config, null, 2),
+      "utf-8"
+    );
+  }
+  /**
+   * 获取已安装的 MCP 服务列表
+   */
+  getInstalledServers() {
+    const config = this.readMcpConfig();
+    return Object.keys(config.mcpServers || {});
+  }
+  /**
+   * 检查 MCP 服务器是否已安装
+   */
+  isServerInstalled(serverId) {
+    return this.getInstalledServers().includes(serverId);
+  }
+  /**
+   * 安装单个 MCP 服务器
+   * @param server MCP 服务器配置
+   * @param userEnv 用户提供的环境变量（如 API Key）
+   */
+  installServer(server, userEnv) {
+    const config = this.readMcpConfig();
+    if (!config.mcpServers) {
+      config.mcpServers = {};
+    }
+    if (server.transport === "http" || server.transport === "sse") {
+      const headers = {};
+      if (server.headers) {
+        for (const [key, value] of Object.entries(server.headers)) {
+          const match = value.match(/^\$\{(.+)\}$/);
+          if (match && userEnv) {
+            const varName = match[1];
+            headers[key] = userEnv[varName] || value;
+          } else {
+            headers[key] = value;
+          }
+        }
+      }
+      config.mcpServers[server.id] = {
+        transport: server.transport,
+        url: server.url,
+        ...Object.keys(headers).length > 0 ? { headers } : {}
+      };
+    } else {
+      config.mcpServers[server.id] = {
+        command: server.command,
+        args: server.args,
+        ...server.env || userEnv ? { env: { ...server.env, ...userEnv } } : {}
+      };
+    }
+    this.writeMcpConfig(config);
+  }
+  /**
+   * 卸载单个 MCP 服务器
+   */
+  uninstallServer(serverId) {
+    const config = this.readMcpConfig();
+    delete config.mcpServers[serverId];
+    this.writeMcpConfig(config);
+  }
+  /**
+   * 批量安装 MCP 服务器（不提示输入 API Key）
+   */
+  installServers(servers) {
+    const config = this.readMcpConfig();
+    if (!config.mcpServers) {
+      config.mcpServers = {};
+    }
+    for (const server of servers) {
+      if (server.transport === "http" || server.transport === "sse") {
+        config.mcpServers[server.id] = {
+          transport: server.transport,
+          url: server.url,
+          ...server.headers ? { headers: server.headers } : {}
+        };
+      } else {
+        config.mcpServers[server.id] = {
+          command: server.command,
+          args: server.args,
+          ...server.env ? { env: server.env } : {}
+        };
+      }
+    }
+    this.writeMcpConfig(config);
+  }
+  /**
+   * 批量卸载 MCP 服务器
+   */
+  uninstallServers(serverIds) {
+    const config = this.readMcpConfig();
+    for (const serverId of serverIds) {
+      delete config.mcpServers[serverId];
+    }
+    this.writeMcpConfig(config);
+  }
+};
+
+// src/cli/menus/mcp.ts
+var mcpService = new McpService();
+async function showMcpMenu() {
+  showHeader();
+  console.log(createBoxTitle("MCP \u670D\u52A1\u7BA1\u7406"));
+  console.log();
+  console.log();
+  console.log(theme.info("         \u{1F680}  \u656C\u8BF7\u671F\u5F85  \u{1F680}"));
+  console.log();
+  console.log(theme.dim("    MCP \u670D\u52A1\u7BA1\u7406\u529F\u80FD\u5373\u5C06\u4E0A\u7EBF"));
+  console.log(theme.dim("    \u652F\u6301\u672C\u5730+\u4E91\u7AEF MCP \u670D\u52A1\u7BA1\u7406"));
+  console.log(theme.dim("    \u656C\u8BF7\u671F\u5F85..."));
+  console.log();
+  console.log();
+  await inquirer5.prompt([
+    { type: "input", name: "continue", message: "\u6309\u56DE\u8F66\u952E\u8FD4\u56DE..." }
+  ]);
+  return;
+}
+
+// src/cli/menus/plugins.ts
+import { execSync as execSync4 } from "child_process";
+import fs7 from "fs";
+import inquirer6 from "inquirer";
+import ora6 from "ora";
+import os8 from "os";
+import path8 from "path";
+
+// src/cli/services/marketplace.ts
+import { execSync as execSync3 } from "child_process";
+import fs6 from "fs";
+import os7 from "os";
+import path7 from "path";
+var MarketplaceService = class {
+  cacheManager;
+  constructor() {
+    this.cacheManager = new CacheManager("markets");
+  }
+  /**
+   * 获取市场列表（从本地配置文件读取）
+   */
+  async fetchMarkets() {
+    try {
+      if (fs6.existsSync(MARKETS_CONFIG_FILE)) {
+        const content = fs6.readFileSync(MARKETS_CONFIG_FILE, "utf-8");
+        const data = JSON.parse(content);
+        if (data.markets && Array.isArray(data.markets)) {
+          return this.normalizeMarkets(data.markets);
+        }
+      }
+      showWarning("\u4F7F\u7528\u5185\u7F6E\u9ED8\u8BA4\u5E02\u573A\u914D\u7F6E");
+      return BUILTIN_DEFAULT_MARKETS;
+    } catch (error) {
+      showWarning("\u8BFB\u53D6\u914D\u7F6E\u6587\u4EF6\u5931\u8D25\uFF0C\u4F7F\u7528\u5185\u7F6E\u9ED8\u8BA4\u5E02\u573A\u914D\u7F6E");
+      return BUILTIN_DEFAULT_MARKETS;
+    }
+  }
+  /**
+   * 标准化市场数据（移除内部字段）
+   */
+  normalizeMarkets(rawMarkets) {
+    return rawMarkets.map((market) => ({
+      name: market.name,
+      source: market.source,
+      description: market.description,
+      category: market.category,
+      recommended: market.recommended || false,
+      default: market.default || false
+    }));
+  }
+  /**
+   * 获取已安装的市场列表
+   */
+  async getInstalledMarkets() {
+    try {
+      const output = this.execClaude("plugin marketplace list");
+      return this.parseMarketplaceList(output);
+    } catch (error) {
+      return [];
+    }
+  }
+  /**
+   * 检查市场是否已安装（通过源地址或名称匹配）
+   */
+  async isMarketInstalled(marketSource, marketName) {
+    const installed = await this.getInstalledMarkets();
+    const normalizedSource = marketSource.replace(/\.git$/, "");
+    return installed.some((m) => {
+      if (m.source) {
+        const normalizedInstalled = m.source.replace(/\.git$/, "");
+        if (normalizedInstalled === normalizedSource) {
+          return true;
+        }
+        if (marketName && normalizedInstalled.includes(marketName)) {
+          return true;
+        }
+      }
+      if (marketName) {
+        const baseMarketName = marketName.replace(/-dev$/, "");
+        const baseInstalledName = m.name.replace(/-dev$/, "");
+        if (baseMarketName === baseInstalledName) {
+          return true;
+        }
+      }
+      return false;
+    });
+  }
+  /**
+   * 根据源地址或名称获取已安装市场的名称
+   */
+  async getInstalledMarketName(marketSource, marketName) {
+    const installed = await this.getInstalledMarkets();
+    const normalizedSource = marketSource.replace(/\.git$/, "");
+    const found = installed.find((m) => {
+      if (m.source) {
+        const normalizedInstalled = m.source.replace(/\.git$/, "");
+        if (normalizedInstalled === normalizedSource) {
+          return true;
+        }
+        if (marketName && normalizedInstalled.includes(marketName)) {
+          return true;
+        }
+      }
+      if (marketName) {
+        const baseMarketName = marketName.replace(/-dev$/, "");
+        const baseInstalledName = m.name.replace(/-dev$/, "");
+        if (baseMarketName === baseInstalledName) {
+          return true;
+        }
+      }
+      return false;
+    });
+    return found ? found.name : null;
+  }
+  /**
+   * 添加市场
+   */
+  async addMarket(market) {
+    try {
+      this.execClaude(`plugin marketplace add "${market.source}"`);
+      return true;
+    } catch (error) {
+      if (error.message.includes("already exists") || error.message.includes("already configured") || error.message.includes("already installed")) {
+        return true;
+      }
+      throw error;
+    }
+  }
+  /**
+   * 从市场获取插件列表（带版本和更新检测）
+   */
+  async getMarketPlugins(marketName) {
+    try {
+      const marketplacePath = this.getMarketplacePath(marketName);
+      const manifestPath = path7.join(
+        marketplacePath,
+        ".claude-plugin",
+        "marketplace.json"
+      );
+      if (!fs6.existsSync(manifestPath)) {
+        return [];
+      }
+      const manifest = JSON.parse(fs6.readFileSync(manifestPath, "utf-8"));
+      if (!manifest.plugins || !Array.isArray(manifest.plugins)) {
+        return [];
+      }
+      const installedVersions = await this.getInstalledPluginVersions();
+      return manifest.plugins.map((plugin) => {
+        const pluginFullId = `${plugin.name}@${marketName}`;
+        const installedVersion = installedVersions.get(pluginFullId);
+        const marketVersion = plugin.version || "1.0.0";
+        return {
+          id: plugin.name,
+          name: plugin.name.charAt(0).toUpperCase() + plugin.name.slice(1),
+          description: plugin.description,
+          marketplace: marketName,
+          category: plugin.category || "development",
+          recommended: true,
+          version: marketVersion,
+          installedVersion,
+          hasUpdate: installedVersion ? this.compareVersions(marketVersion, installedVersion) > 0 : false
+        };
+      });
+    } catch (error) {
+      console.error("\u8BFB\u53D6\u5E02\u573A\u63D2\u4EF6\u5217\u8868\u5931\u8D25:", error);
+      return [];
+    }
+  }
+  /**
+   * 获取已安装插件的版本信息
+   */
+  async getInstalledPluginVersions() {
+    const versions = /* @__PURE__ */ new Map();
+    try {
+      const output = this.execClaude("plugin list --json");
+      const data = JSON.parse(output);
+      if (data.installed && Array.isArray(data.installed)) {
+        for (const plugin of data.installed) {
+          versions.set(plugin.id, plugin.version);
+        }
+      }
+    } catch (error) {
+    }
+    return versions;
+  }
+  /**
+   * 比较版本号
+   * @returns >0 如果 v1 > v2, =0 如果相等, <0 如果 v1 < v2
+   */
+  compareVersions(v1, v2) {
+    const parts1 = v1.split(".").map(Number);
+    const parts2 = v2.split(".").map(Number);
+    for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+      const num1 = parts1[i] || 0;
+      const num2 = parts2[i] || 0;
+      if (num1 > num2) return 1;
+      if (num1 < num2) return -1;
+    }
+    return 0;
+  }
+  /**
+   * 刷新市场列表（清除缓存并重新获取）
+   */
+  async refreshMarkets() {
+    this.cacheManager.clear();
+    return this.fetchMarkets();
+  }
+  /**
+   * 更新单个市场
+   */
+  async updateMarket(marketName) {
+    try {
+      this.execClaude(`plugin marketplace update "${marketName}"`);
+      return true;
+    } catch (error) {
+      throw new Error(`\u66F4\u65B0\u5E02\u573A\u5931\u8D25: ${error.message}`);
+    }
+  }
+  /**
+   * 更新所有市场
+   */
+  async updateAllMarkets() {
+    try {
+      this.execClaude("plugin marketplace update");
+      return true;
+    } catch (error) {
+      throw new Error(`\u66F4\u65B0\u6240\u6709\u5E02\u573A\u5931\u8D25: ${error.message}`);
+    }
+  }
+  /**
+   * 更新单个插件
+   */
+  async updatePlugin(pluginName) {
+    try {
+      this.execClaude(`plugin update "${pluginName}"`);
+      return true;
+    } catch (error) {
+      throw new Error(`\u66F4\u65B0\u63D2\u4EF6\u5931\u8D25: ${error.message}`);
+    }
+  }
+  /**
+   * 降级处理
+   */
+  handleFallback(cached) {
+    if (cached) {
+      showWarning("\u4F7F\u7528\u7F13\u5B58\u7684\u5E02\u573A\u5217\u8868\uFF08API \u6682\u65F6\u4E0D\u53EF\u7528\uFF09");
+      return cached.data.markets;
+    }
+    showWarning("\u4F7F\u7528\u5185\u7F6E\u9ED8\u8BA4\u5E02\u573A\u914D\u7F6E");
+    return BUILTIN_DEFAULT_MARKETS;
+  }
+  /**
+   * 解析 marketplace list 输出
+   */
+  parseMarketplaceList(output) {
+    const markets = [];
+    const lines = output.split("\n");
+    let currentMarket = null;
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("\u276F ")) {
+        if (currentMarket) {
+          markets.push(currentMarket);
+        }
+        const name = trimmed.substring(2).trim();
+        currentMarket = { name };
+      } else if (currentMarket && trimmed.startsWith("Source:")) {
+        const match = trimmed.match(/Source:\s+\w+\s+\((.+)\)/);
+        if (match) {
+          currentMarket.source = match[1];
+        }
+      }
+    }
+    if (currentMarket) {
+      markets.push(currentMarket);
+    }
+    return markets;
+  }
+  /**
+   * 获取市场仓库路径
+   */
+  getMarketplacePath(marketName) {
+    return path7.join(
+      os7.homedir(),
+      ".claude",
+      "plugins",
+      "marketplaces",
+      marketName
+    );
+  }
+  /**
+   * 执行 Claude 命令
+   */
+  execClaude(command) {
+    try {
+      return execSync3(`claude ${command}`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch (error) {
+      throw new Error(`\u6267\u884C\u547D\u4EE4\u5931\u8D25: ${error.message}
+${error.stderr || ""}`);
+    }
+  }
+};
+
+// src/cli/menus/plugins.ts
+function execClaude(command) {
+  try {
+    return execSync4(`claude ${command}`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch (error) {
+    throw new Error(`\u6267\u884C\u547D\u4EE4\u5931\u8D25: ${error.message}
+${error.stderr || ""}`);
+  }
+}
+var marketplaceService = new MarketplaceService();
+function getInstalledPlugins() {
+  try {
+    const output = execClaude("plugin list");
+    const plugins = [];
+    const lines = output.split("\n");
+    let currentPlugin = {};
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("\u276F ")) {
+        if (currentPlugin.name) {
+          plugins.push(currentPlugin);
+        }
+        currentPlugin = { name: trimmed.substring(2).trim() };
+      } else if (trimmed.startsWith("Version:")) {
+        currentPlugin.version = trimmed.substring(8).trim();
+      } else if (trimmed.startsWith("Status:")) {
+        currentPlugin.enabled = trimmed.includes("enabled");
+      }
+    }
+    if (currentPlugin.name) {
+      plugins.push(currentPlugin);
+    }
+    return plugins;
+  } catch (error) {
+    return [];
+  }
+}
+function getPluginStatus(pluginFullName, installedPlugins) {
+  const installed = installedPlugins.find((p) => p.name === pluginFullName);
+  if (!installed) return "not_installed";
+  return installed.enabled ? "enabled" : "disabled";
+}
+function getStatusText(status) {
+  switch (status) {
+    case "not_installed":
+      return theme.dim("[\u672A\u5B89\u88C5]");
+    case "enabled":
+      return theme.success("[\u5DF2\u542F\u7528]");
+    case "disabled":
+      return theme.warning("[\u5DF2\u7981\u7528]");
+  }
+}
+async function ensureDefaultMarkets(markets) {
+  for (const market of markets) {
+    if (market.default) {
+      const isInstalled = await marketplaceService.isMarketInstalled(
+        market.source,
+        market.name
+      );
+      if (!isInstalled) {
+        try {
+          await marketplaceService.addMarket(market);
+        } catch (error) {
+        }
+      }
+    }
+  }
+}
+async function showPluginsMenu() {
+  const spinner = ora6("\u6B63\u5728\u52A0\u8F7D\u63D2\u4EF6\u5E02\u573A...").start();
+  const markets = await marketplaceService.fetchMarkets();
+  await ensureDefaultMarkets(markets);
+  const installedMarkets = await marketplaceService.getInstalledMarkets();
+  spinner.stop();
+  while (true) {
+    showHeader();
+    console.log(createBoxTitle("\u63D2\u4EF6\u5E02\u573A"));
+    console.log();
+    console.log(theme.primary("\u{1F4E6} \u53EF\u7528\u5E02\u573A\uFF1A"));
+    console.log();
+    console.log(theme.dim("\u2191\u2193 \u9009\u62E9 | Enter \u786E\u8BA4"));
+    console.log();
+    const marketChoices = markets.map((market) => {
+      const isInstalled = installedMarkets.some((m) => {
+        if (m.source) {
+          const normalizedSource = market.source.replace(/\.git$/, "");
+          const normalizedInstalled = m.source.replace(/\.git$/, "");
+          if (normalizedInstalled === normalizedSource) {
+            return true;
+          }
+          if (normalizedInstalled.includes(market.name)) {
+            return true;
+          }
+        }
+        const baseMarketName = market.name.replace(/-dev$/, "");
+        const baseInstalledName = m.name.replace(/-dev$/, "");
+        return baseMarketName === baseInstalledName;
+      });
+      const statusIcon = isInstalled ? theme.success("\u2713") : theme.dim("\u2022");
+      const categoryLabel = getCategoryLabel(market.category);
+      return {
+        name: `  ${statusIcon} [${categoryLabel}] ${market.name} - ${theme.dim(
+          market.description
+        )}`,
+        value: { type: "market", market }
+      };
+    });
+    const choices = [
+      ...marketChoices,
+      new inquirer6.Separator(),
+      {
+        name: `  ${theme.info("\u{1F504}")} \u5237\u65B0\u5E02\u573A\u5217\u8868`,
+        value: { type: "refresh" }
+      },
+      {
+        name: `  ${theme.info("\u2B06\uFE0F")}  \u66F4\u65B0\u6240\u6709\u5E02\u573A`,
+        value: { type: "update_all_markets" }
+      },
+      new inquirer6.Separator(),
+      {
+        name: `  ${theme.dim("<-")} \u8FD4\u56DE`,
+        value: { type: "back" }
+      },
+      {
+        name: `  ${theme.dim("X")}  \u9000\u51FA`,
+        value: { type: "exit" }
+      }
+    ];
+    const { selection } = await inquirer6.prompt([
+      {
+        type: "list",
+        name: "selection",
+        message: "\u8BF7\u9009\u62E9\u5E02\u573A\uFF1A",
+        pageSize: 15,
+        choices
+      }
+    ]);
+    if (selection.type === "back") {
+      return;
+    }
+    if (selection.type === "exit") {
+      process.exit(0);
+    }
+    if (selection.type === "refresh") {
+      const refreshSpinner = ora6("\u6B63\u5728\u5237\u65B0\u5E02\u573A\u5217\u8868...").start();
+      const newMarkets = await marketplaceService.refreshMarkets();
+      markets.length = 0;
+      markets.push(...newMarkets);
+      refreshSpinner.succeed("\u5E02\u573A\u5217\u8868\u5DF2\u5237\u65B0");
+      await new Promise((resolve) => {
+        setTimeout(() => resolve(), 800);
+      });
+      continue;
+    }
+    if (selection.type === "update_all_markets") {
+      const updateSpinner = ora6("\u6B63\u5728\u66F4\u65B0\u6240\u6709\u5E02\u573A...").start();
+      try {
+        await marketplaceService.updateAllMarkets();
+        updateSpinner.succeed("\u6240\u6709\u5E02\u573A\u5DF2\u66F4\u65B0");
+        await new Promise((resolve) => {
+          setTimeout(() => resolve(), 1e3);
+        });
+      } catch (error) {
+        updateSpinner.fail(`\u66F4\u65B0\u5931\u8D25: ${error.message}`);
+        await new Promise((resolve) => {
+          setTimeout(() => resolve(), 1500);
+        });
+      }
+      continue;
+    }
+    if (selection.type === "market") {
+      await showMarketPlugins(selection.market);
+    }
+  }
+}
+function getCategoryLabel(category) {
+  switch (category) {
+    case "official":
+      return theme.success("\u5B98\u65B9");
+    case "team":
+      return theme.info("\u56E2\u961F");
+    case "experimental":
+      return theme.warning("\u5B9E\u9A8C");
+    default:
+      return theme.dim("\u5176\u4ED6");
+  }
+}
+async function showMarketPlugins(market) {
+  const isInstalled = await marketplaceService.isMarketInstalled(
+    market.source,
+    market.name
+  );
+  if (!isInstalled) {
+    const addSpinner = ora6("\u6B63\u5728\u6DFB\u52A0\u5E02\u573A...").start();
+    try {
+      await marketplaceService.addMarket(market);
+      addSpinner.succeed("\u5E02\u573A\u6DFB\u52A0\u6210\u529F");
+    } catch (error) {
+      addSpinner.fail(`\u5E02\u573A\u6DFB\u52A0\u5931\u8D25: ${error.message}`);
+      await new Promise((resolve) => {
+        setTimeout(() => resolve(), 2e3);
+      });
+      return;
+    }
+    await new Promise((resolve) => {
+      setTimeout(() => resolve(), 800);
+    });
+  }
+  const installedMarketName = await marketplaceService.getInstalledMarketName(
+    market.source,
+    market.name
+  );
+  if (!installedMarketName) {
+    showWarning("\u65E0\u6CD5\u627E\u5230\u5DF2\u5B89\u88C5\u7684\u5E02\u573A");
+    return;
+  }
+  const loadingSpinner = ora6("\u6B63\u5728\u52A0\u8F7D\u63D2\u4EF6\u5217\u8868...").start();
+  const marketplacePlugins = await marketplaceService.getMarketPlugins(
+    installedMarketName
+  );
+  let installedPlugins = getInstalledPlugins();
+  loadingSpinner.stop();
+  while (true) {
+    showHeader();
+    console.log(createBoxTitle(`${market.name} \u63D2\u4EF6\u5E02\u573A`));
+    console.log();
+    console.log(`${theme.dim("\u63CF\u8FF0:")} ${market.description}`);
+    console.log(`${theme.dim("\u6E90\u5730\u5740:")} ${market.source}`);
+    console.log();
+    console.log(theme.primary("\u{1F4E6} \u53EF\u7528\u63D2\u4EF6\uFF1A"));
+    console.log();
+    console.log(theme.dim("\u2191\u2193 \u9009\u62E9 | Enter \u786E\u8BA4"));
+    console.log();
+    const pluginStatuses = /* @__PURE__ */ new Map();
+    for (const p of marketplacePlugins) {
+      const pluginFullName = `${p.id}@${p.marketplace}`;
+      pluginStatuses.set(
+        pluginFullName,
+        getPluginStatus(pluginFullName, installedPlugins)
+      );
+    }
+    const pluginChoices = marketplacePlugins.map((p) => {
+      const pluginFullName = `${p.id}@${p.marketplace}`;
+      const status = pluginStatuses.get(pluginFullName);
+      const statusText = getStatusText(status);
+      const updateBadge = p.hasUpdate ? theme.warning(" (\u6709\u66F4\u65B0)") : "";
+      return {
+        name: `  ${statusText} ${p.name}${updateBadge} - ${theme.dim(
+          p.description
+        )}`,
+        value: { type: "plugin", plugin: p, status }
+      };
+    });
+    const hasUpdatablePlugins = marketplacePlugins.some(
+      (p) => p.hasUpdate && pluginStatuses.get(`${p.id}@${p.marketplace}`) !== "not_installed"
+    );
+    const choices = [
+      ...pluginChoices,
+      new inquirer6.Separator(),
+      {
+        name: `  ${theme.success("\u26A1")} \u4E00\u952E\u5B89\u88C5\u5168\u90E8`,
+        value: { type: "install_all" }
+      },
+      ...hasUpdatablePlugins ? [
+        {
+          name: `  ${theme.info("\u2B06\uFE0F")}  \u66F4\u65B0\u6240\u6709\u5DF2\u5B89\u88C5\u63D2\u4EF6`,
+          value: { type: "update_all_plugins" }
+        }
+      ] : [],
+      {
+        name: `  ${theme.info("\u{1F504}")} \u66F4\u65B0\u6B64\u5E02\u573A`,
+        value: { type: "update_market" }
+      },
+      new inquirer6.Separator(),
+      {
+        name: `  ${theme.dim("<-")} \u8FD4\u56DE`,
+        value: { type: "back" }
+      },
+      {
+        name: `  ${theme.dim("X")}  \u9000\u51FA`,
+        value: { type: "exit" }
+      }
+    ];
+    const { selection } = await inquirer6.prompt([
+      {
+        type: "list",
+        name: "selection",
+        message: "\u8BF7\u9009\u62E9\u63D2\u4EF6\uFF1A",
+        pageSize: 15,
+        choices
+      }
+    ]);
+    if (selection.type === "back") {
+      return;
+    }
+    if (selection.type === "exit") {
+      process.exit(0);
+    }
+    if (selection.type === "install_all") {
+      await handleInstallAll(marketplacePlugins);
+      installedPlugins = getInstalledPlugins();
+      continue;
+    }
+    if (selection.type === "update_all_plugins") {
+      const updateSpinner = ora6("\u6B63\u5728\u66F4\u65B0\u6240\u6709\u5DF2\u5B89\u88C5\u7684\u63D2\u4EF6...").start();
+      try {
+        const pluginsToUpdate = marketplacePlugins.filter(
+          (p) => p.hasUpdate && pluginStatuses.get(`${p.id}@${p.marketplace}`) !== "not_installed"
+        );
+        for (const plugin of pluginsToUpdate) {
+          const pluginFullName = `${plugin.id}@${plugin.marketplace}`;
+          updateSpinner.text = `\u6B63\u5728\u66F4\u65B0 ${plugin.name}...`;
+          await marketplaceService.updatePlugin(pluginFullName);
+        }
+        updateSpinner.succeed("\u6240\u6709\u63D2\u4EF6\u5DF2\u66F4\u65B0");
+        await new Promise((resolve) => {
+          setTimeout(() => resolve(), 1e3);
+        });
+        installedPlugins = getInstalledPlugins();
+      } catch (error) {
+        updateSpinner.fail(`\u66F4\u65B0\u5931\u8D25: ${error.message}`);
+        await new Promise((resolve) => {
+          setTimeout(() => resolve(), 1500);
+        });
+      }
+      continue;
+    }
+    if (selection.type === "update_market") {
+      const updateSpinner = ora6(`\u6B63\u5728\u66F4\u65B0\u5E02\u573A ${market.name}...`).start();
+      try {
+        await marketplaceService.updateMarket(installedMarketName);
+        updateSpinner.succeed("\u5E02\u573A\u5DF2\u66F4\u65B0");
+        await new Promise((resolve) => {
+          setTimeout(() => resolve(), 1e3);
+        });
+        const updatedPlugins = await marketplaceService.getMarketPlugins(
+          installedMarketName
+        );
+        marketplacePlugins.length = 0;
+        marketplacePlugins.push(...updatedPlugins);
+        installedPlugins = getInstalledPlugins();
+      } catch (error) {
+        updateSpinner.fail(`\u66F4\u65B0\u5931\u8D25: ${error.message}`);
+        await new Promise((resolve) => {
+          setTimeout(() => resolve(), 1500);
+        });
+      }
+      continue;
+    }
+    if (selection.type === "plugin") {
+      await showPluginDetail(selection.plugin, selection.status);
+      installedPlugins = getInstalledPlugins();
+    }
+  }
+}
+async function showPluginDetail(plugin, initialStatus) {
+  const pluginFullName = `${plugin.id}@${plugin.marketplace}`;
+  let needRefresh = true;
+  let currentStatus = initialStatus;
+  while (true) {
+    showHeader();
+    console.log(createBoxTitle(`\u63D2\u4EF6\u8BE6\u60C5\uFF1A${plugin.id}`));
+    console.log();
+    console.log(`  ${theme.primary("\u540D\u79F0\uFF1A")} ${plugin.name}`);
+    console.log(
+      `  ${theme.primary("\u5206\u7C7B\uFF1A")} ${theme.info(
+        plugin.category || "development"
+      )}`
+    );
+    console.log(`  ${theme.primary("\u63CF\u8FF0\uFF1A")} ${plugin.description}`);
+    console.log();
+    if (needRefresh) {
+      const spinner = ora6("\u6B63\u5728\u83B7\u53D6\u63D2\u4EF6\u72B6\u6001...").start();
+      const installedPlugins = getInstalledPlugins();
+      currentStatus = getPluginStatus(pluginFullName, installedPlugins);
+      spinner.stop();
+      needRefresh = false;
+    }
+    const status = currentStatus;
+    if (status === "not_installed") {
+      console.log(`  ${theme.primary("\u72B6\u6001\uFF1A")} ${theme.dim("[\u672A\u5B89\u88C5]")}`);
+    } else {
+      console.log(`  ${theme.primary("\u72B6\u6001\uFF1A")} ${theme.success("[\u5DF2\u5B89\u88C5]")}`);
+      if (plugin.installedVersion) {
+        console.log(
+          `  ${theme.primary("\u5F53\u524D\u7248\u672C\uFF1A")} ${plugin.installedVersion}`
+        );
+      }
+      if (plugin.version) {
+        console.log(`  ${theme.primary("\u5E02\u573A\u7248\u672C\uFF1A")} ${plugin.version}`);
+      }
+      if (plugin.hasUpdate) {
+        console.log(`  ${theme.warning("\u2B06\uFE0F  \u6709\u65B0\u7248\u672C\u53EF\u7528")}`);
+      }
+      console.log(
+        `  ${theme.primary("\u542F\u7528\u72B6\u6001\uFF1A")} ${status === "enabled" ? theme.success("[\u5DF2\u542F\u7528]") : theme.warning("[\u5DF2\u7981\u7528]")}`
+      );
+    }
+    console.log();
+    console.log(theme.dim("\u2191\u2193 \u9009\u62E9 | Enter \u786E\u8BA4"));
+    console.log();
+    let actionChoices = [];
+    if (status === "not_installed") {
+      actionChoices = [
+        {
+          name: `  ${theme.success(">")}   \u5B89\u88C5\u63D2\u4EF6`,
+          value: "install"
+        }
+      ];
+    } else if (status === "enabled") {
+      actionChoices = [
+        ...plugin.hasUpdate ? [
+          {
+            name: `  ${theme.info("\u2B06\uFE0F")}   \u66F4\u65B0\u63D2\u4EF6`,
+            value: "update"
+          }
+        ] : [],
+        {
+          name: `  ${theme.warning(">")}   \u7981\u7528\u63D2\u4EF6`,
+          value: "disable"
+        },
+        {
+          name: `  ${theme.error("*")}   \u5378\u8F7D\u63D2\u4EF6`,
+          value: "uninstall"
+        }
+      ];
+    } else if (status === "disabled") {
+      actionChoices = [
+        ...plugin.hasUpdate ? [
+          {
+            name: `  ${theme.info("\u2B06\uFE0F")}   \u66F4\u65B0\u63D2\u4EF6`,
+            value: "update"
+          }
+        ] : [],
+        {
+          name: `  ${theme.success(">")}   \u542F\u7528\u63D2\u4EF6`,
+          value: "enable"
+        },
+        {
+          name: `  ${theme.error("*")}   \u5378\u8F7D\u63D2\u4EF6`,
+          value: "uninstall"
+        }
+      ];
+    }
+    const choices = [
+      ...actionChoices,
+      new inquirer6.Separator(),
+      {
+        name: `  ${theme.dim("<-")} \u8FD4\u56DE`,
+        value: "back"
+      },
+      {
+        name: `  ${theme.dim("X")}  \u9000\u51FA`,
+        value: "exit"
+      }
+    ];
+    const { action } = await inquirer6.prompt([
+      {
+        type: "list",
+        name: "action",
+        message: "\u8BF7\u9009\u62E9\u64CD\u4F5C\uFF1A",
+        pageSize: 10,
+        choices
+      }
+    ]);
+    if (action === "back") {
+      return;
+    }
+    if (action === "exit") {
+      process.exit(0);
+    }
+    await executePluginAction(action, plugin, pluginFullName);
+    needRefresh = true;
+  }
+}
+async function executePluginAction(action, plugin, pluginFullName) {
+  const spinner = ora6();
+  try {
+    switch (action) {
+      case "install":
+        console.log();
+        console.log(`$ claude plugin install ${pluginFullName}`);
+        spinner.start(`${theme.success("+")} \u6B63\u5728\u5B89\u88C5\u63D2\u4EF6...`);
+        execClaude(`plugin install ${pluginFullName}`);
+        spinner.succeed(`${theme.success("+")} \u63D2\u4EF6\u5B89\u88C5\u6210\u529F`);
+        break;
+      case "enable":
+        console.log();
+        console.log(`$ claude plugin enable ${pluginFullName}`);
+        spinner.start(`${theme.success("+")} \u6B63\u5728\u542F\u7528\u63D2\u4EF6...`);
+        execClaude(`plugin enable ${pluginFullName}`);
+        spinner.succeed(`${theme.success("+")} \u63D2\u4EF6\u5DF2\u542F\u7528`);
+        break;
+      case "disable":
+        console.log();
+        console.log(`$ claude plugin disable ${pluginFullName}`);
+        spinner.start(`${theme.warning("*")} \u6B63\u5728\u7981\u7528\u63D2\u4EF6...`);
+        execClaude(`plugin disable ${pluginFullName}`);
+        spinner.succeed(`${theme.warning("*")} \u63D2\u4EF6\u5DF2\u7981\u7528`);
+        break;
+      case "update":
+        console.log();
+        console.log(`$ claude plugin update ${pluginFullName}`);
+        spinner.start(`${theme.info("\u2B06\uFE0F")}  \u6B63\u5728\u66F4\u65B0\u63D2\u4EF6...`);
+        await marketplaceService.updatePlugin(pluginFullName);
+        spinner.succeed(`${theme.success("\u2B06\uFE0F")}  \u63D2\u4EF6\u5DF2\u66F4\u65B0`);
+        break;
+      case "uninstall": {
+        console.log();
+        const { confirm } = await inquirer6.prompt([
+          {
+            type: "confirm",
+            name: "confirm",
+            message: `\u786E\u5B9A\u8981\u5378\u8F7D\u63D2\u4EF6 "${plugin.name}" \u5417\uFF1F`,
+            default: false
+          }
+        ]);
+        if (confirm) {
+          console.log(`$ claude plugin uninstall ${pluginFullName}`);
+          spinner.start(`${theme.error("-")} \u6B63\u5728\u5378\u8F7D\u63D2\u4EF6...`);
+          let uninstalled = false;
+          const scopes = ["user", "project", "local"];
+          for (const scope of scopes) {
+            try {
+              execClaude(`plugin uninstall ${pluginFullName} --scope ${scope}`);
+              uninstalled = true;
+              break;
+            } catch (e) {
+              if (!e.message.includes("scope")) {
+                throw e;
+              }
+            }
+          }
+          if (uninstalled) {
+            spinner.succeed(`${theme.error("-")} \u63D2\u4EF6\u5DF2\u5378\u8F7D`);
+          } else {
+            spinner.fail("CLI \u5378\u8F7D\u5931\u8D25");
+            console.log();
+            showWarning("Claude CLI \u65E0\u6CD5\u5378\u8F7D\u6B64\u63D2\u4EF6\uFF08\u5DF2\u77E5 bug\uFF09");
+            const { manualClean } = await inquirer6.prompt([
+              {
+                type: "confirm",
+                name: "manualClean",
+                message: "\u662F\u5426\u624B\u52A8\u6E05\u7406\u914D\u7F6E\u6587\u4EF6\u6765\u5B8C\u6210\u5378\u8F7D\uFF1F",
+                default: true
+              }
+            ]);
+            if (manualClean) {
+              try {
+                const settingsPath = path8.join(
+                  os8.homedir(),
+                  ".claude",
+                  "settings.json"
+                );
+                const settings = JSON.parse(
+                  fs7.readFileSync(settingsPath, "utf-8")
+                );
+                if (settings.enabledPlugins) {
+                  const keysToRemove = Object.keys(
+                    settings.enabledPlugins
+                  ).filter((key) => key.startsWith(`${plugin.id}@`));
+                  for (const key of keysToRemove) {
+                    delete settings.enabledPlugins[key];
+                  }
+                }
+                fs7.writeFileSync(
+                  settingsPath,
+                  JSON.stringify(settings, null, 2)
+                );
+                console.log(theme.success("\u2713 \u5DF2\u4ECE\u914D\u7F6E\u4E2D\u79FB\u9664\u63D2\u4EF6"));
+                showInfo("\u91CD\u542F Claude Code \u540E\u751F\u6548");
+              } catch (e) {
+                showWarning("\u624B\u52A8\u6E05\u7406\u5931\u8D25\uFF0C\u8BF7\u624B\u52A8\u7F16\u8F91 ~/.claude/settings.json");
+              }
+            } else {
+              showInfo('\u5EFA\u8BAE\uFF1A\u4F7F\u7528"\u7981\u7528\u63D2\u4EF6"\u6765\u505C\u7528\u6B64\u63D2\u4EF6');
+            }
+          }
+        }
+        break;
+      }
+    }
+  } catch (error) {
+    spinner.fail(`\u64CD\u4F5C\u5931\u8D25: ${error.message}`);
+  }
+  await new Promise((resolve) => {
+    setTimeout(() => resolve(), 800);
+  });
+}
+async function handleInstallAll(marketplacePlugins) {
+  console.log();
+  const recommendedPlugins = marketplacePlugins.filter((p) => p.recommended);
+  const { confirm } = await inquirer6.prompt([
+    {
+      type: "confirm",
+      name: "confirm",
+      message: `\u786E\u5B9A\u8981\u5B89\u88C5\u5168\u90E8 ${recommendedPlugins.length} \u4E2A\u63A8\u8350\u63D2\u4EF6\u5417\uFF1F`,
+      default: true
+    }
+  ]);
+  if (!confirm) return;
+  const spinner = ora6("\u6B63\u5728\u5B89\u88C5\u63D2\u4EF6...").start();
+  try {
+    for (const plugin of recommendedPlugins) {
+      const pluginFullName = `${plugin.id}@${plugin.marketplace}`;
+      spinner.text = `\u6B63\u5728\u5B89\u88C5 ${plugin.name}...`;
+      const installedPlugins = getInstalledPlugins();
+      const installed = installedPlugins.find((p) => p.name === pluginFullName);
+      if (installed) {
+        if (!installed.enabled) {
+          execClaude(`plugin enable ${pluginFullName}`);
+        }
+      } else {
+        execClaude(`plugin install ${pluginFullName}`);
+      }
+    }
+    spinner.succeed(`\u6210\u529F\u5B89\u88C5 ${recommendedPlugins.length} \u4E2A\u63A8\u8350\u63D2\u4EF6`);
+    console.log();
+    showInfo("\u63D2\u4EF6\u5DF2\u751F\u6548\uFF0C\u65E0\u9700\u91CD\u542F Claude Code");
+  } catch (error) {
+    spinner.fail(`\u5B89\u88C5\u5931\u8D25: ${error.message}`);
+  }
+  console.log();
+  await inquirer6.prompt([
+    { type: "input", name: "continue", message: "\u6309\u56DE\u8F66\u952E\u7EE7\u7EED..." }
+  ]);
+}
+
+// src/cli/menus/settings.ts
+import fs8 from "fs";
+import inquirer7 from "inquirer";
+import os9 from "os";
+import path9 from "path";
+var SETTINGS_FILE2 = path9.join(os9.homedir(), ".claude", "settings.json");
+var LANGUAGE_OPTIONS = [
+  { name: "\u4E2D\u6587 (chinese)", value: "chinese" },
+  { name: "English", value: "english" },
+  { name: "\u65E5\u672C\u8A9E (japanese)", value: "japanese" },
+  { name: "\uD55C\uAD6D\uC5B4 (korean)", value: "korean" },
+  { name: "Espa\xF1ol (spanish)", value: "spanish" },
+  { name: "Fran\xE7ais (french)", value: "french" },
+  { name: "Deutsch (german)", value: "german" },
+  { name: "\u5176\u4ED6\uFF08\u624B\u52A8\u8F93\u5165\uFF09", value: "__custom__" }
+];
+async function showSettingsMenu() {
+  while (true) {
+    showHeader();
+    console.log(createBoxTitle("Claude Code \u914D\u7F6E"));
+    console.log();
+    const { choice } = await inquirer7.prompt([
+      {
+        type: "list",
+        name: "choice",
+        message: "\u8BF7\u9009\u62E9\u914D\u7F6E\u7C7B\u522B\uFF1A",
+        choices: [
+          {
+            name: `\u57FA\u7840\u8BBE\u7F6E`,
+            value: "basic" /* BASIC */
+          },
+          {
+            name: `\u67E5\u770B\u914D\u7F6E\u6587\u4EF6`,
+            value: "view_config" /* VIEW_CONFIG */
+          },
+          new inquirer7.Separator(),
+          {
+            name: `${theme.dim("<-")} \u8FD4\u56DE`,
+            value: "back" /* BACK */
+          },
+          {
+            name: `${theme.dim("X")}  \u9000\u51FA`,
+            value: "exit" /* EXIT */
+          }
+        ]
+      }
+    ]);
+    switch (choice) {
+      case "basic" /* BASIC */:
+        await showBasicSettings();
+        break;
+      case "view_config" /* VIEW_CONFIG */:
+        await handleViewConfig();
+        break;
+      case "back" /* BACK */:
+        return;
+      case "exit" /* EXIT */:
+        process.exit(0);
+    }
+  }
+}
+async function showBasicSettings() {
+  while (true) {
+    showHeader();
+    console.log(createBoxTitle("\u57FA\u7840\u8BBE\u7F6E"));
+    console.log();
+    const settings = readClaudeSettings();
+    const currentLanguage = settings.language || "\u672A\u8BBE\u7F6E";
+    const currentCleanupDays = settings.cleanupPeriodDays ?? 30;
+    const currentPlansDir = settings.plansDirectory || "./plans";
+    const currentShowDuration = settings.showTurnDuration ?? false;
+    const currentSpinnerTips = settings.spinnerTipsEnabled ?? true;
+    const { choice } = await inquirer7.prompt([
+      {
+        type: "list",
+        name: "choice",
+        message: "\u8BF7\u9009\u62E9\u8981\u4FEE\u6539\u7684\u914D\u7F6E\uFF1A",
+        choices: [
+          {
+            name: `\u54CD\u5E94\u8BED\u8A00 ${theme.dim(`[\u5F53\u524D: ${currentLanguage}]`)}`,
+            value: "language" /* LANGUAGE */
+          },
+          {
+            name: `\u4F1A\u8BDD\u6E05\u7406\u5468\u671F ${theme.dim(
+              `[\u5F53\u524D: ${currentCleanupDays}\u5929]`
+            )}`,
+            value: "cleanupPeriodDays" /* CLEANUP_DAYS */
+          },
+          {
+            name: `\u8BA1\u5212\u6587\u4EF6\u76EE\u5F55 ${theme.dim(`[\u5F53\u524D: ${currentPlansDir}]`)}`,
+            value: "plansDirectory" /* PLANS_DIR */
+          },
+          {
+            name: `\u663E\u793A\u54CD\u5E94\u8017\u65F6 ${theme.dim(
+              `[\u5F53\u524D: ${currentShowDuration ? "\u5F00\u542F" : "\u5173\u95ED"}]`
+            )}`,
+            value: "showTurnDuration" /* SHOW_DURATION */
+          },
+          {
+            name: `\u663E\u793A\u52A0\u8F7D\u63D0\u793A ${theme.dim(
+              `[\u5F53\u524D: ${currentSpinnerTips ? "\u5F00\u542F" : "\u5173\u95ED"}]`
+            )}`,
+            value: "spinnerTipsEnabled" /* SPINNER_TIPS */
+          },
+          new inquirer7.Separator(),
+          {
+            name: `${theme.dim("<-")} \u8FD4\u56DE`,
+            value: "back" /* BACK */
+          },
+          {
+            name: `${theme.dim("X")}  \u9000\u51FA`,
+            value: "exit" /* EXIT */
+          }
+        ]
+      }
+    ]);
+    switch (choice) {
+      case "language" /* LANGUAGE */:
+        await handleLanguageSetting();
+        break;
+      case "cleanupPeriodDays" /* CLEANUP_DAYS */:
+        await handleCleanupDaysSetting();
+        break;
+      case "plansDirectory" /* PLANS_DIR */:
+        await handlePlansDirSetting();
+        break;
+      case "showTurnDuration" /* SHOW_DURATION */:
+        await handleBooleanSetting("showTurnDuration", "\u663E\u793A\u54CD\u5E94\u8017\u65F6");
+        break;
+      case "spinnerTipsEnabled" /* SPINNER_TIPS */:
+        await handleBooleanSetting("spinnerTipsEnabled", "\u663E\u793A\u52A0\u8F7D\u63D0\u793A");
+        break;
+      case "back" /* BACK */:
+        return;
+      case "exit" /* EXIT */:
+        process.exit(0);
+    }
+  }
+}
+async function handleLanguageSetting() {
+  console.log();
+  const { language } = await inquirer7.prompt([
+    {
+      type: "list",
+      name: "language",
+      message: "\u8BF7\u9009\u62E9\u54CD\u5E94\u8BED\u8A00\uFF1A",
+      choices: LANGUAGE_OPTIONS
+    }
+  ]);
+  let finalLanguage = language;
+  if (language === "__custom__") {
+    const { customLanguage } = await inquirer7.prompt([
+      {
+        type: "input",
+        name: "customLanguage",
+        message: "\u8BF7\u8F93\u5165\u8BED\u8A00\u540D\u79F0\uFF08\u82F1\u6587\uFF09\uFF1A",
+        validate: (input) => {
+          if (!input || input.trim().length === 0) {
+            return "\u8BED\u8A00\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A";
+          }
+          return true;
+        }
+      }
+    ]);
+    finalLanguage = customLanguage;
+  }
+  try {
+    const settings = readClaudeSettings();
+    settings.language = finalLanguage;
+    writeClaudeSettings(settings);
+    showSuccess(`\u54CD\u5E94\u8BED\u8A00\u5DF2\u8BBE\u7F6E\u4E3A: ${finalLanguage}`);
+  } catch (error) {
+    showError(`\u4FDD\u5B58\u5931\u8D25: ${error.message}`);
+  }
+}
+async function handleCleanupDaysSetting() {
+  console.log();
+  showInfo("\u8BBE\u7F6E\u4E3A 0 \u8868\u793A\u6BCF\u6B21\u542F\u52A8\u90FD\u6E05\u7406\u6240\u6709\u5386\u53F2\u4F1A\u8BDD");
+  console.log();
+  const { days } = await inquirer7.prompt([
+    {
+      type: "number",
+      name: "days",
+      message: "\u8BF7\u8F93\u5165\u4F1A\u8BDD\u6E05\u7406\u5468\u671F\uFF08\u5929\uFF09\uFF1A",
+      default: 30,
+      validate: (input) => {
+        if (isNaN(input) || input < 0) {
+          return "\u8BF7\u8F93\u5165\u6709\u6548\u7684\u5929\u6570\uFF08>=0\uFF09";
+        }
+        return true;
+      }
+    }
+  ]);
+  try {
+    const settings = readClaudeSettings();
+    settings.cleanupPeriodDays = days;
+    writeClaudeSettings(settings);
+    showSuccess(`\u4F1A\u8BDD\u6E05\u7406\u5468\u671F\u5DF2\u8BBE\u7F6E\u4E3A: ${days}\u5929`);
+  } catch (error) {
+    showError(`\u4FDD\u5B58\u5931\u8D25: ${error.message}`);
+  }
+}
+async function handlePlansDirSetting() {
+  console.log();
+  showInfo("\u53EF\u4F7F\u7528\u76F8\u5BF9\u8DEF\u5F84\uFF08\u76F8\u5BF9\u4E8E\u9879\u76EE\u6839\u76EE\u5F55\uFF09\u6216\u7EDD\u5BF9\u8DEF\u5F84");
+  console.log();
+  const { dir } = await inquirer7.prompt([
+    {
+      type: "input",
+      name: "dir",
+      message: "\u8BF7\u8F93\u5165\u8BA1\u5212\u6587\u4EF6\u76EE\u5F55\uFF1A",
+      default: "./plans"
+    }
+  ]);
+  try {
+    const settings = readClaudeSettings();
+    settings.plansDirectory = dir;
+    writeClaudeSettings(settings);
+    showSuccess(`\u8BA1\u5212\u6587\u4EF6\u76EE\u5F55\u5DF2\u8BBE\u7F6E\u4E3A: ${dir}`);
+  } catch (error) {
+    showError(`\u4FDD\u5B58\u5931\u8D25: ${error.message}`);
+  }
+}
+async function handleBooleanSetting(key, label) {
+  console.log();
+  const settings = readClaudeSettings();
+  const currentValue = settings[key] ?? key === "spinnerTipsEnabled";
+  const { value } = await inquirer7.prompt([
+    {
+      type: "list",
+      name: "value",
+      message: `${label}\uFF1A`,
+      choices: [
+        { name: "\u5F00\u542F", value: true },
+        { name: "\u5173\u95ED", value: false }
+      ],
+      default: currentValue
+    }
+  ]);
+  try {
+    settings[key] = value;
+    writeClaudeSettings(settings);
+    showSuccess(`${label}\u5DF2${value ? "\u5F00\u542F" : "\u5173\u95ED"}`);
+  } catch (error) {
+    showError(`\u4FDD\u5B58\u5931\u8D25: ${error.message}`);
+  }
+}
+async function handleViewConfig() {
+  console.log();
+  console.log(theme.primary(`\u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84: ${SETTINGS_FILE2}`));
+  console.log();
+  try {
+    if (fs8.existsSync(SETTINGS_FILE2)) {
+      const content = fs8.readFileSync(SETTINGS_FILE2, "utf-8");
+      console.log(theme.dim("\u2500".repeat(50)));
+      console.log(content);
+      console.log(theme.dim("\u2500".repeat(50)));
+    } else {
+      showWarning("\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B58\u5728");
+    }
+  } catch (error) {
+    showError(`\u8BFB\u53D6\u5931\u8D25: ${error.message}`);
+  }
+  console.log();
+  await inquirer7.prompt([
+    { type: "input", name: "continue", message: "\u6309\u56DE\u8F66\u952E\u7EE7\u7EED..." }
+  ]);
+}
+
+// src/cli/menus/main.ts
+async function showMainMenu() {
+  let claudeInfo = detectClaudeInstallation();
+  while (true) {
+    showHeader();
+    const claudeStatus = formatClaudeStatus(claudeInfo);
+    console.log(
+      `Claude Code: ${claudeInfo.installed ? theme.success(claudeStatus) : theme.dim(claudeStatus)}`
+    );
+    const profileStatus = getCurrentProfileStatus();
+    const apiKeyStatus = getApiKeyStatus();
+    const baseUrlStatus = getBaseUrlStatus();
+    console.log(`\u5F53\u524D\u914D\u7F6E:    ${profileStatus}`);
+    console.log(`Base URL:    ${baseUrlStatus}`);
+    console.log(`API Key:     ${apiKeyStatus}
+`);
+    console.log(createBoxTitle("\u4E3B\u83DC\u5355"));
+    console.log();
+    const { choice } = await inquirer9.prompt([
+      {
+        type: "list",
+        name: "choice",
+        message: "\u8BF7\u9009\u62E9\u64CD\u4F5C\uFF1A",
+        pageSize: 10,
+        choices: [
+          {
+            name: `${theme.primary("1.")} Claude Code \u7BA1\u7406 ${theme.dim(
+              "(\u5B89\u88C5/\u5378\u8F7D)"
+            )}`,
+            value: "manage" /* MANAGE */
+          },
+          {
+            name: `${theme.primary("2.")} \u6388\u6743\u767B\u5F55`,
+            value: "auth" /* AUTH */
+          },
+          {
+            name: `${theme.primary("3.")} Claude Code \u914D\u7F6E`,
+            value: "settings" /* SETTINGS */
+          },
+          {
+            name: `${theme.primary("4.")} MCP \u670D\u52A1\u7BA1\u7406`,
+            value: "mcp" /* MCP */
+          },
+          {
+            name: `${theme.primary("5.")} \u63D2\u4EF6\u5E02\u573A`,
+            value: "plugins" /* PLUGINS */
+          },
+          {
+            name: `${theme.primary("6.")} \u542F\u52A8 Web UI ${theme.dim(
+              "(\u56FE\u5F62\u5316\u754C\u9762)"
+            )}`,
+            value: "webui" /* WEBUI */
+          },
+          new inquirer9.Separator(),
+          {
+            name: `${theme.dim("0.")} \u9000\u51FA`,
+            value: "exit" /* EXIT */
+          }
+        ]
+      }
+    ]);
+    switch (choice) {
+      case "manage" /* MANAGE */:
+        await showManageMenu();
+        claudeInfo = detectClaudeInstallation();
+        break;
+      case "auth" /* AUTH */:
+        await showAuthMenu();
+        break;
+      case "settings" /* SETTINGS */:
+        await showSettingsMenu();
+        break;
+      case "mcp" /* MCP */:
+        await showMcpMenu();
+        break;
+      case "plugins" /* PLUGINS */:
+        await showPluginsMenu();
+        break;
+      case "webui" /* WEBUI */: {
+        const { launchWebUI: launchWebUI2 } = (init_webui(), __toCommonJS(webui_exports));
+        await launchWebUI2();
+        break;
+      }
+      case "exit" /* EXIT */:
+        console.log("\n\u518D\u89C1\uFF01");
+        process.exit(0);
+    }
+  }
+}
+
+// src/cli/index.ts
+init_version();
+var pkg2 = require_package();
+async function main() {
+  try {
+    const args = process.argv.slice(2);
+    if (args.includes("--version") || args.includes("-v")) {
+      console.log(`v${pkg2.version}`);
+      process.exit(0);
+    }
+    if (args.includes("--test-update")) {
+      const { testUpdate: testUpdate2 } = (init_version(), __toCommonJS(version_exports));
+      await testUpdate2();
+      process.exit(0);
+    }
+    if (args.includes("ui")) {
+      const { launchWebUI: launchWebUI2 } = (init_webui(), __toCommonJS(webui_exports));
+      await launchWebUI2();
+      process.exit(0);
+    }
+    if (args.includes("--help") || args.includes("-h")) {
+      console.log(`
+Code Helper v${pkg2.version}
+A unified tool to manage your Claude Code
+
+Usage:
+  code-helper             Launch interactive menu
+  code-helper ui          Launch Web UI interface
+  code-helper --version   Show version number
+  code-helper --help      Show help information
+  code-helper --test-update  Test version update functionality
+
+  You can also use these command aliases:
+  - ch
+  - maco
+
+Options:
+  -v, --version           Show version number
+  -h, --help              Show help information
+  --test-update           Test version update functionality
+  ui                      Launch Web UI interface
+
+Installation:
+  Recommended global installation for better experience:
+    npm install -g code-helper
+
+  Global installation will automatically check for updates
+
+Web UI Launch:
+  1. code-helper ui       Launch via code-helper command
+  2. npx @siteboon/claude-code-ui   Launch UI directly
+`);
+      process.exit(0);
+    }
+    await checkAndUpdate();
+    showHeader();
+    await showMainMenu();
+  } catch (error) {
+    if (error?.message === "User force closed the prompt") {
+      console.log("\n\u518D\u89C1\uFF01");
+      process.exit(0);
+    }
+    console.error("\u53D1\u751F\u9519\u8BEF:", error);
+    process.exit(1);
+  }
+}
+main();
+//# sourceMappingURL=index.mjs.map