zcf 2.7.1 → 2.8.1

package/dist/{shared/zcf.CZ3RjfyP.mjs → chunks/simple-config.mjs}

@@ -5,10 +5,21 @@ import { join, dirname } from 'pathe';
 import dayjs from 'dayjs';
 import { fileURLToPath } from 'node:url';
 import { exec } from 'tinyexec';
-import { rm, mkdir, copyFile as copyFile$1 } from 'node:fs/promises';
+import { exec as exec$1 } from 'child_process';
+import { promisify } from 'util';
+import ora from 'ora';
+import prompts$1 from 'prompts';
+import { readFile as readFile$1, writeFile as writeFile$1, mkdir } from 'fs/promises';
+import { join as join$1 } from 'path';
+import { homedir as homedir$1 } from 'os';
+import semver from 'semver';
+import { rm, mkdir as mkdir$1, copyFile as copyFile$1 } from 'node:fs/promises';
+import { exec as exec$2 } from 'node:child_process';
+import { promisify as promisify$1 } from 'node:util';
 import { homedir, platform } from 'node:os';
+import { join as join$2 } from 'node:path';
 
-const version = "2.7.1";
+const version = "2.8.1";
 const homepage = "https://github.com/UfoMiao/zcf";
 
 const common$1 = {
@@ -52,6 +63,7 @@ const installation$1 = {
   installPrompt: "\u68C0\u6D4B\u5230 Claude Code \u672A\u5B89\u88C5\uFF0C\u662F\u5426\u81EA\u52A8\u5B89\u88C5\uFF1F",
   installing: "\u6B63\u5728\u5B89\u88C5 Claude Code...",
   installSuccess: "Claude Code \u5B89\u88C5\u6210\u529F",
+  alreadyInstalled: "Claude Code \u5DF2\u5B89\u88C5",
   installFailed: "Claude Code \u5B89\u88C5\u5931\u8D25",
   npmNotFound: "npm \u672A\u5B89\u88C5\u3002\u8BF7\u5148\u5B89\u88C5 Node.js \u548C npm\u3002",
   // Termux specific
@@ -70,6 +82,8 @@ const api$1 = {
   authTokenDesc: "\u9002\u7528\u4E8E\u901A\u8FC7 OAuth \u6216\u6D4F\u89C8\u5668\u767B\u5F55\u83B7\u53D6\u7684\u4EE4\u724C",
   useApiKey: "\u4F7F\u7528 API Key (\u5BC6\u94A5\u8BA4\u8BC1)",
   apiKeyDesc: "\u9002\u7528\u4E8E\u4ECE Anthropic Console \u83B7\u53D6\u7684 API \u5BC6\u94A5",
+  useCcrProxy: "\u4F7F\u7528 CCR \u4EE3\u7406",
+  ccrProxyDesc: "\u901A\u8FC7 Claude Code Router \u4F7F\u7528\u591A\u4E2A AI \u6A21\u578B",
   skipApi: "\u8DF3\u8FC7\uFF08\u7A0D\u540E\u624B\u52A8\u914D\u7F6E\uFF09",
   enterApiUrl: "\u8BF7\u8F93\u5165 API URL",
   enterAuthToken: "\u8BF7\u8F93\u5165 Auth Token",
@@ -117,11 +131,21 @@ const configuration$1 = {
   // Model configuration
   selectDefaultModel: "\u9009\u62E9\u9ED8\u8BA4\u6A21\u578B",
   modelConfigSuccess: "\u9ED8\u8BA4\u6A21\u578B\u5DF2\u914D\u7F6E",
+  existingModelConfig: "\u68C0\u6D4B\u5230\u5DF2\u6709\u6A21\u578B\u914D\u7F6E",
+  currentModel: "\u5F53\u524D\u6A21\u578B",
+  modifyModel: "\u662F\u5426\u4FEE\u6539\u6A21\u578B\u914D\u7F6E\uFF1F",
+  keepModel: "\u4FDD\u6301\u5F53\u524D\u6A21\u578B\u914D\u7F6E",
+  defaultModelOption: "\u9ED8\u8BA4\uFF08\u8BA9 Claude Code \u81EA\u52A8\u9009\u62E9\uFF09",
+  modelConfigured: "\u9ED8\u8BA4\u6A21\u578B\u5DF2\u914D\u7F6E",
   // AI memory configuration
   selectMemoryOption: "\u9009\u62E9\u914D\u7F6E\u9009\u9879",
   configureAiLanguage: "\u914D\u7F6E AI \u8F93\u51FA\u8BED\u8A00",
   configureAiPersonality: "\u914D\u7F6E AI \u4E2A\u6027\u98CE\u683C",
   aiLanguageConfigured: "AI \u8F93\u51FA\u8BED\u8A00\u5DF2\u914D\u7F6E",
+  existingLanguageConfig: "\u68C0\u6D4B\u5230\u5DF2\u6709 AI \u8F93\u51FA\u8BED\u8A00\u914D\u7F6E",
+  currentLanguage: "\u5F53\u524D\u8BED\u8A00",
+  modifyLanguage: "\u662F\u5426\u4FEE\u6539 AI \u8F93\u51FA\u8BED\u8A00\uFF1F",
+  keepLanguage: "\u4FDD\u6301\u5F53\u524D\u8BED\u8A00\u914D\u7F6E",
   // AI personality
   selectAiPersonality: "\u9009\u62E9 AI \u4E2A\u6027\u98CE\u683C",
   customPersonalityHint: "\u5B9A\u4E49\u4F60\u81EA\u5DF1\u7684\u4E2A\u6027",
@@ -147,7 +171,17 @@ const configuration$1 = {
   openSettingsJsonDesc: "\u9AD8\u7EA7\u7528\u6237\u81EA\u5B9A\u4E49",
   envImportSuccess: "\u73AF\u5883\u53D8\u91CF\u5DF2\u5BFC\u5165",
   permissionsImportSuccess: "\u6743\u9650\u914D\u7F6E\u5DF2\u5BFC\u5165",
-  openingSettingsJson: "\u6B63\u5728\u6253\u5F00 settings.json..."
+  openingSettingsJson: "\u6B63\u5728\u6253\u5F00 settings.json...",
+  // JSON config related
+  invalidConfiguration: "\u914D\u7F6E\u65E0\u6548",
+  failedToParseJson: "\u89E3\u6790 JSON \u6587\u4EF6\u5931\u8D25:",
+  failedToBackupConfig: "\u5907\u4EFD\u914D\u7F6E\u5931\u8D25",
+  failedToReadTemplateSettings: "\u8BFB\u53D6\u6A21\u677F\u8BBE\u7F6E\u5931\u8D25",
+  failedToMergeSettings: "\u5408\u5E76\u8BBE\u7F6E\u5931\u8D25",
+  preservingExistingSettings: "\u4FDD\u7559\u73B0\u6709\u8BBE\u7F6E",
+  memoryDirNotFound: "\u672A\u627E\u5230\u8BB0\u5FC6\u76EE\u5F55",
+  failedToSetOnboarding: "\u8BBE\u7F6E\u5F15\u5BFC\u6807\u5FD7\u5931\u8D25",
+  fixWindowsMcp: "\u4FEE\u590D Windows MCP \u914D\u7F6E\uFF1F"
 };
 
 const mcp$1 = {
@@ -174,11 +208,14 @@ const menu$1 = {
   menuOptions: {
     fullInit: "\u5B8C\u6574\u521D\u59CB\u5316",
     importWorkflow: "\u5BFC\u5165\u5DE5\u4F5C\u6D41",
+    configureApiOrCcr: "\u914D\u7F6E API \u6216 CCR \u4EE3\u7406",
     configureApi: "\u914D\u7F6E API",
     configureMcp: "\u914D\u7F6E MCP",
     configureModel: "\u914D\u7F6E\u9ED8\u8BA4\u6A21\u578B",
     configureAiMemory: "\u914D\u7F6E Claude \u5168\u5C40\u8BB0\u5FC6",
     configureEnvPermission: "\u5BFC\u5165\u63A8\u8350\u73AF\u5883\u53D8\u91CF\u548C\u6743\u9650\u914D\u7F6E",
+    configureCcr: "\u914D\u7F6E\u6A21\u578B\u4EE3\u7406 (CCR)",
+    ccrManagement: "CCR",
     ccusage: "ccusage",
     installBmad: "\u5B89\u88C5 BMad Method",
     clearCache: "\u6E05\u9664\u504F\u597D\u7F13\u5B58",
@@ -186,13 +223,16 @@ const menu$1 = {
     exit: "\u9000\u51FA"
   },
   menuDescriptions: {
-    fullInit: "\u5B89\u88C5 Claude Code + \u5BFC\u5165\u5DE5\u4F5C\u6D41 + \u914D\u7F6E API + \u914D\u7F6E MCP \u670D\u52A1",
+    fullInit: "\u5B89\u88C5 Claude Code + \u5BFC\u5165\u5DE5\u4F5C\u6D41 + \u914D\u7F6E API \u6216 CCR \u4EE3\u7406 + \u914D\u7F6E MCP \u670D\u52A1",
     importWorkflow: "\u4EC5\u5BFC\u5165/\u66F4\u65B0\u5DE5\u4F5C\u6D41\u76F8\u5173\u6587\u4EF6",
+    configureApiOrCcr: "\u914D\u7F6E API URL\u3001\u8BA4\u8BC1\u4FE1\u606F\u6216 CCR \u4EE3\u7406",
     configureApi: "\u914D\u7F6E API URL \u548C\u8BA4\u8BC1\u4FE1\u606F",
     configureMcp: "\u914D\u7F6E MCP \u670D\u52A1\uFF08\u542B Windows \u4FEE\u590D\uFF09",
     configureModel: "\u8BBE\u7F6E\u9ED8\u8BA4\u6A21\u578B\uFF08opus/sonnet\uFF09",
     configureAiMemory: "\u914D\u7F6E AI \u8F93\u51FA\u8BED\u8A00\u548C\u89D2\u8272\u98CE\u683C",
     configureEnvPermission: "\u5BFC\u5165\u9690\u79C1\u4FDD\u62A4\u73AF\u5883\u53D8\u91CF\u548C\u7CFB\u7EDF\u6743\u9650\u914D\u7F6E",
+    configureCcr: "\u914D\u7F6E Claude Code Router \u4EE5\u4F7F\u7528\u591A\u4E2A AI \u6A21\u578B",
+    ccrManagement: "\u914D\u7F6E Claude Code Router \u4EE5\u4F7F\u7528\u591A\u4E2A AI \u6A21\u578B",
     ccusage: "Claude Code \u7528\u91CF\u5206\u6790",
     installBmad: "AI \u9A71\u52A8\u7684\u5F00\u53D1\u65B9\u6CD5\u8BBA\u6846\u67B6",
     clearCache: "\u6E05\u9664\u504F\u597D\u8BED\u8A00\u7B49\u7F13\u5B58",
@@ -326,19 +366,121 @@ const tools$1 = {
   errorDetails: "\u9519\u8BEF\u8BE6\u60C5:"
 };
 
+const ccrMessages$1 = {
+  // Installation
+  installingCcr: "\u6B63\u5728\u5B89\u88C5 Claude Code Router...",
+  ccrInstallSuccess: "Claude Code Router \u5B89\u88C5\u6210\u529F",
+  ccrInstallFailed: "\u5B89\u88C5 Claude Code Router \u5931\u8D25",
+  ccrAlreadyInstalled: "Claude Code Router \u5DF2\u5B89\u88C5",
+  // Configuration
+  configureCcr: "\u914D\u7F6E\u6A21\u578B\u4EE3\u7406 (CCR)",
+  useCcrProxy: "\u4F7F\u7528 CCR \u4EE3\u7406",
+  ccrProxyDesc: "\u901A\u8FC7 Claude Code Router \u8FDE\u63A5\u591A\u4E2A AI \u6A21\u578B",
+  fetchingPresets: "\u6B63\u5728\u83B7\u53D6\u63D0\u4F9B\u5546\u9884\u8BBE...",
+  noPresetsAvailable: "\u6CA1\u6709\u53EF\u7528\u7684\u9884\u8BBE",
+  selectCcrPreset: "\u9009\u62E9\u4E00\u4E2A\u63D0\u4F9B\u5546\u9884\u8BBE\uFF1A",
+  keyRequired: "API \u5BC6\u94A5\u4E0D\u80FD\u4E3A\u7A7A",
+  // Existing config
+  existingCcrConfig: "\u53D1\u73B0\u73B0\u6709\u7684 CCR \u914D\u7F6E",
+  overwriteCcrConfig: "\u662F\u5426\u5907\u4EFD\u73B0\u6709\u7684 CCR \u914D\u7F6E\u5E76\u91CD\u65B0\u914D\u7F6E\uFF1F",
+  keepingExistingConfig: "\u4FDD\u7559\u73B0\u6709\u914D\u7F6E",
+  backupCcrConfig: "\u6B63\u5728\u5907\u4EFD\u73B0\u6709\u7684 CCR \u914D\u7F6E...",
+  ccrBackupSuccess: "CCR \u914D\u7F6E\u5DF2\u5907\u4EFD\u5230\uFF1A{path}",
+  ccrBackupFailed: "\u5907\u4EFD CCR \u914D\u7F6E\u5931\u8D25",
+  // Model selection
+  selectDefaultModelForProvider: "\u9009\u62E9 {provider} \u7684\u9ED8\u8BA4\u6A21\u578B\uFF1A",
+  enterApiKeyForProvider: "\u8BF7\u8F93\u5165 {provider} \u7684 API \u5BC6\u94A5\uFF1A",
+  // Skip option
+  skipOption: "\u8DF3\u8FC7\uFF0C\u5728 CCR \u4E2D\u81EA\u884C\u914D\u7F6E",
+  skipConfiguring: "\u8DF3\u8FC7\u9884\u8BBE\u914D\u7F6E\uFF0C\u5C06\u521B\u5EFA\u7A7A\u914D\u7F6E\u6846\u67B6",
+  // Success/Error messages
+  ccrConfigSuccess: "CCR \u914D\u7F6E\u5DF2\u4FDD\u5B58",
+  proxyConfigSuccess: "\u4EE3\u7406\u8BBE\u7F6E\u5DF2\u914D\u7F6E",
+  ccrConfigFailed: "\u914D\u7F6E CCR \u5931\u8D25",
+  ccrSetupComplete: "CCR \u8BBE\u7F6E\u5B8C\u6210",
+  fetchPresetsError: "\u83B7\u53D6\u63D0\u4F9B\u5546\u9884\u8BBE\u5931\u8D25",
+  failedToStartCcrService: "\u542F\u52A8 CCR \u670D\u52A1\u5931\u8D25",
+  errorStartingCcrService: "\u542F\u52A8 CCR \u670D\u52A1\u65F6\u51FA\u9519",
+  // CCR service status
+  ccrRestartSuccess: "CCR \u670D\u52A1\u5DF2\u91CD\u542F",
+  ccrRestartFailed: "CCR \u670D\u52A1\u91CD\u542F\u5931\u8D25",
+  // Configuration tips
+  configTips: "\u914D\u7F6E\u63D0\u793A",
+  useClaudeCommand: "\u8BF7\u4F7F\u7528 claude \u547D\u4EE4\u542F\u52A8 Claude Code\uFF08\u800C\u975E ccr code\uFF09",
+  advancedConfigTip: "\u60A8\u53EF\u4EE5\u4F7F\u7528 ccr ui \u547D\u4EE4\u8FDB\u884C\u66F4\u9AD8\u7EA7\u7684\u914D\u7F6E",
+  manualConfigTip: "\u624B\u52A8\u4FEE\u6539\u914D\u7F6E\u6587\u4EF6\u540E\uFF0C\u8BF7\u6267\u884C ccr restart \u4F7F\u914D\u7F6E\u751F\u6548",
+  // CCR Menu
+  ccrMenuTitle: "CCR - Claude Code Router \u7BA1\u7406",
+  ccrMenuOptions: {
+    initCcr: "\u521D\u59CB\u5316 CCR",
+    startUi: "\u542F\u52A8 CCR UI",
+    checkStatus: "\u67E5\u8BE2 CCR \u72B6\u6001",
+    restart: "\u91CD\u542F CCR",
+    start: "\u542F\u52A8 CCR",
+    stop: "\u505C\u6B62 CCR",
+    back: "\u8FD4\u56DE\u4E3B\u83DC\u5355"
+  },
+  ccrMenuDescriptions: {
+    initCcr: "\u5B89\u88C5\u5E76\u914D\u7F6E CCR",
+    startUi: "\u6253\u5F00 Web \u754C\u9762\u7BA1\u7406 CCR",
+    checkStatus: "\u67E5\u770B CCR \u670D\u52A1\u8FD0\u884C\u72B6\u6001",
+    restart: "\u91CD\u542F CCR \u670D\u52A1",
+    start: "\u542F\u52A8 CCR \u670D\u52A1",
+    stop: "\u505C\u6B62 CCR \u670D\u52A1"
+  },
+  // Command execution messages
+  startingCcrUi: "\u6B63\u5728\u542F\u52A8 CCR UI...",
+  ccrUiStarted: "CCR UI \u5DF2\u542F\u52A8",
+  checkingCcrStatus: "\u6B63\u5728\u67E5\u8BE2 CCR \u72B6\u6001...",
+  ccrStatusTitle: "CCR \u72B6\u6001\u4FE1\u606F\uFF1A",
+  restartingCcr: "\u6B63\u5728\u91CD\u542F CCR...",
+  ccrRestarted: "CCR \u5DF2\u91CD\u542F",
+  startingCcr: "\u6B63\u5728\u542F\u52A8 CCR...",
+  ccrStarted: "CCR \u5DF2\u542F\u52A8",
+  stoppingCcr: "\u6B63\u5728\u505C\u6B62 CCR...",
+  ccrStopped: "CCR \u5DF2\u505C\u6B62",
+  ccrCommandFailed: "\u6267\u884C CCR \u547D\u4EE4\u5931\u8D25",
+  // Configuration check messages
+  ccrNotConfigured: "CCR \u5C1A\u672A\u914D\u7F6E\u3002\u8BF7\u5148\u521D\u59CB\u5316 CCR\u3002",
+  pleaseInitFirst: "\u8BF7\u9009\u62E9\u9009\u9879 1 \u6765\u521D\u59CB\u5316 CCR\u3002",
+  // UI API Key messages
+  ccrUiApiKey: "CCR UI \u767B\u5F55\u5BC6\u94A5",
+  ccrUiApiKeyHint: "\u4F7F\u7528\u6B64\u5BC6\u94A5\u767B\u5F55 CCR UI \u754C\u9762"
+};
+
+const updater$1 = {
+  checkingVersion: "\u6B63\u5728\u68C0\u67E5\u7248\u672C...",
+  checkingTools: "\u68C0\u67E5\u5DE5\u5177\u7248\u672C",
+  ccrNotInstalled: "CCR \u672A\u5B89\u88C5",
+  ccrUpToDate: "CCR \u5DF2\u662F\u6700\u65B0\u7248\u672C (v{version})",
+  claudeCodeNotInstalled: "Claude Code \u672A\u5B89\u88C5",
+  claudeCodeUpToDate: "Claude Code \u5DF2\u662F\u6700\u65B0\u7248\u672C (v{version})",
+  cannotCheckVersion: "\u65E0\u6CD5\u68C0\u67E5\u6700\u65B0\u7248\u672C",
+  currentVersion: "\u5F53\u524D\u7248\u672C: v{version}",
+  latestVersion: "\u6700\u65B0\u7248\u672C: v{version}",
+  confirmUpdate: "\u662F\u5426\u66F4\u65B0 {tool} \u5230\u6700\u65B0\u7248\u672C\uFF1F",
+  updateSkipped: "\u5DF2\u8DF3\u8FC7\u66F4\u65B0",
+  updating: "\u6B63\u5728\u66F4\u65B0 {tool}...",
+  updateSuccess: "{tool} \u66F4\u65B0\u6210\u529F\uFF01",
+  updateFailed: "{tool} \u66F4\u65B0\u5931\u8D25",
+  checkFailed: "\u7248\u672C\u68C0\u67E5\u5931\u8D25"
+};
+
 const zhCN = {
-  ...common$1,
-  ...language$1,
-  ...installation$1,
-  ...api$1,
-  ...configuration$1,
-  ...mcp$1,
-  ...menu$1,
-  ...workflow$1,
-  ...cli$1,
-  ...bmad$1,
-  ...errors$1,
-  ...tools$1
+  common: common$1,
+  language: language$1,
+  installation: installation$1,
+  api: api$1,
+  configuration: configuration$1,
+  mcp: mcp$1,
+  menu: menu$1,
+  workflow: workflow$1,
+  cli: cli$1,
+  bmad: bmad$1,
+  errors: errors$1,
+  tools: tools$1,
+  ccr: ccrMessages$1,
+  updater: updater$1
 };
 
 const common = {
@@ -382,6 +524,7 @@ const installation = {
   installPrompt: "Claude Code not found. Install automatically?",
   installing: "Installing Claude Code...",
   installSuccess: "Claude Code installed successfully",
+  alreadyInstalled: "Claude Code is already installed",
   installFailed: "Failed to install Claude Code",
   npmNotFound: "npm is not installed. Please install Node.js and npm first.",
   // Termux specific
@@ -400,6 +543,8 @@ const api = {
   authTokenDesc: "For tokens obtained via OAuth or browser login",
   useApiKey: "Use API Key (Key authentication)",
   apiKeyDesc: "For API keys from Anthropic Console",
+  useCcrProxy: "Use CCR Proxy",
+  ccrProxyDesc: "Use multiple AI models via Claude Code Router",
   skipApi: "Skip (configure manually later)",
   enterApiUrl: "Enter API URL",
   enterAuthToken: "Enter Auth Token",
@@ -447,11 +592,21 @@ const configuration = {
   // Model configuration
   selectDefaultModel: "Select default model",
   modelConfigSuccess: "Default model configured",
+  existingModelConfig: "Existing model configuration detected",
+  currentModel: "Current model",
+  modifyModel: "Modify model configuration?",
+  keepModel: "Keeping existing model configuration",
+  defaultModelOption: "Default (Let Claude Code choose)",
+  modelConfigured: "Default model configured",
   // AI memory configuration
   selectMemoryOption: "Select configuration option",
   configureAiLanguage: "Configure AI output language",
   configureAiPersonality: "Configure AI personality",
   aiLanguageConfigured: "AI output language configured",
+  existingLanguageConfig: "Existing AI output language configuration detected",
+  currentLanguage: "Current language",
+  modifyLanguage: "Modify AI output language?",
+  keepLanguage: "Keeping existing language configuration",
   // AI personality
   selectAiPersonality: "Select AI personality",
   customPersonalityHint: "Define your own personality",
@@ -477,7 +632,17 @@ const configuration = {
   openSettingsJsonDesc: "Advanced user customization",
   envImportSuccess: "Environment variables imported",
   permissionsImportSuccess: "Permissions imported",
-  openingSettingsJson: "Opening settings.json..."
+  openingSettingsJson: "Opening settings.json...",
+  // JSON config related
+  invalidConfiguration: "Invalid configuration",
+  failedToParseJson: "Failed to parse JSON file:",
+  failedToBackupConfig: "Failed to backup config",
+  failedToReadTemplateSettings: "Failed to read template settings",
+  failedToMergeSettings: "Failed to merge settings",
+  preservingExistingSettings: "Preserving existing settings",
+  memoryDirNotFound: "Memory directory not found",
+  failedToSetOnboarding: "Failed to set onboarding flag",
+  fixWindowsMcp: "Fix Windows MCP configuration?"
 };
 
 const mcp = {
@@ -504,11 +669,14 @@ const menu = {
   menuOptions: {
     fullInit: "Full initialization",
     importWorkflow: "Import workflow",
+    configureApiOrCcr: "Configure API / CCR proxy",
     configureApi: "Configure API",
     configureMcp: "Configure MCP",
     configureModel: "Configure default model",
     configureAiMemory: "Configure Claude global memory",
     configureEnvPermission: "Import recommended environment variables and permissions",
+    configureCcr: "Configure Model Proxy (CCR)",
+    ccrManagement: "CCR",
     ccusage: "ccusage",
     installBmad: "Install BMad Method",
     clearCache: "Clear preference cache",
@@ -516,13 +684,16 @@ const menu = {
     exit: "Exit"
   },
   menuDescriptions: {
-    fullInit: "Install Claude Code + Import workflow + Configure API + Configure MCP services",
+    fullInit: "Install Claude Code + Import workflow + Configure API or CCR proxy + Configure MCP services",
     importWorkflow: "Import/update workflow-related files only",
+    configureApiOrCcr: "Configure API URL, authentication or CCR proxy",
     configureApi: "Configure API URL and authentication",
     configureMcp: "Configure MCP services (includes Windows fix)",
     configureModel: "Set default model (opus/sonnet)",
     configureAiMemory: "Configure AI output language and personality",
     configureEnvPermission: "Import privacy protection environment variables and system permissions",
+    configureCcr: "Configure Claude Code Router to use multiple AI models",
+    ccrManagement: "Configure Claude Code Router to use multiple AI models",
     ccusage: "Claude Code usage analysis",
     installBmad: "AI-driven development methodology framework",
     clearCache: "Clear preference language and other caches",
@@ -656,25 +827,130 @@ const tools = {
   errorDetails: "Error details:"
 };
 
+const ccrMessages = {
+  // Installation
+  installingCcr: "Installing Claude Code Router...",
+  ccrInstallSuccess: "Claude Code Router installed successfully",
+  ccrInstallFailed: "Failed to install Claude Code Router",
+  ccrAlreadyInstalled: "Claude Code Router is already installed",
+  // Configuration
+  configureCcr: "Configure Model Proxy (CCR)",
+  useCcrProxy: "Use CCR Proxy",
+  ccrProxyDesc: "Connect to multiple AI models via Claude Code Router",
+  fetchingPresets: "Fetching provider presets...",
+  noPresetsAvailable: "No presets available",
+  selectCcrPreset: "Select a provider preset:",
+  keyRequired: "API key is required",
+  // Existing config
+  existingCcrConfig: "Existing CCR configuration found",
+  overwriteCcrConfig: "Backup existing CCR configuration and reconfigure?",
+  keepingExistingConfig: "Keeping existing configuration",
+  backupCcrConfig: "Backing up existing CCR configuration...",
+  ccrBackupSuccess: "CCR configuration backed up to: {path}",
+  ccrBackupFailed: "Failed to backup CCR configuration",
+  // Model selection
+  selectDefaultModelForProvider: "Select default model for {provider}:",
+  enterApiKeyForProvider: "Enter API key for {provider}:",
+  // Skip option
+  skipOption: "Skip, configure in CCR manually",
+  skipConfiguring: "Skipping preset configuration, will create empty configuration framework",
+  // Success/Error messages
+  ccrConfigSuccess: "CCR configuration saved",
+  proxyConfigSuccess: "Proxy settings configured",
+  ccrConfigFailed: "Failed to configure CCR",
+  ccrSetupComplete: "CCR setup complete",
+  fetchPresetsError: "Failed to fetch provider presets",
+  failedToStartCcrService: "Failed to start CCR service",
+  errorStartingCcrService: "Error starting CCR service",
+  // CCR service status
+  ccrRestartSuccess: "CCR service restarted",
+  ccrRestartFailed: "Failed to restart CCR service",
+  // Configuration tips
+  configTips: "Configuration Tips",
+  useClaudeCommand: "Use the claude command to start Claude Code (not ccr code)",
+  advancedConfigTip: "You can use the ccr ui command for advanced configuration",
+  manualConfigTip: "After manually modifying the configuration file, run ccr restart to apply changes",
+  // CCR Menu
+  ccrMenuTitle: "CCR - Claude Code Router Management",
+  ccrMenuOptions: {
+    initCcr: "Initialize CCR",
+    startUi: "Start CCR UI",
+    checkStatus: "Check CCR Status",
+    restart: "Restart CCR",
+    start: "Start CCR",
+    stop: "Stop CCR",
+    back: "Back to Main Menu"
+  },
+  ccrMenuDescriptions: {
+    initCcr: "Install and configure CCR",
+    startUi: "Open web interface to manage CCR",
+    checkStatus: "View CCR service status",
+    restart: "Restart CCR service",
+    start: "Start CCR service",
+    stop: "Stop CCR service"
+  },
+  // Command execution messages
+  startingCcrUi: "Starting CCR UI...",
+  ccrUiStarted: "CCR UI started",
+  checkingCcrStatus: "Checking CCR status...",
+  ccrStatusTitle: "CCR Status:",
+  restartingCcr: "Restarting CCR...",
+  ccrRestarted: "CCR restarted",
+  startingCcr: "Starting CCR...",
+  ccrStarted: "CCR started",
+  stoppingCcr: "Stopping CCR...",
+  ccrStopped: "CCR stopped",
+  ccrCommandFailed: "Failed to execute CCR command",
+  // Configuration check messages
+  ccrNotConfigured: "CCR is not configured yet. Please initialize CCR first.",
+  pleaseInitFirst: "Please select option 1 to initialize CCR.",
+  // UI API Key messages
+  ccrUiApiKey: "CCR UI API Key",
+  ccrUiApiKeyHint: "Use this API key to login to CCR UI"
+};
+
+const updater = {
+  checkingVersion: "Checking version...",
+  checkingTools: "Checking tool versions",
+  ccrNotInstalled: "CCR is not installed",
+  ccrUpToDate: "CCR is up to date (v{version})",
+  claudeCodeNotInstalled: "Claude Code is not installed",
+  claudeCodeUpToDate: "Claude Code is up to date (v{version})",
+  cannotCheckVersion: "Cannot check latest version",
+  currentVersion: "Current version: v{version}",
+  latestVersion: "Latest version: v{version}",
+  confirmUpdate: "Update {tool} to the latest version?",
+  updateSkipped: "Update skipped",
+  updating: "Updating {tool}...",
+  updateSuccess: "{tool} updated successfully!",
+  updateFailed: "{tool} update failed",
+  checkFailed: "Version check failed"
+};
+
 const en = {
-  ...common,
-  ...language,
-  ...installation,
-  ...api,
-  ...configuration,
-  ...mcp,
-  ...menu,
-  ...workflow,
-  ...cli,
-  ...bmad,
-  ...errors,
-  ...tools
+  common,
+  language,
+  installation,
+  api,
+  configuration,
+  mcp,
+  menu,
+  workflow,
+  cli,
+  bmad,
+  errors,
+  tools,
+  ccr: ccrMessages,
+  updater
 };
 
-const translations = {
+const I18N$1 = {
   "zh-CN": zhCN,
   en
 };
+function getTranslation(lang) {
+  return I18N$1[lang];
+}
 
 const CLAUDE_DIR = join(homedir(), ".claude");
 const SETTINGS_FILE = join(CLAUDE_DIR, "settings.json");
@@ -692,7 +968,7 @@ const AI_OUTPUT_LANGUAGES = {
   en: { label: "English", directive: "Always respond in English" },
   custom: { label: "Custom", directive: "" }
 };
-const I18N = translations;
+const I18N = I18N$1;
 const MCP_SERVICES = [
   {
     id: "context7",
@@ -763,6 +1039,21 @@ const MCP_SERVICES = [
   }
 ];
 
+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;
+  });
+}
+
 class FileSystemError extends Error {
   constructor(message, path, cause) {
     super(message);
@@ -874,8 +1165,8 @@ function readJsonConfig(path, options = {}) {
     const content = readFile(path);
     const data = JSON.parse(content);
     if (validate && !validate(data)) {
-      const i18n = I18N[readZcfConfig()?.preferredLang || "en"];
-      console.warn(`${i18n.invalidConfiguration} (${path})`);
+      const i18n = getTranslation(readZcfConfig()?.preferredLang || "en");
+      console.warn(`${i18n.configuration.invalidConfiguration} (${path})`);
       return defaultValue;
     }
     if (sanitize) {
@@ -883,8 +1174,8 @@ function readJsonConfig(path, options = {}) {
     }
     return data;
   } catch (error) {
-    const i18n = I18N[readZcfConfig()?.preferredLang || "en"];
-    console.error(`${i18n.failedToParseJson} ${path}`, error);
+    const i18n = getTranslation(readZcfConfig()?.preferredLang || "en");
+    console.error(`${i18n.configuration.failedToParseJson} ${path}`, error);
     return defaultValue;
   }
 }
@@ -909,8 +1200,8 @@ function backupJsonConfig(path, backupDir) {
     copyFile(path, backupPath);
     return backupPath;
   } catch (error) {
-    const i18n = I18N[readZcfConfig()?.preferredLang || "en"];
-    console.error(i18n.failedToBackupConfig, error);
+    const i18n = getTranslation(readZcfConfig()?.preferredLang || "en");
+    console.error(i18n.configuration.failedToBackupConfig, error);
     return null;
   }
 }
@@ -990,23 +1281,23 @@ function getPersonalityInfo(personalityId) {
   return AI_PERSONALITIES.find((p) => p.id === personalityId);
 }
 async function configureAiPersonality(scriptLang, showExisting = true) {
-  const i18n = I18N[scriptLang];
+  const i18n = getTranslation(scriptLang);
   const existingPersonality = getExistingPersonality();
   if (showExisting && existingPersonality) {
     const personalityInfo = getPersonalityInfo(existingPersonality);
     if (personalityInfo) {
-      console.log("\n" + ansis.blue(`\u2139 ${i18n.existingPersonality || "Existing AI personality configuration"}`));
+      console.log("\n" + ansis.blue(`\u2139 ${i18n.configuration.existingPersonality || "Existing AI personality configuration"}`));
       console.log(
-        ansis.gray(`  ${i18n.currentPersonality || "Current personality"}: ${personalityInfo.name[scriptLang]}`)
+        ansis.gray(`  ${i18n.configuration.currentPersonality || "Current personality"}: ${personalityInfo.name[scriptLang]}`)
       );
       const { modify } = await inquirer.prompt({
         type: "confirm",
         name: "modify",
-        message: i18n.modifyPersonality || "Modify AI personality?",
+        message: i18n.configuration.modifyPersonality || "Modify AI personality?",
         default: false
       });
       if (!modify) {
-        console.log(ansis.green(`\u2714 ${i18n.keepPersonality || "Keeping existing personality"}`));
+        console.log(ansis.green(`\u2714 ${i18n.configuration.keepPersonality || "Keeping existing personality"}`));
         return;
       }
     }
@@ -1014,16 +1305,16 @@ async function configureAiPersonality(scriptLang, showExisting = true) {
   const { personality } = await inquirer.prompt({
     type: "list",
     name: "personality",
-    message: i18n.selectAiPersonality || "Select AI personality",
-    choices: AI_PERSONALITIES.map((p) => ({
-      name: p.id !== "custom" ? `${p.name[scriptLang]} - ${ansis.gray(p.directive[scriptLang].substring(0, 50) + "...")}` : `${p.name[scriptLang]} - ${ansis.gray(i18n.customPersonalityHint || "Define your own personality")}`,
+    message: i18n.configuration.selectAiPersonality || "Select AI personality",
+    choices: addNumbersToChoices(AI_PERSONALITIES.map((p) => ({
+      name: p.id !== "custom" ? `${p.name[scriptLang]} - ${ansis.gray(p.directive[scriptLang].substring(0, 50) + "...")}` : `${p.name[scriptLang]} - ${ansis.gray(i18n.configuration.customPersonalityHint || "Define your own personality")}`,
       value: p.id,
       short: p.name[scriptLang]
-    })),
+    }))),
     default: existingPersonality ? AI_PERSONALITIES.findIndex((p) => p.id === existingPersonality) : 0
   });
   if (!personality) {
-    console.log(ansis.yellow(i18n.cancelled));
+    console.log(ansis.yellow(i18n.common.cancelled));
     return;
   }
   let directive = "";
@@ -1031,11 +1322,11 @@ async function configureAiPersonality(scriptLang, showExisting = true) {
     const { customDirective } = await inquirer.prompt({
       type: "input",
       name: "customDirective",
-      message: i18n.enterCustomPersonality || "Enter custom personality directive",
-      validate: (value) => !!value || i18n.directiveCannotBeEmpty
+      message: i18n.configuration.enterCustomPersonality || "Enter custom personality directive",
+      validate: (value) => !!value || i18n.configuration.directiveCannotBeEmpty
     });
     if (!customDirective) {
-      console.log(ansis.yellow(i18n.cancelled));
+      console.log(ansis.yellow(i18n.common.cancelled));
       return;
     }
     directive = customDirective;
@@ -1047,14 +1338,16 @@ async function configureAiPersonality(scriptLang, showExisting = true) {
   }
   await applyPersonalityDirective(directive);
   updateZcfConfig({ aiPersonality: personality });
-  console.log(ansis.green(`\u2714 ${i18n.personalityConfigured || "AI personality configured"}`));
+  console.log(ansis.green(`\u2714 ${i18n.configuration.personalityConfigured || "AI personality configured"}`));
 }
 async function applyPersonalityDirective(directive) {
   try {
     const personalityFile = join(CLAUDE_DIR, "personality.md");
     writeFile(personalityFile, directive);
   } catch (error) {
-    console.error(ansis.red(I18N[readZcfConfig()?.preferredLang || "en"].failedToApplyPersonality), error);
+    const lang = readZcfConfig()?.preferredLang || "en";
+    const errorI18n = getTranslation(lang);
+    console.error(ansis.red(errorI18n.configuration.failedToApplyPersonality || "Failed to apply personality"), error);
   }
 }
 
@@ -1090,9 +1383,9 @@ function handleExitPromptError(error) {
   if (error instanceof Error && error.name === "ExitPromptError") {
     const zcfConfig = readZcfConfig();
     const defaultLang = zcfConfig?.preferredLang || "zh-CN";
-    const i18n = I18N[defaultLang];
+    const i18n = getTranslation(defaultLang);
     console.log(ansis.cyan(`
-${i18n.goodbye}
+${i18n.common.goodbye}
 `));
     process.exit(0);
   }
@@ -1101,7 +1394,8 @@ ${i18n.goodbye}
 function handleGeneralError(error, lang) {
   const zcfConfig = readZcfConfig();
   const defaultLang = lang || zcfConfig?.preferredLang || "en";
-  const errorMsg = I18N[defaultLang].error;
+  const i18n = getTranslation(defaultLang);
+  const errorMsg = i18n.common.error || "Error";
   console.error(ansis.red(`${errorMsg}:`), error);
   if (error instanceof Error) {
     console.error(ansis.gray(`Stack: ${error.stack}`));
@@ -1200,6 +1494,142 @@ function mergeAndCleanPermissions(templatePermissions, userPermissions) {
   return cleanupPermissions(template, user);
 }
 
+function getPlatform() {
+  const p = platform();
+  if (p === "win32") return "windows";
+  if (p === "darwin") return "macos";
+  return "linux";
+}
+function isTermux() {
+  return !!(process.env.PREFIX && process.env.PREFIX.includes("com.termux")) || !!process.env.TERMUX_VERSION || existsSync("/data/data/com.termux/files/usr");
+}
+function getTermuxPrefix() {
+  return process.env.PREFIX || "/data/data/com.termux/files/usr";
+}
+function isWindows() {
+  return getPlatform() === "windows";
+}
+function getMcpCommand() {
+  if (isWindows()) {
+    return ["cmd", "/c", "npx"];
+  }
+  return ["npx"];
+}
+async function commandExists(command) {
+  try {
+    const cmd = getPlatform() === "windows" ? "where" : "which";
+    const res = await exec(cmd, [command]);
+    if (res.exitCode === 0) {
+      return true;
+    }
+  } catch {
+  }
+  if (isTermux()) {
+    const termuxPrefix = getTermuxPrefix();
+    const possiblePaths = [
+      `${termuxPrefix}/bin/${command}`,
+      `${termuxPrefix}/usr/bin/${command}`,
+      `/data/data/com.termux/files/usr/bin/${command}`
+    ];
+    for (const path of possiblePaths) {
+      if (existsSync(path)) {
+        return true;
+      }
+    }
+  }
+  if (getPlatform() !== "windows") {
+    const commonPaths = [
+      `/usr/local/bin/${command}`,
+      `/usr/bin/${command}`,
+      `/bin/${command}`,
+      `${process.env.HOME}/.local/bin/${command}`
+    ];
+    for (const path of commonPaths) {
+      if (existsSync(path)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+function getMcpConfigPath() {
+  return ClAUDE_CONFIG_FILE;
+}
+function readMcpConfig() {
+  return readJsonConfig(ClAUDE_CONFIG_FILE);
+}
+function writeMcpConfig(config) {
+  writeJsonConfig(ClAUDE_CONFIG_FILE, config);
+}
+function backupMcpConfig() {
+  const backupBaseDir = join(CLAUDE_DIR, "backup");
+  return backupJsonConfig(ClAUDE_CONFIG_FILE, backupBaseDir);
+}
+function mergeMcpServers(existing, newServers) {
+  const config = existing || { mcpServers: {} };
+  if (!config.mcpServers) {
+    config.mcpServers = {};
+  }
+  Object.assign(config.mcpServers, newServers);
+  return config;
+}
+function applyPlatformCommand(config) {
+  if (config.command === "npx" && isWindows()) {
+    const mcpCmd = getMcpCommand();
+    config.command = mcpCmd[0];
+    config.args = [...mcpCmd.slice(1), ...config.args || []];
+  }
+}
+function buildMcpServerConfig(baseConfig, apiKey, placeholder = "YOUR_EXA_API_KEY", envVarName) {
+  const config = deepClone(baseConfig);
+  applyPlatformCommand(config);
+  if (!apiKey) {
+    return config;
+  }
+  if (envVarName && config.env) {
+    config.env[envVarName] = apiKey;
+    return config;
+  }
+  if (config.args) {
+    config.args = config.args.map((arg) => arg.replace(placeholder, apiKey));
+  }
+  if (config.url) {
+    config.url = config.url.replace(placeholder, apiKey);
+  }
+  return config;
+}
+function fixWindowsMcpConfig(config) {
+  if (!isWindows() || !config.mcpServers) {
+    return config;
+  }
+  const fixed = { ...config };
+  for (const [, serverConfig] of Object.entries(fixed.mcpServers)) {
+    if (serverConfig && typeof serverConfig === "object" && "command" in serverConfig) {
+      applyPlatformCommand(serverConfig);
+    }
+  }
+  return fixed;
+}
+function addCompletedOnboarding() {
+  try {
+    let config = readMcpConfig();
+    if (!config) {
+      config = { mcpServers: {} };
+    }
+    if (config.hasCompletedOnboarding === true) {
+      return;
+    }
+    config.hasCompletedOnboarding = true;
+    writeMcpConfig(config);
+  } catch (error) {
+    const lang = readZcfConfig()?.preferredLang || "en";
+    const i18n = getTranslation(lang);
+    console.error(i18n.configuration?.failedToAddOnboardingFlag || "Failed to add onboarding flag", error);
+    throw error;
+  }
+}
+
 function ensureClaudeDir() {
   ensureDir(CLAUDE_DIR);
 }
@@ -1239,8 +1669,8 @@ function copyConfigFiles(lang, onlyMd = false) {
 function copyClaudeMemoryFiles(lang, rootDir) {
   const memorySourceDir = join(rootDir, "templates", lang, "memory");
   if (!exists(memorySourceDir)) {
-    const i18n = I18N[lang];
-    throw new Error(`${i18n.memoryDirNotFound || "Memory directory not found:"} ${memorySourceDir}`);
+    const i18n = getTranslation(lang);
+    throw new Error(`${i18n.configuration.memoryDirNotFound || "Memory directory not found:"} ${memorySourceDir}`);
   }
   const files = readDir(memorySourceDir);
   files?.forEach((file) => {
@@ -1259,7 +1689,9 @@ function getDefaultSettings() {
     const templateSettingsPath = join(rootDir, "templates", "settings.json");
     return readJsonConfig(templateSettingsPath) || {};
   } catch (error) {
-    console.error(I18N[readZcfConfig()?.preferredLang || "en"].failedToReadTemplateSettings, error);
+    const lang = readZcfConfig()?.preferredLang || "en";
+    const i18n = getTranslation(lang);
+    console.error(i18n.configuration.failedToReadTemplateSettings || "Failed to read template settings", error);
     return {};
   }
 }
@@ -1284,6 +1716,13 @@ function configureApi(apiConfig) {
     settings.env.ANTHROPIC_BASE_URL = apiConfig.url;
   }
   writeJsonConfig(SETTINGS_FILE, settings);
+  try {
+    addCompletedOnboarding();
+  } catch (error) {
+    const lang = readZcfConfig()?.preferredLang || "en";
+    const i18n = getTranslation(lang);
+    console.error(i18n.configuration.failedToSetOnboarding || "Failed to set onboarding flag", error);
+  }
   return apiConfig;
 }
 function mergeConfigs(sourceFile, targetFile) {
@@ -1299,14 +1738,20 @@ function updateDefaultModel(model) {
   if (existingSettings) {
     settings = existingSettings;
   }
-  settings.model = model;
+  if (model === "default") {
+    delete settings.model;
+  } else {
+    settings.model = model;
+  }
   writeJsonConfig(SETTINGS_FILE, settings);
 }
 function mergeSettingsFile(templatePath, targetPath) {
   try {
     const templateSettings = readJsonConfig(templatePath);
     if (!templateSettings) {
-      console.error(I18N[readZcfConfig()?.preferredLang || "en"].failedToReadTemplateSettings);
+      const lang = readZcfConfig()?.preferredLang || "en";
+      const i18n = getTranslation(lang);
+      console.error(i18n.configuration?.failedToReadTemplateSettings || "Failed to read template settings");
       return;
     }
     if (!exists(targetPath)) {
@@ -1333,14 +1778,28 @@ function mergeSettingsFile(templatePath, targetPath) {
     }
     writeJsonConfig(targetPath, mergedSettings);
   } catch (error) {
-    console.error(I18N[readZcfConfig()?.preferredLang || "en"].failedToMergeSettings, error);
+    const lang = readZcfConfig()?.preferredLang || "en";
+    const i18n = getTranslation(lang);
+    console.error(i18n.configuration.failedToMergeSettings || "Failed to merge settings", error);
     if (exists(targetPath)) {
-      console.error(I18N[readZcfConfig()?.preferredLang || "en"].preservingExistingSettings);
+      const lang2 = readZcfConfig()?.preferredLang || "en";
+      const i18n2 = getTranslation(lang2);
+      console.warn(i18n2.configuration.preservingExistingSettings || "Preserving existing settings");
     } else {
       copyFile(templatePath, targetPath);
     }
   }
 }
+function getExistingModelConfig() {
+  const settings = readJsonConfig(SETTINGS_FILE);
+  if (!settings) {
+    return null;
+  }
+  if (!settings.model) {
+    return "default";
+  }
+  return settings.model;
+}
 function getExistingApiConfig() {
   const settings = readJsonConfig(SETTINGS_FILE);
   if (!settings || !settings.env) {
@@ -1379,11 +1838,11 @@ function applyAiLanguageDirective(aiOutputLang) {
 }
 
 function validateApiKey(apiKey, lang = "zh-CN") {
-  const i18n = I18N[lang];
+  const i18n = getTranslation(lang);
   if (!apiKey || apiKey.trim() === "") {
     return {
       isValid: false,
-      error: i18n.apiKeyValidation.empty
+      error: i18n.api.apiKeyValidation.empty
     };
   }
   return { isValid: true };
@@ -1401,22 +1860,22 @@ async function configureApiCompletely(i18n, scriptLang, preselectedAuthType) {
     const { authType: selectedAuthType } = await inquirer.prompt({
       type: "list",
       name: "authType",
-      message: i18n.configureApi,
-      choices: [
+      message: i18n.api.configureApi,
+      choices: addNumbersToChoices([
         {
-          name: `${i18n.useAuthToken} - ${ansis.gray(i18n.authTokenDesc)}`,
+          name: `${i18n.api.useAuthToken} - ${ansis.gray(i18n.api.authTokenDesc)}`,
           value: "auth_token",
-          short: i18n.useAuthToken
+          short: i18n.api.useAuthToken
         },
         {
-          name: `${i18n.useApiKey} - ${ansis.gray(i18n.apiKeyDesc)}`,
+          name: `${i18n.api.useApiKey} - ${ansis.gray(i18n.api.apiKeyDesc)}`,
           value: "api_key",
-          short: i18n.useApiKey
+          short: i18n.api.useApiKey
         }
-      ]
+      ])
     });
     if (!selectedAuthType) {
-      console.log(ansis.yellow(i18n.cancelled));
+      console.log(ansis.yellow(i18n.common.cancelled));
       return null;
     }
     authType = selectedAuthType;
@@ -1424,39 +1883,39 @@ async function configureApiCompletely(i18n, scriptLang, preselectedAuthType) {
   const { url } = await inquirer.prompt({
     type: "input",
     name: "url",
-    message: i18n.enterApiUrl,
+    message: i18n.api.enterApiUrl,
     validate: (value) => {
-      if (!value) return i18n.urlRequired;
+      if (!value) return i18n.api.urlRequired;
       try {
         new URL(value);
         return true;
       } catch {
-        return i18n.invalidUrl;
+        return i18n.api.invalidUrl;
       }
     }
   });
   if (url === void 0) {
-    console.log(ansis.yellow(i18n.cancelled));
+    console.log(ansis.yellow(i18n.common.cancelled));
     return null;
   }
-  const keyMessage = authType === "auth_token" ? i18n.enterAuthToken : i18n.enterApiKey;
+  const keyMessage = authType === "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.keyRequired;
+        return i18n.api.keyRequired;
       }
       const validation = validateApiKey(value, scriptLang);
       if (!validation.isValid) {
-        return validation.error || i18n.invalidKeyFormat;
+        return validation.error || i18n.api.invalidKeyFormat;
       }
       return true;
     }
   });
   if (key === void 0) {
-    console.log(ansis.yellow(i18n.cancelled));
+    console.log(ansis.yellow(i18n.common.cancelled));
     return null;
   }
   console.log(ansis.gray(`  API Key: ${formatApiKeyDisplay(key)}`));
@@ -1471,276 +1930,356 @@ async function modifyApiConfigPartially(existingConfig, i18n, scriptLang) {
   const { item } = await inquirer.prompt({
     type: "list",
     name: "item",
-    message: i18n.selectModifyItems,
-    choices: [
-      { name: i18n.modifyApiUrl, value: "url" },
-      { name: i18n.modifyApiKey, value: "key" },
-      { name: i18n.modifyAuthType, value: "authType" }
-    ]
+    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.cancelled));
+    console.log(ansis.yellow(i18n.common.cancelled));
     return;
   }
   if (item === "url") {
     const { url } = await inquirer.prompt({
       type: "input",
       name: "url",
-      message: i18n.enterNewApiUrl.replace("{url}", currentConfig.url || i18n.none),
+      message: i18n.api.enterNewApiUrl.replace("{url}", currentConfig.url || i18n.common.none),
       default: currentConfig.url,
       validate: (value) => {
-        if (!value) return i18n.urlRequired;
+        if (!value) return i18n.api.urlRequired;
         try {
           new URL(value);
           return true;
         } catch {
-          return i18n.invalidUrl;
+          return i18n.api.invalidUrl;
         }
       }
     });
     if (url === void 0) {
-      console.log(ansis.yellow(i18n.cancelled));
+      console.log(ansis.yellow(i18n.common.cancelled));
       return;
     }
     currentConfig.url = url;
     const savedConfig = configureApi(currentConfig);
     if (savedConfig) {
-      console.log(ansis.green(`\u2714 ${i18n.modificationSaved}`));
-      console.log(ansis.gray(`  ${i18n.apiConfigUrl}: ${savedConfig.url}`));
+      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.enterNewApiKey.replace("{key}", currentConfig.key ? formatApiKeyDisplay(currentConfig.key) : i18n.none) : i18n.enterNewApiKey.replace("{key}", currentConfig.key ? formatApiKeyDisplay(currentConfig.key) : i18n.none);
+    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.keyRequired;
+          return i18n.api.keyRequired;
         }
         const validation = validateApiKey(value, scriptLang);
         if (!validation.isValid) {
-          return validation.error || i18n.invalidKeyFormat;
+          return validation.error || i18n.api.invalidKeyFormat;
         }
         return true;
       }
     });
     if (key === void 0) {
-      console.log(ansis.yellow(i18n.cancelled));
+      console.log(ansis.yellow(i18n.common.cancelled));
       return;
     }
     currentConfig.key = key;
     const savedConfig = configureApi(currentConfig);
     if (savedConfig) {
-      console.log(ansis.green(`\u2714 ${i18n.modificationSaved}`));
-      console.log(ansis.gray(`  ${i18n.apiConfigKey}: ${formatApiKeyDisplay(savedConfig.key)}`));
+      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.selectNewAuthType.replace("{type}", currentConfig.authType || i18n.none),
-      choices: [
+      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.cancelled));
+      console.log(ansis.yellow(i18n.common.cancelled));
       return;
     }
     currentConfig.authType = authType;
     const savedConfig = configureApi(currentConfig);
     if (savedConfig) {
-      console.log(ansis.green(`\u2714 ${i18n.modificationSaved}`));
-      console.log(ansis.gray(`  ${i18n.apiConfigAuthType}: ${savedConfig.authType}`));
+      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 = I18N[scriptLang];
+  const i18n = getTranslation(scriptLang);
   const backupDir = backupExistingConfig();
   if (backupDir) {
-    console.log(ansis.gray(`\u2714 ${i18n.backupSuccess}: ${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.configSuccess} ${CLAUDE_DIR}`));
-  console.log("\n" + ansis.cyan(i18n.complete));
+  console.log(ansis.green(`\u2714 ${i18n.configuration.configSuccess} ${CLAUDE_DIR}`));
+  console.log("\n" + ansis.cyan(i18n.common.complete));
 }
 
-function getPlatform() {
-  const p = platform();
-  if (p === "win32") return "windows";
-  if (p === "darwin") return "macos";
-  return "linux";
+function format(template, replacements) {
+  return template.replace(/\{(\w+)\}/g, (match, key) => {
+    return replacements[key] || match;
+  });
 }
-function isTermux() {
-  return !!(process.env.PREFIX && process.env.PREFIX.includes("com.termux")) || !!process.env.TERMUX_VERSION || existsSync("/data/data/com.termux/files/usr");
+
+const execAsync$3 = promisify(exec$1);
+const CACHE_DIR = join$1(homedir$1(), ".claude", "cache");
+const CACHE_FILE = join$1(CACHE_DIR, "version-cache.json");
+const CACHE_DURATION = 24 * 60 * 60 * 1e3;
+async function ensureCacheDir() {
+  try {
+    await mkdir(CACHE_DIR, { recursive: true });
+  } catch (error) {
+  }
 }
-function getTermuxPrefix() {
-  return process.env.PREFIX || "/data/data/com.termux/files/usr";
+async function readCache() {
+  try {
+    const content = await readFile$1(CACHE_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
 }
-function isWindows() {
-  return getPlatform() === "windows";
+async function writeCache(cache) {
+  await ensureCacheDir();
+  await writeFile$1(CACHE_FILE, JSON.stringify(cache, null, 2));
 }
-function getMcpCommand() {
-  if (isWindows()) {
-    return ["cmd", "/c", "npx"];
+async function getInstalledVersion(command) {
+  try {
+    let stdout;
+    try {
+      const result = await execAsync$3(`${command} -v`);
+      stdout = result.stdout;
+    } catch {
+      const result = await execAsync$3(`${command} --version`);
+      stdout = result.stdout;
+    }
+    const versionMatch = stdout.match(/(\d+\.\d+\.\d+(?:-[\w.]+)?)/);
+    return versionMatch ? versionMatch[1] : null;
+  } catch {
+    return null;
   }
-  return ["npx"];
 }
-async function commandExists(command) {
-  try {
-    const cmd = getPlatform() === "windows" ? "where" : "which";
-    const res = await exec(cmd, [command]);
-    if (res.exitCode === 0) {
-      return true;
+async function getLatestVersion(packageName, useCache = true) {
+  if (useCache) {
+    const cache = await readCache();
+    const cached = cache[packageName];
+    if (cached && Date.now() - cached.checkedAt < CACHE_DURATION) {
+      return cached.version;
     }
+  }
+  try {
+    const { stdout } = await execAsync$3(`npm view ${packageName} version`);
+    const version = stdout.trim();
+    const cache = await readCache();
+    cache[packageName] = {
+      version,
+      checkedAt: Date.now()
+    };
+    await writeCache(cache);
+    return version;
   } catch {
+    return null;
   }
-  if (isTermux()) {
-    const termuxPrefix = getTermuxPrefix();
-    const possiblePaths = [
-      `${termuxPrefix}/bin/${command}`,
-      `${termuxPrefix}/usr/bin/${command}`,
-      `/data/data/com.termux/files/usr/bin/${command}`
-    ];
-    for (const path of possiblePaths) {
-      if (existsSync(path)) {
-        return true;
+}
+function compareVersions(current, latest) {
+  if (!semver.valid(current) || !semver.valid(latest)) {
+    return -1;
+  }
+  return semver.compare(current, latest);
+}
+function shouldUpdate(current, latest) {
+  return compareVersions(current, latest) < 0;
+}
+async function checkCcrVersion() {
+  const currentVersion = await getInstalledVersion("ccr");
+  let latestVersion = await getLatestVersion("@musistudio/claude-code-router");
+  if (!latestVersion) {
+    latestVersion = await getLatestVersion("claude-code-router");
+  }
+  return {
+    installed: currentVersion !== null,
+    currentVersion,
+    latestVersion,
+    needsUpdate: currentVersion && latestVersion ? shouldUpdate(currentVersion, latestVersion) : false
+  };
+}
+async function checkClaudeCodeVersion() {
+  const currentVersion = await getInstalledVersion("claude");
+  const latestVersion = await getLatestVersion("@anthropic-ai/claude-code");
+  return {
+    installed: currentVersion !== null,
+    currentVersion,
+    latestVersion,
+    needsUpdate: currentVersion && latestVersion ? shouldUpdate(currentVersion, latestVersion) : false
+  };
+}
+
+const execAsync$2 = promisify(exec$1);
+async function updateCcr(scriptLang, force = false) {
+  const i18n = getTranslation(scriptLang);
+  const spinner = ora(i18n.updater.checkingVersion).start();
+  try {
+    const { installed, currentVersion, latestVersion, needsUpdate } = await checkCcrVersion();
+    spinner.stop();
+    if (!installed) {
+      console.log(ansis.yellow(i18n.updater.ccrNotInstalled));
+      return false;
+    }
+    if (!needsUpdate && !force) {
+      console.log(ansis.green(format(i18n.updater.ccrUpToDate, { version: currentVersion || "" })));
+      return true;
+    }
+    if (!latestVersion) {
+      console.log(ansis.yellow(i18n.updater.cannotCheckVersion));
+      return false;
+    }
+    console.log(ansis.cyan(format(i18n.updater.currentVersion, { version: currentVersion || "" })));
+    console.log(ansis.cyan(format(i18n.updater.latestVersion, { version: latestVersion })));
+    const { confirm } = await prompts$1({
+      type: "confirm",
+      name: "confirm",
+      message: format(i18n.updater.confirmUpdate, { tool: "CCR" }),
+      initial: true
+    });
+    if (!confirm) {
+      console.log(ansis.gray(i18n.updater.updateSkipped));
+      return true;
+    }
+    const updateSpinner = ora(format(i18n.updater.updating, { tool: "CCR" })).start();
+    try {
+      try {
+        await execAsync$2("npm update -g @musistudio/claude-code-router");
+      } catch {
+        await execAsync$2("npm update -g claude-code-router");
       }
+      updateSpinner.succeed(format(i18n.updater.updateSuccess, { tool: "CCR" }));
+      return true;
+    } catch (error) {
+      updateSpinner.fail(format(i18n.updater.updateFailed, { tool: "CCR" }));
+      console.error(ansis.red(error instanceof Error ? error.message : String(error)));
+      return false;
     }
+  } catch (error) {
+    spinner.fail(i18n.updater.checkFailed);
+    console.error(ansis.red(error instanceof Error ? error.message : String(error)));
+    return false;
   }
-  if (getPlatform() !== "windows") {
-    const commonPaths = [
-      `/usr/local/bin/${command}`,
-      `/usr/bin/${command}`,
-      `/bin/${command}`,
-      `${process.env.HOME}/.local/bin/${command}`
-    ];
-    for (const path of commonPaths) {
-      if (existsSync(path)) {
-        return true;
-      }
+}
+async function updateClaudeCode(scriptLang, force = false) {
+  const i18n = getTranslation(scriptLang);
+  const spinner = ora(i18n.updater.checkingVersion).start();
+  try {
+    const { installed, currentVersion, latestVersion, needsUpdate } = await checkClaudeCodeVersion();
+    spinner.stop();
+    if (!installed) {
+      console.log(ansis.yellow(i18n.updater.claudeCodeNotInstalled));
+      return false;
+    }
+    if (!needsUpdate && !force) {
+      console.log(ansis.green(format(i18n.updater.claudeCodeUpToDate, { version: currentVersion || "" })));
+      return true;
+    }
+    if (!latestVersion) {
+      console.log(ansis.yellow(i18n.updater.cannotCheckVersion));
+      return false;
+    }
+    console.log(ansis.cyan(format(i18n.updater.currentVersion, { version: currentVersion || "" })));
+    console.log(ansis.cyan(format(i18n.updater.latestVersion, { version: latestVersion })));
+    const { confirm } = await prompts$1({
+      type: "confirm",
+      name: "confirm",
+      message: format(i18n.updater.confirmUpdate, { tool: "Claude Code" }),
+      initial: true
+    });
+    if (!confirm) {
+      console.log(ansis.gray(i18n.updater.updateSkipped));
+      return true;
     }
+    const updateSpinner = ora(format(i18n.updater.updating, { tool: "Claude Code" })).start();
+    try {
+      await execAsync$2("npm update -g @anthropic-ai/claude-code");
+      updateSpinner.succeed(format(i18n.updater.updateSuccess, { tool: "Claude Code" }));
+      return true;
+    } catch (error) {
+      updateSpinner.fail(format(i18n.updater.updateFailed, { tool: "Claude Code" }));
+      console.error(ansis.red(error instanceof Error ? error.message : String(error)));
+      return false;
+    }
+  } catch (error) {
+    spinner.fail(i18n.updater.checkFailed);
+    console.error(ansis.red(error instanceof Error ? error.message : String(error)));
+    return false;
   }
-  return false;
+}
+async function checkAndUpdateTools(scriptLang) {
+  const i18n = getTranslation(scriptLang);
+  console.log(ansis.bold.cyan(`
+\u{1F50D} ${i18n.updater.checkingTools}
+`));
+  await updateCcr(scriptLang);
+  console.log();
+  await updateClaudeCode(scriptLang);
 }
 
 async function isClaudeCodeInstalled() {
   return await commandExists("claude");
 }
 async function installClaudeCode(lang) {
-  const i18n = I18N[lang];
+  const i18n = getTranslation(lang);
+  const installed = await isClaudeCodeInstalled();
+  if (installed) {
+    console.log(ansis.green(`\u2714 ${i18n.installation.alreadyInstalled}`));
+    await updateClaudeCode(lang);
+    return;
+  }
   if (isTermux()) {
-    console.log(ansis.yellow(`\u2139 ${i18n.termuxDetected}`));
+    console.log(ansis.yellow(`\u2139 ${i18n.installation.termuxDetected}`));
     const termuxPrefix = getTermuxPrefix();
-    console.log(ansis.gray(i18n.termuxPathInfo.replace("{path}", termuxPrefix)));
+    console.log(ansis.gray(i18n.installation.termuxPathInfo.replace("{path}", termuxPrefix)));
     console.log(ansis.gray(`Node.js: ${termuxPrefix}/bin/node`));
     console.log(ansis.gray(`npm: ${termuxPrefix}/bin/npm`));
   }
-  console.log(i18n.installing);
+  console.log(i18n.installation.installing);
   try {
     await exec("npm", ["install", "-g", "@anthropic-ai/claude-code"]);
-    console.log(`\u2714 ${i18n.installSuccess}`);
+    console.log(`\u2714 ${i18n.installation.installSuccess}`);
     if (isTermux()) {
       console.log(ansis.gray(`
 Claude Code installed to: ${getTermuxPrefix()}/bin/claude`));
     }
   } catch (error) {
-    console.error(`\u2716 ${i18n.installFailed}`);
+    console.error(`\u2716 ${i18n.installation.installFailed}`);
     if (isTermux()) {
       console.error(ansis.yellow(`
-${i18n.termuxInstallHint}
+${i18n.installation.termuxInstallHint}
 `));
     }
     throw error;
   }
 }
 
-function getMcpConfigPath() {
-  return ClAUDE_CONFIG_FILE;
-}
-function readMcpConfig() {
-  return readJsonConfig(ClAUDE_CONFIG_FILE);
-}
-function writeMcpConfig(config) {
-  writeJsonConfig(ClAUDE_CONFIG_FILE, config);
-}
-function backupMcpConfig() {
-  const backupBaseDir = join(CLAUDE_DIR, "backup");
-  return backupJsonConfig(ClAUDE_CONFIG_FILE, backupBaseDir);
-}
-function mergeMcpServers(existing, newServers) {
-  const config = existing || { mcpServers: {} };
-  if (!config.mcpServers) {
-    config.mcpServers = {};
-  }
-  Object.assign(config.mcpServers, newServers);
-  return config;
-}
-function applyPlatformCommand(config) {
-  if (config.command === "npx" && isWindows()) {
-    const mcpCmd = getMcpCommand();
-    config.command = mcpCmd[0];
-    config.args = [...mcpCmd.slice(1), ...config.args || []];
-  }
-}
-function buildMcpServerConfig(baseConfig, apiKey, placeholder = "YOUR_EXA_API_KEY", envVarName) {
-  const config = deepClone(baseConfig);
-  applyPlatformCommand(config);
-  if (!apiKey) {
-    return config;
-  }
-  if (envVarName && config.env) {
-    config.env[envVarName] = apiKey;
-    return config;
-  }
-  if (config.args) {
-    config.args = config.args.map((arg) => arg.replace(placeholder, apiKey));
-  }
-  if (config.url) {
-    config.url = config.url.replace(placeholder, apiKey);
-  }
-  return config;
-}
-function fixWindowsMcpConfig(config) {
-  if (!isWindows() || !config.mcpServers) {
-    return config;
-  }
-  const fixed = { ...config };
-  for (const [, serverConfig] of Object.entries(fixed.mcpServers)) {
-    if (serverConfig && typeof serverConfig === "object" && "command" in serverConfig) {
-      applyPlatformCommand(serverConfig);
-    }
-  }
-  return fixed;
-}
-function addCompletedOnboarding() {
-  try {
-    let config = readMcpConfig();
-    if (!config) {
-      config = { mcpServers: {} };
-    }
-    config.hasCompletedOnboarding = true;
-    config = fixWindowsMcpConfig(config);
-    writeMcpConfig(config);
-  } catch (error) {
-    console.error(I18N[readZcfConfig()?.preferredLang || "en"].failedToAddOnboardingFlag, error);
-    throw error;
-  }
-}
-
 async function selectAiOutputLanguage(scriptLang, defaultLang) {
-  const i18n = I18N[scriptLang];
+  const i18n = getTranslation(scriptLang);
   console.log(ansis.dim(`
-  ${i18n.aiOutputLangHint}
+  ${i18n.language.aiOutputLangHint}
 `));
   const aiLangChoices = Object.entries(AI_OUTPUT_LANGUAGES).map(([key, value]) => ({
     title: value.label,
@@ -1750,15 +2289,15 @@ async function selectAiOutputLanguage(scriptLang, defaultLang) {
   const { lang } = await inquirer.prompt({
     type: "list",
     name: "lang",
-    message: i18n.selectAiOutputLang,
-    choices: aiLangChoices.map((choice) => ({
+    message: i18n.language.selectAiOutputLang,
+    choices: addNumbersToChoices(aiLangChoices.map((choice) => ({
       name: choice.title,
       value: choice.value
-    })),
+    }))),
     default: defaultChoice
   });
   if (!lang) {
-    console.log(ansis.yellow(i18n.cancelled));
+    console.log(ansis.yellow(i18n.common.cancelled));
     process.exit(0);
   }
   let aiOutputLang = lang;
@@ -1766,11 +2305,11 @@ async function selectAiOutputLanguage(scriptLang, defaultLang) {
     const { customLang } = await inquirer.prompt({
       type: "input",
       name: "customLang",
-      message: i18n.enterCustomLanguage,
-      validate: (value) => !!value || i18n.languageRequired
+      message: i18n.language.enterCustomLanguage,
+      validate: (value) => !!value || i18n.language?.languageRequired || "Language is required"
     });
     if (!customLang) {
-      console.log(ansis.yellow(i18n.cancelled));
+      console.log(ansis.yellow(i18n.common.cancelled));
       process.exit(0);
     }
     return customLang;
@@ -1789,10 +2328,10 @@ async function selectScriptLanguage(currentLang) {
     type: "list",
     name: "lang",
     message: "Select ZCF display language / \u9009\u62E9ZCF\u663E\u793A\u8BED\u8A00",
-    choices: SUPPORTED_LANGS.map((l) => ({
+    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"));
@@ -1806,19 +2345,26 @@ async function selectScriptLanguage(currentLang) {
   return scriptLang;
 }
 async function resolveAiOutputLanguage(scriptLang, commandLineOption, savedConfig) {
-  const i18n = I18N[scriptLang];
+  const i18n = getTranslation(scriptLang);
   if (commandLineOption) {
     return commandLineOption;
   }
   if (savedConfig?.aiOutputLang) {
-    console.log(ansis.gray(`\u2714 ${i18n.aiOutputLangHint}: ${savedConfig.aiOutputLang}`));
+    console.log(ansis.gray(`\u2714 ${i18n.language.aiOutputLangHint}: ${savedConfig.aiOutputLang}`));
     return savedConfig.aiOutputLang;
   }
   return await selectAiOutputLanguage(scriptLang, scriptLang);
 }
 
+const prompts = {
+  __proto__: null,
+  resolveAiOutputLanguage: resolveAiOutputLanguage,
+  selectAiOutputLanguage: selectAiOutputLanguage,
+  selectScriptLanguage: selectScriptLanguage
+};
+
 async function selectMcpServices(scriptLang) {
-  const i18n = I18N[scriptLang];
+  const i18n = getTranslation(scriptLang);
   const choices = MCP_SERVICES.map((service) => ({
     name: `${service.name[scriptLang]} - ${ansis.gray(service.description[scriptLang])}`,
     value: service.id,
@@ -1827,11 +2373,11 @@ async function selectMcpServices(scriptLang) {
   const { services } = await inquirer.prompt({
     type: "checkbox",
     name: "services",
-    message: `${i18n.selectMcpServices}${i18n.multiSelectHint}`,
+    message: `${i18n.mcp.selectMcpServices}${i18n.common.multiSelectHint}`,
     choices
   });
   if (services === void 0) {
-    console.log(ansis.yellow(i18n.cancelled));
+    console.log(ansis.yellow(i18n.common.cancelled));
     return void 0;
   }
   return services;
@@ -1891,11 +2437,11 @@ function getRootDir() {
   return dirname(distDir);
 }
 async function selectAndInstallWorkflows(configLang, scriptLang) {
-  const i18n = I18N[scriptLang];
+  const i18n = getTranslation(scriptLang);
   const workflows = getOrderedWorkflows();
   const choices = workflows.map((workflow) => {
     const nameKey = workflow.id;
-    const name = i18n.workflowOption[nameKey] || workflow.id;
+    const name = i18n.workflow.workflowOption[nameKey] || workflow.id;
     return {
       name,
       value: workflow.id,
@@ -1905,11 +2451,11 @@ async function selectAndInstallWorkflows(configLang, scriptLang) {
   const { selectedWorkflows } = await inquirer.prompt({
     type: "checkbox",
     name: "selectedWorkflows",
-    message: `${i18n.selectWorkflowType}${i18n.multiSelectHint}`,
+    message: `${i18n.workflow.selectWorkflowType}${i18n.common.multiSelectHint}`,
     choices
   });
   if (!selectedWorkflows || selectedWorkflows.length === 0) {
-    console.log(ansis.yellow(i18n.cancelled));
+    console.log(ansis.yellow(i18n.common.cancelled));
     return;
   }
   await cleanupOldVersionFiles(scriptLang);
@@ -1922,7 +2468,7 @@ async function selectAndInstallWorkflows(configLang, scriptLang) {
 }
 async function installWorkflowWithDependencies(config, configLang, scriptLang) {
   const rootDir = getRootDir();
-  const i18n = I18N[scriptLang];
+  const i18n = getTranslation(scriptLang);
   const result = {
     workflow: config.id,
     success: true,
@@ -1930,12 +2476,12 @@ async function installWorkflowWithDependencies(config, configLang, scriptLang) {
     installedAgents: [],
     errors: []
   };
-  const workflowName = i18n.workflowOption[config.id] || config.id;
+  const workflowName = i18n.workflow.workflowOption[config.id] || config.id;
   console.log(ansis.cyan(`
-\u{1F4E6} ${i18n.installingWorkflow}: ${workflowName}...`));
+\u{1F4E6} ${i18n.workflow.installingWorkflow}: ${workflowName}...`));
   const commandsDir = join(CLAUDE_DIR, "commands", "zcf");
   if (!existsSync(commandsDir)) {
-    await mkdir(commandsDir, { recursive: true });
+    await mkdir$1(commandsDir, { recursive: true });
   }
   for (const commandFile of config.commands) {
     const commandSource = join(rootDir, "templates", configLang, "workflow", config.category, "commands", commandFile);
@@ -1945,9 +2491,9 @@ async function installWorkflowWithDependencies(config, configLang, scriptLang) {
       try {
         await copyFile$1(commandSource, commandDest);
         result.installedCommands.push(destFileName);
-        console.log(ansis.gray(`  \u2714 ${i18n.installedCommand}: zcf/${destFileName}`));
+        console.log(ansis.gray(`  \u2714 ${i18n.workflow.installedCommand}: zcf/${destFileName}`));
       } catch (error) {
-        const errorMsg = `${i18n.failedToInstallCommand} ${commandFile}: ${error}`;
+        const errorMsg = `${i18n.workflow.failedToInstallCommand} ${commandFile}: ${error}`;
         result.errors?.push(errorMsg);
         console.error(ansis.red(`  \u2717 ${errorMsg}`));
         result.success = false;
@@ -1957,7 +2503,7 @@ async function installWorkflowWithDependencies(config, configLang, scriptLang) {
   if (config.autoInstallAgents && config.agents.length > 0) {
     const agentsCategoryDir = join(CLAUDE_DIR, "agents", "zcf", config.category);
     if (!existsSync(agentsCategoryDir)) {
-      await mkdir(agentsCategoryDir, { recursive: true });
+      await mkdir$1(agentsCategoryDir, { recursive: true });
     }
     for (const agent of config.agents) {
       const agentSource = join(rootDir, "templates", configLang, "workflow", config.category, "agents", agent.filename);
@@ -1966,9 +2512,9 @@ async function installWorkflowWithDependencies(config, configLang, scriptLang) {
         try {
           await copyFile$1(agentSource, agentDest);
           result.installedAgents.push(agent.filename);
-          console.log(ansis.gray(`  \u2714 ${i18n.installedAgent}: zcf/${config.category}/${agent.filename}`));
+          console.log(ansis.gray(`  \u2714 ${i18n.workflow.installedAgent}: zcf/${config.category}/${agent.filename}`));
         } catch (error) {
-          const errorMsg = `${i18n.failedToInstallAgent} ${agent.filename}: ${error}`;
+          const errorMsg = `${i18n.workflow.failedToInstallAgent} ${agent.filename}: ${error}`;
           result.errors?.push(errorMsg);
           console.error(ansis.red(`  \u2717 ${errorMsg}`));
           if (agent.required) {
@@ -1979,20 +2525,20 @@ async function installWorkflowWithDependencies(config, configLang, scriptLang) {
     }
   }
   if (result.success) {
-    console.log(ansis.green(`\u2714 ${workflowName} ${i18n.workflowInstallSuccess}`));
+    console.log(ansis.green(`\u2714 ${workflowName} ${i18n.workflow.workflowInstallSuccess}`));
     if (config.id === "bmadWorkflow") {
       console.log(ansis.cyan(`
-${i18n.bmadInitPrompt}`));
+${i18n.bmad.bmadInitPrompt}`));
     }
   } else {
-    console.log(ansis.red(`\u2717 ${workflowName} ${i18n.workflowInstallError}`));
+    console.log(ansis.red(`\u2717 ${workflowName} ${i18n.workflow.workflowInstallError}`));
   }
   return result;
 }
 async function cleanupOldVersionFiles(scriptLang) {
-  const i18n = I18N[scriptLang];
+  const i18n = getTranslation(scriptLang);
   console.log(ansis.cyan(`
-\u{1F9F9} ${i18n.cleaningOldFiles || "Cleaning up old version files"}...`));
+\u{1F9F9} ${i18n.workflow.cleaningOldFiles || "Cleaning up old version files"}...`));
   const oldCommandFiles = [
     join(CLAUDE_DIR, "commands", "workflow.md"),
     join(CLAUDE_DIR, "commands", "feat.md")
@@ -2005,9 +2551,9 @@ async function cleanupOldVersionFiles(scriptLang) {
     if (existsSync(file)) {
       try {
         await rm(file, { force: true });
-        console.log(ansis.gray(`  \u2714 ${i18n.removedOldFile || "Removed old file"}: ${file.replace(CLAUDE_DIR, "~/.claude")}`));
+        console.log(ansis.gray(`  \u2714 ${i18n.workflow.removedOldFile || "Removed old file"}: ${file.replace(CLAUDE_DIR, "~/.claude")}`));
       } catch (error) {
-        console.error(ansis.yellow(`  \u26A0 ${i18n.failedToRemoveFile || "Failed to remove"}: ${file.replace(CLAUDE_DIR, "~/.claude")}`));
+        console.error(ansis.yellow(`  \u26A0 ${i18n.workflow.failedToRemoveFile || "Failed to remove"}: ${file.replace(CLAUDE_DIR, "~/.claude")}`));
       }
     }
   }
@@ -2015,14 +2561,468 @@ async function cleanupOldVersionFiles(scriptLang) {
     if (existsSync(file)) {
       try {
         await rm(file, { force: true });
-        console.log(ansis.gray(`  \u2714 ${i18n.removedOldFile || "Removed old file"}: ${file.replace(CLAUDE_DIR, "~/.claude")}`));
+        console.log(ansis.gray(`  \u2714 ${i18n.workflow.removedOldFile || "Removed old file"}: ${file.replace(CLAUDE_DIR, "~/.claude")}`));
       } catch (error) {
-        console.error(ansis.yellow(`  \u26A0 ${i18n.failedToRemoveFile || "Failed to remove"}: ${file.replace(CLAUDE_DIR, "~/.claude")}`));
+        console.error(ansis.yellow(`  \u26A0 ${i18n.workflow.failedToRemoveFile || "Failed to remove"}: ${file.replace(CLAUDE_DIR, "~/.claude")}`));
       }
     }
   }
 }
 
+const execAsync$1 = promisify$1(exec$2);
+async function isCcrInstalled() {
+  try {
+    await execAsync$1("ccr version");
+    return true;
+  } catch {
+    try {
+      await execAsync$1("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}`));
+    await updateCcr(scriptLang);
+    return;
+  }
+  console.log(ansis.cyan(`\u{1F4E6} ${i18n.ccr.installingCcr}`));
+  try {
+    await execAsync$1("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}`));
+      await updateCcr(scriptLang);
+      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 = promisify$1(exec$2);
+const CCR_CONFIG_DIR = join$2(homedir(), ".claude-code-router");
+const CCR_CONFIG_FILE = join$2(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$2(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-zcf-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-zcf-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("ccr restart");
+    console.log(ansis.green(`\u2714 ${i18n.ccr.ccrRestartSuccess}`));
+    console.log(ansis.cyan(`${i18n.ccr.checkingCcrStatus}`));
+    const { stdout } = await execAsync("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-zcf-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);
+}
+
 async function init(options = {}) {
   try {
     if (!options.skipBanner) {
@@ -2032,22 +3032,22 @@ async function init(options = {}) {
     const i18n = I18N[scriptLang];
     if (isTermux()) {
       console.log(ansis.yellow(`
-\u2139 ${i18n.termuxDetected}`));
-      console.log(ansis.gray(i18n.termuxEnvironmentInfo));
+\u2139 ${i18n.installation.termuxDetected}`));
+      console.log(ansis.gray(i18n.installation.termuxEnvironmentInfo));
     }
     let configLang = options.configLang;
     if (!configLang) {
       const { lang } = await inquirer.prompt({
         type: "list",
         name: "lang",
-        message: i18n.selectConfigLang,
-        choices: SUPPORTED_LANGS.map((l) => ({
-          name: `${LANG_LABELS[l]} - ${i18n.configLangHint[l]}`,
+        message: i18n.language.selectConfigLang,
+        choices: addNumbersToChoices(SUPPORTED_LANGS.map((l) => ({
+          name: `${LANG_LABELS[l]} - ${i18n.language.configLangHint[l]}`,
           value: l
-        }))
+        })))
       });
       if (!lang) {
-        console.log(ansis.yellow(i18n.cancelled));
+        console.log(ansis.yellow(i18n.common.cancelled));
         process.exit(0);
       }
       configLang = lang;
@@ -2059,20 +3059,20 @@ async function init(options = {}) {
       const { shouldInstall } = await inquirer.prompt({
         type: "confirm",
         name: "shouldInstall",
-        message: i18n.installPrompt,
+        message: i18n.installation.installPrompt,
         default: true
       });
       if (shouldInstall === void 0) {
-        console.log(ansis.yellow(i18n.cancelled));
+        console.log(ansis.yellow(i18n.common.cancelled));
         process.exit(0);
       }
       if (shouldInstall) {
         await installClaudeCode(scriptLang);
       } else {
-        console.log(ansis.yellow(i18n.skip));
+        console.log(ansis.yellow(i18n.common.skip));
       }
     } else {
-      console.log(ansis.green(`\u2714 ${i18n.installSuccess}`));
+      console.log(ansis.green(`\u2714 ${i18n.installation.alreadyInstalled}`));
     }
     ensureClaudeDir();
     let action = "new";
@@ -2080,21 +3080,21 @@ async function init(options = {}) {
       const { action: userAction } = await inquirer.prompt({
         type: "list",
         name: "action",
-        message: i18n.existingConfig,
-        choices: [
-          { name: i18n.backupAndOverwrite, value: "backup" },
-          { name: i18n.updateDocsOnly, value: "docs-only" },
-          { name: i18n.mergeConfig, value: "merge" },
-          { name: i18n.skip, value: "skip" }
-        ]
+        message: i18n.configuration.existingConfig,
+        choices: addNumbersToChoices([
+          { name: i18n.configuration.backupAndOverwrite, value: "backup" },
+          { name: i18n.configuration.updateDocsOnly, value: "docs-only" },
+          { name: i18n.configuration.mergeConfig, value: "merge" },
+          { name: i18n.common.skip, value: "skip" }
+        ])
       });
       if (!userAction) {
-        console.log(ansis.yellow(i18n.cancelled));
+        console.log(ansis.yellow(i18n.common.cancelled));
         process.exit(0);
       }
       action = userAction;
       if (action === "skip") {
-        console.log(ansis.yellow(i18n.skip));
+        console.log(ansis.yellow(i18n.common.skip));
         return;
       }
     }
@@ -2103,65 +3103,103 @@ async function init(options = {}) {
     if (action !== "docs-only" && (isNewInstall || ["backup", "merge"].includes(action))) {
       const existingApiConfig = getExistingApiConfig();
       if (existingApiConfig) {
-        console.log("\n" + ansis.blue(`\u2139 ${i18n.existingApiConfig}`));
-        console.log(ansis.gray(`  ${i18n.apiConfigUrl}: ${existingApiConfig.url || i18n.notConfigured}`));
+        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.apiConfigKey}: ${existingApiConfig.key ? formatApiKeyDisplay(existingApiConfig.key) : i18n.notConfigured}`
+            `  ${i18n.api.apiConfigKey}: ${existingApiConfig.key ? formatApiKeyDisplay(existingApiConfig.key) : i18n.common.notConfigured}`
           )
         );
-        console.log(ansis.gray(`  ${i18n.apiConfigAuthType}: ${existingApiConfig.authType || i18n.notConfigured}
+        console.log(ansis.gray(`  ${i18n.api.apiConfigAuthType}: ${existingApiConfig.authType || i18n.common.notConfigured}
 `));
         const { action: apiAction } = await inquirer.prompt({
           type: "list",
           name: "action",
-          message: i18n.selectApiAction,
-          choices: [
-            { name: i18n.keepExistingConfig, value: "keep" },
-            { name: i18n.modifyAllConfig, value: "modify-all" },
-            { name: i18n.modifyPartialConfig, value: "modify-partial" },
-            { name: i18n.skipApi, value: "skip" }
-          ]
+          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" },
+            { name: i18n.api.skipApi, value: "skip" }
+          ])
         });
         if (!apiAction) {
-          console.log(ansis.yellow(i18n.cancelled));
+          console.log(ansis.yellow(i18n.common.cancelled));
           process.exit(0);
         }
         if (apiAction === "keep" || apiAction === "skip") {
           apiConfig = null;
+          if (apiAction === "keep") {
+            try {
+              addCompletedOnboarding();
+            } catch (error) {
+              console.error(ansis.red(i18n.configuration.failedToSetOnboarding), error);
+            }
+          }
         } else if (apiAction === "modify-partial") {
           await modifyApiConfigPartially(existingApiConfig, i18n, scriptLang);
           apiConfig = null;
         } else if (apiAction === "modify-all") {
           apiConfig = await configureApiCompletely(i18n, scriptLang);
+        } else if (apiAction === "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}`));
+            apiConfig = null;
+          }
         }
       } else {
         const { apiChoice } = await inquirer.prompt({
           type: "list",
           name: "apiChoice",
-          message: i18n.configureApi,
+          message: i18n.api.configureApi,
           choices: [
             {
-              name: `${i18n.useAuthToken} - ${ansis.gray(i18n.authTokenDesc)}`,
+              name: `${i18n.api.useAuthToken} - ${ansis.gray(i18n.api.authTokenDesc)}`,
               value: "auth_token",
-              short: i18n.useAuthToken
+              short: i18n.api.useAuthToken
             },
             {
-              name: `${i18n.useApiKey} - ${ansis.gray(i18n.apiKeyDesc)}`,
+              name: `${i18n.api.useApiKey} - ${ansis.gray(i18n.api.apiKeyDesc)}`,
               value: "api_key",
-              short: i18n.useApiKey
+              short: i18n.api.useApiKey
             },
             {
-              name: i18n.skipApi,
+              name: `${i18n.api.useCcrProxy} - ${ansis.gray(i18n.api.ccrProxyDesc)}`,
+              value: "ccr_proxy",
+              short: i18n.api.useCcrProxy
+            },
+            {
+              name: i18n.api.skipApi,
               value: "skip"
             }
           ]
         });
         if (!apiChoice) {
-          console.log(ansis.yellow(i18n.cancelled));
+          console.log(ansis.yellow(i18n.common.cancelled));
           process.exit(0);
         }
-        if (apiChoice !== "skip") {
+        if (apiChoice === "ccr_proxy") {
+          const ccrInstalled = await isCcrInstalled();
+          if (!ccrInstalled) {
+            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}`));
+            apiConfig = null;
+          }
+        } else if (apiChoice !== "skip") {
           apiConfig = await configureApiCompletely(i18n, scriptLang, apiChoice);
         }
       }
@@ -2169,7 +3207,7 @@ async function init(options = {}) {
     if (["backup", "docs-only", "merge"].includes(action)) {
       const backupDir = backupExistingConfig();
       if (backupDir) {
-        console.log(ansis.gray(`\u2714 ${i18n.backupSuccess}: ${backupDir}`));
+        console.log(ansis.gray(`\u2714 ${i18n.configuration.backupSuccess}: ${backupDir}`));
       }
     }
     if (action === "docs-only") {
@@ -2184,30 +3222,25 @@ async function init(options = {}) {
     if (apiConfig && action !== "docs-only") {
       const configuredApi = configureApi(apiConfig);
       if (configuredApi) {
-        console.log(ansis.green(`\u2714 ${i18n.apiConfigSuccess}`));
+        console.log(ansis.green(`\u2714 ${i18n.api.apiConfigSuccess}`));
         console.log(ansis.gray(`  URL: ${configuredApi.url}`));
         console.log(ansis.gray(`  Key: ${formatApiKeyDisplay(configuredApi.key)}`));
-        try {
-          addCompletedOnboarding();
-        } catch (error) {
-          console.error(ansis.red(i18n.failedToSetOnboarding), error);
-        }
       }
     }
     if (action !== "docs-only") {
       const { shouldConfigureMcp } = await inquirer.prompt({
         type: "confirm",
         name: "shouldConfigureMcp",
-        message: i18n.configureMcp,
+        message: i18n.mcp.configureMcp,
         default: true
       });
       if (shouldConfigureMcp === void 0) {
-        console.log(ansis.yellow(i18n.cancelled));
+        console.log(ansis.yellow(i18n.common.cancelled));
         process.exit(0);
       }
       if (shouldConfigureMcp) {
         if (isWindows()) {
-          console.log(ansis.blue(`\u2139 ${I18N[scriptLang].windowsDetected}`));
+          console.log(ansis.blue(`\u2139 ${i18n.installation.windowsDetected}`));
         }
         const selectedServices = await selectMcpServices(scriptLang);
         if (selectedServices === void 0) {
@@ -2216,7 +3249,7 @@ async function init(options = {}) {
         if (selectedServices.length > 0) {
           const mcpBackupPath = backupMcpConfig();
           if (mcpBackupPath) {
-            console.log(ansis.gray(`\u2714 ${i18n.mcpBackupSuccess}: ${mcpBackupPath}`));
+            console.log(ansis.gray(`\u2714 ${i18n.mcp.mcpBackupSuccess}: ${mcpBackupPath}`));
           }
           const newServers = {};
           for (const serviceId of selectedServices) {
@@ -2228,10 +3261,10 @@ async function init(options = {}) {
                 type: "input",
                 name: "apiKey",
                 message: service.apiKeyPrompt[scriptLang],
-                validate: (value) => !!value || i18n.keyRequired
+                validate: (value) => !!value || i18n.api.keyRequired
               });
               if (apiKey === void 0) {
-                console.log(ansis.yellow(`${i18n.skip}: ${service.name[scriptLang]}`));
+                console.log(ansis.yellow(`${i18n.common.skip}: ${service.name[scriptLang]}`));
                 continue;
               }
               if (apiKey) {
@@ -2247,9 +3280,9 @@ async function init(options = {}) {
           mergedConfig = fixWindowsMcpConfig(mergedConfig);
           try {
             writeMcpConfig(mergedConfig);
-            console.log(ansis.green(`\u2714 ${i18n.mcpConfigSuccess}`));
+            console.log(ansis.green(`\u2714 ${i18n.mcp.mcpConfigSuccess}`));
           } catch (error) {
-            console.error(ansis.red(`${i18n.failedToWriteMcpConfig} ${error}`));
+            console.error(ansis.red(`${i18n.configuration.failedToWriteMcpConfig} ${error}`));
           }
         }
       }
@@ -2259,8 +3292,8 @@ async function init(options = {}) {
       preferredLang: scriptLang,
       aiOutputLang
     });
-    console.log(ansis.green(`\u2714 ${i18n.configSuccess} ${CLAUDE_DIR}`));
-    console.log("\n" + ansis.cyan(i18n.complete));
+    console.log(ansis.green(`\u2714 ${i18n.configuration.configSuccess} ${CLAUDE_DIR}`));
+    console.log("\n" + ansis.cyan(i18n.common.complete));
   } catch (error) {
     if (!handleExitPromptError(error)) {
       handleGeneralError(error, options.lang);
@@ -2346,4 +3379,4 @@ async function openSettingsJson() {
   }
 }
 
-export { handleExitPromptError as $, AI_OUTPUT_LANGUAGES as A, backupMcpConfig as B, CLAUDE_DIR as C, mergeMcpServers as D, buildMcpServerConfig as E, fixWindowsMcpConfig as F, addCompletedOnboarding as G, updateZcfConfig as H, I18N as I, readZcfConfig as J, resolveAiOutputLanguage as K, LEGACY_ZCF_CONFIG_FILE as L, MCP_SERVICES as M, configureAiPersonality as N, isWindows as O, selectMcpServices as P, formatApiKeyDisplay as Q, modifyApiConfigPartially as R, SETTINGS_FILE as S, validateApiKey as T, readZcfConfigAsync as U, displayBanner as V, selectScriptLanguage as W, updatePromptOnly as X, selectAndInstallWorkflows as Y, ZCF_CONFIG_FILE as Z, version as _, importRecommendedEnv as a, handleGeneralError as a0, displayBannerWithInfo as a1, importRecommendedPermissions as b, commandExists as c, cleanupPermissions as d, CLAUDE_MD_FILE as e, ClAUDE_CONFIG_FILE as f, getPlatform as g, SUPPORTED_LANGS as h, init as i, LANG_LABELS as j, isClaudeCodeInstalled as k, installClaudeCode as l, mergeAndCleanPermissions as m, ensureClaudeDir as n, openSettingsJson as o, backupExistingConfig as p, copyConfigFiles as q, configureApi as r, mergeConfigs as s, mergeSettingsFile as t, updateDefaultModel as u, getExistingApiConfig as v, applyAiLanguageDirective as w, getMcpConfigPath as x, readMcpConfig as y, writeMcpConfig as z };
+export { readCcrConfig as $, AI_OUTPUT_LANGUAGES as A, writeMcpConfig as B, CLAUDE_DIR as C, backupMcpConfig as D, mergeMcpServers as E, buildMcpServerConfig as F, fixWindowsMcpConfig as G, addCompletedOnboarding as H, I18N as I, getTranslation as J, addNumbersToChoices as K, LEGACY_ZCF_CONFIG_FILE as L, MCP_SERVICES as M, updateZcfConfig as N, readZcfConfig as O, configureAiPersonality as P, isWindows as Q, selectMcpServices as R, SETTINGS_FILE as S, formatApiKeyDisplay as T, modifyApiConfigPartially as U, isCcrInstalled as V, installCcr as W, setupCcrConfiguration as X, validateApiKey as Y, ZCF_CONFIG_FILE as Z, readZcfConfigAsync as _, importRecommendedEnv as a, configureCcrFeature as a0, handleExitPromptError as a1, handleGeneralError as a2, displayBanner as a3, selectScriptLanguage as a4, resolveAiOutputLanguage as a5, updatePromptOnly as a6, selectAndInstallWorkflows as a7, version as a8, displayBannerWithInfo as a9, checkAndUpdateTools as aa, prompts as ab, importRecommendedPermissions as b, commandExists as c, cleanupPermissions as d, CLAUDE_MD_FILE as e, ClAUDE_CONFIG_FILE as f, getPlatform as g, SUPPORTED_LANGS as h, init as i, LANG_LABELS as j, isClaudeCodeInstalled as k, installClaudeCode as l, mergeAndCleanPermissions as m, ensureClaudeDir as n, openSettingsJson as o, backupExistingConfig as p, copyConfigFiles as q, configureApi as r, mergeConfigs as s, mergeSettingsFile as t, updateDefaultModel as u, getExistingModelConfig as v, getExistingApiConfig as w, applyAiLanguageDirective as x, getMcpConfigPath as y, readMcpConfig as z };