zcf 2.12.12 → 3.0.0

package/dist/cli.mjs

@@ -1,22 +1,26 @@
 #!/usr/bin/env node
 import cac from 'cac';
 import ansis from 'ansis';
-import { R as ensureI18nInitialized, T as i18n, U as readCcrConfig, V as isCcrInstalled, W as installCcr, X as configureCcrFeature, Y as handleExitPromptError, _ as handleGeneralError, Z as ZCF_CONFIG_FILE, h as SUPPORTED_LANGS, $ as addNumbersToChoices, j as LANG_LABELS, a0 as updateZcfConfig, a1 as changeLanguage, o as openSettingsJson, d as importRecommendedPermissions, b as importRecommendedEnv, a2 as readZcfConfig, K as applyAiLanguageDirective, a3 as configureOutputStyle, I as getExistingModelConfig, F as updateCustomModel, G as updateDefaultModel, a4 as isWindows, r as readMcpConfig, s as fixWindowsMcpConfig, w as writeMcpConfig, a5 as selectMcpServices, n as backupMcpConfig, a6 as getMcpServices, q as buildMcpServerConfig, p as mergeMcpServers, J as getExistingApiConfig, a7 as formatApiKeyDisplay, t as addCompletedOnboarding, a8 as modifyApiConfigPartially, a9 as setupCcrConfiguration, aa as validateApiKey, D as configureApi, ab as COMETIX_COMMAND_NAME, ac as COMETIX_COMMANDS, ad as installCometixLine, ae as checkAndUpdateTools, af as displayBanner, ag as resolveAiOutputLanguage, ah as updatePromptOnly, ai as selectAndInstallWorkflows, aj as checkClaudeCodeVersionAndPrompt, ak as version, al as displayBannerWithInfo, i as init, am as readZcfConfigAsync, an as initI18n, ao as selectScriptLanguage } from './chunks/simple-config.mjs';
-import { existsSync, unlinkSync } from 'node:fs';
+import { a0 as ensureI18nInitialized, W as i18n, a3 as readCcrConfig, a4 as isCcrInstalled, a5 as installCcr, a6 as configureCcrFeature, a7 as handleExitPromptError, a8 as handleGeneralError, l as SUPPORTED_LANGS, a2 as addNumbersToChoices, n as LANG_LABELS, a9 as updateZcfConfig, aa as changeLanguage, ab as readZcfConfig, o as openSettingsJson, d as importRecommendedPermissions, b as importRecommendedEnv, P as applyAiLanguageDirective, ac as configureOutputStyle, N as getExistingModelConfig, J as updateCustomModel, K as updateDefaultModel, ad as isWindows, r as readMcpConfig, v as fixWindowsMcpConfig, w as writeMcpConfig, ae as selectMcpServices, s as backupMcpConfig, af as getMcpServices, u as buildMcpServerConfig, t as mergeMcpServers, O as getExistingApiConfig, ag as formatApiKeyDisplay, x as addCompletedOnboarding, ah as modifyApiConfigPartially, ai as setupCcrConfiguration, aj as validateApiKey, H as configureApi, ak as COMETIX_COMMAND_NAME, al as COMETIX_COMMANDS, am as installCometixLine, an as checkAndUpdateTools, ao as readJsonConfig, ap as writeJsonConfig, h as ZCF_CONFIG_FILE, aq as displayBanner, ar as runCodexUpdate, as as version, at as resolveAiOutputLanguage, au as updatePromptOnly, av as selectAndInstallWorkflows, aw as checkClaudeCodeVersionAndPrompt, k as isCodeToolType, D as DEFAULT_CODE_TOOL_TYPE, ax as displayBannerWithInfo, ay as runCodexUninstall, az as configureCodexMcp, aA as configureCodexApi, aB as runCodexWorkflowImport, aC as runCodexFullInit, i as init, aD as listCodexProviders, aE as getCurrentCodexProvider, aF as switchCodexProvider, X as readCodexConfig, aG as switchToOfficialLogin, aH as switchToProvider, aI as readZcfConfigAsync, aJ as initI18n, aK as selectScriptLanguage } from './chunks/simple-config.mjs';
+import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import inquirer from 'inquirer';
 import { join } from 'pathe';
 import { exec, spawn } from 'node:child_process';
 import { promisify } from 'node:util';
 import process from 'node:process';
