aico-cli 0.0.1

package/dist/cli.mjs

@@ -0,0 +1,1475 @@
+#!/usr/bin/env node
+import cac from 'cac';
+import ansis from 'ansis';
+import { J as readZcfConfig, K as inquirer, N as addNumbersToChoices, O as updateZcfConfig, P as getTranslation, h as SUPPORTED_LANGS, j as LANG_LABELS, k as AI_OUTPUT_LANGUAGES, Q as version, q as backupExistingConfig, r as copyConfigFiles, x as applyAiLanguageDirective, R as configureAiPersonality, C as CLAUDE_DIR, w as getExistingApiConfig, s as configureApi, T as readJsonConfig, H as addCompletedOnboarding, S as SETTINGS_FILE, U as writeJsonConfig, o as openSettingsJson, b as importRecommendedPermissions, a as importRecommendedEnv, V as isWindows, z as readMcpConfig, G as fixWindowsMcpConfig, B as writeMcpConfig, W as selectMcpServices, D as backupMcpConfig, M as MCP_SERVICES, F as buildMcpServerConfig, E as mergeMcpServers, X as displayBanner, I as I18N, Y as selectAndInstallWorkflows, Z as handleExitPromptError, _ as handleGeneralError, $ as displayBannerWithInfo, a0 as readZcfConfigAsync, i as init, a1 as executeWithEscapeSupport, a2 as EscapeKeyPressed } from './shared/aico-cli.D4gky7Vp.mjs';
+import inquirer$1 from 'inquirer';
+import { existsSync, copyFileSync, mkdirSync } from 'node:fs';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import dayjs from 'dayjs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { x } from 'tinyexec';
+import 'pathe';
+import { exec as exec$1 } from 'child_process';
+import { promisify as promisify$1 } from 'util';
+import 'node:url';
+import 'node:fs/promises';
+
+async function selectAiOutputLanguage(scriptLang, defaultLang) {
+  const i18n = getTranslation(scriptLang);
+  console.log(ansis.dim(`
+  ${i18n.language.aiOutputLangHint}
+`));
+  const aiLangChoices = Object.entries(AI_OUTPUT_LANGUAGES).map(
+    ([key, value]) => ({
+      title: value.label,
+      value: key
+    })
+  );
+  const defaultChoice = defaultLang || (scriptLang === "zh-CN" ? "zh-CN" : "en");
+  const { lang } = await inquirer.prompt({
+    type: "list",
+    name: "lang",
+    message: i18n.language.selectAiOutputLang,
+    choices: addNumbersToChoices(
+      aiLangChoices.map((choice) => ({
+        name: choice.title,
+        value: choice.value
+      }))
+    ),
+    default: defaultChoice
+  });
+  if (!lang) {
+    console.log(ansis.yellow(i18n.common.cancelled));
+    process.exit(0);
+  }
+  let aiOutputLang = lang;
+  if (aiOutputLang === "custom") {
+    const { customLang } = await inquirer.prompt({
+      type: "input",
+      name: "customLang",
+      message: i18n.language.enterCustomLanguage,
+      validate: (value) => !!value || i18n.language?.languageRequired || "Language is required"
+    });
+    if (!customLang) {
+      console.log(ansis.yellow(i18n.common.cancelled));
+      process.exit(0);
+    }
+    return customLang;
+  }
+  return aiOutputLang;
+}
+async function selectScriptLanguage(currentLang) {
+  const zcfConfig = readZcfConfig();
+  if (zcfConfig?.preferredLang) {
+    return zcfConfig.preferredLang;
+  }
+  const { lang } = await inquirer.prompt({
+    type: "list",
+    name: "lang",
+    message: "Select AICO display language / \u9009\u62E9\u663E\u793A\u8BED\u8A00",
+    choices: addNumbersToChoices(
+      SUPPORTED_LANGS.map((l) => ({
+        name: LANG_LABELS[l],
+        value: l
+      }))
+    )
+  });
+  if (!lang) {
+    console.log(ansis.yellow("Operation cancelled / \u64CD\u4F5C\u5DF2\u53D6\u6D88"));
+    process.exit(0);
+  }
+  const scriptLang = lang;
+  updateZcfConfig({
+    version,
+    preferredLang: scriptLang
+  });
+  return scriptLang;
+}
+async function resolveAiOutputLanguage(scriptLang, commandLineOption, savedConfig) {
+  const i18n = getTranslation(scriptLang);
+  if (commandLineOption) {
+    return commandLineOption;
+  }
+  if (savedConfig?.aiOutputLang) {
+    console.log(
+      ansis.gray(
+        `\u2714 ${i18n.language.aiOutputLangHint}: ${savedConfig.aiOutputLang}`
+      )
+    );
+    return savedConfig.aiOutputLang;
+  }
+  return await selectAiOutputLanguage(scriptLang, scriptLang);
+}
+
+function validateApiKey(apiKey, lang = "zh-CN") {
+  const i18n = getTranslation(lang);
+  if (!apiKey || apiKey.trim() === "") {
+    return {
+      isValid: false,
+      error: i18n.api.apiKeyValidation.empty
+    };
+  }
+  return { isValid: true };
+}
+function formatApiKeyDisplay(apiKey) {
+  if (!apiKey || apiKey.length < 12) {
+    return apiKey;
+  }
+  return `${apiKey.substring(0, 8)}...${apiKey.substring(apiKey.length - 4)}`;
+}
+
+async function modifyApiConfigPartially(existingConfig, i18n, scriptLang) {
+  let currentConfig = { ...existingConfig };
+  const latestConfig = getExistingApiConfig();
+  if (latestConfig) {
+    currentConfig = latestConfig;
+  }
+  const { item } = await inquirer.prompt({
+    type: "list",
+    name: "item",
+    message: i18n.api.selectModifyItems,
+    choices: addNumbersToChoices([
+      { name: i18n.api.modifyApiUrl, value: "url" },
+      { name: i18n.api.modifyApiKey, value: "key" },
+      { name: i18n.api.modifyAuthType, value: "authType" }
+    ])
+  });
+  if (!item) {
+    console.log(ansis.yellow(i18n.common.cancelled));
+    return;
+  }
+  if (item === "url") {
+    const { url } = await inquirer.prompt({
+      type: "input",
+      name: "url",
+      message: i18n.api.enterNewApiUrl.replace("{url}", currentConfig.url || i18n.common.none),
+      default: currentConfig.url,
+      validate: (value) => {
+        if (!value) return i18n.api.urlRequired;
+        try {
+          new URL(value);
+          return true;
+        } catch {
+          return i18n.api.invalidUrl;
+        }
+      }
+    });
+    if (url === void 0) {
+      console.log(ansis.yellow(i18n.common.cancelled));
+      return;
+    }
+    currentConfig.url = url;
+    const savedConfig = configureApi(currentConfig);
+    if (savedConfig) {
+      console.log(ansis.green(`\u2714 ${i18n.api.modificationSaved}`));
+      console.log(ansis.gray(`  ${i18n.api.apiConfigUrl}: ${savedConfig.url}`));
+    }
+  } else if (item === "key") {
+    const authType = currentConfig.authType || "auth_token";
+    const keyMessage = authType === "auth_token" ? i18n.api.enterNewApiKey.replace("{key}", currentConfig.key ? formatApiKeyDisplay(currentConfig.key) : i18n.common.none) : i18n.api.enterNewApiKey.replace("{key}", currentConfig.key ? formatApiKeyDisplay(currentConfig.key) : i18n.common.none);
+    const { key } = await inquirer.prompt({
+      type: "input",
+      name: "key",
+      message: keyMessage,
+      validate: (value) => {
+        if (!value) {
+          return i18n.api.keyRequired;
+        }
+        const validation = validateApiKey(value, scriptLang);
+        if (!validation.isValid) {
+          return validation.error || i18n.api.invalidKeyFormat;
+        }
+        return true;
+      }
+    });
+    if (key === void 0) {
+      console.log(ansis.yellow(i18n.common.cancelled));
+      return;
+    }
+    currentConfig.key = key;
+    const savedConfig = configureApi(currentConfig);
+    if (savedConfig) {
+      console.log(ansis.green(`\u2714 ${i18n.api.modificationSaved}`));
+      console.log(ansis.gray(`  ${i18n.api.apiConfigKey}: ${formatApiKeyDisplay(savedConfig.key)}`));
+    }
+  } else if (item === "authType") {
+    const { authType } = await inquirer.prompt({
+      type: "list",
+      name: "authType",
+      message: i18n.api.selectNewAuthType.replace("{type}", currentConfig.authType || i18n.common.none),
+      choices: addNumbersToChoices([
+        { name: "Auth Token (OAuth)", value: "auth_token" },
+        { name: "API Key", value: "api_key" }
+      ]),
+      default: currentConfig.authType === "api_key" ? 1 : 0
+    });
+    if (authType === void 0) {
+      console.log(ansis.yellow(i18n.common.cancelled));
+      return;
+    }
+    currentConfig.authType = authType;
+    const savedConfig = configureApi(currentConfig);
+    if (savedConfig) {
+      console.log(ansis.green(`\u2714 ${i18n.api.modificationSaved}`));
+      console.log(ansis.gray(`  ${i18n.api.apiConfigAuthType}: ${savedConfig.authType}`));
+    }
+  }
+}
+async function updatePromptOnly(configLang, scriptLang, aiOutputLang) {
+  const i18n = getTranslation(scriptLang);
+  const backupDir = backupExistingConfig();
+  if (backupDir) {
+    console.log(ansis.gray(`\u2714 ${i18n.configuration.backupSuccess}: ${backupDir}`));
+  }
+  copyConfigFiles(configLang, true);
+  if (aiOutputLang) {
+    applyAiLanguageDirective(aiOutputLang);
+  }
+  await configureAiPersonality(scriptLang);
+  console.log(ansis.green(`\u2714 ${i18n.configuration.configSuccess} ${CLAUDE_DIR}`));
+  console.log("\n" + ansis.cyan(i18n.common.complete));
+}
+
+const execAsync$2 = promisify(exec);
+async function isCcrInstalled() {
+  try {
+    await execAsync$2("ccr version");
+    return true;
+  } catch {
+    try {
+      await execAsync$2("which ccr");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+async function installCcr(scriptLang) {
+  const i18n = getTranslation(scriptLang);
+  const installed = await isCcrInstalled();
+  if (installed) {
+    console.log(ansis.green(`\u2714 ${i18n.ccr.ccrAlreadyInstalled}`));
+    return;
+  }
+  console.log(ansis.cyan(`\u{1F4E6} ${i18n.ccr.installingCcr}`));
+  try {
+    await execAsync$2("npm install -g claude-code-router --force");
+    console.log(ansis.green(`\u2714 ${i18n.ccr.ccrInstallSuccess}`));
+  } catch (error) {
+    if (error.message?.includes("EEXIST")) {
+      console.log(ansis.yellow(`\u26A0 ${i18n.ccr.ccrAlreadyInstalled}`));
+      return;
+    }
+    console.error(ansis.red(`\u2716 ${i18n.ccr.ccrInstallFailed}`));
+    throw error;
+  }
+}
+
+const PROVIDER_PRESETS_URL = "https://pub-0dc3e1677e894f07bbea11b17a29e032.r2.dev/providers.json";
+async function fetchProviderPresets() {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    const response = await fetch(PROVIDER_PRESETS_URL, {
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    const data = await response.json();
+    const presets = [];
+    if (Array.isArray(data)) {
+      for (const provider of data) {
+        if (provider && typeof provider === "object") {
+          presets.push({
+            name: provider.name || "",
+            provider: provider.name || "",
+            baseURL: provider.api_base_url || provider.baseURL || provider.url,
+            requiresApiKey: provider.api_key === "" || provider.requiresApiKey !== false,
+            models: provider.models || [],
+            description: provider.description || provider.name || "",
+            transformer: provider.transformer
+          });
+        }
+      }
+    } else if (data && typeof data === "object") {
+      for (const [key, value] of Object.entries(data)) {
+        if (typeof value === "object" && value !== null) {
+          const provider = value;
+          presets.push({
+            name: provider.name || key,
+            provider: key,
+            baseURL: provider.api_base_url || provider.baseURL || provider.url,
+            requiresApiKey: provider.api_key === "" || provider.requiresApiKey !== false,
+            models: provider.models || [],
+            description: provider.description || "",
+            transformer: provider.transformer
+          });
+        }
+      }
+    }
+    return presets;
+  } catch (error) {
+    return getFallbackPresets();
+  }
+}
+function getFallbackPresets() {
+  return [
+    {
+      name: "dashscope",
+      provider: "dashscope",
+      baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions",
+      requiresApiKey: true,
+      models: ["qwen3-coder-plus"],
+      description: "Alibaba DashScope",
+      transformer: {
+        use: [["maxtoken", { max_tokens: 65536 }]],
+        "qwen3-coder-plus": {
+          use: ["enhancetool"]
+        }
+      }
+    },
+    {
+      name: "deepseek",
+      provider: "deepseek",
+      baseURL: "https://api.deepseek.com/chat/completions",
+      requiresApiKey: true,
+      models: ["deepseek-chat", "deepseek-reasoner"],
+      description: "DeepSeek AI models",
+      transformer: {
+        use: ["deepseek"],
+        "deepseek-chat": {
+          use: ["tooluse"]
+        }
+      }
+    },
+    {
+      name: "gemini",
+      provider: "gemini",
+      baseURL: "https://generativelanguage.googleapis.com/v1beta/models/",
+      requiresApiKey: true,
+      models: ["gemini-2.5-flash", "gemini-2.5-pro"],
+      description: "Google Gemini models",
+      transformer: {
+        use: ["gemini"]
+      }
+    },
+    {
+      name: "modelscope",
+      provider: "modelscope",
+      baseURL: "https://api-inference.modelscope.cn/v1/chat/completions",
+      requiresApiKey: true,
+      models: ["Qwen/Qwen3-Coder-480B-A35B-Instruct", "Qwen/Qwen3-235B-A22B-Thinking-2507", "ZhipuAI/GLM-4.5"],
+      description: "ModelScope AI models",
+      transformer: {
+        use: [["maxtoken", { max_tokens: 65536 }]],
+        "Qwen/Qwen3-Coder-480B-A35B-Instruct": {
+          use: ["enhancetool"]
+        },
+        "Qwen/Qwen3-235B-A22B-Thinking-2507": {
+          use: ["reasoning"]
+        }
+      }
+    },
+    {
+      name: "openrouter",
+      provider: "openrouter",
+      baseURL: "https://openrouter.ai/api/v1/chat/completions",
+      requiresApiKey: true,
+      models: [
+        "google/gemini-2.5-pro-preview",
+        "anthropic/claude-sonnet-4",
+        "anthropic/claude-3.5-sonnet",
+        "anthropic/claude-3.7-sonnet:thinking"
+      ],
+      description: "OpenRouter API",
+      transformer: {
+        use: ["openrouter"]
+      }
+    },
+    {
+      name: "siliconflow",
+      provider: "siliconflow",
+      baseURL: "https://api.siliconflow.cn/v1/chat/completions",
+      requiresApiKey: true,
+      models: ["moonshotai/Kimi-K2-Instruct"],
+      description: "SiliconFlow AI",
+      transformer: {
+        use: [["maxtoken", { max_tokens: 16384 }]]
+      }
+    },
+    {
+      name: "volcengine",
+      provider: "volcengine",
+      baseURL: "https://ark.cn-beijing.volces.com/api/v3/chat/completions",
+      requiresApiKey: true,
+      models: ["deepseek-v3-250324", "deepseek-r1-250528"],
+      description: "Volcengine AI",
+      transformer: {
+        use: ["deepseek"]
+      }
+    }
+  ];
+}
+
+const execAsync$1 = promisify(exec);
+const CCR_CONFIG_DIR = join(homedir(), ".claude-code-router");
+const CCR_CONFIG_FILE = join(CCR_CONFIG_DIR, "config.json");
+const CCR_BACKUP_DIR = CCR_CONFIG_DIR;
+function ensureCcrConfigDir() {
+  if (!existsSync(CCR_CONFIG_DIR)) {
+    mkdirSync(CCR_CONFIG_DIR, { recursive: true });
+  }
+}
+function backupCcrConfig(scriptLang) {
+  const i18n = getTranslation(scriptLang);
+  try {
+    if (!existsSync(CCR_CONFIG_FILE)) {
+      return null;
+    }
+    const timestamp = dayjs().format("YYYY-MM-DDTHH-mm-ss-SSS") + "Z";
+    const backupFileName = `config.json.${timestamp}.bak`;
+    const backupPath = join(CCR_BACKUP_DIR, backupFileName);
+    console.log(ansis.cyan(`${i18n.ccr.backupCcrConfig}`));
+    copyFileSync(CCR_CONFIG_FILE, backupPath);
+    console.log(ansis.green(`\u2714 ${i18n.ccr.ccrBackupSuccess.replace("{path}", backupPath)}`));
+    return backupPath;
+  } catch (error) {
+    console.error(ansis.red(`${i18n.ccr.ccrBackupFailed}:`), error.message);
+    return null;
+  }
+}
+function readCcrConfig() {
+  if (!existsSync(CCR_CONFIG_FILE)) {
+    return null;
+  }
+  return readJsonConfig(CCR_CONFIG_FILE);
+}
+function writeCcrConfig(config) {
+  ensureCcrConfigDir();
+  writeJsonConfig(CCR_CONFIG_FILE, config);
+}
+async function configureCcrProxy(ccrConfig) {
+  const settings = readJsonConfig(SETTINGS_FILE) || {};
+  const host = ccrConfig.HOST || "127.0.0.1";
+  const port = ccrConfig.PORT || 3456;
+  const apiKey = ccrConfig.APIKEY || "sk-aico-x-ccr";
+  if (!settings.env) {
+    settings.env = {};
+  }
+  settings.env.ANTHROPIC_BASE_URL = `http://${host}:${port}`;
+  settings.env.ANTHROPIC_API_KEY = apiKey;
+  writeJsonConfig(SETTINGS_FILE, settings);
+}
+async function selectCcrPreset(scriptLang) {
+  const i18n = getTranslation(scriptLang);
+  console.log(ansis.cyan(`${i18n.ccr.fetchingPresets}`));
+  const presets = await fetchProviderPresets();
+  if (!presets || presets.length === 0) {
+    console.log(ansis.yellow(`${i18n.ccr.noPresetsAvailable}`));
+    return null;
+  }
+  try {
+    const choices = [
+      ...presets.map((p, index) => ({
+        name: `${index + 1}. ${p.name}`,
+        value: p
+      })),
+      {
+        name: `${presets.length + 1}. ${i18n.ccr.skipOption}`,
+        value: "skip"
+      }
+    ];
+    const { preset } = await inquirer.prompt({
+      type: "list",
+      name: "preset",
+      message: i18n.ccr.selectCcrPreset,
+      choices
+    });
+    return preset;
+  } catch (error) {
+    if (error.name === "ExitPromptError") {
+      console.log(ansis.yellow(i18n.common.cancelled));
+      return null;
+    }
+    throw error;
+  }
+}
+async function configureCcrWithPreset(preset, scriptLang) {
+  const i18n = getTranslation(scriptLang);
+  const provider = {
+    name: preset.name,
+    // Use the original name from JSON
+    api_base_url: preset.baseURL || "",
+    api_key: "",
+    models: preset.models
+  };
+  if (preset.transformer) {
+    provider.transformer = preset.transformer;
+  }
+  if (preset.requiresApiKey) {
+    try {
+      const { apiKey } = await inquirer.prompt({
+        type: "input",
+        name: "apiKey",
+        message: i18n.ccr.enterApiKeyForProvider.replace("{provider}", preset.name),
+        validate: (value) => !!value || i18n.api.keyRequired
+      });
+      provider.api_key = apiKey;
+    } catch (error) {
+      if (error.name === "ExitPromptError") {
+        throw error;
+      }
+      throw error;
+    }
+  } else {
+    provider.api_key = "sk-free";
+  }
+  let defaultModel = preset.models[0];
+  if (preset.models.length > 1) {
+    try {
+      const { model } = await inquirer.prompt({
+        type: "list",
+        name: "model",
+        message: i18n.ccr.selectDefaultModelForProvider.replace("{provider}", preset.name),
+        choices: preset.models.map((m, index) => ({
+          name: `${index + 1}. ${m}`,
+          value: m
+        }))
+      });
+      defaultModel = model;
+    } catch (error) {
+      if (error.name === "ExitPromptError") {
+        throw error;
+      }
+      throw error;
+    }
+  }
+  const router = {
+    default: `${preset.name},${defaultModel}`,
+    // Use the original name
+    background: `${preset.name},${defaultModel}`,
+    think: `${preset.name},${defaultModel}`,
+    longContext: `${preset.name},${defaultModel}`,
+    longContextThreshold: 6e4,
+    webSearch: `${preset.name},${defaultModel}`
+  };
+  const config = {
+    LOG: true,
+    CLAUDE_PATH: "",
+    HOST: "127.0.0.1",
+    PORT: 3456,
+    APIKEY: "sk-aico-x-ccr",
+    API_TIMEOUT_MS: "600000",
+    PROXY_URL: "",
+    transformers: [],
+    Providers: [provider],
+    Router: router
+  };
+  return config;
+}
+async function restartAndCheckCcrStatus(scriptLang) {
+  const i18n = getTranslation(scriptLang);
+  try {
+    console.log(ansis.cyan(`${i18n.ccr.restartingCcr}`));
+    await execAsync$1("ccr restart");
+    console.log(ansis.green(`\u2714 ${i18n.ccr.ccrRestartSuccess}`));
+    console.log(ansis.cyan(`${i18n.ccr.checkingCcrStatus}`));
+    const { stdout } = await execAsync$1("ccr status");
+    console.log(ansis.gray(stdout));
+  } catch (error) {
+    console.error(ansis.red(`${i18n.ccr.ccrRestartFailed}:`), error.message || error);
+    if (process.env.DEBUG) {
+      console.error("Full error:", error);
+    }
+  }
+}
+function showConfigurationTips(scriptLang, apiKey) {
+  const i18n = getTranslation(scriptLang);
+  console.log(ansis.bold.cyan(`
+\u{1F4CC} ${i18n.ccr.configTips}:`));
+  console.log(ansis.blue(`  \u2022 ${i18n.ccr.advancedConfigTip}`));
+  console.log(ansis.blue(`  \u2022 ${i18n.ccr.manualConfigTip}`));
+  console.log(ansis.bold.yellow(`  \u2022 ${i18n.ccr.useClaudeCommand}`));
+  if (apiKey) {
+    console.log(ansis.bold.green(`  \u2022 ${i18n.ccr.ccrUiApiKey || "CCR UI API Key"}: ${apiKey}`));
+    console.log(ansis.gray(`    ${i18n.ccr.ccrUiApiKeyHint || "Use this API key to login to CCR UI"}`));
+  }
+  console.log("");
+}
+async function setupCcrConfiguration(scriptLang) {
+  const i18n = getTranslation(scriptLang);
+  try {
+    const existingConfig = readCcrConfig();
+    if (existingConfig) {
+      console.log(ansis.blue(`\u2139 ${i18n.ccr.existingCcrConfig}`));
+      let shouldBackupAndReconfigure = false;
+      try {
+        const result = await inquirer.prompt({
+          type: "confirm",
+          name: "overwrite",
+          message: i18n.ccr.overwriteCcrConfig,
+          default: false
+        });
+        shouldBackupAndReconfigure = result.overwrite;
+      } catch (error) {
+        if (error.name === "ExitPromptError") {
+          console.log(ansis.yellow(i18n.common.cancelled));
+          return false;
+        }
+        throw error;
+      }
+      if (!shouldBackupAndReconfigure) {
+        console.log(ansis.yellow(`${i18n.ccr.keepingExistingConfig}`));
+        await configureCcrProxy(existingConfig);
+        return true;
+      }
+      backupCcrConfig(scriptLang);
+    }
+    const preset = await selectCcrPreset(scriptLang);
+    if (!preset) {
+      return false;
+    }
+    let config;
+    if (preset === "skip") {
+      console.log(ansis.yellow(`${i18n.ccr.skipConfiguring}`));
+      config = {
+        LOG: false,
+        CLAUDE_PATH: "",
+        HOST: "127.0.0.1",
+        PORT: 3456,
+        APIKEY: "sk-aico-x-ccr",
+        API_TIMEOUT_MS: "600000",
+        PROXY_URL: "",
+        transformers: [],
+        Providers: [],
+        // Empty providers array
+        Router: {
+          // Empty router configuration - user will configure in CCR UI
+        }
+      };
+    } else {
+      config = await configureCcrWithPreset(preset, scriptLang);
+    }
+    writeCcrConfig(config);
+    console.log(ansis.green(`\u2714 ${i18n.ccr.ccrConfigSuccess}`));
+    await configureCcrProxy(config);
+    console.log(ansis.green(`\u2714 ${i18n.ccr.proxyConfigSuccess}`));
+    await restartAndCheckCcrStatus(scriptLang);
+    showConfigurationTips(scriptLang, config.APIKEY);
+    try {
+      addCompletedOnboarding();
+    } catch (error) {
+      console.error(ansis.red(i18n.configuration.failedToSetOnboarding), error);
+    }
+    return true;
+  } catch (error) {
+    if (error.name === "ExitPromptError") {
+      console.log(ansis.yellow(i18n.common.cancelled));
+      return false;
+    }
+    console.error(ansis.red(`${i18n.ccr.ccrConfigFailed}:`), error);
+    return false;
+  }
+}
+async function configureCcrFeature(scriptLang) {
+  const i18n = getTranslation(scriptLang);
+  const backupDir = backupExistingConfig();
+  if (backupDir) {
+    console.log(ansis.gray(`\u2714 ${i18n.configuration.backupSuccess}: ${backupDir}`));
+  }
+  await setupCcrConfiguration(scriptLang);
+}
+
+function handleCancellation(scriptLang) {
+  const i18n = getTranslation(scriptLang);
+  console.log(ansis.yellow(i18n.common.cancelled));
+}
+async function configureApiFeature(scriptLang) {
+  const i18n = getTranslation(scriptLang);
+  const existingApiConfig = getExistingApiConfig();
+  if (existingApiConfig) {
+    console.log("\n" + ansis.blue(`\u2139 ${i18n.api.existingApiConfig}`));
+    console.log(ansis.gray(`  ${i18n.api.apiConfigUrl}: ${existingApiConfig.url || i18n.common.notConfigured}`));
+    console.log(ansis.gray(`  ${i18n.api.apiConfigKey}: ${existingApiConfig.key ? formatApiKeyDisplay(existingApiConfig.key) : i18n.common.notConfigured}`));
+    console.log(ansis.gray(`  ${i18n.api.apiConfigAuthType}: ${existingApiConfig.authType || i18n.common.notConfigured}
+`));
+    const { action } = await inquirer.prompt({
+      type: "list",
+      name: "action",
+      message: i18n.api.selectApiAction,
+      choices: addNumbersToChoices([
+        { name: i18n.api.keepExistingConfig, value: "keep" },
+        { name: i18n.api.modifyAllConfig, value: "modify-all" },
+        { name: i18n.api.modifyPartialConfig, value: "modify-partial" },
+        { name: i18n.api.useCcrProxy, value: "use-ccr" }
+      ])
+    });
+    if (!action) {
+      handleCancellation(scriptLang);
+      return;
+    }
+    if (action === "keep") {
+      console.log(ansis.green(`\u2714 ${i18n.api.keepExistingConfig}`));
+      try {
+        addCompletedOnboarding();
+      } catch (error) {
+        console.error(ansis.red(i18n.configuration.failedToSetOnboarding), error);
+      }
+      return;
+    } else if (action === "modify-partial") {
+      await modifyApiConfigPartially(existingApiConfig, i18n, scriptLang);
+      return;
+    } else if (action === "use-ccr") {
+      const ccrInstalled = await isCcrInstalled();
+      if (!ccrInstalled) {
+        console.log(ansis.yellow(`${i18n.ccr.installingCcr}`));
+        await installCcr(scriptLang);
+      } else {
+        console.log(ansis.green(`\u2714 ${i18n.ccr.ccrAlreadyInstalled}`));
+      }
+      const ccrConfigured = await setupCcrConfiguration(scriptLang);
+      if (ccrConfigured) {
+        console.log(ansis.green(`\u2714 ${i18n.ccr.ccrSetupComplete}`));
+      }
+      return;
+    }
+  }
+  const { apiChoice } = await inquirer.prompt({
+    type: "list",
+    name: "apiChoice",
+    message: i18n.api.configureApi,
+    choices: addNumbersToChoices([
+      {
+        name: `${i18n.api.useAuthToken} - ${ansis.gray(i18n.api.authTokenDesc)}`,
+        value: "auth_token",
+        short: i18n.api.useAuthToken
+      },
+      {
+        name: `${i18n.api.useApiKey} - ${ansis.gray(i18n.api.apiKeyDesc)}`,
+        value: "api_key",
+        short: i18n.api.useApiKey
+      },
+      {
+        name: `${i18n.api.useCcrProxy} - ${ansis.gray(i18n.api.ccrProxyDesc)}`,
+        value: "ccr_proxy",
+        short: i18n.api.useCcrProxy
+      },
+      { name: i18n.api.skipApi, value: "skip" }
+    ])
+  });
+  if (!apiChoice || apiChoice === "skip") {
+    return;
+  }
+  if (apiChoice === "ccr_proxy") {
+    const ccrInstalled = await isCcrInstalled();
+    if (!ccrInstalled) {
+      console.log(ansis.yellow(`${i18n.ccr.installingCcr}`));
+      await installCcr(scriptLang);
+    } else {
+      console.log(ansis.green(`\u2714 ${i18n.ccr.ccrAlreadyInstalled}`));
+    }
+    const ccrConfigured = await setupCcrConfiguration(scriptLang);
+    if (ccrConfigured) {
+      console.log(ansis.green(`\u2714 ${i18n.ccr.ccrSetupComplete}`));
+    }
+    return;
+  }
+  const { url } = await inquirer.prompt({
+    type: "input",
+    name: "url",
+    message: i18n.api.enterApiUrl,
+    validate: (value) => {
+      if (!value) return i18n.api.urlRequired;
+      try {
+        new URL(value);
+        return true;
+      } catch {
+        return i18n.api.invalidUrl;
+      }
+    }
+  });
+  if (!url) {
+    handleCancellation(scriptLang);
+    return;
+  }
+  const keyMessage = apiChoice === "auth_token" ? i18n.api.enterAuthToken : i18n.api.enterApiKey;
+  const { key } = await inquirer.prompt({
+    type: "input",
+    name: "key",
+    message: keyMessage,
+    validate: (value) => {
+      if (!value) {
+        return i18n.api.keyRequired;
+      }
+      const validation = validateApiKey(value, scriptLang);
+      if (!validation.isValid) {
+        return validation.error || i18n.api.invalidKeyFormat;
+      }
+      return true;
+    }
+  });
+  if (!key) {
+    handleCancellation(scriptLang);
+    return;
+  }
+  const apiConfig = { url, key, authType: apiChoice };
+  const configuredApi = configureApi(apiConfig);
+  if (configuredApi) {
+    console.log(ansis.green(`\u2714 ${i18n.api.apiConfigSuccess}`));
+    console.log(ansis.gray(`  URL: ${configuredApi.url}`));
+    console.log(ansis.gray(`  Key: ${formatApiKeyDisplay(configuredApi.key)}`));
+  }
+}
+async function configureMcpFeature(scriptLang) {
+  const i18n = getTranslation(scriptLang);
+  if (isWindows()) {
+    const { fixWindows } = await inquirer.prompt({
+      type: "confirm",
+      name: "fixWindows",
+      message: i18n.configuration.fixWindowsMcp || "Fix Windows MCP configuration?",
+      default: true
+    });
+    if (fixWindows) {
+      const existingConfig = readMcpConfig() || { mcpServers: {} };
+      const fixedConfig = fixWindowsMcpConfig(existingConfig);
+      writeMcpConfig(fixedConfig);
+      console.log(ansis.green(`\u2714 Windows MCP configuration fixed`));
+    }
+  }
+  const selectedServices = await selectMcpServices(scriptLang);
+  if (!selectedServices) {
+    return;
+  }
+  if (selectedServices.length > 0) {
+    const mcpBackupPath = backupMcpConfig();
+    if (mcpBackupPath) {
+      console.log(ansis.gray(`\u2714 ${i18n.mcp.mcpBackupSuccess}: ${mcpBackupPath}`));
+    }
+    const newServers = {};
+    for (const serviceId of selectedServices) {
+      const service = MCP_SERVICES.find((s) => s.id === serviceId);
+      if (!service) continue;
+      let config = service.config;
+      if (service.requiresApiKey) {
+        const { apiKey } = await inquirer.prompt({
+          type: "input",
+          name: "apiKey",
+          message: service.apiKeyPrompt[scriptLang],
+          validate: (value) => !!value || i18n.api.keyRequired
+        });
+        if (apiKey) {
+          config = buildMcpServerConfig(service.config, apiKey, service.apiKeyPlaceholder, service.apiKeyEnvVar);
+        } else {
+          continue;
+        }
+      }
+      newServers[service.id] = config;
+    }
+    const existingConfig = readMcpConfig();
+    let mergedConfig = mergeMcpServers(existingConfig, newServers);
+    mergedConfig = fixWindowsMcpConfig(mergedConfig);
+    writeMcpConfig(mergedConfig);
+    console.log(ansis.green(`\u2714 ${i18n.mcp.mcpConfigSuccess}`));
+  }
+}
+async function configureAiMemoryFeature(scriptLang) {
+  const i18n = getTranslation(scriptLang);
+  const { option } = await inquirer.prompt({
+    type: "list",
+    name: "option",
+    message: "Select configuration option",
+    choices: addNumbersToChoices([
+      {
+        name: i18n.configuration.configureAiLanguage || "Configure AI output language",
+        value: "language"
+      },
+      {
+        name: i18n.configuration.configureAiPersonality || "Configure AI personality",
+        value: "personality"
+      }
+    ])
+  });
+  if (!option) {
+    return;
+  }
+  if (option === "language") {
+    const zcfConfig = readZcfConfig();
+    const aiOutputLang = await resolveAiOutputLanguage(scriptLang, void 0, zcfConfig);
+    applyAiLanguageDirective(aiOutputLang);
+    updateZcfConfig({ aiOutputLang });
+    console.log(ansis.green(`\u2714 ${i18n.configuration.aiLanguageConfigured || "AI output language configured"}`));
+  } else {
+    await configureAiPersonality(scriptLang);
+  }
+}
+async function configureEnvPermissionFeature(scriptLang) {
+  const i18n = getTranslation(scriptLang);
+  const { choice } = await inquirer.prompt({
+    type: "list",
+    name: "choice",
+    message: i18n.configuration?.selectEnvPermissionOption || "Select option",
+    choices: addNumbersToChoices([
+      {
+        name: `${i18n.configuration?.importRecommendedEnv || "Import environment"} ${ansis.gray("- " + (i18n.configuration?.importRecommendedEnvDesc || "Import env settings"))}`,
+        value: "env"
+      },
+      {
+        name: `${i18n.configuration?.importRecommendedPermissions || "Import permissions"} ${ansis.gray("- " + (i18n.configuration?.importRecommendedPermissionsDesc || "Import permission settings"))}`,
+        value: "permissions"
+      },
+      {
+        name: `${i18n.configuration?.openSettingsJson || "Open settings"} ${ansis.gray("- " + (i18n.configuration?.openSettingsJsonDesc || "View settings file"))}`,
+        value: "open"
+      }
+    ])
+  });
+  if (!choice) {
+    handleCancellation(scriptLang);
+    return;
+  }
+  try {
+    switch (choice) {
+      case "env":
+        await importRecommendedEnv();
+        console.log(ansis.green(`\u2705 ${i18n.configuration.envImportSuccess}`));
+        break;
+      case "permissions":
+        await importRecommendedPermissions();
+        console.log(ansis.green(`\u2705 ${i18n.configuration?.permissionsImportSuccess || "Permissions imported"}`));
+        break;
+      case "open":
+        console.log(ansis.cyan(i18n.configuration?.openingSettingsJson || "Opening settings.json..."));
+        await openSettingsJson();
+        break;
+    }
+  } catch (error) {
+    console.error(ansis.red(`${i18n.common.error}: ${error.message}`));
+  }
+}
+
+async function update(options = {}) {
+  try {
+    if (!options.skipBanner) {
+      displayBanner("Update configuration for Claude Code");
+    }
+    const scriptLang = await selectScriptLanguage();
+    const zcfConfig = readZcfConfig();
+    const i18n = I18N[scriptLang];
+    const configLang = options.configLang || "zh-CN";
+    const aiOutputLang = await resolveAiOutputLanguage(scriptLang, options.aiOutputLang, zcfConfig);
+    console.log(ansis.cyan(`
+${i18n.workflow.updatingPrompts}
+`));
+    await updatePromptOnly(configLang, scriptLang, aiOutputLang);
+    await selectAndInstallWorkflows(configLang, scriptLang);
+    updateZcfConfig({
+      version,
+      preferredLang: scriptLang,
+      aiOutputLang
+    });
+  } catch (error) {
+    if (!handleExitPromptError(error)) {
+      handleGeneralError(error);
+    }
+  }
+}
+
+async function showMainMenu() {
+  try {
+    displayBannerWithInfo();
+    const zcfConfig = await readZcfConfigAsync();
+    let scriptLang = zcfConfig?.preferredLang || await selectScriptLanguage();
+    const menuProcessors = {
+      "1": {
+        key: "1",
+        labelKey: "fullInit",
+        processor: () => init({ lang: scriptLang, skipBanner: true }),
+        section: "\u57FA\u7840\u914D\u7F6E"
+      },
+      "2": {
+        key: "2",
+        labelKey: "importWorkflow",
+        processor: () => update({ skipBanner: true }),
+        section: "\u57FA\u7840\u914D\u7F6E"
+      },
+      "3": {
+        key: "3",
+        labelKey: "configureMcp",
+        processor: () => configureMcpFeature(scriptLang),
+        section: "\u57FA\u7840\u914D\u7F6E"
+      },
+      "4": {
+        key: "4",
+        labelKey: "configureAiMemory",
+        processor: () => configureAiMemoryFeature(scriptLang),
+        section: "\u57FA\u7840\u914D\u7F6E"
+      },
+      "5": {
+        key: "5",
+        labelKey: "configureApi",
+        processor: () => configureApiFeature(scriptLang),
+        section: "\u57FA\u7840\u914D\u7F6E"
+      },
+      "6": {
+        key: "6",
+        labelKey: "configureEnvPermission",
+        processor: () => configureEnvPermissionFeature(scriptLang),
+        section: "\u57FA\u7840\u914D\u7F6E"
+      }
+    };
+    let exitMenu = false;
+    while (!exitMenu) {
+      const i18n = I18N[scriptLang];
+      const menuChoices = Object.values(menuProcessors).map((item) => ({
+        name: `${item.key}. ${i18n.menu.menuOptions[item.labelKey]} - ${ansis.gray(i18n.menu.menuDescriptions[item.labelKey])}`,
+        value: item.key,
+        short: i18n.menu.menuOptions[item.labelKey]
+      }));
+      menuChoices.push({
+        name: `0. ${i18n.common.exit || "\u9000\u51FA"}`,
+        value: "0",
+        short: i18n.common.exit || "\u9000\u51FA"
+      });
+      const { choice } = await inquirer$1.prompt({
+        type: "list",
+        name: "choice",
+        message: i18n.menu.selectFunction,
+        choices: menuChoices
+      });
+      if (!choice) {
+        console.log(ansis.yellow(i18n.common.cancelled));
+        exitMenu = true;
+        break;
+      }
+      const menuChoice = choice.toLowerCase();
+      if (menuChoice === "0") {
+        exitMenu = true;
+        console.log(ansis.cyan(i18n.common.goodbye));
+        continue;
+      }
+      const selectedItem = menuProcessors[choice];
+      if (selectedItem) {
+        const success = await executeWithEscapeSupport(
+          selectedItem.processor,
+          i18n
+        );
+        if (success) {
+          if (selectedItem.key === "0") {
+            try {
+              const result = await selectedItem.processor();
+              if (result !== scriptLang) {
+                scriptLang = result;
+              }
+            } catch (error) {
+            }
+          }
+          await handleMenuContinuation(choice, i18n);
+        }
+      }
+    }
+  } catch (error) {
+    if (!handleExitPromptError(error)) {
+      handleGeneralError(error);
+    }
+  }
+}
+async function handleMenuContinuation(choice, i18n) {
+  console.log("\n" + ansis.dim("\u2500".repeat(50)) + "\n");
+  if (choice === "0" || choice === "-" || choice.toLowerCase() === "u" || choice.toLowerCase() === "r") {
+    return;
+  }
+  try {
+    const { continue: shouldContinue } = await inquirer.prompt({
+      type: "confirm",
+      name: "continue",
+      message: i18n.common.returnToMenu,
+      default: true
+    });
+    if (!shouldContinue) {
+      console.log(ansis.cyan(i18n.common.goodbye));
+      process.exit(0);
+    }
+  } catch (error) {
+    if (error instanceof EscapeKeyPressed) {
+      console.log(
+        ansis.yellow(`
+${i18n.common.returnToPrevious || "\u8FD4\u56DE\u4E0A\u4E00\u6B65"}`)
+      );
+      return;
+    }
+    throw error;
+  }
+}
+
+const execAsync = promisify$1(exec$1);
+async function runCcrUi(scriptLang, apiKey) {
+  const i18n = I18N[scriptLang];
+  console.log(ansis.cyan(`
+\u{1F5A5}\uFE0F  ${i18n.ccr.startingCcrUi}`));
+  if (apiKey) {
+    console.log(ansis.bold.green(`
+\u{1F511} ${i18n.ccr.ccrUiApiKey || "CCR UI API Key"}: ${apiKey}`));
+    console.log(ansis.gray(`   ${i18n.ccr.ccrUiApiKeyHint || "Use this API key to login to CCR UI"}
+`));
+  }
+  try {
+    const { stdout, stderr } = await execAsync("ccr ui");
+    if (stdout) console.log(stdout);
+    if (stderr) console.error(ansis.yellow(stderr));
+    console.log(ansis.green(`\u2714 ${i18n.ccr.ccrUiStarted}`));
+  } catch (error) {
+    console.error(ansis.red(`\u2716 ${i18n.ccr.ccrCommandFailed}: ${error instanceof Error ? error.message : String(error)}`));
+    throw error;
+  }
+}
+async function runCcrStatus(scriptLang) {
+  const i18n = I18N[scriptLang];
+  console.log(ansis.cyan(`
+\u{1F4CA} ${i18n.ccr.checkingCcrStatus}`));
+  try {
+    const { stdout, stderr } = await execAsync("ccr status");
+    if (stdout) {
+      console.log("\n" + ansis.bold(i18n.ccr.ccrStatusTitle));
+      console.log(stdout);
+    }
+    if (stderr) console.error(ansis.yellow(stderr));
+  } catch (error) {
+    console.error(ansis.red(`\u2716 ${i18n.ccr.ccrCommandFailed}: ${error instanceof Error ? error.message : String(error)}`));
+    throw error;
+  }
+}
+async function runCcrRestart(scriptLang) {
+  const i18n = I18N[scriptLang];
+  console.log(ansis.cyan(`
+\u{1F504} ${i18n.ccr.restartingCcr}`));
+  try {
+    const { stdout, stderr } = await execAsync("ccr restart");
+    if (stdout) console.log(stdout);
+    if (stderr) console.error(ansis.yellow(stderr));
+    console.log(ansis.green(`\u2714 ${i18n.ccr.ccrRestarted}`));
+  } catch (error) {
+    console.error(ansis.red(`\u2716 ${i18n.ccr.ccrCommandFailed}: ${error instanceof Error ? error.message : String(error)}`));
+    throw error;
+  }
+}
+async function runCcrStart(scriptLang) {
+  const i18n = I18N[scriptLang];
+  console.log(ansis.cyan(`
+\u25B6\uFE0F  ${i18n.ccr.startingCcr}`));
+  try {
+    const { stdout, stderr } = await execAsync("ccr start");
+    if (stdout) console.log(stdout);
+    if (stderr) console.error(ansis.yellow(stderr));
+    console.log(ansis.green(`\u2714 ${i18n.ccr.ccrStarted}`));
+  } catch (error) {
+    console.error(ansis.red(`\u2716 ${i18n.ccr.ccrCommandFailed}: ${error instanceof Error ? error.message : String(error)}`));
+    throw error;
+  }
+}
+async function runCcrStop(scriptLang) {
+  const i18n = I18N[scriptLang];
+  console.log(ansis.cyan(`
+\u23F9\uFE0F  ${i18n.ccr.stoppingCcr}`));
+  try {
+    const { stdout, stderr } = await execAsync("ccr stop");
+    if (stdout) console.log(stdout);
+    if (stderr) console.error(ansis.yellow(stderr));
+    console.log(ansis.green(`\u2714 ${i18n.ccr.ccrStopped}`));
+  } catch (error) {
+    console.error(ansis.red(`\u2716 ${i18n.ccr.ccrCommandFailed}: ${error instanceof Error ? error.message : String(error)}`));
+    throw error;
+  }
+}
+
+function isCcrConfigured() {
+  const CCR_CONFIG_FILE = join(homedir(), ".claude-code-router", "config.json");
+  if (!existsSync(CCR_CONFIG_FILE)) {
+    return false;
+  }
+  const config = readCcrConfig();
+  return config !== null && config.Providers && config.Providers.length > 0;
+}
+async function showCcrMenu(scriptLang) {
+  try {
+    const i18n = I18N[scriptLang];
+    console.log("\n" + ansis.cyan("\u2550".repeat(50)));
+    console.log(ansis.bold.cyan(`  ${i18n.ccr.ccrMenuTitle}`));
+    console.log(ansis.cyan("\u2550".repeat(50)) + "\n");
+    console.log(`  ${ansis.cyan("1.")} ${i18n.ccr.ccrMenuOptions.initCcr} ${ansis.gray("- " + i18n.ccr.ccrMenuDescriptions.initCcr)}`);
+    console.log(`  ${ansis.cyan("2.")} ${i18n.ccr.ccrMenuOptions.startUi} ${ansis.gray("- " + i18n.ccr.ccrMenuDescriptions.startUi)}`);
+    console.log(`  ${ansis.cyan("3.")} ${i18n.ccr.ccrMenuOptions.checkStatus} ${ansis.gray("- " + i18n.ccr.ccrMenuDescriptions.checkStatus)}`);
+    console.log(`  ${ansis.cyan("4.")} ${i18n.ccr.ccrMenuOptions.restart} ${ansis.gray("- " + i18n.ccr.ccrMenuDescriptions.restart)}`);
+    console.log(`  ${ansis.cyan("5.")} ${i18n.ccr.ccrMenuOptions.start} ${ansis.gray("- " + i18n.ccr.ccrMenuDescriptions.start)}`);
+    console.log(`  ${ansis.cyan("6.")} ${i18n.ccr.ccrMenuOptions.stop} ${ansis.gray("- " + i18n.ccr.ccrMenuDescriptions.stop)}`);
+    console.log(`  ${ansis.yellow("0.")} ${i18n.ccr.ccrMenuOptions.back}`);
+    console.log("");
+    const { choice } = await inquirer.prompt({
+      type: "input",
+      name: "choice",
+      message: i18n.common.enterChoice,
+      validate: (value) => {
+        const valid = ["1", "2", "3", "4", "5", "6", "0"];
+        return valid.includes(value) || i18n.common.invalidChoice;
+      }
+    });
+    switch (choice) {
+      case "1":
+        const ccrInstalled = await isCcrInstalled();
+        if (!ccrInstalled) {
+          console.log(ansis.yellow(`${i18n.ccr.installingCcr}`));
+          await installCcr(scriptLang);
+        } else {
+          console.log(ansis.green(`\u2714 ${i18n.ccr.ccrAlreadyInstalled}`));
+        }
+        await configureCcrFeature(scriptLang);
+        console.log(ansis.green(`
+\u2714 ${i18n.ccr.ccrSetupComplete}`));
+        break;
+      case "2":
+        if (!isCcrConfigured()) {
+          console.log(ansis.yellow(`
+\u26A0\uFE0F  ${i18n.ccr.ccrNotConfigured || "CCR is not configured yet. Please initialize CCR first."}`));
+          console.log(ansis.cyan(`   ${i18n.ccr.pleaseInitFirst || "Please select option 1 to initialize CCR."}
+`));
+        } else {
+          const config = readCcrConfig();
+          await runCcrUi(scriptLang, config?.APIKEY);
+        }
+        break;
+      case "3":
+        if (!isCcrConfigured()) {
+          console.log(ansis.yellow(`
+\u26A0\uFE0F  ${i18n.ccr.ccrNotConfigured || "CCR is not configured yet. Please initialize CCR first."}`));
+          console.log(ansis.cyan(`   ${i18n.ccr.pleaseInitFirst || "Please select option 1 to initialize CCR."}
+`));
+        } else {
+          await runCcrStatus(scriptLang);
+        }
+        break;
+      case "4":
+        if (!isCcrConfigured()) {
+          console.log(ansis.yellow(`
+\u26A0\uFE0F  ${i18n.ccr.ccrNotConfigured || "CCR is not configured yet. Please initialize CCR first."}`));
+          console.log(ansis.cyan(`   ${i18n.ccr.pleaseInitFirst || "Please select option 1 to initialize CCR."}
+`));
+        } else {
+          await runCcrRestart(scriptLang);
+        }
+        break;
+      case "5":
+        if (!isCcrConfigured()) {
+          console.log(ansis.yellow(`
+\u26A0\uFE0F  ${i18n.ccr.ccrNotConfigured || "CCR is not configured yet. Please initialize CCR first."}`));
+          console.log(ansis.cyan(`   ${i18n.ccr.pleaseInitFirst || "Please select option 1 to initialize CCR."}
+`));
+        } else {
+          await runCcrStart(scriptLang);
+        }
+        break;
+      case "6":
+        if (!isCcrConfigured()) {
+          console.log(ansis.yellow(`
+\u26A0\uFE0F  ${i18n.ccr.ccrNotConfigured || "CCR is not configured yet. Please initialize CCR first."}`));
+          console.log(ansis.cyan(`   ${i18n.ccr.pleaseInitFirst || "Please select option 1 to initialize CCR."}
+`));
+        } else {
+          await runCcrStop(scriptLang);
+        }
+        break;
+      case "0":
+        return false;
+    }
+    if (choice !== "0") {
+      console.log("\n" + ansis.dim("\u2500".repeat(50)) + "\n");
+      const { continueInCcr } = await inquirer.prompt({
+        type: "confirm",
+        name: "continueInCcr",
+        message: i18n.common.returnToMenu || "Return to CCR menu?",
+        default: true
+      });
+      if (continueInCcr) {
+        return await showCcrMenu(scriptLang);
+      }
+    }
+    return false;
+  } catch (error) {
+    if (!handleExitPromptError(error)) {
+      handleGeneralError(error, scriptLang);
+    }
+    return false;
+  }
+}
+
+function getValidLanguage(lang) {
+  return lang && lang in I18N ? lang : "en";
+}
+
+async function executeCcusage(args = []) {
+  try {
+    let lang = "en";
+    try {
+      const zcfConfig = await readZcfConfigAsync();
+      const rawLang = zcfConfig?.preferredLang || "en";
+      lang = getValidLanguage(rawLang);
+    } catch {
+      lang = "en";
+    }
+    const i18n = I18N[lang];
+    const command = "npx";
+    const commandArgs = ["ccusage@latest", ...args || []];
+    console.log(ansis.cyan(i18n.tools.runningCcusage));
+    console.log(ansis.gray(`$ npx ccusage@latest ${(args || []).join(" ")}`));
+    console.log("");
+    await x(command, commandArgs, {
+      nodeOptions: {
+        stdio: "inherit"
+      }
+    });
+  } catch (error) {
+    let lang = "en";
+    try {
+      const zcfConfig = await readZcfConfigAsync();
+      const rawLang = zcfConfig?.preferredLang || "en";
+      lang = getValidLanguage(rawLang);
+    } catch {
+      lang = "en";
+    }
+    const i18n = I18N[lang];
+    console.error(ansis.red(i18n.tools.ccusageFailed));
+    console.error(ansis.yellow(i18n.tools.checkNetworkConnection));
+    if (process.env.DEBUG) {
+      console.error(ansis.gray(i18n.tools.errorDetails), error);
+    }
+    if (process.env.NODE_ENV !== "test") {
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+
+async function ccr(options = {}) {
+  try {
+    if (!options.skipBanner) {
+      displayBannerWithInfo();
+    }
+    const zcfConfig = await readZcfConfigAsync();
+    const scriptLang = options.lang || zcfConfig?.preferredLang || await selectScriptLanguage();
+    const continueInCcr = await showCcrMenu(scriptLang);
+    if (!continueInCcr && !options.skipBanner) {
+      await showMainMenu();
+    }
+  } catch (error) {
+    if (!handleExitPromptError(error)) {
+      handleGeneralError(error, options.lang);
+    }
+  }
+}
+
+function setupCommands(cli) {
+  cli.command("[lang]", "Show interactive menu (default)").option("--init", "Run full initialization directly").option("--config-lang, -c <lang>", "Configuration language (zh-CN, en)").option("--force, -f", "Force overwrite existing configuration").action(async (lang, options) => {
+    await handleDefaultCommand(lang, options);
+  });
+  cli.command("init", "Initialize Claude Code configuration").alias("i").option("--lang, -l <lang>", "AICO 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").action(async (options) => {
+    await handleInitCommand(options);
+  });
+  cli.command("update", "Update Claude Code prompts only").alias("u").option("--config-lang, -c <lang>", "Configuration language (zh-CN, en)").action(async (options) => {
+    await handleUpdateCommand(options);
+  });
+  cli.command("ccr", "Configure Claude Code Router for model proxy").option("--lang, -l <lang>", "Display language (zh-CN, en)").action(async (options) => {
+    await ccr({ lang: options.lang });
+  });
+  cli.command("ccu [...args]", "Run Claude Code usage analysis tool").allowUnknownOptions().action(async (args) => {
+    await executeCcusage(args);
+  });
+  cli.help((sections) => customizeHelp(sections));
+  cli.version(version);
+}
+async function handleDefaultCommand(lang, options) {
+  if (options.init) {
+    await init({
+      lang: lang || options.lang,
+      configLang: options.configLang,
+      force: options.force
+    });
+  } else {
+    await showMainMenu();
+  }
+}
+async function handleInitCommand(options) {
+  await init({
+    lang: options.lang,
+    configLang: options.configLang,
+    aiOutputLang: options.aiOutputLang,
+    force: options.force
+  });
+}
+async function handleUpdateCommand(options) {
+  await update({ configLang: options.configLang });
+}
+function customizeHelp(sections) {
+  sections.unshift({
+    title: "",
+    body: ansis.cyan.bold(`AICO - Zero-Config Claude-Code Flow v${version}`)
+  });
+  sections.push({
+    title: ansis.yellow("Commands / \u547D\u4EE4:"),
+    body: [
+      `  ${ansis.cyan("aico")}              Show interactive menu (default) / \u663E\u793A\u4EA4\u4E92\u5F0F\u83DC\u5355\uFF08\u9ED8\u8BA4\uFF09`,
+      `  ${ansis.cyan("aico init")} | ${ansis.cyan(
+        "i"
+      )}     Initialize Claude Code configuration / \u521D\u59CB\u5316 Claude Code \u914D\u7F6E`,
+      `  ${ansis.cyan("aico update")} | ${ansis.cyan("u")}   Update workflow-related md files / \u4EC5\u66F4\u65B0\u5DE5\u4F5C\u6D41\u76F8\u5173md`,
+      `  ${ansis.cyan("aico ccr")}          Configure Claude Code Router / \u914D\u7F6E\u6A21\u578B\u4EE3\u7406`,
+      `  ${ansis.cyan("aico ccu")} [args]   Run Claude Code usage analysis / \u8FD0\u884C Claude Code \u7528\u91CF\u5206\u6790`,
+      "",
+      ansis.gray("  Shortcuts / \u5FEB\u6377\u65B9\u5F0F:"),
+      `  ${ansis.cyan("aico i")}            Quick init / \u5FEB\u901F\u521D\u59CB\u5316`,
+      `  ${ansis.cyan("aico u")}            Quick update / \u5FEB\u901F\u66F4\u65B0`
+    ].join("\n")
+  });
+  sections.push({
+    title: ansis.yellow("Options / \u9009\u9879:"),
+    body: [
+      `  ${ansis.green("--init")}                    Run full initialization directly / \u76F4\u63A5\u8FD0\u884C\u5B8C\u6574\u521D\u59CB\u5316`,
+      `  ${ansis.green("--config-lang, -c")} <lang>  Configuration language / \u914D\u7F6E\u8BED\u8A00 (zh-CN, en)`,
+      `  ${ansis.green("--force, -f")}               Force overwrite / \u5F3A\u5236\u8986\u76D6\u73B0\u6709\u914D\u7F6E`,
+      `  ${ansis.green("--help, -h")}                Display help / \u663E\u793A\u5E2E\u52A9`,
+      `  ${ansis.green("--version, -v")}             Display version / \u663E\u793A\u7248\u672C`
+    ].join("\n")
+  });
+  sections.push({
+    title: ansis.yellow("Examples / \u793A\u4F8B:"),
+    body: [
+      ansis.gray("  # Show interactive menu / \u663E\u793A\u4EA4\u4E92\u5F0F\u83DC\u5355"),
+      `  ${ansis.cyan("npx aico")}`,
+      "",
+      ansis.gray("  # Run full initialization / \u8FD0\u884C\u5B8C\u6574\u521D\u59CB\u5316"),
+      `  ${ansis.cyan("npx aico init")}`,
+      `  ${ansis.cyan("npx aico i")}`,
+      `  ${ansis.cyan("npx aico --init")}`,
+      "",
+      ansis.gray("  # Update workflow-related md files only / \u4EC5\u66F4\u65B0\u5DE5\u4F5C\u6D41\u76F8\u5173md\u6587\u4EF6"),
+      `  ${ansis.cyan("npx aico u")}`,
+      "",
+      ansis.gray("  # Run Claude Code usage analysis / \u8FD0\u884C Claude Code \u7528\u91CF\u5206\u6790"),
+      `  ${ansis.cyan("npx aico ccu")}               ${ansis.gray("# Daily usage (default)")}`,
+      `  ${ansis.cyan("npx aico ccu monthly --json")}`,
+      "",
+      ansis.gray("  # Force overwrite with Chinese config / \u5F3A\u5236\u4F7F\u7528\u4E2D\u6587\u914D\u7F6E\u8986\u76D6"),
+      `  ${ansis.cyan("npx aico --init -c zh-CN -f")}`,
+      `  ${ansis.cyan("npx aico --init --config-lang zh-CN --force")}`
+    ].join("\n")
+  });
+  return sections;
+}
+
+async function main() {
+  const cli = cac("aico");
+  setupCommands(cli);
+  cli.parse();
+}
+main().catch(console.error);