@xwm111/ccs 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,2407 @@
+#!/usr/bin/env node
+import cac from 'cac';
+import ansis from 'ansis';
+import { D as DEFAULT_CODE_TOOL_TYPE, X as ensureDir, P as exists, Y as readFile, _ as writeFile, e as ZCF_CONFIG_FILE, $ as readJsonConfig, L as LEGACY_ZCF_CONFIG_FILES, Z as ZCF_CONFIG_DIR, j as isCodeToolType, l as SUPPORTED_LANGS, H as i18n, G as ensureI18nInitialized, a0 as checkAndUpdateTools, S as SETTINGS_FILE, a1 as clearModelEnv, a2 as copyFile, r as resolveCodeToolType, a3 as version, a4 as homepage, m as LANG_LABELS, a5 as changeLanguage, E as switchToOfficialLogin, a6 as writeJsonConfig, W as promptBoolean, h as CODE_TOOL_BANNERS, a7 as initI18n } from './chunks/auto-updater.mjs';
+import process from 'node:process';
+import { existsSync, mkdirSync, renameSync, copyFileSync, rmSync } from 'node:fs';
+import { dirname, join } from 'pathe';
+import { edit, parse, stringify, initSync } from '@rainbowatcher/toml-edit-js';
+import inquirer from 'inquirer';
+import dayjs from 'dayjs';
+import { homedir } from 'node:os';
+import { pathExists } from 'fs-extra';
+import { exec } from 'tinyexec';
+import trash from 'trash';
+import 'node:url';
+import 'ora';
+import 'semver';
+import 'i18next';
+import 'i18next-fs-backend';
+import 'inquirer-toggle';
+import 'node:child_process';
+import 'node:util';
+
+let initialized = false;
+function ensureTomlInitSync() {
+  if (!initialized) {
+    initSync();
+    initialized = true;
+  }
+}
+function parseToml(content) {
+  ensureTomlInitSync();
+  return parse(content);
+}
+function stringifyToml(data) {
+  ensureTomlInitSync();
+  return stringify(data);
+}
+function batchEditToml(content, edits) {
+  ensureTomlInitSync();
+  let result = content;
+  for (const [path, value] of edits) {
+    result = edit(result, path, value);
+  }
+  return result;
+}
+
+function isSupportedLang(value) {
+  return SUPPORTED_LANGS.includes(value);
+}
+function sanitizePreferredLang(lang) {
+  return isSupportedLang(lang) ? lang : "en";
+}
+function sanitizeCodeToolType(codeTool) {
+  return isCodeToolType(codeTool) ? codeTool : DEFAULT_CODE_TOOL_TYPE;
+}
+function readTomlConfig(configPath) {
+  try {
+    if (!exists(configPath)) {
+      return null;
+    }
+    const content = readFile(configPath);
+    const parsed = parseToml(content);
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function insertAtTopLevelStart(topLevel, content) {
+  const lines = topLevel.split("\n");
+  let insertLineIndex = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (trimmed === "" || trimmed.startsWith("#")) {
+      insertLineIndex = i + 1;
+    } else {
+      insertLineIndex = i;
+      break;
+    }
+  }
+  lines.splice(insertLineIndex, 0, content.replace(/\n$/, ""));
+  return lines.join("\n");
+}
+function insertAfterVersionField(topLevel, content) {
+  const versionRegex = /^version\s*=\s*["'][^"']*["'][ \t]*(?:#.*)?$/m;
+  const match = topLevel.match(versionRegex);
+  if (match && match.index !== void 0) {
+    const versionEnd = match.index + match[0].length;
+    const before = topLevel.slice(0, versionEnd);
+    const after = topLevel.slice(versionEnd);
+    return `${before}
+${content.replace(/\n$/, "")}${after}`;
+  }
+  return insertAtTopLevelStart(topLevel, content);
+}
+function updateTopLevelTomlFields(content, version, lastUpdated) {
+  const firstSectionMatch = content.match(/^\[/m);
+  const topLevelEnd = firstSectionMatch?.index ?? content.length;
+  let topLevel = content.slice(0, topLevelEnd);
+  const rest = content.slice(topLevelEnd);
+  const versionRegex = /^version\s*=\s*["'][^"']*["'][ \t]*(?:#.*)?$/m;
+  const versionMatch = topLevel.match(versionRegex);
+  if (versionMatch) {
+    topLevel = topLevel.replace(versionRegex, `version = "${version}"`);
+  } else {
+    topLevel = insertAtTopLevelStart(topLevel, `version = "${version}"`);
+  }
+  const lastUpdatedRegex = /^lastUpdated\s*=\s*["'][^"']*["'][ \t]*(?:#.*)?$/m;
+  const lastUpdatedMatch = topLevel.match(lastUpdatedRegex);
+  if (lastUpdatedMatch) {
+    topLevel = topLevel.replace(lastUpdatedRegex, `lastUpdated = "${lastUpdated}"`);
+  } else {
+    topLevel = insertAfterVersionField(topLevel, `lastUpdated = "${lastUpdated}"`);
+  }
+  if (rest.length > 0 && !topLevel.endsWith("\n\n") && !topLevel.endsWith("\n")) {
+    topLevel += "\n";
+  }
+  return topLevel + rest;
+}
+function writeTomlConfig(configPath, config) {
+  try {
+    const configDir = dirname(configPath);
+    ensureDir(configDir);
+    if (exists(configPath)) {
+      const existingContent = readFile(configPath);
+      const edits = [
+        // General section
+        ["general.preferredLang", config.general.preferredLang],
+        ["general.currentTool", config.general.currentTool]
+      ];
+      if (config.general.templateLang !== void 0) {
+        edits.push(["general.templateLang", config.general.templateLang]);
+      }
+      if (config.general.aiOutputLang !== void 0) {
+        edits.push(["general.aiOutputLang", config.general.aiOutputLang]);
+      }
+      edits.push(
+        ["claudeCode.enabled", config.claudeCode.enabled],
+        ["claudeCode.outputStyles", config.claudeCode.outputStyles],
+        ["claudeCode.installType", config.claudeCode.installType]
+      );
+      if (config.claudeCode.defaultOutputStyle !== void 0) {
+        edits.push(["claudeCode.defaultOutputStyle", config.claudeCode.defaultOutputStyle]);
+      }
+      if (config.claudeCode.currentProfile !== void 0) {
+        edits.push(["claudeCode.currentProfile", config.claudeCode.currentProfile]);
+      }
+      if (config.claudeCode.profiles !== void 0) {
+        edits.push(["claudeCode.profiles", config.claudeCode.profiles]);
+      }
+      if (config.claudeCode.version !== void 0) {
+        edits.push(["claudeCode.version", config.claudeCode.version]);
+      }
+      try {
+        let updatedContent = batchEditToml(existingContent, edits);
+        updatedContent = updateTopLevelTomlFields(
+          updatedContent,
+          config.version,
+          config.lastUpdated
+        );
+        const expectedProfiles = Object.keys(config.claudeCode.profiles || {}).length;
+        if (expectedProfiles > 0) {
+          const verify = parseToml(updatedContent);
+          const actualProfiles = Object.keys(verify?.claudeCode?.profiles || {}).length;
+          if (actualProfiles !== expectedProfiles) {
+            throw new Error("Incremental edit produced inconsistent profiles");
+          }
+        }
+        writeFile(configPath, updatedContent);
+      } catch {
+        const tomlContent = stringifyToml(config);
+        writeFile(configPath, tomlContent);
+      }
+    } else {
+      const tomlContent = stringifyToml(config);
+      writeFile(configPath, tomlContent);
+    }
+  } catch {
+  }
+}
+function createDefaultTomlConfig(preferredLang = "en", claudeCodeInstallType = "global") {
+  return {
+    version: "1.0.0",
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+    general: {
+      preferredLang,
+      templateLang: preferredLang,
+      // Default templateLang to preferredLang for new installations
+      aiOutputLang: preferredLang === "zh-CN" ? "zh-CN" : void 0,
+      currentTool: DEFAULT_CODE_TOOL_TYPE
+    },
+    claudeCode: {
+      enabled: true,
+      outputStyles: ["engineer-professional"],
+      defaultOutputStyle: "engineer-professional",
+      installType: claudeCodeInstallType,
+      currentProfile: "",
+      profiles: {}
+    }
+  };
+}
+function migrateFromJsonConfig(jsonConfig) {
+  const claudeCodeInstallType = jsonConfig.claudeCodeInstallation?.type || "global";
+  const defaultConfig = createDefaultTomlConfig("en", claudeCodeInstallType);
+  const tomlConfig = {
+    version: jsonConfig.version || defaultConfig.version,
+    lastUpdated: jsonConfig.lastUpdated || (/* @__PURE__ */ new Date()).toISOString(),
+    general: {
+      preferredLang: jsonConfig.preferredLang || defaultConfig.general.preferredLang,
+      templateLang: jsonConfig.templateLang || jsonConfig.preferredLang || defaultConfig.general.preferredLang,
+      // Backward compatibility: use preferredLang as default
+      aiOutputLang: jsonConfig.aiOutputLang || defaultConfig.general.aiOutputLang,
+      currentTool: jsonConfig.codeToolType || defaultConfig.general.currentTool
+    },
+    claudeCode: {
+      enabled: jsonConfig.codeToolType === "claude-code",
+      outputStyles: jsonConfig.outputStyles || defaultConfig.claudeCode.outputStyles,
+      defaultOutputStyle: jsonConfig.defaultOutputStyle ?? defaultConfig.claudeCode.defaultOutputStyle,
+      installType: claudeCodeInstallType,
+      currentProfile: jsonConfig.currentProfileId || defaultConfig.claudeCode.currentProfile,
+      profiles: jsonConfig.claudeCode?.profiles || {}
+    }
+  };
+  return tomlConfig;
+}
+function convertTomlToLegacyConfig(tomlConfig) {
+  return {
+    version: tomlConfig.version,
+    preferredLang: tomlConfig.general.preferredLang,
+    templateLang: tomlConfig.general.templateLang,
+    aiOutputLang: tomlConfig.general.aiOutputLang,
+    outputStyles: tomlConfig.claudeCode.outputStyles,
+    defaultOutputStyle: tomlConfig.claudeCode.defaultOutputStyle,
+    codeToolType: tomlConfig.general.currentTool,
+    lastUpdated: tomlConfig.lastUpdated
+  };
+}
+function convertLegacyToTomlConfig(legacyConfig) {
+  return migrateFromJsonConfig(legacyConfig);
+}
+function normalizeZcfConfig(config) {
+  if (!config) {
+    return null;
+  }
+  return {
+    version: typeof config.version === "string" ? config.version : "1.0.0",
+    preferredLang: sanitizePreferredLang(config.preferredLang),
+    templateLang: config.templateLang ? sanitizePreferredLang(config.templateLang) : void 0,
+    aiOutputLang: config.aiOutputLang,
+    outputStyles: Array.isArray(config.outputStyles) ? config.outputStyles : void 0,
+    defaultOutputStyle: typeof config.defaultOutputStyle === "string" ? config.defaultOutputStyle : void 0,
+    codeToolType: sanitizeCodeToolType(config.codeToolType),
+    lastUpdated: typeof config.lastUpdated === "string" ? config.lastUpdated : (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function migrateZcfConfigIfNeeded() {
+  const target = ZCF_CONFIG_FILE;
+  const removed = [];
+  const targetExists = existsSync(target);
+  const legacySources = LEGACY_ZCF_CONFIG_FILES.filter((path) => existsSync(path));
+  if (!targetExists && legacySources.length > 0) {
+    const source = legacySources[0];
+    if (!existsSync(ZCF_CONFIG_DIR)) {
+      mkdirSync(ZCF_CONFIG_DIR, { recursive: true });
+    }
+    try {
+      renameSync(source, target);
+    } catch (error) {
+      if (error?.code !== "EXDEV") {
+        throw error;
+      }
+      copyFileSync(source, target);
+      rmSync(source, { force: true });
+    }
+    for (const leftover of legacySources.slice(1)) {
+      try {
+        rmSync(leftover, { force: true });
+        removed.push(leftover);
+      } catch {
+      }
+    }
+    return { migrated: true, source, target, removed };
+  }
+  if (targetExists && legacySources.length > 0) {
+    for (const source of legacySources) {
+      try {
+        rmSync(source, { force: true });
+        removed.push(source);
+      } catch {
+      }
+    }
+    return { migrated: false, target, removed };
+  }
+  return { migrated: false, target, removed };
+}
+function readZcfConfig() {
+  migrateZcfConfigIfNeeded();
+  const tomlConfig = readTomlConfig(ZCF_CONFIG_FILE);
+  if (tomlConfig) {
+    return convertTomlToLegacyConfig(tomlConfig);
+  }
+  const raw = readJsonConfig(ZCF_CONFIG_FILE.replace(".toml", ".json"));
+  const normalized = normalizeZcfConfig(raw || null);
+  if (normalized) {
+    return normalized;
+  }
+  for (const legacyPath of LEGACY_ZCF_CONFIG_FILES) {
+    if (existsSync(legacyPath)) {
+      const legacyRaw = readJsonConfig(legacyPath);
+      const legacyNormalized = normalizeZcfConfig(legacyRaw || null);
+      if (legacyNormalized) {
+        return legacyNormalized;
+      }
+    }
+  }
+  return null;
+}
+async function readZcfConfigAsync() {
+  return readZcfConfig();
+}
+function writeZcfConfig(config) {
+  try {
+    const sanitizedConfig = {
+      ...config,
+      codeToolType: sanitizeCodeToolType(config.codeToolType)
+    };
+    const existingTomlConfig = readTomlConfig(ZCF_CONFIG_FILE);
+    const tomlConfig = convertLegacyToTomlConfig(sanitizedConfig);
+    if (existingTomlConfig?.claudeCode) {
+      if (existingTomlConfig.claudeCode.profiles) {
+        tomlConfig.claudeCode.profiles = existingTomlConfig.claudeCode.profiles;
+      }
+      if (existingTomlConfig.claudeCode.currentProfile !== void 0) {
+        tomlConfig.claudeCode.currentProfile = existingTomlConfig.claudeCode.currentProfile;
+      }
+      if (existingTomlConfig.claudeCode.version) {
+        tomlConfig.claudeCode.version = existingTomlConfig.claudeCode.version;
+      }
+    }
+    writeTomlConfig(ZCF_CONFIG_FILE, tomlConfig);
+  } catch {
+  }
+}
+function updateZcfConfig(updates) {
+  const existingConfig = readZcfConfig();
+  const newConfig = {
+    version: updates.version || existingConfig?.version || "1.0.0",
+    preferredLang: updates.preferredLang || existingConfig?.preferredLang || "en",
+    templateLang: updates.templateLang !== void 0 ? updates.templateLang : existingConfig?.templateLang,
+    aiOutputLang: updates.aiOutputLang || existingConfig?.aiOutputLang,
+    outputStyles: updates.outputStyles !== void 0 ? updates.outputStyles : existingConfig?.outputStyles,
+    defaultOutputStyle: updates.defaultOutputStyle !== void 0 ? updates.defaultOutputStyle : existingConfig?.defaultOutputStyle,
+    codeToolType: updates.codeToolType || existingConfig?.codeToolType || DEFAULT_CODE_TOOL_TYPE,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeZcfConfig(newConfig);
+}
+function readDefaultTomlConfig() {
+  return readTomlConfig(ZCF_CONFIG_FILE);
+}
+
+const CODE_TYPE_ABBREVIATIONS = {
+  cc: "claude-code"
+};
+async function resolveCodeType$1(codeTypeParam) {
+  if (codeTypeParam) {
+    const normalizedParam = codeTypeParam.toLowerCase().trim();
+    if (normalizedParam in CODE_TYPE_ABBREVIATIONS) {
+      return CODE_TYPE_ABBREVIATIONS[normalizedParam];
+    }
+    if (isValidCodeType(normalizedParam)) {
+      return normalizedParam;
+    }
+    const validAbbreviations = Object.keys(CODE_TYPE_ABBREVIATIONS);
+    const validFullTypes = Object.values(CODE_TYPE_ABBREVIATIONS);
+    const validOptions = [...validAbbreviations, ...validFullTypes].join(", ");
+    let defaultValue = DEFAULT_CODE_TOOL_TYPE;
+    try {
+      const config = await readZcfConfigAsync();
+      if (config?.codeToolType && isValidCodeType(config.codeToolType)) {
+        defaultValue = config.codeToolType;
+      }
+    } catch {
+    }
+    throw new Error(
+      i18n.t("errors:invalidCodeType", { value: codeTypeParam, validOptions, defaultValue })
+    );
+  }
+  try {
+    const config = await readZcfConfigAsync();
+    if (config?.codeToolType && isValidCodeType(config.codeToolType)) {
+      return config.codeToolType;
+    }
+  } catch {
+  }
+  return DEFAULT_CODE_TOOL_TYPE;
+}
+function isValidCodeType(value) {
+  return value === "claude-code";
+}
+
+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;
+      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);
+  }
+}
+
+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 ClaudeCodeConfigManager {
+  static CONFIG_FILE = ZCF_CONFIG_FILE;
+  static LEGACY_CONFIG_FILE = join(ZCF_CONFIG_DIR, "claude-code-configs.json");
+  /**
+   * Ensure configuration directory exists
+   */
+  static ensureConfigDir() {
+    ensureDir(ZCF_CONFIG_DIR);
+  }
+  /**
+   * Read TOML configuration
+   */
+  static readTomlConfig() {
+    return readDefaultTomlConfig();
+  }
+  /**
+   * Load TOML configuration, falling back to default when missing
+   */
+  static loadTomlConfig() {
+    const existingConfig = this.readTomlConfig();
+    if (existingConfig) {
+      return existingConfig;
+    }
+    return createDefaultTomlConfig();
+  }
+  /**
+   * Migrate legacy JSON-based configuration into TOML storage
+   */
+  static migrateFromLegacyConfig() {
+    if (!exists(this.LEGACY_CONFIG_FILE)) {
+      return null;
+    }
+    try {
+      const legacyConfig = readJsonConfig(this.LEGACY_CONFIG_FILE);
+      if (!legacyConfig) {
+        return null;
+      }
+      const normalizedProfiles = {};
+      const existingKeys = /* @__PURE__ */ new Set();
+      let migratedCurrentKey = "";
+      Object.entries(legacyConfig.profiles || {}).forEach(([legacyKey, profile]) => {
+        const sourceProfile = profile;
+        const name = sourceProfile.name?.trim() || legacyKey;
+        const baseKey = this.generateProfileId(name);
+        let uniqueKey = baseKey || legacyKey;
+        let suffix = 2;
+        while (existingKeys.has(uniqueKey)) {
+          uniqueKey = `${baseKey || legacyKey}-${suffix++}`;
+        }
+        existingKeys.add(uniqueKey);
+        const sanitizedProfile = this.sanitizeProfile({
+          ...sourceProfile,
+          name
+        });
+        normalizedProfiles[uniqueKey] = {
+          ...sanitizedProfile,
+          id: uniqueKey
+        };
+        if (legacyConfig.currentProfileId === legacyKey || legacyConfig.currentProfileId === sourceProfile.id) {
+          migratedCurrentKey = uniqueKey;
+        }
+      });
+      if (!migratedCurrentKey && legacyConfig.currentProfileId) {
+        const fallbackKey = this.generateProfileId(legacyConfig.currentProfileId);
+        if (existingKeys.has(fallbackKey)) {
+          migratedCurrentKey = fallbackKey;
+        }
+      }
+      if (!migratedCurrentKey && existingKeys.size > 0) {
+        migratedCurrentKey = Array.from(existingKeys)[0];
+      }
+      const migratedConfig = {
+        currentProfileId: migratedCurrentKey,
+        profiles: normalizedProfiles
+      };
+      this.writeConfig(migratedConfig);
+      return migratedConfig;
+    } catch (error) {
+      console.error("Failed to migrate legacy Claude Code config:", error);
+      return null;
+    }
+  }
+  /**
+   * Read configuration
+   */
+  static readConfig() {
+    try {
+      const tomlConfig = readDefaultTomlConfig();
+      if (!tomlConfig || !tomlConfig.claudeCode) {
+        return this.migrateFromLegacyConfig();
+      }
+      const { claudeCode } = tomlConfig;
+      const rawProfiles = claudeCode.profiles || {};
+      const sanitizedProfiles = Object.fromEntries(
+        Object.entries(rawProfiles).map(([key, profile]) => {
+          const storedProfile = this.sanitizeProfile({
+            ...profile,
+            name: profile.name || key
+          });
+          return [key, { ...storedProfile, id: key }];
+        })
+      );
+      const configData = {
+        currentProfileId: claudeCode.currentProfile || "",
+        profiles: sanitizedProfiles
+      };
+      if (Object.keys(configData.profiles).length === 0) {
+        const migrated = this.migrateFromLegacyConfig();
+        if (migrated) {
+          return migrated;
+        }
+      }
+      return configData;
+    } catch (error) {
+      console.error("Failed to read Claude Code config:", error);
+      return null;
+    }
+  }
+  /**
+   * Write configuration
+   */
+  static writeConfig(config) {
+    try {
+      this.ensureConfigDir();
+      const keyMap = /* @__PURE__ */ new Map();
+      const sanitizedProfiles = Object.fromEntries(
+        Object.entries(config.profiles).map(([key, profile]) => {
+          const normalizedName = profile.name?.trim() || key;
+          const profileKey = this.generateProfileId(normalizedName);
+          keyMap.set(key, profileKey);
+          const sanitizedProfile = this.sanitizeProfile({
+            ...profile,
+            name: normalizedName
+          });
+          return [profileKey, sanitizedProfile];
+        })
+      );
+      const tomlConfig = this.loadTomlConfig();
+      const nextTomlConfig = {
+        ...tomlConfig,
+        claudeCode: {
+          ...tomlConfig.claudeCode,
+          currentProfile: keyMap.get(config.currentProfileId) || config.currentProfileId,
+          profiles: sanitizedProfiles
+        }
+      };
+      writeTomlConfig(this.CONFIG_FILE, nextTomlConfig);
+    } catch (error) {
+      console.error("Failed to write Claude Code config:", error);
+      throw new Error(`Failed to write config: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  /**
+   * Create empty configuration
+   */
+  static createEmptyConfig() {
+    return {
+      currentProfileId: "",
+      profiles: {}
+    };
+  }
+  /**
+   * Apply profile settings to Claude Code runtime
+   */
+  static async applyProfileSettings(profile) {
+    const { ensureI18nInitialized, i18n } = await import('./chunks/auto-updater.mjs').then(function (n) { return n.a8; });
+    ensureI18nInitialized();
+    try {
+      if (!profile) {
+        const { switchToOfficialLogin } = await import('./chunks/auto-updater.mjs').then(function (n) { return n.ab; });
+        switchToOfficialLogin();
+        return;
+      }
+      const { readJsonConfig: readJsonConfig2, writeJsonConfig } = await import('./chunks/auto-updater.mjs').then(function (n) { return n.a9; });
+      const settings = readJsonConfig2(SETTINGS_FILE) || {};
+      if (!settings.env)
+        settings.env = {};
+      clearModelEnv(settings.env);
+      if (profile.authType === "api_key") {
+        settings.env.ANTHROPIC_API_KEY = profile.apiKey;
+        delete settings.env.ANTHROPIC_AUTH_TOKEN;
+      } else if (profile.authType === "auth_token") {
+        settings.env.ANTHROPIC_AUTH_TOKEN = profile.apiKey;
+        delete settings.env.ANTHROPIC_API_KEY;
+      }
+      if (profile.baseUrl)
+        settings.env.ANTHROPIC_BASE_URL = profile.baseUrl;
+      else
+        delete settings.env.ANTHROPIC_BASE_URL;
+      const hasModelConfig = Boolean(
+        profile.primaryModel || profile.defaultHaikuModel || profile.defaultSonnetModel || profile.defaultOpusModel
+      );
+      if (hasModelConfig) {
+        if (profile.primaryModel)
+          settings.env.ANTHROPIC_MODEL = profile.primaryModel;
+        if (profile.defaultHaikuModel)
+          settings.env.ANTHROPIC_DEFAULT_HAIKU_MODEL = profile.defaultHaikuModel;
+        if (profile.defaultSonnetModel)
+          settings.env.ANTHROPIC_DEFAULT_SONNET_MODEL = profile.defaultSonnetModel;
+        if (profile.defaultOpusModel)
+          settings.env.ANTHROPIC_DEFAULT_OPUS_MODEL = profile.defaultOpusModel;
+      } else {
+        clearModelEnv(settings.env);
+      }
+      writeJsonConfig(SETTINGS_FILE, settings);
+      const { setPrimaryApiKey, addCompletedOnboarding } = await import('./chunks/auto-updater.mjs').then(function (n) { return n.aa; });
+      setPrimaryApiKey();
+      addCompletedOnboarding();
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      throw new Error(`${i18n.t("multi-config:failedToApplySettings")}: ${reason}`);
+    }
+  }
+  static async applyCurrentProfile() {
+    const currentProfile = this.getCurrentProfile();
+    await this.applyProfileSettings(currentProfile);
+  }
+  /**
+   * Remove unsupported fields from profile payload
+   */
+  static sanitizeProfile(profile) {
+    const sanitized = {
+      name: profile.name,
+      authType: profile.authType
+    };
+    if (profile.apiKey)
+      sanitized.apiKey = profile.apiKey;
+    if (profile.baseUrl)
+      sanitized.baseUrl = profile.baseUrl;
+    if (profile.primaryModel)
+      sanitized.primaryModel = profile.primaryModel;
+    if (profile.defaultHaikuModel)
+      sanitized.defaultHaikuModel = profile.defaultHaikuModel;
+    if (profile.defaultSonnetModel)
+      sanitized.defaultSonnetModel = profile.defaultSonnetModel;
+    if (profile.defaultOpusModel)
+      sanitized.defaultOpusModel = profile.defaultOpusModel;
+    return sanitized;
+  }
+  /**
+   * Backup configuration
+   */
+  static backupConfig() {
+    try {
+      if (!exists(this.CONFIG_FILE)) {
+        return null;
+      }
+      const timestamp = dayjs().format("YYYY-MM-DD_HH-mm-ss");
+      const backupPath = join(ZCF_CONFIG_DIR, `config.backup.${timestamp}.toml`);
+      copyFile(this.CONFIG_FILE, backupPath);
+      return backupPath;
+    } catch (error) {
+      console.error("Failed to backup Claude Code config:", error);
+      return null;
+    }
+  }
+  /**
+   * Add configuration
+   */
+  static async addProfile(profile) {
+    try {
+      const validationErrors = this.validateProfile(profile);
+      if (validationErrors.length > 0) {
+        return {
+          success: false,
+          error: `Validation failed: ${validationErrors.join(", ")}`
+        };
+      }
+      const backupPath = this.backupConfig();
+      let config = this.readConfig();
+      if (!config) {
+        config = this.createEmptyConfig();
+      }
+      if (profile.id && config.profiles[profile.id]) {
+        return {
+          success: false,
+          error: `Profile with ID "${profile.id}" already exists`,
+          backupPath: backupPath || void 0
+        };
+      }
+      const normalizedName = profile.name.trim();
+      const profileKey = this.generateProfileId(normalizedName);
+      const existingNames = Object.values(config.profiles).map((p) => p.name || "");
+      if (config.profiles[profileKey] || existingNames.some((name) => name.toLowerCase() === normalizedName.toLowerCase())) {
+        return {
+          success: false,
+          error: `Profile with name "${profile.name}" already exists`,
+          backupPath: backupPath || void 0
+        };
+      }
+      const sanitizedProfile = this.sanitizeProfile({
+        ...profile,
+        name: normalizedName
+      });
+      const runtimeProfile = {
+        ...sanitizedProfile,
+        id: profileKey
+      };
+      config.profiles[profileKey] = runtimeProfile;
+      if (!config.currentProfileId) {
+        config.currentProfileId = profileKey;
+      }
+      this.writeConfig(config);
+      return {
+        success: true,
+        backupPath: backupPath || void 0,
+        addedProfile: runtimeProfile
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Update configuration
+   */
+  static async updateProfile(id, data) {
+    try {
+      const validationErrors = this.validateProfile(data, true);
+      if (validationErrors.length > 0) {
+        return {
+          success: false,
+          error: `Validation failed: ${validationErrors.join(", ")}`
+        };
+      }
+      const backupPath = this.backupConfig();
+      const config = this.readConfig();
+      if (!config || !config.profiles[id]) {
+        return {
+          success: false,
+          error: `Profile with ID "${id}" not found`,
+          backupPath: backupPath || void 0
+        };
+      }
+      const existingProfile = config.profiles[id];
+      const nextName = data.name !== void 0 ? data.name.trim() : existingProfile.name;
+      const nextKey = this.generateProfileId(nextName);
+      const nameChanged = nextKey !== id;
+      if (nameChanged) {
+        const duplicateName = Object.entries(config.profiles).some(([key, profile]) => key !== id && (profile.name || "").toLowerCase() === nextName.toLowerCase());
+        if (duplicateName || config.profiles[nextKey]) {
+          return {
+            success: false,
+            error: `Profile with name "${data.name}" already exists`,
+            backupPath: backupPath || void 0
+          };
+        }
+      }
+      const mergedProfile = this.sanitizeProfile({
+        ...existingProfile,
+        ...data,
+        name: nextName
+      });
+      if (nameChanged) {
+        delete config.profiles[id];
+        config.profiles[nextKey] = {
+          ...mergedProfile,
+          id: nextKey
+        };
+        if (config.currentProfileId === id) {
+          config.currentProfileId = nextKey;
+        }
+      } else {
+        config.profiles[id] = {
+          ...mergedProfile,
+          id
+        };
+      }
+      this.writeConfig(config);
+      return {
+        success: true,
+        backupPath: backupPath || void 0,
+        updatedProfile: {
+          ...mergedProfile,
+          id: nameChanged ? nextKey : id
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Delete configuration
+   */
+  static async deleteProfile(id) {
+    try {
+      const backupPath = this.backupConfig();
+      const config = this.readConfig();
+      if (!config || !config.profiles[id]) {
+        return {
+          success: false,
+          error: `Profile with ID "${id}" not found`,
+          backupPath: backupPath || void 0
+        };
+      }
+      const profileCount = Object.keys(config.profiles).length;
+      if (profileCount === 1) {
+        return {
+          success: false,
+          error: "Cannot delete the last profile. At least one profile must remain.",
+          backupPath: backupPath || void 0
+        };
+      }
+      delete config.profiles[id];
+      if (config.currentProfileId === id) {
+        const remainingIds = Object.keys(config.profiles);
+        config.currentProfileId = remainingIds[0];
+      }
+      this.writeConfig(config);
+      return {
+        success: true,
+        backupPath: backupPath || void 0,
+        remainingProfiles: Object.entries(config.profiles).map(([key, profile]) => ({
+          ...profile,
+          id: key
+        }))
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Delete multiple configurations
+   */
+  static async deleteProfiles(ids) {
+    try {
+      const backupPath = this.backupConfig();
+      const config = this.readConfig();
+      if (!config) {
+        return {
+          success: false,
+          error: "No configuration found",
+          backupPath: backupPath || void 0
+        };
+      }
+      const missingIds = ids.filter((id) => !config.profiles[id]);
+      if (missingIds.length > 0) {
+        return {
+          success: false,
+          error: `Profiles not found: ${missingIds.join(", ")}`,
+          backupPath: backupPath || void 0
+        };
+      }
+      const remainingCount = Object.keys(config.profiles).length - ids.length;
+      if (remainingCount === 0) {
+        return {
+          success: false,
+          error: "Cannot delete all profiles. At least one profile must remain.",
+          backupPath: backupPath || void 0
+        };
+      }
+      let newCurrentProfileId;
+      ids.forEach((id) => {
+        delete config.profiles[id];
+      });
+      if (ids.includes(config.currentProfileId)) {
+        const remainingIds = Object.keys(config.profiles);
+        config.currentProfileId = remainingIds[0];
+        newCurrentProfileId = config.currentProfileId;
+      }
+      this.writeConfig(config);
+      return {
+        success: true,
+        backupPath: backupPath || void 0,
+        newCurrentProfileId,
+        deletedProfiles: ids,
+        remainingProfiles: Object.entries(config.profiles).map(([key, profile]) => ({
+          ...profile,
+          id: key
+        }))
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Generate profile ID from name
+   */
+  static generateProfileId(name) {
+    return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "profile";
+  }
+  /**
+   * Switch configuration
+   */
+  static async switchProfile(id) {
+    try {
+      const config = this.readConfig();
+      if (!config || !config.profiles[id]) {
+        return {
+          success: false,
+          error: "Profile not found"
+        };
+      }
+      if (config.currentProfileId === id) {
+        return { success: true };
+      }
+      config.currentProfileId = id;
+      this.writeConfig(config);
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * List all configurations
+   */
+  static listProfiles() {
+    const config = this.readConfig();
+    if (!config) {
+      return [];
+    }
+    return Object.values(config.profiles);
+  }
+  /**
+   * Get current configuration
+   */
+  static getCurrentProfile() {
+    const config = this.readConfig();
+    if (!config || !config.currentProfileId) {
+      return null;
+    }
+    return config.profiles[config.currentProfileId] || null;
+  }
+  /**
+   * Get configuration by ID
+   */
+  static getProfileById(id) {
+    const config = this.readConfig();
+    if (!config) {
+      return null;
+    }
+    return config.profiles[id] || null;
+  }
+  /**
+   * Get configuration by name
+   */
+  static getProfileByName(name) {
+    const config = this.readConfig();
+    if (!config) {
+      return null;
+    }
+    return Object.values(config.profiles).find((p) => p.name === name) || null;
+  }
+  /**
+   * Switch to official login
+   */
+  static async switchToOfficial() {
+    try {
+      const config = this.readConfig();
+      if (!config) {
+        return { success: true };
+      }
+      config.currentProfileId = "";
+      this.writeConfig(config);
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Validate configuration
+   */
+  static validateProfile(profile, isUpdate = false) {
+    const errors = [];
+    if (!isUpdate && (!profile.name || typeof profile.name !== "string" || profile.name.trim() === "")) {
+      errors.push("Profile name is required");
+    }
+    if (profile.name && typeof profile.name !== "string") {
+      errors.push("Profile name must be a string");
+    }
+    if (profile.authType && !["api_key", "auth_token", "ccr_proxy"].includes(profile.authType)) {
+      errors.push("Invalid auth type. Must be one of: api_key, auth_token, ccr_proxy");
+    }
+    if (profile.authType === "api_key" || profile.authType === "auth_token") {
+      if (!profile.apiKey || typeof profile.apiKey !== "string" || profile.apiKey.trim() === "") {
+        errors.push("API key is required for api_key and auth_token types");
+      }
+    }
+    if (profile.baseUrl) {
+      try {
+        new URL(profile.baseUrl);
+      } catch {
+        errors.push("Invalid base URL format");
+      }
+    }
+    return errors;
+  }
+  /**
+   * 检查是否为最后一个配置
+   */
+  static isLastProfile(id) {
+    const config = this.readConfig();
+    if (!config || !config.profiles[id]) {
+      return false;
+    }
+    return Object.keys(config.profiles).length === 1;
+  }
+}
+
+function handleExitPromptError(error) {
+  const isExitError = error instanceof Error && (error.name === "ExitPromptError" || error.message?.includes("ExitPromptError") || error.message?.includes("User force closed the prompt"));
+  if (isExitError) {
+    ensureI18nInitialized();
+    console.log(ansis.cyan(`
+${i18n.t("common:goodbye")}
+`));
+    process.exit(0);
+  }
+  return false;
+}
+function handleGeneralError(error) {
+  ensureI18nInitialized();
+  console.error(ansis.red(`${i18n.t("errors:generalError")}:`), error);
+  if (error instanceof Error) {
+    console.error(ansis.gray(`${i18n.t("errors:stackTrace")}: ${error.stack}`));
+  }
+  process.exit(1);
+}
+
+function addNumbersToChoices(choices, startFrom = 1, format = (n) => `${n}. `) {
+  let currentNumber = startFrom;
+  return choices.map((choice) => {
+    if (choice.disabled) {
+      return choice;
+    }
+    const numbered = {
+      ...choice,
+      name: `${format(currentNumber)}${choice.name}`
+    };
+    currentNumber++;
+    return numbered;
+  });
+}
+
+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(codeType);
+    return resolved;
+  }
+  const zcfConfig = readZcfConfig();
+  if (zcfConfig?.codeToolType && isCodeToolType(zcfConfig.codeToolType)) {
+    return zcfConfig.codeToolType;
+  }
+  return DEFAULT_CODE_TOOL_TYPE;
+}
+async function handleList(codeType) {
+  resolveCodeType(codeType);
+  await listClaudeCodeProfiles();
+}
+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) {
+  resolveCodeType(codeType);
+  await handleClaudeCodeDirectSwitch(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 {
+    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) {
+  resolveCodeType(codeType);
+  await handleClaudeCodeInteractiveSwitch();
+}
+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("api:useOfficialLogin")} ${ansis.yellow(`(${i18n.t("common:current")})`)}` : `  ${i18n.t("api:useOfficialLogin")}`,
+      value: "official"
+    });
+    Object.values(profiles).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;
+  }
+}
+
+const configSwitch = {
+  __proto__: null,
+  configSwitchCommand: configSwitchCommand
+};
+
+function getDisplayWidth(str) {
+  let width = 0;
+  for (const char of str) {
+    if (char.match(/[\u4E00-\u9FFF\uFF01-\uFF60\u3000-\u303F]/)) {
+      width += 2;
+    } else {
+      width += 1;
+    }
+  }
+  return width;
+}
+function padToDisplayWidth(str, targetWidth) {
+  const currentWidth = getDisplayWidth(str);
+  const paddingNeeded = Math.max(0, targetWidth - currentWidth);
+  return str + " ".repeat(paddingNeeded);
+}
+function displayBanner(subtitle) {
+  ensureI18nInitialized();
+  i18n.t("cli:banner.subtitle");
+  const subtitleText = subtitle;
+  const paddedSubtitle = padToDisplayWidth(subtitleText, 30);
+  const paddedTitle = padToDisplayWidth("Claude Code Switch", 60);
+  console.log(
+    ansis.cyan.bold(`
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551                                                                \u2551
+\u2551    \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557                                    \u2551
+\u2551   \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D                                    \u2551
+\u2551   \u2588\u2588\u2551     \u2588\u2588\u2551      \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557                                    \u2551
+\u2551   \u2588\u2588\u2551     \u2588\u2588\u2551      \u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551                                    \u2551
+\u2551   \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551                                    \u2551
+\u2551    \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D     ${ansis.gray(paddedSubtitle)} \u2551
+\u2551                                                                \u2551
+\u2551   ${ansis.white.bold(paddedTitle)} \u2551
+\u2551                                                                \u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+`)
+  );
+}
+function displayBannerWithInfo(subtitle) {
+  displayBanner(subtitle);
+  console.log(ansis.gray(`  Version: ${ansis.cyan(version)}  |  ${ansis.cyan(homepage)}
+`));
+}
+
+async function handleCancellation() {
+  ensureI18nInitialized();
+  console.log(ansis.yellow(i18n.t("common:cancelled")));
+}
+async function handleOfficialLoginMode() {
+  ensureI18nInitialized();
+  const success = switchToOfficialLogin();
+  if (success) {
+    console.log(ansis.green(`\u2714 ${i18n.t("api:officialLoginConfigured")}`));
+  } else {
+    console.log(ansis.red(i18n.t("api:officialLoginFailed")));
+  }
+}
+async function handleCustomApiMode() {
+  ensureI18nInitialized();
+  const { configureIncrementalManagement } = await import('./chunks/claude-code-incremental-manager.mjs');
+  await configureIncrementalManagement();
+}
+async function handleSwitchConfigMode() {
+  ensureI18nInitialized();
+  const { configSwitchCommand } = await Promise.resolve().then(function () { return configSwitch; });
+  await configSwitchCommand({});
+}
+async function configureApiFeature() {
+  ensureI18nInitialized();
+  const { mode } = await inquirer.prompt({
+    type: "list",
+    name: "mode",
+    message: i18n.t("api:apiModePrompt"),
+    choices: addNumbersToChoices([
+      { name: i18n.t("api:apiModeOfficial"), value: "official" },
+      { name: i18n.t("api:apiModeCustom"), value: "custom" },
+      { name: i18n.t("api:apiModeSwitch"), value: "switch" },
+      { name: i18n.t("api:apiModeSkip"), value: "skip" }
+    ])
+  });
+  if (!mode || mode === "skip") {
+    await handleCancellation();
+    return;
+  }
+  switch (mode) {
+    case "official":
+      await handleOfficialLoginMode();
+      break;
+    case "custom":
+      await handleCustomApiMode();
+      break;
+    case "switch":
+      await handleSwitchConfigMode();
+      break;
+    default:
+      await handleCancellation();
+      break;
+  }
+}
+async function promptCustomModels(defaultPrimaryModel, defaultHaikuModel, defaultSonnetModel, defaultOpusModel) {
+  const { primaryModel } = await inquirer.prompt({
+    type: "input",
+    name: "primaryModel",
+    message: `${i18n.t("configuration:enterPrimaryModel")}${i18n.t("common:emptyToSkip")}`,
+    default: defaultPrimaryModel || ""
+  });
+  const { haikuModel } = await inquirer.prompt({
+    type: "input",
+    name: "haikuModel",
+    message: `${i18n.t("configuration:enterHaikuModel")}${i18n.t("common:emptyToSkip")}`,
+    default: defaultHaikuModel || ""
+  });
+  const { sonnetModel } = await inquirer.prompt({
+    type: "input",
+    name: "sonnetModel",
+    message: `${i18n.t("configuration:enterSonnetModel")}${i18n.t("common:emptyToSkip")}`,
+    default: defaultSonnetModel || ""
+  });
+  const { opusModel } = await inquirer.prompt({
+    type: "input",
+    name: "opusModel",
+    message: `${i18n.t("configuration:enterOpusModel")}${i18n.t("common:emptyToSkip")}`,
+    default: defaultOpusModel || ""
+  });
+  return { primaryModel, haikuModel, sonnetModel, opusModel };
+}
+async function changeScriptLanguageFeature(currentLang) {
+  ensureI18nInitialized();
+  const { lang } = await inquirer.prompt({
+    type: "list",
+    name: "lang",
+    message: i18n.t("language:selectScriptLang"),
+    choices: addNumbersToChoices(
+      SUPPORTED_LANGS.map((l) => ({
+        name: LANG_LABELS[l],
+        value: l
+      }))
+    ),
+    default: SUPPORTED_LANGS.indexOf(currentLang)
+  });
+  if (!lang) {
+    return currentLang;
+  }
+  updateZcfConfig({ preferredLang: lang });
+  await changeLanguage(lang);
+  console.log(ansis.green(`\u2714 ${i18n.t("language:languageChanged") || "Language changed"}`));
+  return lang;
+}
+
+const features = {
+  __proto__: null,
+  changeScriptLanguageFeature: changeScriptLanguageFeature,
+  configureApiFeature: configureApiFeature,
+  promptCustomModels: promptCustomModels
+};
+
+async function moveToTrash(paths) {
+  const pathArray = Array.isArray(paths) ? paths : [paths];
+  const results = [];
+  for (const path of pathArray) {
+    try {
+      const exists = await pathExists(path);
+      if (!exists) {
+        results.push({
+          success: false,
+          path,
+          error: "Path does not exist"
+        });
+        continue;
+      }
+      await trash(path);
+      results.push({
+        success: true,
+        path
+      });
+    } catch (error) {
+      results.push({
+        success: false,
+        path,
+        error: error.message || "Unknown error occurred"
+      });
+    }
+  }
+  return results;
+}
+
+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("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("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/installer.mjs');
+        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("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("");
+  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 printSeparator() {
+  console.log(`
+${ansis.dim("\u2500".repeat(50))}
+`);
+}
+async function showMenu() {
+  console.log(ansis.cyan(i18n.t("menu:selectFunction")));
+  console.log("");
+  console.log(
+    `  ${ansis.cyan("1.")} ${i18n.t("menu:menuOptions.configureApiOrCcr")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.configureApiOrCcr")}`)}`
+  );
+  console.log("");
+  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.uninstall")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.uninstall")}`)}`
+  );
+  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", "0", "-", "+", "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 configureApiFeature();
+      break;
+    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 "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() {
+  try {
+    let exitMenu = false;
+    while (!exitMenu) {
+      displayBannerWithInfo(CODE_TOOL_BANNERS["claude-code"] || "ccs");
+      const result = await showMenu();
+      if (result === "exit") {
+        exitMenu = true;
+      }
+    }
+  } catch (error) {
+    if (!handleExitPromptError(error)) {
+      handleGeneralError(error);
+    }
+  }
+}
+
+const LANGUAGE_SELECTION_MESSAGES = {
+  selectLanguage: "Select ZCF display language / \u9009\u62E9ZCF\u663E\u793A\u8BED\u8A00",
+  operationCancelled: "Operation cancelled / \u64CD\u4F5C\u5DF2\u53D6\u6D88"
+};
+async function selectScriptLanguage(currentLang) {
+  const zcfConfig = readZcfConfig();
+  if (zcfConfig?.preferredLang) {
+    return zcfConfig.preferredLang;
+  }
+  const { lang } = await inquirer.prompt({
+    type: "list",
+    name: "lang",
+    message: LANGUAGE_SELECTION_MESSAGES.selectLanguage,
+    choices: addNumbersToChoices(SUPPORTED_LANGS.map((l) => ({
+      name: LANG_LABELS[l],
+      value: l
+    })))
+  });
+  if (!lang) {
+    console.log(ansis.yellow(LANGUAGE_SELECTION_MESSAGES.operationCancelled));
+    process.exit(0);
+  }
+  const scriptLang = lang;
+  updateZcfConfig({
+    version,
+    preferredLang: scriptLang
+  });
+  return scriptLang;
+}
+
+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(`ccs - Claude Code Switch v${version}`)
+  });
+  sections.push({
+    title: ansis.yellow(i18n.t("cli:help.commands")),
+    body: [
+      `  ${ansis.cyan("ccs")}                      ${i18n.t("cli:help.commandDescriptions.showInteractiveMenuDefault")}`,
+      `  ${ansis.cyan("ccs config-switch")} | ${ansis.cyan("cs")}  ${i18n.t("cli:help.commandDescriptions.switchConfiguration")}`,
+      `  ${ansis.cyan("ccs check-updates")} | ${ansis.cyan("check")}  ${i18n.t("cli:help.commandDescriptions.checkUpdateVersions")}`,
+      `  ${ansis.cyan("ccs uninstall")}            ${i18n.t("cli:help.commandDescriptions.uninstallConfigurations")}`
+    ].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("--all-lang, -g")} <lang>  ${i18n.t("cli:help.optionDescriptions.setAllLanguageParams")}`,
+      `  ${ansis.green("--list, -l")}             ${i18n.t("cli:help.optionDescriptions.listConfigurations")}`,
+      `  ${ansis.green("--help, -h")}             ${i18n.t("cli:help.optionDescriptions.displayHelp")}`,
+      `  ${ansis.green("--version, -v")}          ${i18n.t("cli:help.optionDescriptions.displayVersion")}`
+    ].join("\n")
+  });
+  sections.push({
+    title: ansis.yellow(i18n.t("cli:help.examples")),
+    body: [
+      ansis.gray(`  # ${i18n.t("cli:help.exampleDescriptions.showInteractiveMenu")}`),
+      `  ${ansis.cyan("npx @xwm111/ccs")}`,
+      "",
+      ansis.gray(`  # ${i18n.t("cli:help.exampleDescriptions.switchConfiguration")}`),
+      `  ${ansis.cyan("ccs config-switch --list")}`,
+      `  ${ansis.cyan("ccs cs my-endpoint")}`,
+      "",
+      ansis.gray(`  # ${i18n.t("cli:help.exampleDescriptions.checkAndUpdateTools")}`),
+      `  ${ansis.cyan("ccs check-updates")}`,
+      `  ${ansis.cyan("ccs check")}`,
+      "",
+      ansis.gray(`  # ${i18n.t("cli:help.exampleDescriptions.uninstallConfigurations")}`),
+      `  ${ansis.cyan("ccs uninstall")}`,
+      ""
+    ].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>", "Display language (zh-CN, en)").option("--all-lang, -g <lang>", "Set all language parameters to this value").action(await withLanguageResolution(async () => {
+    await showMainMenu();
+  }));
+  cli.command("config-switch [target]", "Switch Claude Code API configuration, or list available configurations").alias("cs").option("--lang <lang>", "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,
+      list: options.list
+    });
+  }));
+  cli.command("uninstall", "Remove ccs configurations and tools").option("--lang, -l <lang>", "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 ccs to latest versions").alias("check").option("--lang, -l <lang>", "Display language (zh-CN, en)").option("--all-lang, -g <lang>", "Set all language parameters to this value").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("ccs");
+  await setupCommands(cli);
+  cli.parse();
+}
+main().catch(console.error);
+
+export { ClaudeCodeConfigManager as C, addNumbersToChoices as a, features as f };