-import { x } from 'tinyexec';
+import { x, exec as exec$1 } from 'tinyexec';
+import { pathExists } from 'fs-extra';
+import { m as moveToTrash } from './shared/zcf.DGjQxTq_.mjs';
 import 'dayjs';
 import 'node:url';
 import 'ora';
 import 'semver';
+import 'smol-toml';
 import 'node:fs/promises';
 import 'i18next';
 import 'i18next-fs-backend';
+import 'trash';
 
 const execAsync$1 = promisify(exec);
 async function runCcrUi(apiKey) {
@@ -398,7 +402,7 @@ async function configureMcpFeature() {
       const existingConfig = readMcpConfig() || { mcpServers: {} };
       const fixedConfig = fixWindowsMcpConfig(existingConfig);
       writeMcpConfig(fixedConfig);
-      console.log(ansis.green(`\u2714 Windows MCP configuration fixed`));
+      console.log(ansis.green(`\u2714 ${i18n.t("configuration:windowsMcpConfigFixed")}`));
     }
   }
   const selectedServices = await selectMcpServices();
@@ -418,9 +422,9 @@ async function configureMcpFeature() {
       let config = service.config;
       if (service.requiresApiKey) {
         const { apiKey } = await inquirer.prompt({
-          type: "input",
+          type: "password",
           name: "apiKey",
-          message: service.apiKeyPrompt,
+          message: service.apiKeyPrompt + i18n.t("common:inputHidden"),
           validate: async (value) => !!value || i18n.t("api:keyRequired")
         });
         if (apiKey) {
@@ -555,7 +559,7 @@ ${ansis.blue(`\u2139 ${i18n.t("configuration:existingLanguageConfig") || "Existi
         return;
       }
     }
-    const { selectAiOutputLanguage } = await import('./chunks/simple-config.mjs').then(function (n) { return n.ap; });
+    const { selectAiOutputLanguage } = await import('./chunks/simple-config.mjs').then(function (n) { return n.aM; });
     const aiOutputLang = await selectAiOutputLanguage();
     applyAiLanguageDirective(aiOutputLang);
     updateZcfConfig({ aiOutputLang });
@@ -564,25 +568,6 @@ ${ansis.blue(`\u2139 ${i18n.t("configuration:existingLanguageConfig") || "Existi
     await configureOutputStyle();
   }
 }
-async function clearZcfCacheFeature() {
-  ensureI18nInitialized();
-  const { confirm } = await inquirer.prompt({
-    type: "confirm",
-    name: "confirm",
-    message: i18n.t("configuration:confirmClearCache") || "Clear all ZCF preferences cache?",
-    default: false
-  });
-  if (!confirm) {
-    await handleCancellation();
-    return;
-  }
-  if (existsSync(ZCF_CONFIG_FILE)) {
-    unlinkSync(ZCF_CONFIG_FILE);
-    console.log(ansis.green(`\u2714 ${i18n.t("configuration:cacheCleared") || "ZCF cache cleared"}`));
-  } else {
-    console.log(ansis.yellow("No cache found"));
-  }
-}
 async function changeScriptLanguageFeature(currentLang) {
   ensureI18nInitialized();
   const { lang } = await inquirer.prompt({
@@ -605,6 +590,214 @@ async function changeScriptLanguageFeature(currentLang) {
   console.log(ansis.green(`\u2714 ${i18n.t("language:languageChanged") || "Language changed"}`));
   return lang;
 }
+async function configureCodexDefaultModelFeature() {
+  ensureI18nInitialized();
+  const { readCodexConfig } = await import('./chunks/simple-config.mjs').then(function (n) { return n.aN; });
+  const existingConfig = readCodexConfig();
+  const currentModel = existingConfig?.model;
+  if (currentModel) {
+    console.log(`
+${ansis.blue(`\u2139 ${i18n.t("configuration:existingModelConfig") || "Existing model configuration"}`)}`);
+    const modelDisplay = currentModel === "gpt-5-codex" ? "GPT-5-Codex" : currentModel === "gpt-5" ? "GPT-5" : currentModel.charAt(0).toUpperCase() + currentModel.slice(1);
+    console.log(ansis.gray(`  ${i18n.t("configuration:currentModel") || "Current model"}: ${modelDisplay}
+`));
+    const { modify } = await inquirer.prompt({
+      type: "confirm",
+      name: "modify",
+      message: i18n.t("configuration:modifyModel") || "Modify model configuration?",
+      default: false
+    });
+    if (!modify) {
+      console.log(ansis.green(`\u2714 ${i18n.t("configuration:keepModel") || "Keeping existing model configuration"}`));
+      return;
+    }
+  }
+  const { model } = await inquirer.prompt({
+    type: "list",
+    name: "model",
+    message: i18n.t("configuration:selectDefaultModel") || "Select default model",
+    choices: addNumbersToChoices([
+      {
+        name: i18n.t("configuration:codexModelOptions.gpt5"),
+        value: "gpt-5"
+      },
+      {
+        name: i18n.t("configuration:codexModelOptions.gpt5Codex"),
+        value: "gpt-5-codex"
+      },
+      {
+        name: i18n.t("configuration:codexModelOptions.custom"),
+        value: "custom"
+      }
+    ]),
+    default: currentModel ? ["gpt-5", "gpt-5-codex", "custom"].indexOf(currentModel) : 1
+    // Default to gpt-5-codex
+  });
+  if (!model) {
+    await handleCancellation();
+    return;
+  }
+  if (model === "custom") {
+    const { customModel } = await inquirer.prompt({
+      type: "input",
+      name: "customModel",
+      message: `${i18n.t("configuration:enterCustomModel")}${i18n.t("common:emptyToSkip")}`,
+      default: ""
+    });
+    if (!customModel.trim()) {
+      console.log(ansis.yellow(`\u26A0 ${i18n.t("configuration:customModelSkipped") || "Custom model configuration skipped"}`));
+      return;
+    }
+    await updateCodexModelProvider(customModel.trim());
+    console.log(ansis.green(`\u2714 ${i18n.t("configuration:customModelConfigured") || "Custom model configuration completed"}`));
+    return;
+  }
+  await updateCodexModelProvider(model);
+  console.log(ansis.green(`\u2714 ${i18n.t("configuration:modelConfigured") || "Default model configured"}`));
+}
+async function configureCodexAiMemoryFeature() {
+  ensureI18nInitialized();
+  const { option } = await inquirer.prompt({
+    type: "list",
+    name: "option",
+    message: i18n.t("configuration:selectMemoryOption") || "Select configuration option",
+    choices: addNumbersToChoices([
+      {
+        name: i18n.t("configuration:configureAiLanguage") || "Configure AI output language",
+        value: "language"
+      },
+      {
+        name: i18n.t("configuration:configureSystemPromptStyle") || "Configure global AI system prompt style",
+        value: "systemPrompt"
+      }
+    ])
+  });
+  if (!option) {
+    return;
+  }
+  if (option === "language") {
+    const zcfConfig = readZcfConfig();
+    const existingLang = zcfConfig?.aiOutputLang;
+    if (existingLang) {
+      console.log(
+        `
+${ansis.blue(`\u2139 ${i18n.t("configuration:existingLanguageConfig") || "Existing AI output language configuration"}`)}`
+      );
+      console.log(ansis.gray(`  ${i18n.t("configuration:currentLanguage") || "Current language"}: ${existingLang}
+`));
+      const { modify } = await inquirer.prompt({
+        type: "confirm",
+        name: "modify",
+        message: i18n.t("configuration:modifyLanguage") || "Modify AI output language?",
+        default: false
+      });
+      if (!modify) {
+        console.log(ansis.green(`\u2714 ${i18n.t("configuration:keepLanguage") || "Keeping existing language configuration"}`));
+        await ensureLanguageDirectiveInAgents(existingLang);
+        return;
+      }
+    }
+    const { selectAiOutputLanguage } = await import('./chunks/simple-config.mjs').then(function (n) { return n.aM; });
+    const aiOutputLang = await selectAiOutputLanguage();
+    await updateCodexLanguageDirective(aiOutputLang);
+    updateZcfConfig({ aiOutputLang });
+    console.log(ansis.green(`\u2714 ${i18n.t("configuration:aiLanguageConfigured") || "AI output language configured"}`));
+  } else if (option === "systemPrompt") {
+    const zcfConfig = readZcfConfig();
+    const currentLang = zcfConfig?.aiOutputLang || "English";
+    const { runCodexSystemPromptSelection } = await import('./chunks/simple-config.mjs').then(function (n) { return n.aN; });
+    await runCodexSystemPromptSelection();
+    await ensureLanguageDirectiveInAgents(currentLang);
+    console.log(ansis.green(`\u2714 ${i18n.t("configuration:systemPromptConfigured")}`));
+  }
+}
+async function updateCodexModelProvider(modelProvider) {
+  const { readCodexConfig, writeCodexConfig, backupCodexConfig, getBackupMessage } = await import('./chunks/simple-config.mjs').then(function (n) { return n.aN; });
+  const backupPath = backupCodexConfig();
+  if (backupPath) {
+    console.log(ansis.gray(getBackupMessage(backupPath)));
+  }
+  const existingConfig = readCodexConfig();
+  const updatedConfig = {
+    ...existingConfig,
+    model: modelProvider,
+    // Set the model field
+    modelProvider: existingConfig?.modelProvider || null,
+    // Preserve existing API provider
+    providers: existingConfig?.providers || [],
+    mcpServices: existingConfig?.mcpServices || [],
+    managed: true,
+    otherConfig: existingConfig?.otherConfig || [],
+    modelProviderCommented: existingConfig?.modelProviderCommented
+  };
+  writeCodexConfig(updatedConfig);
+}
+async function ensureLanguageDirectiveInAgents(aiOutputLang) {
+  const { readFile, writeFile, exists } = await import('./chunks/simple-config.mjs').then(function (n) { return n.aL; });
+  const { homedir } = await import('node:os');
+  const { join } = await import('pathe');
+  const CODEX_AGENTS_FILE = join(homedir(), ".codex", "AGENTS.md");
+  if (!exists(CODEX_AGENTS_FILE)) {
+    console.log(ansis.yellow(i18n.t("codex:agentsFileNotFound")));
+    return;
+  }
+  const content = readFile(CODEX_AGENTS_FILE);
+  const languageLabels = {
+    "Chinese": "Chinese-simplified",
+    "English": "English",
+    "zh-CN": "Chinese-simplified",
+    "en": "English"
+  };
+  const langLabel = languageLabels[aiOutputLang] || aiOutputLang;
+  const hasLanguageDirective = /\*\*Most Important:\s*Always respond in [^*]+\*\*/i.test(content);
+  if (!hasLanguageDirective) {
+    const { backupCodexAgents, getBackupMessage } = await import('./chunks/simple-config.mjs').then(function (n) { return n.aN; });
+    const backupPath = backupCodexAgents();
+    if (backupPath) {
+      console.log(ansis.gray(getBackupMessage(backupPath)));
+    }
+    let updatedContent = content;
+    if (!updatedContent.endsWith("\n")) {
+      updatedContent += "\n";
+    }
+    updatedContent += `
+**Most Important:Always respond in ${langLabel}**
+`;
+    writeFile(CODEX_AGENTS_FILE, updatedContent);
+    console.log(ansis.gray(`  ${i18n.t("configuration:addedLanguageDirective")}: ${langLabel}`));
+  }
+}
+async function updateCodexLanguageDirective(aiOutputLang) {
+  const { readFile, writeFile, exists } = await import('./chunks/simple-config.mjs').then(function (n) { return n.aL; });
+  const { backupCodexAgents, getBackupMessage } = await import('./chunks/simple-config.mjs').then(function (n) { return n.aN; });
+  const { homedir } = await import('node:os');
+  const { join } = await import('pathe');
+  const CODEX_AGENTS_FILE = join(homedir(), ".codex", "AGENTS.md");
+  if (!exists(CODEX_AGENTS_FILE)) {
+    console.log(ansis.yellow(i18n.t("codex:agentsFileNotFound")));
+    return;
+  }
+  const backupPath = backupCodexAgents();
+  if (backupPath) {
+    console.log(ansis.gray(getBackupMessage(backupPath)));
+  }
+  let content = readFile(CODEX_AGENTS_FILE);
+  const languageLabels = {
+    "Chinese": "Chinese-simplified",
+    "English": "English",
+    "zh-CN": "Chinese-simplified",
+    "en": "English"
+  };
+  const langLabel = languageLabels[aiOutputLang] || aiOutputLang;
+  content = content.replace(/\*\*Most Important:\s*Always respond in [^*]+\*\*\s*/g, "");
+  if (!content.endsWith("\n")) {
+    content += "\n";
+  }
+  content += `
+**Most Important:Always respond in ${langLabel}**
+`;
+  writeFile(CODEX_AGENTS_FILE, content);
+}
 async function configureEnvPermissionFeature() {
   ensureI18nInitialized();
   const { choice } = await inquirer.prompt({
@@ -866,33 +1059,783 @@ async function checkUpdates(options = {}) {
   }
 }
 
+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 {
+        await exec$1("npm", ["uninstall", "-g", "@anthropic-ai/claude-code"]);
+        result.removed.push("@anthropic-ai/claude-code package");
+        result.success = true;
+      } 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(`Failed to uninstall Claude Code package: ${npmError.message}`);
+        }
+      }
+    } catch (error) {
+      result.errors.push(`Failed to uninstall Claude Code: ${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();
+    const uninstaller = new ZcfUninstaller(options.lang || "en");
+    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(ansis.yellow(i18n.t("uninstall:warning")));
+  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 inquirer.prompt({
+    type: "confirm",
+    name: "confirm",
+    message: i18n.t("uninstall:confirmComplete"),
+    default: 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 inquirer.prompt({
+    type: "confirm",
+    name: "confirm",
+    message: i18n.t("uninstall:confirmCustom"),
+    default: 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 (isCodeToolType(optionValue)) {
+    return optionValue;
+  }
+  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();
-    let configLang = options.configLang;
-    if (!configLang) {
-      const LANG_HINT_KEYS = {
-        "zh-CN": i18n.t("language:configLangHint.zh-CN"),
-        "en": i18n.t("language:configLangHint.en")
-      };
-      const { lang } = await inquirer.prompt({
-        type: "list",
-        name: "lang",
-        message: i18n.t("language:updateConfigLangPrompt"),
-        choices: addNumbersToChoices(SUPPORTED_LANGS.map((l) => ({
-          name: `${LANG_LABELS[l]} - ${LANG_HINT_KEYS[l]}`,
-          value: l
-        })))
-      });
-      if (!lang) {
-        console.log(ansis.yellow(i18n.t("common:cancelled")));
-        process.exit(0);
+    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
+        });
       }
-      configLang = lang;
+      return;
     }
+    const { resolveTemplateLanguage } = await import('./chunks/simple-config.mjs').then(function (n) { return n.aM; });
+    const configLang = await resolveTemplateLanguage(
+      options.configLang,
+      // Command line option
+      zcfConfig
+    );
     const aiOutputLang = await resolveAiOutputLanguage(i18n.language, options.aiOutputLang, zcfConfig);
     console.log(ansis.cyan(`
 ${i18n.t("configuration:updatingPrompts")}
@@ -902,7 +1845,10 @@ ${i18n.t("configuration:updatingPrompts")}
     await checkClaudeCodeVersionAndPrompt(false);
     updateZcfConfig({
       version,
-      aiOutputLang
+      templateLang: configLang,
+      // 保存模板语言选择
+      aiOutputLang,
+      codeToolType
     });
   } catch (error) {
     if (!handleExitPromptError(error)) {
@@ -911,156 +1857,321 @@ ${i18n.t("configuration:updatingPrompts")}
   }
 }
 
+const CODE_TOOL_LABELS = {
+  "claude-code": "Claude Code",
+  "codex": "Codex"
+};
+const CODE_TOOL_BANNERS = {
+  "claude-code": "for Claude Code",
+  "codex": "for 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 { continue: shouldContinue } = await inquirer.prompt({
+    type: "confirm",
+    name: "continue",
+    message: i18n.t("common:returnToMenu"),
+    default: 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 runCodexWorkflowImport();
+      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 { continue: shouldContinue } = await inquirer.prompt({
+    type: "confirm",
+    name: "continue",
+    message: i18n.t("common:returnToMenu"),
+    default: true
+  });
+  if (!shouldContinue) {
+    console.log(ansis.cyan(i18n.t("common:goodbye")));
+    return "exit";
+  }
+  return void 0;
+}
 async function showMainMenu() {
   try {
-    displayBannerWithInfo();
     let exitMenu = false;
     while (!exitMenu) {
-      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("");
-      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("");
-      console.log("  ------------ ZCF ------------");
-      console.log(
-        `  ${ansis.cyan("0.")} ${i18n.t("menu:menuOptions.changeLanguage")} ${ansis.gray(
-          `- ${i18n.t("menu:menuDescriptions.changeLanguage")}`
-        )}`
-      );
-      console.log(
-        `  ${ansis.cyan("-.")} ${i18n.t("menu:menuOptions.clearCache")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.clearCache")}`)}`
-      );
-      console.log(
-        `  ${ansis.cyan("+.")} ${i18n.t("menu:menuOptions.checkUpdates")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.checkUpdates")}`)}`
-      );
-      console.log(`  ${ansis.red("Q.")} ${ansis.red(i18n.t("menu:menuOptions.exit"))}`);
-      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", "7", "r", "R", "u", "U", "l", "L", "0", "-", "+", "q", "Q"];
-          return valid.includes(value) || i18n.t("common:invalidChoice");
-        }
-      });
-      if (!choice) {
-        console.log(ansis.yellow(i18n.t("common:cancelled")));
+      const codeTool = getCurrentCodeTool();
+      displayBannerWithInfo(CODE_TOOL_BANNERS[codeTool] || "ZCF");
+      const result = codeTool === "codex" ? await showCodexMenu() : await showClaudeCodeMenu();
+      if (result === "exit") {
         exitMenu = true;
-        break;
-      }
-      switch (choice.toLowerCase()) {
-        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":
-        case "R":
-          await runCcrMenuFeature();
-          break;
-        case "u":
-        case "U":
-          await runCcusageFeature();
-          break;
-        case "l":
-        case "L":
-          await runCometixMenuFeature();
-          break;
-        case "0": {
-          const currentLang = i18n.language;
-          await changeScriptLanguageFeature(currentLang);
-          break;
-        }
-        case "-":
-          await clearZcfCacheFeature();
-          break;
-        case "+":
-          await checkUpdates();
-          break;
-        case "q":
-          exitMenu = true;
-          console.log(ansis.cyan(i18n.t("common:goodbye")));
-          break;
-      }
-      if (!exitMenu && choice.toLowerCase() !== "q") {
-        if (choice === "0" || choice === "-" || choice === "+" || choice.toLowerCase() === "u" || choice.toLowerCase() === "r" || choice.toLowerCase() === "l") {
-          console.log(`
-${ansis.dim("\u2500".repeat(50))}
-`);
-          continue;
-        }
-        console.log(`
-${ansis.dim("\u2500".repeat(50))}
-`);
-        const { continue: shouldContinue } = await inquirer.prompt({
-          type: "confirm",
-          name: "continue",
-          message: i18n.t("common:returnToMenu"),
-          default: true
-        });
-        if (!shouldContinue) {
-          exitMenu = true;
-          console.log(ansis.cyan(i18n.t("common:goodbye")));
-        }
+      } else if (result === "switch") {
+        continue;
       }
     }
   } catch (error) {
@@ -1086,6 +2197,103 @@ async function ccr(options = {}) {
   }
 }
 
+async function configSwitchCommand(options) {
+  try {
+    ensureI18nInitialized();
+    if (options.list) {
+      await handleListProviders();
+      return;
+    }
+    if (options.provider) {
+      await handleDirectSwitch(options.provider);
+      return;
+    }
+    await handleInteractiveSwitch();
+  } catch (error) {
+    if (process.env.NODE_ENV === "test" || process.env.VITEST) {
+      throw error;
+    }
+    handleGeneralError(error);
+  }
+}
+async function handleListProviders() {
+  const providers = await listCodexProviders();
+  const currentProvider = await getCurrentCodexProvider();
+  console.log(ansis.cyan(i18n.t("codex:listProvidersTitle")));
+  console.log("");
+  if (providers.length === 0) {
+    console.log(ansis.yellow(i18n.t("codex:noProvidersAvailable")));
+    return;
+  }
+  if (currentProvider) {
+    console.log(ansis.green(`${i18n.t("codex:currentProvider", { provider: currentProvider })}`));
+    console.log("");
+  }
+  for (const provider of providers) {
+    const marker = currentProvider === provider.id ? ansis.green("\u25CF ") : "  ";
+    console.log(`${marker}${ansis.cyan(provider.id)} - ${provider.name}`);
+    console.log(`    ${ansis.gray(provider.baseUrl)}`);
+  }
+}
+async function handleDirectSwitch(providerId) {
+  await switchCodexProvider(providerId);
+}
+async function handleInteractiveSwitch() {
+  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;
+  }
+}
+
 async function resolveAndSwitchLanguage(lang, options, skipPrompt = false) {
   const zcfConfig = await readZcfConfigAsync();
   const targetLang = options?.allLang || lang || options?.lang || zcfConfig?.preferredLang || (skipPrompt ? "en" : await selectScriptLanguage());
@@ -1116,7 +2324,7 @@ function extractLanguageOptions(options) {
 function customizeHelp(sections) {
   sections.unshift({
     title: "",
-    body: ansis.cyan.bold(`ZCF - Zero-Config Claude-Code Flow v${version}`)
+    body: ansis.cyan.bold(`ZCF - Zero-Config Code Flow v${version}`)
   });
   sections.push({
     title: ansis.yellow(i18n.t("cli:help.commands")),
@@ -1128,6 +2336,7 @@ function customizeHelp(sections) {
       `  ${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")}`),
@@ -1157,6 +2366,7 @@ function customizeHelp(sections) {
       `  ${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)`,
       `  ${ansis.green("--install-cometix-line, -x")} <value> ${i18n.t("cli:help.optionDescriptions.installStatuslineTool")} (${i18n.t("cli:help.defaults.prefix")} true)`
     ].join("\n")
   });
@@ -1180,6 +2390,9 @@ function customizeHelp(sections) {
       `  ${ansis.cyan("npx zcf ccu")}               ${ansis.gray(`# ${i18n.t("cli:help.defaults.dailyUsage")}`)}`,
       `  ${ansis.cyan("npx zcf ccu monthly --json")}`,
       "",
+      ansis.gray(`  # ${i18n.t("cli:help.exampleDescriptions.uninstallConfigurations")}`),
+      `  ${ansis.cyan("npx zcf uninstall")}         ${ansis.gray(`# ${i18n.t("cli:help.defaults.interactiveUninstall")}`)}`,
+      "",
       ansis.gray(`  # ${i18n.t("cli:help.exampleDescriptions.checkAndUpdateTools")}`),
       `  ${ansis.cyan("npx zcf check-updates")}     ${ansis.gray(`# ${i18n.t("cli:help.defaults.updateTools")}`)}`,
       `  ${ansis.cyan("npx zcf check")}`,
@@ -1200,10 +2413,10 @@ async function setupCommands(cli) {
     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").action(await withLanguageResolution(async () => {
+  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)", { default: DEFAULT_CODE_TOOL_TYPE }).action(await withLanguageResolution(async () => {
     await showMainMenu();
   }));
-  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("--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("--install-cometix-line, -x <value>", `Install CCometixLine statusline tool (true/false), ${i18n.t("cli:help.defaults.prefix")} true`).action(await withLanguageResolution(async (options) => {
+  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("--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)", { default: DEFAULT_CODE_TOOL_TYPE }).option("--install-cometix-line, -x <value>", `Install CCometixLine statusline tool (true/false), ${i18n.t("cli:help.defaults.prefix")} true`).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) => {
@@ -1215,6 +2428,15 @@ async function setupCommands(cli) {
   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 [provider]", "Switch Codex provider or list available providers").alias("cs").option("--lang, -l <lang>", "ZCF display language (zh-CN, en)").option("--all-lang, -g <lang>", "Set all language parameters to this value").option("--list", "List available providers").action(await withLanguageResolution(async (provider, options) => {
+    await configSwitchCommand({
+      provider,
+      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("--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").action(await withLanguageResolution(async () => {
     await checkUpdates();
   }));