@benbenwu/zcf 3.6.4

package/dist/cli.mjs

@@ -0,0 +1,2013 @@
+#!/usr/bin/env node
+import cac from 'cac';
+import ansis from 'ansis';
+import { an as ensureI18nInitialized, ao as i18n, aQ as readCcrConfig, aL as isCcrInstalled, aM as installCcr, aR as configureCcrFeature, ar as promptBoolean, aS as handleExitPromptError, aT as handleGeneralError, aU as COMETIX_COMMAND_NAME, aV as COMETIX_COMMANDS, aW as installCometixLine, ap as addNumbersToChoices, aX as checkAndUpdateTools, aY as runCodexUpdate, aZ as resolveCodeType$1, aw as readJsonConfig, a_ as writeJsonConfig, t as ZCF_CONFIG_FILE, aG as readZcfConfig, D as DEFAULT_CODE_TOOL_TYPE, x as isCodeToolType, a$ as displayBanner, aE as updateZcfConfig, b0 as version, b1 as resolveAiOutputLanguage, b2 as updatePromptOnly, b3 as selectAndInstallWorkflows, b4 as checkClaudeCodeVersionAndPrompt, z as resolveCodeToolType$1, b5 as displayBannerWithInfo, v as CODE_TOOL_BANNERS, b6 as runCodexUninstall, b7 as configureCodexMcp, b8 as configureCodexApi, b9 as runCodexWorkflowImportWithLanguageSelection, ba as runCodexFullInit, i as init, bb as switchCodexProvider, bc as listCodexProviders, aB as readCodexConfig, bd as switchToOfficialLogin, be as switchToProvider, bf as readZcfConfigAsync, bg as initI18n, bh as selectScriptLanguage, aF as changeLanguage } from './chunks/simple-config.mjs';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import inquirer from 'inquirer';
+import { join } from 'pathe';
+import { runCcrStop, runCcrStart, runCcrRestart, runCcrStatus, runCcrUi } from './chunks/commands.mjs';
+import { changeScriptLanguageFeature, configureCodexAiMemoryFeature, configureCodexDefaultModelFeature, configureEnvPermissionFeature, configureAiMemoryFeature, configureDefaultModelFeature, configureMcpFeature, configureApiFeature } from './chunks/features.mjs';
+import process from 'node:process';
+import { x, exec as exec$1 } from 'tinyexec';
+import { exec, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+import { pathExists } from 'fs-extra';
+import { m as moveToTrash } from './shared/zcf.DGjQxTq_.mjs';
+import { ClaudeCodeConfigManager } from './chunks/claude-code-config-manager.mjs';
+import 'dayjs';
+import 'node:url';
+import 'inquirer-toggle';
+import 'ora';
+import 'semver';
+import '@rainbowatcher/toml-edit-js';
+import 'node:fs/promises';
+import 'i18next';
+import 'i18next-fs-backend';
+import 'trash';
+
+function isCcrConfigured() {
+  const CCR_CONFIG_FILE = join(homedir(), ".claude-code-router", "config.json");
+  if (!existsSync(CCR_CONFIG_FILE)) {
+    return false;
+  }
+  const config = readCcrConfig();
+  return config !== null;
+}
+async function showCcrMenu() {
+  try {
+    ensureI18nInitialized();
+    console.log(`
+${ansis.cyan("\u2550".repeat(50))}`);
+    console.log(ansis.bold.cyan(`  ${i18n.t("ccr:ccrMenuTitle")}`));
+    console.log(`${ansis.cyan("\u2550".repeat(50))}
+`);
+    console.log(`  ${ansis.cyan("1.")} ${i18n.t("ccr:ccrMenuOptions.initCcr")} ${ansis.gray(`- ${i18n.t("ccr:ccrMenuDescriptions.initCcr")}`)}`);
+    console.log(`  ${ansis.cyan("2.")} ${i18n.t("ccr:ccrMenuOptions.startUi")} ${ansis.gray(`- ${i18n.t("ccr:ccrMenuDescriptions.startUi")}`)}`);
+    console.log(`  ${ansis.cyan("3.")} ${i18n.t("ccr:ccrMenuOptions.checkStatus")} ${ansis.gray(`- ${i18n.t("ccr:ccrMenuDescriptions.checkStatus")}`)}`);
+    console.log(`  ${ansis.cyan("4.")} ${i18n.t("ccr:ccrMenuOptions.restart")} ${ansis.gray(`- ${i18n.t("ccr:ccrMenuDescriptions.restart")}`)}`);
+    console.log(`  ${ansis.cyan("5.")} ${i18n.t("ccr:ccrMenuOptions.start")} ${ansis.gray(`- ${i18n.t("ccr:ccrMenuDescriptions.start")}`)}`);
+    console.log(`  ${ansis.cyan("6.")} ${i18n.t("ccr:ccrMenuOptions.stop")} ${ansis.gray(`- ${i18n.t("ccr:ccrMenuDescriptions.stop")}`)}`);
+    console.log(`  ${ansis.yellow("0.")} ${i18n.t("ccr:ccrMenuOptions.back")}`);
+    console.log("");
+    const { choice } = await inquirer.prompt({
+      type: "input",
+      name: "choice",
+      message: i18n.t("common:enterChoice"),
+      validate: (value) => {
+        const valid = ["1", "2", "3", "4", "5", "6", "0"];
+        return valid.includes(value) || i18n.t("common:invalidChoice");
+      }
+    });
+    switch (choice) {
+      case "1": {
+        const ccrStatus = await isCcrInstalled();
+        if (!ccrStatus.hasCorrectPackage) {
+          await installCcr();
+        } else {
+          console.log(ansis.green(`\u2714 ${i18n.t("ccr:ccrAlreadyInstalled")}`));
+        }
+        await configureCcrFeature();
+        console.log(ansis.green(`
+\u2714 ${i18n.t("ccr:ccrSetupComplete")}`));
+        break;
+      }
+      case "2":
+        if (!isCcrConfigured()) {
+          console.log(ansis.yellow(`
+\u26A0\uFE0F  ${i18n.t("ccr:ccrNotConfigured")}`));
+          console.log(ansis.cyan(`   ${i18n.t("ccr:pleaseInitFirst")}
+`));
+        } else {
+          const config = readCcrConfig();
+          await runCcrUi(config?.APIKEY);
+        }
+        break;
+      case "3":
+        if (!isCcrConfigured()) {
+          console.log(ansis.yellow(`
+\u26A0\uFE0F  ${i18n.t("ccr:ccrNotConfigured")}`));
+          console.log(ansis.cyan(`   ${i18n.t("ccr:pleaseInitFirst")}
+`));
+        } else {
+          await runCcrStatus();
+        }
+        break;
+      case "4":
+        if (!isCcrConfigured()) {
+          console.log(ansis.yellow(`
+\u26A0\uFE0F  ${i18n.t("ccr:ccrNotConfigured")}`));
+          console.log(ansis.cyan(`   ${i18n.t("ccr:pleaseInitFirst")}
+`));
+        } else {
+          await runCcrRestart();
+        }
+        break;
+      case "5":
+        if (!isCcrConfigured()) {
+          console.log(ansis.yellow(`
+\u26A0\uFE0F  ${i18n.t("ccr:ccrNotConfigured")}`));
+          console.log(ansis.cyan(`   ${i18n.t("ccr:pleaseInitFirst")}
+`));
+        } else {
+          await runCcrStart();
+        }
+        break;
+      case "6":
+        if (!isCcrConfigured()) {
+          console.log(ansis.yellow(`
+\u26A0\uFE0F  ${i18n.t("ccr:ccrNotConfigured")}`));
+          console.log(ansis.cyan(`   ${i18n.t("ccr:pleaseInitFirst")}
+`));
+        } else {
+          await runCcrStop();
+        }
+        break;
+      case "0":
+        return false;
+    }
+    if (choice !== "0") {
+      console.log(`
+${ansis.dim("\u2500".repeat(50))}
+`);
+      const continueInCcr = await promptBoolean({
+        message: i18n.t("common:returnToMenu"),
+        defaultValue: true
+      });
+      if (continueInCcr) {
+        return await showCcrMenu();
+      }
+    }
+    return false;
+  } catch (error) {
+    if (!handleExitPromptError(error)) {
+      handleGeneralError(error);
+    }
+    return false;
+  }
+}
+
+async function executeCcusage(args = []) {
+  try {
+    const command = "npx";
+    const commandArgs = ["ccusage@latest", ...args || []];
+    console.log(ansis.cyan(i18n.t("tools:runningCcusage")));
+    console.log(ansis.gray(`$ npx ccusage@latest ${(args || []).join(" ")}`));
+    console.log("");
+    await x(command, commandArgs, {
+      nodeOptions: {
+        stdio: "inherit"
+      }
+    });
+  } catch (error) {
+    console.error(ansis.red(i18n.t("tools:ccusageFailed")));
+    console.error(ansis.yellow(i18n.t("tools:checkNetworkConnection")));
+    if (process.env.DEBUG) {
+      console.error(ansis.gray(i18n.t("tools:errorDetails")), error);
+    }
+    if (process.env.NODE_ENV !== "test") {
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+
+const execAsync = promisify(exec);
+async function runCometixPrintConfig() {
+  ensureI18nInitialized();
+  try {
+    console.log(ansis.blue(`${i18n.t("cometix:printingConfig")}`));
+    const { stdout } = await execAsync(COMETIX_COMMANDS.PRINT_CONFIG);
+    console.log(stdout);
+  } catch (error) {
+    if (error.message.includes(`command not found: ${COMETIX_COMMAND_NAME}`)) {
+      console.error(ansis.red(`\u2717 ${i18n.t("cometix:commandNotFound")}`));
+    } else {
+      console.error(ansis.red(`\u2717 ${i18n.t("cometix:printConfigFailed")}: ${error}`));
+    }
+    throw error;
+  }
+}
+async function runCometixTuiConfig() {
+  ensureI18nInitialized();
+  return new Promise((resolve, reject) => {
+    console.log(ansis.blue(`${i18n.t("cometix:enteringTuiConfig")}`));
+    const child = spawn(COMETIX_COMMAND_NAME, ["-c"], {
+      stdio: "inherit",
+      // This allows the TUI to interact directly with the terminal
+      shell: true
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        console.log(ansis.green(`\u2713 ${i18n.t("cometix:tuiConfigSuccess")}`));
+        resolve();
+      } else {
+        const error = new Error(`${COMETIX_COMMAND_NAME} -c exited with code ${code}`);
+        console.error(ansis.red(`\u2717 ${i18n.t("cometix:tuiConfigFailed")}: ${error.message}`));
+        reject(error);
+      }
+    });
+    child.on("error", (error) => {
+      if (error.message.includes(`command not found`) || error.message.includes("ENOENT")) {
+        console.error(ansis.red(`\u2717 ${i18n.t("cometix:commandNotFound")}`));
+      } else {
+        console.error(ansis.red(`\u2717 ${i18n.t("cometix:tuiConfigFailed")}: ${error.message}`));
+      }
+      reject(error);
+    });
+  });
+}
+
+async function showCometixMenu() {
+  try {
+    ensureI18nInitialized();
+    console.log(`
+${ansis.cyan("\u2550".repeat(50))}`);
+    console.log(ansis.bold.cyan(`  ${i18n.t("cometix:cometixMenuTitle")}`));
+    console.log(`${ansis.cyan("\u2550".repeat(50))}
+`);
+    console.log(`  ${ansis.cyan("1.")} ${i18n.t("cometix:cometixMenuOptions.installOrUpdate")} ${ansis.gray(`- ${i18n.t("cometix:cometixMenuDescriptions.installOrUpdate")}`)}`);
+    console.log(`  ${ansis.cyan("2.")} ${i18n.t("cometix:cometixMenuOptions.printConfig")} ${ansis.gray(`- ${i18n.t("cometix:cometixMenuDescriptions.printConfig")}`)}`);
+    console.log(`  ${ansis.cyan("3.")} ${i18n.t("cometix:cometixMenuOptions.customConfig")} ${ansis.gray(`- ${i18n.t("cometix:cometixMenuDescriptions.customConfig")}`)}`);
+    console.log(`  ${ansis.yellow("0.")} ${i18n.t("cometix:cometixMenuOptions.back")}`);
+    console.log("");
+    const { choice } = await inquirer.prompt({
+      type: "input",
+      name: "choice",
+      message: i18n.t("common:enterChoice"),
+      validate: async (value) => {
+        const valid = ["1", "2", "3", "0"];
+        return valid.includes(value) || i18n.t("common:invalidChoice");
+      }
+    });
+    switch (choice) {
+      case "1":
+        await installCometixLine();
+        break;
+      case "2":
+        await runCometixPrintConfig();
+        break;
+      case "3":
+        await runCometixTuiConfig();
+        break;
+      case "0":
+        return false;
+    }
+    if (choice !== "0") {
+      console.log(`
+${ansis.dim("\u2500".repeat(50))}
+`);
+      const continueInCometix = await promptBoolean({
+        message: i18n.t("common:returnToMenu"),
+        defaultValue: true
+      });
+      if (continueInCometix) {
+        return await showCometixMenu();
+      }
+    }
+    return false;
+  } catch (error) {
+    if (!handleExitPromptError(error)) {
+      handleGeneralError(error);
+    }
+    return false;
+  }
+}
+
+async function runCcusageFeature() {
+  ensureI18nInitialized();
+  console.log("");
+  console.log(ansis.cyan(i18n.t("menu:menuOptions.ccusage")));
+  console.log(ansis.gray(`${i18n.t("tools:ccusageDescription")}`));
+  console.log("");
+  const choices = [
+    { name: i18n.t("tools:ccusageModes.daily"), value: "daily" },
+    { name: i18n.t("tools:ccusageModes.monthly"), value: "monthly" },
+    { name: i18n.t("tools:ccusageModes.session"), value: "session" },
+    { name: i18n.t("tools:ccusageModes.blocks"), value: "blocks" },
+    { name: i18n.t("tools:ccusageModes.custom"), value: "custom" },
+    { name: i18n.t("common:back"), value: "back" }
+  ];
+  const { mode } = await inquirer.prompt({
+    type: "list",
+    name: "mode",
+    message: i18n.t("tools:selectAnalysisMode"),
+    choices: addNumbersToChoices(choices)
+  });
+  if (mode === "back") {
+    return;
+  }
+  let args = [];
+  if (mode === "custom") {
+    const { customArgs } = await inquirer.prompt({
+      type: "input",
+      name: "customArgs",
+      message: i18n.t("tools:enterCustomArgs"),
+      default: ""
+    });
+    if (customArgs === null || customArgs === void 0 || customArgs === "") {
+      args = [];
+    } else {
+      const argsString = String(customArgs).trim();
+      if (!argsString) {
+        args = [];
+      } else {
+        const argPattern = /"([^"]*)"|'([^']*)'|(\S+)/g;
+        const matches = [];
+        let match = argPattern.exec(argsString);
+        while (match !== null) {
+          const value = match[1] || match[2] || match[3];
+          if (value) {
+            matches.push(value);
+          }
+          match = argPattern.exec(argsString);
+        }
+        args = matches;
+      }
+    }
+  } else {
+    args = [mode];
+  }
+  console.log("");
+  await executeCcusage(args);
+  console.log("");
+  await inquirer.prompt({
+    type: "input",
+    name: "continue",
+    message: ansis.gray(i18n.t("tools:pressEnterToContinue"))
+  });
+}
+async function runCcrMenuFeature() {
+  await showCcrMenu();
+}
+async function runCometixMenuFeature() {
+  await showCometixMenu();
+}
+
+class ToolUpdateScheduler {
+  /**
+   * Update tools based on code type
+   * @param codeType - The code tool type to update
+   * @param skipPrompt - Whether to skip interactive prompts
+   */
+  async updateByCodeType(codeType, skipPrompt = false) {
+    await ensureI18nInitialized();
+    switch (codeType) {
+      case "claude-code":
+        await this.updateClaudeCodeTools(skipPrompt);
+        break;
+      case "codex":
+        await this.updateCodexTools(skipPrompt);
+        break;
+      default:
+        throw new Error(`Unsupported code type: ${codeType}`);
+    }
+  }
+  /**
+   * Update Claude Code related tools
+   * @param skipPrompt - Whether to skip interactive prompts
+   */
+  async updateClaudeCodeTools(skipPrompt) {
+    await checkAndUpdateTools(skipPrompt);
+  }
+  /**
+   * Update Codex tools
+   * @param skipPrompt - Whether to skip interactive prompts
+   */
+  async updateCodexTools(skipPrompt) {
+    await runCodexUpdate(false, skipPrompt);
+  }
+}
+
+async function checkUpdates(options = {}) {
+  try {
+    const skipPrompt = options.skipPrompt || false;
+    let codeType;
+    try {
+      codeType = await resolveCodeType$1(options.codeType);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      console.error(ansis.red(`${errorMessage}
+Defaulting to "claude-code".`));
+      codeType = "claude-code";
+    }
+    const scheduler = new ToolUpdateScheduler();
+    await scheduler.updateByCodeType(codeType, skipPrompt);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(ansis.red(`${i18n.t("updater:errorCheckingUpdates")} ${errorMessage}`));
+    process.exit(1);
+  }
+}
+
+class ZcfUninstaller {
+  _lang;
+  // Reserved for future i18n support
+  conflictResolution = /* @__PURE__ */ new Map();
+  constructor(lang = "en") {
+    this._lang = lang;
+    this.conflictResolution.set("claude-code", ["mcps"]);
+    void this._lang;
+  }
+  /**
+   * 1. Remove outputStyle field from settings.json and output-styles directory
+   */
+  async removeOutputStyles() {
+    const result = {
+      success: false,
+      removed: [],
+      removedConfigs: [],
+      errors: [],
+      warnings: []
+    };
+    try {
+      const settingsPath = join(homedir(), ".claude", "settings.json");
+      const outputStylesPath = join(homedir(), ".claude", "output-styles");
+      if (await pathExists(settingsPath)) {
+        const settings = readJsonConfig(settingsPath) || {};
+        if (settings.outputStyle) {
+          delete settings.outputStyle;
+          writeJsonConfig(settingsPath, settings);
+          result.removedConfigs.push("outputStyle field from settings.json");
+        }
+      } else {
+        result.warnings.push(i18n.t("uninstall:settingsJsonNotFound"));
+      }
+      if (await pathExists(outputStylesPath)) {
+        const trashResult = await moveToTrash(outputStylesPath);
+        if (!trashResult[0]?.success) {
+          result.warnings.push(trashResult[0]?.error || "Failed to move to trash");
+        }
+        result.removed.push("~/.claude/output-styles/");
+      } else {
+        result.warnings.push(i18n.t("uninstall:outputStylesDirectoryNotFound"));
+      }
+      result.success = true;
+    } catch (error) {
+      result.errors.push(`Failed to remove output styles: ${error.message}`);
+    }
+    return result;
+  }
+  /**
+   * 2. Remove custom commands directory (commands/zcf/)
+   */
+  async removeCustomCommands() {
+    const result = {
+      success: false,
+      removed: [],
+      removedConfigs: [],
+      errors: [],
+      warnings: []
+    };
+    try {
+      const commandsPath = join(homedir(), ".claude", "commands", "zcf");
+      if (await pathExists(commandsPath)) {
+        const trashResult = await moveToTrash(commandsPath);
+        if (!trashResult[0]?.success) {
+          result.warnings.push(trashResult[0]?.error || "Failed to move to trash");
+        }
+        result.removed.push("commands/zcf/");
+        result.success = true;
+      } else {
+        result.warnings.push(i18n.t("uninstall:commandsNotFound"));
+        result.success = true;
+      }
+    } catch (error) {
+      result.errors.push(`Failed to remove custom commands: ${error.message}`);
+    }
+    return result;
+  }
+  /**
+   * 3. Remove custom agents directory (agents/zcf/)
+   */
+  async removeCustomAgents() {
+    const result = {
+      success: false,
+      removed: [],
+      removedConfigs: [],
+      errors: [],
+      warnings: []
+    };
+    try {
+      const agentsPath = join(homedir(), ".claude", "agents", "zcf");
+      if (await pathExists(agentsPath)) {
+        const trashResult = await moveToTrash(agentsPath);
+        if (!trashResult[0]?.success) {
+          result.warnings.push(trashResult[0]?.error || "Failed to move to trash");
+        }
+        result.removed.push("agents/zcf/");
+        result.success = true;
+      } else {
+        result.warnings.push(i18n.t("uninstall:agentsNotFound"));
+        result.success = true;
+      }
+    } catch (error) {
+      result.errors.push(`Failed to remove custom agents: ${error.message}`);
+    }
+    return result;
+  }
+  /**
+   * 4. Remove global memory file (CLAUDE.md)
+   */
+  async removeClaudeMd() {
+    const result = {
+      success: false,
+      removed: [],
+      removedConfigs: [],
+      errors: [],
+      warnings: []
+    };
+    try {
+      const claudeMdPath = join(homedir(), ".claude", "CLAUDE.md");
+      if (await pathExists(claudeMdPath)) {
+        const trashResult = await moveToTrash(claudeMdPath);
+        if (!trashResult[0]?.success) {
+          result.warnings.push(trashResult[0]?.error || "Failed to move to trash");
+        }
+        result.removed.push("CLAUDE.md");
+        result.success = true;
+      } else {
+        result.warnings.push(i18n.t("uninstall:claudeMdNotFound"));
+        result.success = true;
+      }
+    } catch (error) {
+      result.errors.push(`Failed to remove CLAUDE.md: ${error.message}`);
+    }
+    return result;
+  }
+  /**
+   * 5. Remove permissions and environment variables
+   */
+  async removePermissionsAndEnvs() {
+    const result = {
+      success: false,
+      removed: [],
+      removedConfigs: [],
+      errors: [],
+      warnings: []
+    };
+    try {
+      const settingsPath = join(homedir(), ".claude", "settings.json");
+      if (await pathExists(settingsPath)) {
+        const settings = readJsonConfig(settingsPath) || {};
+        let modified = false;
+        if (settings.permissions) {
+          delete settings.permissions;
+          result.removedConfigs.push("permissions configuration");
+          modified = true;
+        }
+        if (settings.env) {
+          delete settings.env;
+          result.removedConfigs.push("environment variables");
+          modified = true;
+        }
+        if (modified) {
+          writeJsonConfig(settingsPath, settings);
+        }
+        result.success = true;
+      } else {
+        result.warnings.push(i18n.t("uninstall:settingsJsonNotFound"));
+        result.success = true;
+      }
+    } catch (error) {
+      result.errors.push(`Failed to remove permissions and envs: ${error.message}`);
+    }
+    return result;
+  }
+  /**
+   * 6. Remove MCP servers from .claude.json (mcpServers field only)
+   */
+  async removeMcps() {
+    const result = {
+      success: false,
+      removed: [],
+      removedConfigs: [],
+      errors: [],
+      warnings: []
+    };
+    try {
+      const claudeJsonPath = join(homedir(), ".claude.json");
+      if (await pathExists(claudeJsonPath)) {
+        const config = readJsonConfig(claudeJsonPath) || {};
+        if (config.mcpServers) {
+          delete config.mcpServers;
+          writeJsonConfig(claudeJsonPath, config);
+          result.removedConfigs.push("mcpServers from .claude.json");
+        }
+        result.success = true;
+      } else {
+        result.warnings.push(i18n.t("uninstall:claudeJsonNotFound"));
+        result.success = true;
+      }
+    } catch (error) {
+      result.errors.push(`Failed to remove MCP servers: ${error.message}`);
+    }
+    return result;
+  }
+  /**
+   * 7. Uninstall Claude Code Router and remove configuration
+   */
+  async uninstallCcr() {
+    const result = {
+      success: false,
+      removed: [],
+      removedConfigs: [],
+      errors: [],
+      warnings: []
+    };
+    try {
+      const ccrPath = join(homedir(), ".claude-code-router");
+      if (await pathExists(ccrPath)) {
+        const trashResult = await moveToTrash(ccrPath);
+        if (!trashResult[0]?.success) {
+          result.warnings.push(trashResult[0]?.error || "Failed to move to trash");
+        }
+        result.removed.push(".claude-code-router/");
+      }
+      try {
+        await exec$1("npm", ["uninstall", "-g", "@musistudio/claude-code-router"]);
+        result.removed.push("@musistudio/claude-code-router package");
+        result.success = true;
+      } catch (npmError) {
+        if (npmError.message.includes("not found") || npmError.message.includes("not installed")) {
+          result.warnings.push(i18n.t("uninstall:ccrPackageNotFound"));
+          result.success = true;
+        } else {
+          result.errors.push(`Failed to uninstall CCR package: ${npmError.message}`);
+        }
+      }
+    } catch (error) {
+      result.errors.push(`Failed to uninstall CCR: ${error.message}`);
+    }
+    return result;
+  }
+  /**
+   * 8. Uninstall CCometixLine
+   */
+  async uninstallCcline() {
+    const result = {
+      success: false,
+      removed: [],
+      removedConfigs: [],
+      errors: [],
+      warnings: []
+    };
+    try {
+      await exec$1("npm", ["uninstall", "-g", "@cometix/ccline"]);
+      result.removed.push("@cometix/ccline package");
+      result.success = true;
+    } catch (error) {
+      if (error.message.includes("not found") || error.message.includes("not installed")) {
+        result.warnings.push(i18n.t("uninstall:cclinePackageNotFound"));
+        result.success = true;
+      } else {
+        result.errors.push(`Failed to uninstall CCometixLine: ${error.message}`);
+      }
+    }
+    return result;
+  }
+  /**
+   * 9. Uninstall Claude Code and remove entire .claude.json
+   */
+  async uninstallClaudeCode() {
+    const result = {
+      success: false,
+      removed: [],
+      removedConfigs: [],
+      errors: [],
+      warnings: []
+    };
+    try {
+      const claudeJsonPath = join(homedir(), ".claude.json");
+      if (await pathExists(claudeJsonPath)) {
+        const trashResult = await moveToTrash(claudeJsonPath);
+        if (!trashResult[0]?.success) {
+          result.warnings.push(trashResult[0]?.error || "Failed to move to trash");
+        }
+        result.removed.push(".claude.json (includes MCP configuration)");
+      }
+      try {
+        const { uninstallCodeTool } = await import('./chunks/simple-config.mjs').then(function (n) { return n.br; });
+        const success = await uninstallCodeTool("claude-code");
+        if (success) {
+          result.removed.push("@anthropic-ai/claude-code");
+          result.success = true;
+        } else {
+          result.errors.push(i18n.t("uninstall:uninstallFailed", { codeType: i18n.t("common:claudeCode"), message: "" }));
+        }
+      } catch (npmError) {
+        if (npmError.message.includes("not found") || npmError.message.includes("not installed")) {
+          result.warnings.push(i18n.t("uninstall:claudeCodePackageNotFound"));
+          result.success = true;
+        } else {
+          result.errors.push(i18n.t("uninstall:uninstallFailed", { codeType: i18n.t("common:claudeCode"), message: `: ${npmError.message}` }));
+        }
+      }
+    } catch (error) {
+      result.errors.push(i18n.t("uninstall:uninstallFailed", { codeType: i18n.t("common:claudeCode"), message: `: ${error.message}` }));
+    }
+    return result;
+  }
+  /**
+   * 10. Remove backup files
+   */
+  async removeBackups() {
+    const result = {
+      success: false,
+      removed: [],
+      removedConfigs: [],
+      errors: [],
+      warnings: []
+    };
+    try {
+      const backupPath = join(homedir(), ".claude", "backup");
+      if (await pathExists(backupPath)) {
+        const trashResult = await moveToTrash(backupPath);
+        if (!trashResult[0]?.success) {
+          result.warnings.push(trashResult[0]?.error || "Failed to move to trash");
+        }
+        result.removed.push("backup/");
+        result.success = true;
+      } else {
+        result.warnings.push(i18n.t("uninstall:backupsNotFound"));
+        result.success = true;
+      }
+    } catch (error) {
+      result.errors.push(`Failed to remove backups: ${error.message}`);
+    }
+    return result;
+  }
+  /**
+   * 11. Remove ZCF preference configuration
+   */
+  async removeZcfConfig() {
+    const result = {
+      success: false,
+      removed: [],
+      removedConfigs: [],
+      errors: [],
+      warnings: []
+    };
+    try {
+      const zcfConfigPath = ZCF_CONFIG_FILE;
+      const relativeName = zcfConfigPath.replace(homedir(), "~");
+      if (await pathExists(zcfConfigPath)) {
+        const trashResult = await moveToTrash(zcfConfigPath);
+        if (!trashResult[0]?.success) {
+          result.warnings.push(trashResult[0]?.error || "Failed to move to trash");
+        }
+        result.removed.push(relativeName);
+        result.success = true;
+      } else {
+        result.warnings.push(i18n.t("uninstall:zcfConfigNotFound"));
+        result.success = true;
+      }
+    } catch (error) {
+      result.errors.push(`Failed to remove ZCF config: ${error.message}`);
+    }
+    return result;
+  }
+  /**
+   * Complete uninstall - remove all directories and packages
+   */
+  async completeUninstall() {
+    const result = {
+      success: true,
+      removed: [],
+      removedConfigs: [],
+      errors: [],
+      warnings: []
+    };
+    try {
+      const directoriesToRemove = [
+        { path: join(homedir(), ".claude"), name: "~/.claude/" },
+        { path: join(homedir(), ".claude.json"), name: "~/.claude.json" },
+        { path: join(homedir(), ".claude-code-router"), name: "~/.claude-code-router/" }
+      ];
+      for (const dir of directoriesToRemove) {
+        try {
+          if (await pathExists(dir.path)) {
+            const trashResult = await moveToTrash(dir.path);
+            if (!trashResult[0]?.success) {
+              result.warnings.push(`Failed to move ${dir.name} to trash: ${trashResult[0]?.error || "Unknown error"}`);
+            }
+            result.removed.push(dir.name);
+          }
+        } catch (error) {
+          result.warnings.push(`Failed to remove ${dir.name}: ${error.message}`);
+        }
+      }
+      const packagesToUninstall = [
+        "@musistudio/claude-code-router",
+        "@cometix/ccline",
+        "@anthropic-ai/claude-code"
+      ];
+      for (const pkg of packagesToUninstall) {
+        try {
+          await exec$1("npm", ["uninstall", "-g", pkg]);
+          result.removed.push(`${pkg} package`);
+        } catch (error) {
+          if (error.message.includes("not found") || error.message.includes("not installed")) {
+            if (pkg.includes("claude-code-router")) {
+              result.warnings.push(i18n.t("uninstall:ccrPackageNotFound"));
+            } else if (pkg.includes("ccline")) {
+              result.warnings.push(i18n.t("uninstall:cclinePackageNotFound"));
+            } else {
+              result.warnings.push(i18n.t("uninstall:claudeCodePackageNotFound"));
+            }
+          } else {
+            result.warnings.push(`Failed to uninstall ${pkg}: ${error.message}`);
+          }
+        }
+      }
+    } catch (error) {
+      result.errors.push(`Complete uninstall failed: ${error.message}`);
+      result.success = false;
+    }
+    return result;
+  }
+  /**
+   * Custom uninstall with conflict resolution
+   */
+  async customUninstall(selectedItems) {
+    const resolvedItems = this.resolveConflicts(selectedItems);
+    const results = [];
+    for (const item of resolvedItems) {
+      try {
+        const result = await this.executeUninstallItem(item);
+        results.push(result);
+      } catch (error) {
+        results.push({
+          success: false,
+          removed: [],
+          removedConfigs: [],
+          errors: [`Failed to execute ${item}: ${error.message}`],
+          warnings: []
+        });
+      }
+    }
+    return results;
+  }
+  /**
+   * Resolve conflicts between uninstall items
+   */
+  resolveConflicts(items) {
+    const resolved = [...items];
+    for (const [primary, conflicts] of this.conflictResolution) {
+      if (resolved.includes(primary)) {
+        conflicts.forEach((conflict) => {
+          const index = resolved.indexOf(conflict);
+          if (index > -1) {
+            resolved.splice(index, 1);
+          }
+        });
+      }
+    }
+    return resolved;
+  }
+  /**
+   * Execute uninstall for a specific item
+   */
+  async executeUninstallItem(item) {
+    switch (item) {
+      case "output-styles":
+        return await this.removeOutputStyles();
+      case "commands":
+        return await this.removeCustomCommands();
+      case "agents":
+        return await this.removeCustomAgents();
+      case "claude-md":
+        return await this.removeClaudeMd();
+      case "permissions-envs":
+        return await this.removePermissionsAndEnvs();
+      case "mcps":
+        return await this.removeMcps();
+      case "ccr":
+        return await this.uninstallCcr();
+      case "ccline":
+        return await this.uninstallCcline();
+      case "claude-code":
+        return await this.uninstallClaudeCode();
+      case "backups":
+        return await this.removeBackups();
+      case "zcf-config":
+        return await this.removeZcfConfig();
+      default:
+        return {
+          success: false,
+          removed: [],
+          removedConfigs: [],
+          errors: [`Unknown uninstall item: ${item}`],
+          warnings: []
+        };
+    }
+  }
+}
+
+async function uninstall(options = {}) {
+  try {
+    ensureI18nInitialized();
+    let codeType;
+    if (options.codeType) {
+      try {
+        codeType = await resolveCodeType$1(options.codeType);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(ansis.red(`${i18n.t("errors:generalError")} ${errorMessage}`));
+        const config = readZcfConfig();
+        codeType = config?.codeToolType && isCodeToolType(config.codeToolType) ? config.codeToolType : DEFAULT_CODE_TOOL_TYPE;
+      }
+    } else {
+      const config = readZcfConfig();
+      codeType = config?.codeToolType && isCodeToolType(config.codeToolType) ? config.codeToolType : DEFAULT_CODE_TOOL_TYPE;
+    }
+    const uninstaller = new ZcfUninstaller(options.lang || "en");
+    if (codeType === "codex") {
+      const { runCodexUninstall } = await import('./chunks/simple-config.mjs').then(function (n) { return n.bq; });
+      await runCodexUninstall();
+      return;
+    }
+    if (options.mode && options.mode !== "interactive") {
+      if (options.mode === "complete") {
+        await executeCompleteUninstall(uninstaller);
+        return;
+      } else if (options.mode === "custom" && options.items) {
+        let items;
+        if (typeof options.items === "string") {
+          items = options.items.split(",").map((item) => item.trim());
+        } else {
+          items = options.items;
+        }
+        await executeCustomUninstall(uninstaller, items);
+        return;
+      }
+    }
+    await showInteractiveUninstall(uninstaller);
+  } catch (error) {
+    if (!handleExitPromptError(error)) {
+      handleGeneralError(error);
+    }
+  }
+}
+async function showInteractiveUninstall(uninstaller) {
+  console.log(ansis.cyan.bold(i18n.t("uninstall:title")));
+  console.log("");
+  const { mainChoice } = await inquirer.prompt({
+    type: "list",
+    name: "mainChoice",
+    message: i18n.t("uninstall:selectMainOption"),
+    choices: addNumbersToChoices([
+      {
+        name: `${i18n.t("uninstall:completeUninstall")} - ${ansis.gray(i18n.t("uninstall:completeUninstallDesc"))}`,
+        value: "complete",
+        short: i18n.t("uninstall:completeUninstall")
+      },
+      {
+        name: `${i18n.t("uninstall:customUninstall")} - ${ansis.gray(i18n.t("uninstall:customUninstallDesc"))}`,
+        value: "custom",
+        short: i18n.t("uninstall:customUninstall")
+      }
+    ])
+  });
+  if (!mainChoice) {
+    console.log(ansis.yellow(i18n.t("common:cancelled")));
+    return;
+  }
+  if (mainChoice === "complete") {
+    await executeCompleteUninstall(uninstaller);
+  } else {
+    await showCustomUninstallMenu(uninstaller);
+  }
+}
+async function showCustomUninstallMenu(uninstaller) {
+  console.log("");
+  console.log(ansis.cyan(i18n.t("uninstall:selectCustomItems")));
+  const { customItems } = await inquirer.prompt({
+    type: "checkbox",
+    name: "customItems",
+    message: `${i18n.t("uninstall:selectItemsToRemove")} ${i18n.t("common:multiSelectHint")}`,
+    choices: [
+      {
+        name: i18n.t("uninstall:outputStyles"),
+        value: "output-styles"
+      },
+      {
+        name: i18n.t("uninstall:commands"),
+        value: "commands"
+      },
+      {
+        name: i18n.t("uninstall:agents"),
+        value: "agents"
+      },
+      {
+        name: i18n.t("uninstall:claudeMd"),
+        value: "claude-md"
+      },
+      {
+        name: i18n.t("uninstall:permissionsEnvs"),
+        value: "permissions-envs"
+      },
+      {
+        name: i18n.t("uninstall:mcps"),
+        value: "mcps"
+      },
+      {
+        name: i18n.t("uninstall:ccr"),
+        value: "ccr"
+      },
+      {
+        name: i18n.t("uninstall:ccline"),
+        value: "ccline"
+      },
+      {
+        name: i18n.t("uninstall:claudeCode"),
+        value: "claude-code"
+      },
+      {
+        name: i18n.t("uninstall:backups"),
+        value: "backups"
+      },
+      {
+        name: i18n.t("uninstall:zcfConfig"),
+        value: "zcf-config"
+      }
+    ],
+    validate: (answers) => {
+      if (answers.length === 0) {
+        return i18n.t("uninstall:selectAtLeastOne");
+      }
+      return true;
+    }
+  });
+  if (!customItems || customItems.length === 0) {
+    console.log(ansis.yellow(i18n.t("common:cancelled")));
+    return;
+  }
+  await executeCustomUninstall(uninstaller, customItems);
+}
+async function executeCompleteUninstall(uninstaller) {
+  console.log("");
+  console.log(ansis.red.bold(i18n.t("uninstall:executingComplete")));
+  console.log(ansis.yellow(i18n.t("uninstall:completeWarning")));
+  const confirm = await promptBoolean({
+    message: i18n.t("uninstall:confirmComplete"),
+    defaultValue: false
+  });
+  if (!confirm) {
+    console.log(ansis.yellow(i18n.t("common:cancelled")));
+    return;
+  }
+  console.log("");
+  console.log(ansis.cyan(i18n.t("uninstall:processingComplete")));
+  const result = await uninstaller.completeUninstall();
+  displayUninstallResult("complete", [result]);
+}
+async function executeCustomUninstall(uninstaller, items) {
+  console.log("");
+  console.log(ansis.cyan(i18n.t("uninstall:executingCustom")));
+  console.log(ansis.gray(i18n.t("uninstall:selectedItems")));
+  items.forEach((item) => {
+    console.log(`  \u2022 ${i18n.t(`uninstall:${item}`)}`);
+  });
+  const confirm = await promptBoolean({
+    message: i18n.t("uninstall:confirmCustom"),
+    defaultValue: false
+  });
+  if (!confirm) {
+    console.log(ansis.yellow(i18n.t("common:cancelled")));
+    return;
+  }
+  console.log("");
+  console.log(ansis.cyan(i18n.t("uninstall:processingCustom")));
+  const results = await uninstaller.customUninstall(items);
+  displayUninstallResult("custom", results);
+}
+function displayUninstallResult(mode, results) {
+  console.log("");
+  console.log(ansis.cyan("\u2500".repeat(50)));
+  let totalSuccess = 0;
+  let totalErrors = 0;
+  let totalWarnings = 0;
+  results.forEach((result) => {
+    if (result.success) {
+      totalSuccess++;
+    }
+    if (result.removed && result.removed.length > 0) {
+      console.log(ansis.green(`\u{1F5D1}\uFE0F ${i18n.t("uninstall:movedToTrash")}:`));
+      result.removed.forEach((item) => {
+        console.log(ansis.gray(`  \u2022 ${item}`));
+      });
+    }
+    if (result.removedConfigs && result.removedConfigs.length > 0) {
+      console.log(ansis.green(`\u2714 ${i18n.t("uninstall:removedConfigs")}:`));
+      result.removedConfigs.forEach((item) => {
+        console.log(ansis.gray(`  \u2022 ${item}`));
+      });
+    }
+    if (result.errors && result.errors.length > 0) {
+      totalErrors += result.errors.length;
+      console.log(ansis.red(`\u2716 ${i18n.t("uninstall:errors")}:`));
+      result.errors.forEach((error) => {
+        console.log(ansis.red(`  \u2022 ${error}`));
+      });
+    }
+    if (result.warnings && result.warnings.length > 0) {
+      totalWarnings += result.warnings.length;
+      console.log(ansis.yellow(`\u26A0 ${i18n.t("uninstall:warnings")}:`));
+      result.warnings.forEach((warning) => {
+        console.log(ansis.yellow(`  \u2022 ${warning}`));
+      });
+    }
+  });
+  const totalRemovedFiles = results.reduce((count, result) => count + (result.removed?.length || 0), 0);
+  const totalRemovedConfigs = results.reduce((count, result) => count + (result.removedConfigs?.length || 0), 0);
+  console.log("");
+  console.log(ansis.cyan("\u2500".repeat(50)));
+  if (mode === "complete") {
+    if (totalErrors === 0) {
+      console.log(ansis.green.bold(`\u2714 ${i18n.t("uninstall:completeSuccess")}`));
+    } else {
+      console.log(ansis.yellow.bold(`\u26A0 ${i18n.t("uninstall:completePartialSuccess")}`));
+    }
+  } else {
+    if (totalRemovedFiles > 0 && totalRemovedConfigs > 0) {
+      console.log(ansis.green.bold(`\u2714 ${i18n.t("uninstall:customSuccessBoth", {
+        fileCount: totalRemovedFiles,
+        configCount: totalRemovedConfigs
+      })}`));
+    } else if (totalRemovedFiles > 0) {
+      console.log(ansis.green.bold(`\u2714 ${i18n.t("uninstall:customSuccessFiles", {
+        count: totalRemovedFiles
+      })}`));
+    } else if (totalRemovedConfigs > 0) {
+      console.log(ansis.green.bold(`\u2714 ${i18n.t("uninstall:customSuccessConfigs", {
+        count: totalRemovedConfigs
+      })}`));
+    } else {
+      console.log(ansis.green.bold(`\u2714 ${i18n.t("uninstall:customSuccess", { count: totalSuccess })}`));
+    }
+    if (totalErrors > 0) {
+      console.log(ansis.red(`\u2716 ${i18n.t("uninstall:errorsCount", { count: totalErrors })}`));
+    }
+    if (totalWarnings > 0) {
+      console.log(ansis.yellow(`\u26A0 ${i18n.t("uninstall:warningsCount", { count: totalWarnings })}`));
+    }
+  }
+  console.log("");
+}
+
+function resolveCodeToolType(optionValue, savedValue) {
+  if (optionValue !== void 0) {
+    const resolved = resolveCodeToolType$1(optionValue);
+    if (resolved !== DEFAULT_CODE_TOOL_TYPE || optionValue === DEFAULT_CODE_TOOL_TYPE) {
+      return resolved;
+    }
+  }
+  if (savedValue && isCodeToolType(savedValue)) {
+    return savedValue;
+  }
+  return DEFAULT_CODE_TOOL_TYPE;
+}
+async function update(options = {}) {
+  try {
+    if (!options.skipBanner) {
+      displayBanner(i18n.t("cli:banner.updateSubtitle"));
+    }
+    const zcfConfig = readZcfConfig();
+    const codeToolType = resolveCodeToolType(options.codeType, zcfConfig?.codeToolType);
+    options.codeType = codeToolType;
+    if (codeToolType === "codex") {
+      await runCodexUpdate();
+      const newPreferredLang = options.configLang || zcfConfig?.preferredLang;
+      if (newPreferredLang) {
+        updateZcfConfig({
+          version,
+          preferredLang: newPreferredLang,
+          codeToolType
+        });
+      } else {
+        updateZcfConfig({
+          version,
+          codeToolType
+        });
+      }
+      return;
+    }
+    const { resolveTemplateLanguage } = await import('./chunks/simple-config.mjs').then(function (n) { return n.bo; });
+    const configLang = await resolveTemplateLanguage(
+      options.configLang,
+      // Command line option
+      zcfConfig,
+      options.skipPrompt
+      // Non-interactive mode flag
+    );
+    const aiOutputLang = await resolveAiOutputLanguage(i18n.language, options.aiOutputLang, zcfConfig, options.skipPrompt);
+    console.log(ansis.cyan(`
+${i18n.t("configuration:updatingPrompts")}
+`));
+    await updatePromptOnly(aiOutputLang);
+    await selectAndInstallWorkflows(configLang);
+    await checkClaudeCodeVersionAndPrompt(false);
+    updateZcfConfig({
+      version,
+      templateLang: configLang,
+      // 保存模板语言选择
+      aiOutputLang,
+      codeToolType
+    });
+  } catch (error) {
+    if (!handleExitPromptError(error)) {
+      handleGeneralError(error);
+    }
+  }
+}
+
+const CODE_TOOL_LABELS = {
+  "claude-code": "Claude Code",
+  "codex": "Codex"
+};
+function getCurrentCodeTool() {
+  const config = readZcfConfig();
+  if (config?.codeToolType && isCodeToolType(config.codeToolType)) {
+    return config.codeToolType;
+  }
+  return DEFAULT_CODE_TOOL_TYPE;
+}
+function printSeparator() {
+  console.log(`
+${ansis.dim("\u2500".repeat(50))}
+`);
+}
+function getCodeToolLabel(codeTool) {
+  return CODE_TOOL_LABELS[codeTool] || codeTool;
+}
+async function promptCodeToolSelection(current) {
+  const choices = addNumbersToChoices(Object.entries(CODE_TOOL_LABELS).map(([value, label]) => ({
+    name: label,
+    value,
+    short: label
+  })));
+  const { tool } = await inquirer.prompt({
+    type: "list",
+    name: "tool",
+    message: i18n.t("menu:switchCodeToolPrompt"),
+    default: current,
+    choices
+  });
+  if (!tool) {
+    console.log(ansis.yellow(i18n.t("common:cancelled")));
+    return null;
+  }
+  return tool;
+}
+async function handleCodeToolSwitch(current) {
+  const newTool = await promptCodeToolSelection(current);
+  if (!newTool || newTool === current) {
+    return false;
+  }
+  updateZcfConfig({ codeToolType: newTool });
+  console.log(ansis.green(`\u2714 ${i18n.t("menu:codeToolSwitched", { tool: getCodeToolLabel(newTool) })}`));
+  return true;
+}
+function printOtherToolsSection() {
+  console.log(`  --------- ${i18n.t("menu:menuSections.otherTools")} ----------`);
+  console.log(
+    `  ${ansis.cyan("R.")} ${i18n.t("menu:menuOptions.ccrManagement")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.ccrManagement")}`)}`
+  );
+  console.log(
+    `  ${ansis.cyan("U.")} ${i18n.t("menu:menuOptions.ccusage")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.ccusage")}`)}`
+  );
+  console.log(
+    `  ${ansis.cyan("L.")} ${i18n.t("menu:menuOptions.cometixLine")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.cometixLine")}`)}`
+  );
+  console.log("");
+}
+function printZcfSection(options) {
+  console.log("  ------------ ZCF ------------");
+  console.log(
+    `  ${ansis.cyan("0.")} ${i18n.t("menu:menuOptions.changeLanguage")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.changeLanguage")}`)}`
+  );
+  console.log(
+    `  ${ansis.cyan("S.")} ${i18n.t("menu:menuOptions.switchCodeTool")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.switchCodeTool")}`)}`
+  );
+  console.log(
+    `  ${ansis.cyan("-.")} ${options.uninstallOption} ${ansis.gray(`- ${options.uninstallDescription}`)}`
+  );
+  console.log(
+    `  ${ansis.cyan("+.")} ${options.updateOption} ${ansis.gray(`- ${options.updateDescription}`)}`
+  );
+  console.log(`  ${ansis.red("Q.")} ${ansis.red(i18n.t("menu:menuOptions.exit"))}`);
+  console.log("");
+}
+async function showClaudeCodeMenu() {
+  console.log(ansis.cyan(i18n.t("menu:selectFunction")));
+  console.log("  -------- Claude Code --------");
+  console.log(
+    `  ${ansis.cyan("1.")} ${i18n.t("menu:menuOptions.fullInit")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.fullInit")}`)}`
+  );
+  console.log(
+    `  ${ansis.cyan("2.")} ${i18n.t("menu:menuOptions.importWorkflow")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.importWorkflow")}`)}`
+  );
+  console.log(
+    `  ${ansis.cyan("3.")} ${i18n.t("menu:menuOptions.configureApiOrCcr")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.configureApiOrCcr")}`)}`
+  );
+  console.log(
+    `  ${ansis.cyan("4.")} ${i18n.t("menu:menuOptions.configureMcp")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.configureMcp")}`)}`
+  );
+  console.log(
+    `  ${ansis.cyan("5.")} ${i18n.t("menu:menuOptions.configureModel")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.configureModel")}`)}`
+  );
+  console.log(
+    `  ${ansis.cyan("6.")} ${i18n.t("menu:menuOptions.configureAiMemory")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.configureAiMemory")}`)}`
+  );
+  console.log(
+    `  ${ansis.cyan("7.")} ${i18n.t("menu:menuOptions.configureEnvPermission")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.configureEnvPermission")}`)}`
+  );
+  console.log("");
+  printOtherToolsSection();
+  printZcfSection({
+    uninstallOption: i18n.t("menu:menuOptions.uninstall"),
+    uninstallDescription: i18n.t("menu:menuDescriptions.uninstall"),
+    updateOption: i18n.t("menu:menuOptions.checkUpdates"),
+    updateDescription: i18n.t("menu:menuDescriptions.checkUpdates")
+  });
+  const { choice } = await inquirer.prompt({
+    type: "input",
+    name: "choice",
+    message: i18n.t("common:enterChoice"),
+    validate: (value) => {
+      const valid = ["1", "2", "3", "4", "5", "6", "7", "r", "R", "u", "U", "l", "L", "0", "-", "+", "s", "S", "q", "Q"];
+      return valid.includes(value) || i18n.t("common:invalidChoice");
+    }
+  });
+  if (!choice) {
+    console.log(ansis.yellow(i18n.t("common:cancelled")));
+    return "exit";
+  }
+  const normalized = choice.toLowerCase();
+  switch (normalized) {
+    case "1":
+      await init({ skipBanner: true });
+      break;
+    case "2":
+      await update({ skipBanner: true });
+      break;
+    case "3":
+      await configureApiFeature();
+      break;
+    case "4":
+      await configureMcpFeature();
+      break;
+    case "5":
+      await configureDefaultModelFeature();
+      break;
+    case "6":
+      await configureAiMemoryFeature();
+      break;
+    case "7":
+      await configureEnvPermissionFeature();
+      break;
+    case "r":
+      await runCcrMenuFeature();
+      printSeparator();
+      return void 0;
+    case "u":
+      await runCcusageFeature();
+      printSeparator();
+      return void 0;
+    case "l":
+      await runCometixMenuFeature();
+      printSeparator();
+      return void 0;
+    case "0": {
+      const currentLang = i18n.language;
+      await changeScriptLanguageFeature(currentLang);
+      printSeparator();
+      return void 0;
+    }
+    case "-":
+      await uninstall();
+      printSeparator();
+      return void 0;
+    case "+":
+      await checkUpdates();
+      printSeparator();
+      return void 0;
+    case "s": {
+      const switched = await handleCodeToolSwitch("claude-code");
+      if (switched) {
+        return "switch";
+      }
+      printSeparator();
+      return void 0;
+    }
+    case "q":
+      console.log(ansis.cyan(i18n.t("common:goodbye")));
+      return "exit";
+    default:
+      return void 0;
+  }
+  printSeparator();
+  const shouldContinue = await promptBoolean({
+    message: i18n.t("common:returnToMenu"),
+    defaultValue: true
+  });
+  if (!shouldContinue) {
+    console.log(ansis.cyan(i18n.t("common:goodbye")));
+    return "exit";
+  }
+  return void 0;
+}
+async function showCodexMenu() {
+  console.log(ansis.cyan(i18n.t("menu:selectFunction")));
+  console.log("  -------- Codex --------");
+  console.log(
+    `  ${ansis.cyan("1.")} ${i18n.t("menu:menuOptions.codexFullInit")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.codexFullInit")}`)}`
+  );
+  console.log(
+    `  ${ansis.cyan("2.")} ${i18n.t("menu:menuOptions.codexImportWorkflow")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.codexImportWorkflow")}`)}`
+  );
+  console.log(
+    `  ${ansis.cyan("3.")} ${i18n.t("menu:menuOptions.codexConfigureApi")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.codexConfigureApi")}`)}`
+  );
+  console.log(
+    `  ${ansis.cyan("4.")} ${i18n.t("menu:menuOptions.codexConfigureMcp")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.codexConfigureMcp")}`)}`
+  );
+  console.log(
+    `  ${ansis.cyan("5.")} ${i18n.t("menu:menuOptions.codexConfigureModel")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.codexConfigureModel")}`)}`
+  );
+  console.log(
+    `  ${ansis.cyan("6.")} ${i18n.t("menu:menuOptions.codexConfigureAiMemory")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.codexConfigureAiMemory")}`)}`
+  );
+  console.log("");
+  printZcfSection({
+    uninstallOption: i18n.t("menu:menuOptions.codexUninstall"),
+    uninstallDescription: i18n.t("menu:menuDescriptions.codexUninstall"),
+    updateOption: i18n.t("menu:menuOptions.codexCheckUpdates"),
+    updateDescription: i18n.t("menu:menuDescriptions.codexCheckUpdates")
+  });
+  const { choice } = await inquirer.prompt({
+    type: "input",
+    name: "choice",
+    message: i18n.t("common:enterChoice"),
+    validate: (value) => {
+      const valid = ["1", "2", "3", "4", "5", "6", "0", "-", "+", "s", "S", "q", "Q"];
+      return valid.includes(value) || i18n.t("common:invalidChoice");
+    }
+  });
+  if (!choice) {
+    console.log(ansis.yellow(i18n.t("common:cancelled")));
+    return "exit";
+  }
+  const normalized = choice.toLowerCase();
+  switch (normalized) {
+    case "1":
+      await runCodexFullInit();
+      break;
+    case "2":
+      await runCodexWorkflowImportWithLanguageSelection();
+      break;
+    case "3":
+      await configureCodexApi();
+      break;
+    case "4":
+      await configureCodexMcp();
+      break;
+    case "5":
+      await configureCodexDefaultModelFeature();
+      break;
+    case "6":
+      await configureCodexAiMemoryFeature();
+      break;
+    case "0": {
+      const currentLang = i18n.language;
+      await changeScriptLanguageFeature(currentLang);
+      printSeparator();
+      return void 0;
+    }
+    case "-":
+      await runCodexUninstall();
+      printSeparator();
+      return void 0;
+    case "+":
+      await runCodexUpdate();
+      printSeparator();
+      return void 0;
+    case "s": {
+      const switched = await handleCodeToolSwitch("codex");
+      if (switched) {
+        return "switch";
+      }
+      printSeparator();
+      return void 0;
+    }
+    case "q":
+      console.log(ansis.cyan(i18n.t("common:goodbye")));
+      return "exit";
+    default:
+      return void 0;
+  }
+  printSeparator();
+  const shouldContinue = await promptBoolean({
+    message: i18n.t("common:returnToMenu"),
+    defaultValue: true
+  });
+  if (!shouldContinue) {
+    console.log(ansis.cyan(i18n.t("common:goodbye")));
+    return "exit";
+  }
+  return void 0;
+}
+async function showMainMenu(options = {}) {
+  try {
+    if (options.codeType) {
+      try {
+        const resolvedType = await resolveCodeType$1(options.codeType);
+        const currentType = getCurrentCodeTool();
+        if (resolvedType !== currentType) {
+          updateZcfConfig({ codeToolType: resolvedType });
+          console.log(ansis.green(`\u2714 ${i18n.t("menu:codeToolSwitched", { tool: getCodeToolLabel(resolvedType) })}`));
+        }
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        console.error(ansis.yellow(errorMessage));
+      }
+    }
+    let exitMenu = false;
+    while (!exitMenu) {
+      const codeTool = getCurrentCodeTool();
+      displayBannerWithInfo(CODE_TOOL_BANNERS[codeTool] || "ZCF");
+      const result = codeTool === "codex" ? await showCodexMenu() : await showClaudeCodeMenu();
+      if (result === "exit") {
+        exitMenu = true;
+      } else if (result === "switch") {
+        continue;
+      }
+    }
+  } catch (error) {
+    if (!handleExitPromptError(error)) {
+      handleGeneralError(error);
+    }
+  }
+}
+
+async function ccr(options = {}) {
+  try {
+    if (!options.skipBanner) {
+      displayBannerWithInfo();
+    }
+    const continueInCcr = await showCcrMenu();
+    if (!continueInCcr && !options.skipBanner) {
+      await showMainMenu();
+    }
+  } catch (error) {
+    if (!handleExitPromptError(error)) {
+      handleGeneralError(error);
+    }
+  }
+}
+
+async function configSwitchCommand(options) {
+  try {
+    ensureI18nInitialized();
+    if (options.list) {
+      await handleList(options.codeType);
+      return;
+    }
+    if (options.target) {
+      const resolvedCodeType = resolveCodeType(options.codeType);
+      await handleDirectSwitch(resolvedCodeType, options.target);
+      return;
+    }
+    await handleInteractiveSwitch(options.codeType);
+  } catch (error) {
+    if (process.env.NODE_ENV === "test" || process.env.VITEST) {
+      throw error;
+    }
+    handleGeneralError(error);
+  }
+}
+function resolveCodeType(codeType) {
+  if (codeType !== void 0) {
+    const resolved = resolveCodeToolType$1(codeType);
+    return resolved;
+  }
+  const zcfConfig = readZcfConfig();
+  if (zcfConfig?.codeToolType && isCodeToolType(zcfConfig.codeToolType)) {
+    return zcfConfig.codeToolType;
+  }
+  return DEFAULT_CODE_TOOL_TYPE;
+}
+async function handleList(codeType) {
+  const targetCodeType = resolveCodeType(codeType);
+  if (targetCodeType === "claude-code") {
+    await listClaudeCodeProfiles();
+  } else if (targetCodeType === "codex") {
+    await listCodexProvidersWithDisplay();
+  }
+}
+async function listCodexProvidersWithDisplay() {
+  const providers = await listCodexProviders();
+  const existingConfig = readCodexConfig();
+  const currentProvider = existingConfig?.modelProvider;
+  const isCommented = existingConfig?.modelProviderCommented;
+  if (!providers || providers.length === 0) {
+    console.log(ansis.yellow(i18n.t("codex:noProvidersAvailable")));
+    return;
+  }
+  console.log(ansis.bold(i18n.t("codex:listProvidersTitle")));
+  console.log();
+  if (currentProvider && !isCommented) {
+    console.log(ansis.cyan(i18n.t("codex:currentProvider", { provider: currentProvider })));
+    console.log();
+  }
+  providers.forEach((provider) => {
+    const isCurrent = currentProvider === provider.id && !isCommented;
+    const status = isCurrent ? ansis.green("\u25CF ") : "  ";
+    const current = isCurrent ? ansis.yellow(` (${i18n.t("common:current")})`) : "";
+    console.log(`${status}${ansis.white(provider.name)}${current}`);
+    console.log(`    ${ansis.cyan(`ID: ${provider.id}`)} ${ansis.gray(`(${provider.baseUrl})`)}`);
+    if (provider.tempEnvKey) {
+      console.log(`    ${ansis.gray(`Env: ${provider.tempEnvKey}`)}`);
+    }
+    console.log();
+  });
+}
+async function listClaudeCodeProfiles() {
+  const config = ClaudeCodeConfigManager.readConfig();
+  if (!config || !config.profiles || Object.keys(config.profiles).length === 0) {
+    console.log(ansis.yellow(i18n.t("multi-config:noClaudeCodeProfilesAvailable")));
+    return;
+  }
+  console.log(ansis.bold(i18n.t("multi-config:availableClaudeCodeProfiles")));
+  console.log();
+  const currentProfileId = config.currentProfileId;
+  Object.values(config.profiles).forEach((profile) => {
+    const isCurrent = profile.id === currentProfileId;
+    const status = isCurrent ? ansis.green("\u25CF ") : "  ";
+    const current = isCurrent ? ansis.yellow(i18n.t("common:current")) : "";
+    console.log(`${status}${ansis.white(profile.name)}${current}`);
+    console.log(`    ${ansis.cyan(`ID: ${profile.id}`)} ${ansis.gray(`(${profile.authType})`)}`);
+    console.log();
+  });
+}
+async function handleDirectSwitch(codeType, target) {
+  const resolvedCodeType = resolveCodeType(codeType);
+  if (resolvedCodeType === "claude-code") {
+    await handleClaudeCodeDirectSwitch(target);
+  } else if (resolvedCodeType === "codex") {
+    await switchCodexProvider(target);
+  }
+}
+async function handleClaudeCodeDirectSwitch(target) {
+  if (target === "official") {
+    const result = await ClaudeCodeConfigManager.switchToOfficial();
+    if (result.success) {
+      try {
+        await ClaudeCodeConfigManager.applyProfileSettings(null);
+        console.log(ansis.green(i18n.t("multi-config:successfullySwitchedToOfficial")));
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        console.log(ansis.red(reason));
+      }
+    } else {
+      console.log(ansis.red(i18n.t("multi-config:failedToSwitchToOfficial", { error: result.error })));
+    }
+  } else if (target === "ccr") {
+    const result = await ClaudeCodeConfigManager.switchToCcr();
+    if (result.success) {
+      try {
+        const profile = ClaudeCodeConfigManager.getProfileById("ccr-proxy");
+        await ClaudeCodeConfigManager.applyProfileSettings(profile);
+        console.log(ansis.green(i18n.t("multi-config:successfullySwitchedToCcr")));
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        console.log(ansis.red(reason));
+      }
+    } else {
+      console.log(ansis.red(i18n.t("multi-config:failedToSwitchToCcr", { error: result.error })));
+    }
+  } else {
+    const config = ClaudeCodeConfigManager.readConfig();
+    if (!config || !config.profiles || Object.keys(config.profiles).length === 0) {
+      console.log(ansis.yellow(i18n.t("multi-config:noClaudeCodeProfilesAvailable")));
+      return;
+    }
+    const normalizedTarget = target.trim();
+    let resolvedId = normalizedTarget;
+    let resolvedProfile = config.profiles[normalizedTarget];
+    if (!resolvedProfile) {
+      const match = Object.entries(config.profiles).find(([, profile]) => profile.name === normalizedTarget);
+      if (match) {
+        resolvedId = match[0];
+        resolvedProfile = match[1];
+      }
+    }
+    if (!resolvedProfile) {
+      console.log(ansis.red(i18n.t("multi-config:profileNameNotFound", { name: target })));
+      return;
+    }
+    const result = await ClaudeCodeConfigManager.switchProfile(resolvedId);
+    if (result.success) {
+      try {
+        await ClaudeCodeConfigManager.applyProfileSettings({ ...resolvedProfile, id: resolvedId });
+        console.log(ansis.green(i18n.t("multi-config:successfullySwitchedToProfile", { name: resolvedProfile.name })));
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        console.log(ansis.red(reason));
+      }
+    } else {
+      console.log(ansis.red(i18n.t("multi-config:failedToSwitchToProfile", { error: result.error })));
+    }
+  }
+}
+async function handleInteractiveSwitch(codeType) {
+  const resolvedCodeType = resolveCodeType(codeType);
+  if (resolvedCodeType === "claude-code") {
+    await handleClaudeCodeInteractiveSwitch();
+  } else if (resolvedCodeType === "codex") {
+    await handleCodexInteractiveSwitch();
+  }
+}
+async function handleClaudeCodeInteractiveSwitch() {
+  const config = ClaudeCodeConfigManager.readConfig();
+  if (!config || !config.profiles || Object.keys(config.profiles).length === 0) {
+    console.log(ansis.yellow(i18n.t("multi-config:noClaudeCodeProfilesAvailable")));
+    return;
+  }
+  const currentProfileId = config.currentProfileId;
+  const createClaudeCodeChoices = (profiles, currentProfileId2) => {
+    const choices2 = [];
+    const isOfficialMode = !currentProfileId2 || currentProfileId2 === "official";
+    choices2.push({
+      name: isOfficialMode ? `${ansis.green("\u25CF ")}${i18n.t("codex:useOfficialLogin")} ${ansis.yellow(`(${i18n.t("common:current")})`)}` : `  ${i18n.t("codex:useOfficialLogin")}`,
+      value: "official"
+    });
+    const isCcrMode = currentProfileId2 === "ccr-proxy";
+    choices2.push({
+      name: isCcrMode ? `${ansis.green("\u25CF ")}${i18n.t("multi-config:ccrProxyOption")} ${ansis.yellow(`(${i18n.t("common:current")})`)}` : `  ${i18n.t("multi-config:ccrProxyOption")}`,
+      value: "ccr"
+    });
+    Object.values(profiles).filter((profile) => profile.id !== "ccr-proxy").forEach((profile) => {
+      const isCurrent = profile.id === currentProfileId2;
+      choices2.push({
+        name: isCurrent ? `${ansis.green("\u25CF ")}${profile.name} ${ansis.yellow("(current)")}` : `  ${profile.name}`,
+        value: profile.id
+      });
+    });
+    return choices2;
+  };
+  const choices = createClaudeCodeChoices(config.profiles, currentProfileId);
+  try {
+    const { selectedConfig } = await inquirer.prompt([{
+      type: "list",
+      name: "selectedConfig",
+      message: i18n.t("multi-config:selectClaudeCodeConfiguration"),
+      choices: addNumbersToChoices(choices)
+    }]);
+    if (!selectedConfig) {
+      console.log(ansis.yellow(i18n.t("multi-config:cancelled")));
+      return;
+    }
+    await handleClaudeCodeDirectSwitch(selectedConfig);
+  } catch (error) {
+    if (error.name === "ExitPromptError") {
+      console.log(ansis.cyan(`
+${i18n.t("common:goodbye")}`));
+      return;
+    }
+    throw error;
+  }
+}
+async function handleCodexInteractiveSwitch() {
+  const providers = await listCodexProviders();
+  if (!providers || providers.length === 0) {
+    console.log(ansis.yellow(i18n.t("codex:noProvidersAvailable")));
+    return;
+  }
+  const existingConfig = readCodexConfig();
+  const currentProvider = existingConfig?.modelProvider;
+  const isCommented = existingConfig?.modelProviderCommented;
+  const createApiConfigChoices = (providers2, currentProvider2, isCommented2) => {
+    const choices2 = [];
+    const isOfficialMode = !currentProvider2 || isCommented2;
+    choices2.push({
+      name: isOfficialMode ? `${ansis.green("\u25CF ")}${i18n.t("codex:useOfficialLogin")} ${ansis.yellow("(\u5F53\u524D)")}` : `  ${i18n.t("codex:useOfficialLogin")}`,
+      value: "official"
+    });
+    providers2.forEach((provider) => {
+      const isCurrent = currentProvider2 === provider.id && !isCommented2;
+      choices2.push({
+        name: isCurrent ? `${ansis.green("\u25CF ")}${provider.name} - ${ansis.gray(provider.id)} ${ansis.yellow("(\u5F53\u524D)")}` : `  ${provider.name} - ${ansis.gray(provider.id)}`,
+        value: provider.id
+      });
+    });
+    return choices2;
+  };
+  const choices = createApiConfigChoices(providers, currentProvider, isCommented);
+  try {
+    const { selectedConfig } = await inquirer.prompt([{
+      type: "list",
+      name: "selectedConfig",
+      message: i18n.t("codex:apiConfigSwitchPrompt"),
+      choices: addNumbersToChoices(choices)
+    }]);
+    if (!selectedConfig) {
+      console.log(ansis.yellow(i18n.t("common:cancelled")));
+      return;
+    }
+    let success = false;
+    if (selectedConfig === "official") {
+      success = await switchToOfficialLogin();
+    } else {
+      success = await switchToProvider(selectedConfig);
+    }
+    if (!success) {
+      console.log(ansis.red(i18n.t("common:operationFailed")));
+    }
+  } catch (error) {
+    if (error.name === "ExitPromptError") {
+      console.log(ansis.cyan(`
+${i18n.t("common:goodbye")}`));
+      return;
+    }
+    throw error;
+  }
+}
+
+const configSwitch = {
+  __proto__: null,
+  configSwitchCommand: configSwitchCommand
+};
+
+async function resolveAndSwitchLanguage(lang, options, skipPrompt = false) {
+  const zcfConfig = await readZcfConfigAsync();
+  const targetLang = options?.allLang || lang || options?.lang || zcfConfig?.preferredLang || (skipPrompt ? "en" : await selectScriptLanguage());
+  if (i18n.isInitialized && i18n.language !== targetLang) {
+    await changeLanguage(targetLang);
+  }
+  return targetLang;
+}
+async function withLanguageResolution(action, skipPrompt = false) {
+  return async (...args) => {
+    const options = args[0];
+    const languageOptions = extractLanguageOptions(options);
+    await resolveAndSwitchLanguage(void 0, languageOptions, skipPrompt || languageOptions.skipPrompt);
+    return await action(...args);
+  };
+}
+function extractLanguageOptions(options) {
+  if (!options || typeof options !== "object" || options === null) {
+    return {};
+  }
+  const obj = options;
+  return {
+    lang: typeof obj.lang === "string" ? obj.lang : void 0,
+    allLang: typeof obj.allLang === "string" ? obj.allLang : void 0,
+    skipPrompt: typeof obj.skipPrompt === "boolean" ? obj.skipPrompt : void 0
+  };
+}
+function customizeHelp(sections) {
+  sections.unshift({
+    title: "",
+    body: ansis.cyan.bold(`ZCF - Zero-Config Code Flow v${version}`)
+  });
+  sections.push({
+    title: ansis.yellow(i18n.t("cli:help.commands")),
+    body: [
+      `  ${ansis.cyan("zcf")}              ${i18n.t("cli:help.commandDescriptions.showInteractiveMenuDefault")}`,
+      `  ${ansis.cyan("zcf init")} | ${ansis.cyan(
+        "i"
+      )}     ${i18n.t("cli:help.commandDescriptions.initClaudeCodeConfig")}`,
+      `  ${ansis.cyan("zcf update")} | ${ansis.cyan("u")}   ${i18n.t("cli:help.commandDescriptions.updateWorkflowFiles")}`,
+      `  ${ansis.cyan("zcf ccr")}          ${i18n.t("cli:help.commandDescriptions.configureCcrProxy")}`,
+      `  ${ansis.cyan("zcf ccu")} [args]   ${i18n.t("cli:help.commandDescriptions.claudeCodeUsageAnalysis")}`,
+      `  ${ansis.cyan("zcf uninstall")}     ${i18n.t("cli:help.commandDescriptions.uninstallConfigurations")}`,
+      `  ${ansis.cyan("zcf check-updates")} ${i18n.t("cli:help.commandDescriptions.checkUpdateVersions")}`,
+      "",
+      ansis.gray(`  ${i18n.t("cli:help.shortcuts")}`),
+      `  ${ansis.cyan("zcf i")}            ${i18n.t("cli:help.shortcutDescriptions.quickInit")}`,
+      `  ${ansis.cyan("zcf u")}            ${i18n.t("cli:help.shortcutDescriptions.quickUpdate")}`,
+      `  ${ansis.cyan("zcf check")}        ${i18n.t("cli:help.shortcutDescriptions.quickCheckUpdates")}`
+    ].join("\n")
+  });
+  sections.push({
+    title: ansis.yellow(i18n.t("cli:help.options")),
+    body: [
+      `  ${ansis.green("--lang, -l")} <lang>         ${i18n.t("cli:help.optionDescriptions.displayLanguage")} (zh-CN, en)`,
+      `  ${ansis.green("--config-lang, -c")} <lang>  ${i18n.t("cli:help.optionDescriptions.configurationLanguage")} (zh-CN, en)`,
+      `  ${ansis.green("--force, -f")}               ${i18n.t("cli:help.optionDescriptions.forceOverwrite")}`,
+      `  ${ansis.green("--help, -h")}                ${i18n.t("cli:help.optionDescriptions.displayHelp")}`,
+      `  ${ansis.green("--version, -v")}             ${i18n.t("cli:help.optionDescriptions.displayVersion")}`,
+      "",
+      ansis.gray(`  ${i18n.t("cli:help.nonInteractiveMode")}`),
+      `  ${ansis.green("--skip-prompt, -s")}         ${i18n.t("cli:help.optionDescriptions.skipAllPrompts")}`,
+      `  ${ansis.green("--api-type, -t")} <type>      ${i18n.t("cli:help.optionDescriptions.apiType")} (auth_token, api_key, ccr_proxy, skip)`,
+      `  ${ansis.green("--api-key, -k")} <key>       ${i18n.t("cli:help.optionDescriptions.apiKey")}`,
+      `  ${ansis.green("--api-url, -u")} <url>       ${i18n.t("cli:help.optionDescriptions.customApiUrl")}`,
+      `  ${ansis.green("--api-model, -M")} <model>   ${i18n.t("cli:help.optionDescriptions.apiModel")} (e.g., claude-sonnet-4-5)`,
+      `  ${ansis.green("--api-haiku-model, -H")} <model> ${i18n.t("cli:help.optionDescriptions.apiHaikuModel")} (e.g., claude-haiku-4-5)`,
+      `  ${ansis.green("--api-sonnet-model, -S")} <model> ${i18n.t("cli:help.optionDescriptions.apiSonnetModel")} (e.g., claude-sonnet-4-5)`,
+      `  ${ansis.green("--api-opus-model, -O")} <model> ${i18n.t("cli:help.optionDescriptions.apiOpusModel")} (e.g., claude-opus-4-5)`,
+      `  ${ansis.green("--ai-output-lang, -a")} <lang> ${i18n.t("cli:help.optionDescriptions.aiOutputLanguage")}`,
+      `  ${ansis.green("--all-lang, -g")} <lang>     ${i18n.t("cli:help.optionDescriptions.setAllLanguageParams")}`,
+      `  ${ansis.green("--config-action, -r")} <action> ${i18n.t("cli:help.optionDescriptions.configHandling")} (${i18n.t("cli:help.defaults.prefix")} backup)`,
+      `  ${ansis.green("--mcp-services, -m")} <list>  ${i18n.t("cli:help.optionDescriptions.mcpServices")} (${i18n.t("cli:help.defaults.prefix")} all non-key services)`,
+      `  ${ansis.green("--workflows, -w")} <list>    ${i18n.t("cli:help.optionDescriptions.workflows")} (${i18n.t("cli:help.defaults.prefix")} all workflows)`,
+      `  ${ansis.green("--output-styles, -o")} <styles> ${i18n.t("cli:help.optionDescriptions.outputStyles")} (${i18n.t("cli:help.defaults.prefix")} all custom styles)`,
+      `  ${ansis.green("--default-output-style, -d")} <style> ${i18n.t("cli:help.optionDescriptions.defaultOutputStyle")} (${i18n.t("cli:help.defaults.prefix")} engineer-professional)`,
+      `  ${ansis.green("--code-type, -T")} <type>   ${i18n.t("cli:help.optionDescriptions.codeToolType")} (claude-code, codex, cc=claude-code, cx=codex)`,
+      `  ${ansis.green("--install-cometix-line, -x")} <value> ${i18n.t("cli:help.optionDescriptions.installStatuslineTool")} (${i18n.t("cli:help.defaults.prefix")} true)`
+    ].join("\n")
+  });
+  sections.push({
+    title: ansis.yellow(i18n.t("cli:help.examples")),
+    body: [
+      ansis.gray(`  # ${i18n.t("cli:help.exampleDescriptions.showInteractiveMenu")}`),
+      `  ${ansis.cyan("npx @benbenwu/zcf")}`,
+      "",
+      ansis.gray(`  # ${i18n.t("cli:help.exampleDescriptions.runFullInitialization")}`),
+      `  ${ansis.cyan("npx @benbenwu/zcf init")}`,
+      `  ${ansis.cyan("npx @benbenwu/zcf i")}`,
+      "",
+      ansis.gray(`  # ${i18n.t("cli:help.exampleDescriptions.updateWorkflowFilesOnly")}`),
+      `  ${ansis.cyan("npx @benbenwu/zcf u")}`,
+      "",
+      ansis.gray(`  # ${i18n.t("cli:help.exampleDescriptions.configureClaudeCodeRouter")}`),
+      `  ${ansis.cyan("npx @benbenwu/zcf ccr")}`,
+      "",
+      ansis.gray(`  # ${i18n.t("cli:help.exampleDescriptions.runClaudeCodeUsageAnalysis")}`),
+      `  ${ansis.cyan("npx @benbenwu/zcf ccu")}               ${ansis.gray(`# ${i18n.t("cli:help.defaults.dailyUsage")}`)}`,
+      `  ${ansis.cyan("npx @benbenwu/zcf ccu monthly --json")}`,
+      "",
+      ansis.gray(`  # ${i18n.t("cli:help.exampleDescriptions.uninstallConfigurations")}`),
+      `  ${ansis.cyan("npx @benbenwu/zcf uninstall")}         ${ansis.gray(`# ${i18n.t("cli:help.defaults.interactiveUninstall")}`)}`,
+      "",
+      ansis.gray(`  # ${i18n.t("cli:help.exampleDescriptions.checkAndUpdateTools")}`),
+      `  ${ansis.cyan("npx @benbenwu/zcf check-updates")}     ${ansis.gray(`# ${i18n.t("cli:help.defaults.updateTools")}`)}`,
+      `  ${ansis.cyan("npx @benbenwu/zcf check")}`,
+      "",
+      ansis.gray(`  # ${i18n.t("cli:help.exampleDescriptions.checkClaudeCode")}`),
+      `  ${ansis.cyan("npx @benbenwu/zcf check --code-type claude-code")}`,
+      `  ${ansis.cyan("npx @benbenwu/zcf check -T cc")}`,
+      "",
+      ansis.gray(`  # ${i18n.t("cli:help.exampleDescriptions.checkCodex")}`),
+      `  ${ansis.cyan("npx @benbenwu/zcf check --code-type codex")}`,
+      `  ${ansis.cyan("npx @benbenwu/zcf check -T cx")}`,
+      "",
+      ansis.gray(`  # ${i18n.t("cli:help.exampleDescriptions.nonInteractiveModeCicd")}`),
+      `  ${ansis.cyan('npx @benbenwu/zcf i --skip-prompt --api-type api_key --api-key "sk-ant-..."')}`,
+      `  ${ansis.cyan('npx @benbenwu/zcf i --skip-prompt --all-lang zh-CN --api-type api_key --api-key "key"')}`,
+      `  ${ansis.cyan("npx @benbenwu/zcf i --skip-prompt --api-type ccr_proxy")}`,
+      ""
+    ].join("\n")
+  });
+  return sections;
+}
+async function setupCommands(cli) {
+  try {
+    const zcfConfig = await readZcfConfigAsync();
+    const defaultLang = zcfConfig?.preferredLang || "en";
+    await initI18n(defaultLang);
+  } catch {
+  }
+  cli.command("", "Show interactive menu (default)").option("--lang, -l <lang>", "ZCF display language (zh-CN, en)").option("--all-lang, -g <lang>", "Set all language parameters to this value").option("--config-lang, -c <lang>", "Configuration language (zh-CN, en)").option("--force, -f", "Force overwrite existing configuration").option("--code-type, -T <codeType>", "Select code tool type (claude-code, codex, cc, cx)").action(await withLanguageResolution(async (options) => {
+    await showMainMenu({ codeType: options.codeType });
+  }));
+  cli.command("init", "Initialize Claude Code configuration").alias("i").option("--lang, -l <lang>", "ZCF display language (zh-CN, en)").option("--config-lang, -c <lang>", "Configuration language (zh-CN, en)").option("--ai-output-lang, -a <lang>", "AI output language").option("--force, -f", "Force overwrite existing configuration").option("--skip-prompt, -s", "Skip all interactive prompts (non-interactive mode)").option("--config-action, -r <action>", `Config handling (new/backup/merge/docs-only/skip), ${i18n.t("cli:help.defaults.prefix")} backup`).option("--api-type, -t <type>", "API type (auth_token/api_key/ccr_proxy/skip)").option("--api-key, -k <key>", "API key (used for both API key and auth token types)").option("--api-url, -u <url>", "Custom API URL").option("--api-model, -M <model>", "Primary API model (e.g., claude-sonnet-4-5)").option("--api-haiku-model, -H <model>", "Default Haiku model (e.g., claude-haiku-4-5)").option("--api-sonnet-model, -S <model>", "Default Sonnet model (e.g., claude-sonnet-4-5)").option("--api-opus-model, -O <model>", "Default Opus model (e.g., claude-opus-4-5)").option("--provider, -p <provider>", "API provider preset (302ai, glm, minimax, kimi, custom)").option("--mcp-services, -m <services>", `Comma-separated MCP services to install (context7,mcp-deepwiki,Playwright,exa), "skip" to skip all, "all" for all non-key services, ${i18n.t("cli:help.defaults.prefix")} all`).option("--workflows, -w <workflows>", `Comma-separated workflows to install (sixStepsWorkflow,featPlanUx,gitWorkflow,bmadWorkflow), "skip" to skip all, "all" for all workflows, ${i18n.t("cli:help.defaults.prefix")} all`).option("--output-styles, -o <styles>", `Comma-separated output styles (engineer-professional,nekomata-engineer,laowang-engineer,default,explanatory,learning), "skip" to skip all, "all" for all custom styles, ${i18n.t("cli:help.defaults.prefix")} all`).option("--default-output-style, -d <style>", `Default output style, ${i18n.t("cli:help.defaults.prefix")} engineer-professional`).option("--all-lang, -g <lang>", "Set all language parameters to this value").option("--code-type, -T <codeType>", "Select code tool type (claude-code, codex, cc, cx)").option("--install-cometix-line, -x <value>", `Install CCometixLine statusline tool (true/false), ${i18n.t("cli:help.defaults.prefix")} true`).option("--api-configs <configs>", "API configurations as JSON string for multiple profiles").option("--api-configs-file <file>", "Path to JSON file containing API configurations").action(await withLanguageResolution(async (options) => {
+    await init(options);
+  }));
+  cli.command("update", "Update Claude Code prompts only").alias("u").option("--lang, -l <lang>", "ZCF display language (zh-CN, en)").option("--all-lang, -g <lang>", "Set all language parameters to this value").option("--config-lang, -c <lang>", "Configuration language (zh-CN, en)").action(await withLanguageResolution(async (options) => {
+    await update(options);
+  }));
+  cli.command("ccr", "Configure Claude Code Router for model proxy").option("--lang, -l <lang>", "ZCF display language (zh-CN, en)").option("--all-lang, -g <lang>", "Set all language parameters to this value").action(await withLanguageResolution(async () => {
+    await ccr();
+  }));
+  cli.command("ccu [...args]", "Run Claude Code usage analysis tool").option("--lang, -l <lang>", "ZCF display language (zh-CN, en)").option("--all-lang, -g <lang>", "Set all language parameters to this value").allowUnknownOptions().action(await withLanguageResolution(async (args) => {
+    await executeCcusage(args);
+  }));
+  cli.command("config-switch [target]", "Switch Codex provider or Claude Code configuration, or list available configurations").alias("cs").option("--code-type, -T <type>", "Code tool type (claude-code, codex, cc, cx)").option("--lang <lang>", "ZCF display language (zh-CN, en)").option("--all-lang, -g <lang>", "Set all language parameters to this value").option("--list, -l", "List available configurations").action(await withLanguageResolution(async (target, options) => {
+    await configSwitchCommand({
+      target,
+      codeType: options.codeType,
+      list: options.list
+    });
+  }));
+  cli.command("uninstall", "Remove ZCF configurations and tools").option("--lang, -l <lang>", "ZCF display language (zh-CN, en)").option("--all-lang, -g <lang>", "Set all language parameters to this value").option("--code-type, -T <codeType>", "Select code tool type (claude-code, codex, cc, cx)").option("--mode, -m <mode>", "Uninstall mode (complete/custom/interactive), default: interactive").option("--items, -i <items>", "Comma-separated items for custom uninstall mode").action(await withLanguageResolution(async (options) => {
+    await uninstall(options);
+  }));
+  cli.command("check-updates", "Check and update Claude Code and CCR to latest versions").alias("check").option("--lang, -l <lang>", "ZCF display language (zh-CN, en)").option("--all-lang, -g <lang>", "Set all language parameters to this value").option("--code-type, -T <codeType>", "Select code tool type (claude-code, codex, cc, cx)").option("--skip-prompt, -s", "Skip all interactive prompts (non-interactive mode)").action(await withLanguageResolution(async (options) => {
+    await checkUpdates(options);
+  }));
+  cli.help((sections) => customizeHelp(sections));
+  cli.version(version);
+}
+
+async function main() {
+  const cli = cac("zcf");
+  await setupCommands(cli);
+  cli.parse();
+}
+main().catch(console.error);
+
+export { configSwitch as c };