zcf 3.1.3 → 3.2.0

package/dist/chunks/simple-config.mjs

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, mkdirSync, writeFileSync, copyFileSync, rmSync, rmdirSync, readdirSync, statSync, unlinkSync, renameSync } from 'node:fs';
+import { existsSync, readFileSync, mkdirSync, copyFileSync, writeFileSync, rmSync, rmdirSync, readdirSync, statSync, unlinkSync, renameSync } from 'node:fs';
 import process from 'node:process';
 import ansis from 'ansis';
 import inquirer from 'inquirer';
@@ -10,13 +10,13 @@ import { dirname, join } from 'pathe';
 import { fileURLToPath } from 'node:url';
 import ora from 'ora';
 import semver from 'semver';
-import { parse, stringify } from 'smol-toml';
+import { stringify, parse } from 'smol-toml';
 import { exec, x } from 'tinyexec';
 import { rm, mkdir, copyFile as copyFile$1 } from 'node:fs/promises';
 import i18next from 'i18next';
 import Backend from 'i18next-fs-backend';
 
-const version = "3.1.3";
+const version = "3.2.0";
 const homepage = "https://github.com/UfoMiao/zcf";
 
 const i18n = i18next.createInstance();
@@ -32,6 +32,7 @@ const NAMESPACES = [
   "language",
   "mcp",
   "menu",
+  "multi-config",
   "tools",
   "uninstall",
   "updater",
@@ -377,9 +378,22 @@ const CODE_TOOL_BANNERS = {
   "claude-code": "for Claude Code",
   "codex": "for Codex"
 };
+const CODE_TOOL_ALIASES = {
+  cc: "claude-code",
+  cx: "codex"
+};
 function isCodeToolType(value) {
   return CODE_TOOL_TYPES.includes(value);
 }
+function resolveCodeToolType(value) {
+  if (isCodeToolType(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value in CODE_TOOL_ALIASES) {
+    return CODE_TOOL_ALIASES[value];
+  }
+  return DEFAULT_CODE_TOOL_TYPE;
+}
 const SUPPORTED_LANGS = ["zh-CN", "en"];
 const LANG_LABELS = {
   "zh-CN": "\u7B80\u4F53\u4E2D\u6587",
@@ -409,6 +423,7 @@ const constants = {
   CLAUDE_DIR: CLAUDE_DIR,
   CLAUDE_MD_FILE: CLAUDE_MD_FILE,
   CLAUDE_VSC_CONFIG_FILE: CLAUDE_VSC_CONFIG_FILE,
+  CODE_TOOL_ALIASES: CODE_TOOL_ALIASES,
   CODE_TOOL_BANNERS: CODE_TOOL_BANNERS,
   CODE_TOOL_TYPES: CODE_TOOL_TYPES,
   ClAUDE_CONFIG_FILE: ClAUDE_CONFIG_FILE,
@@ -420,7 +435,8 @@ const constants = {
   ZCF_CONFIG_DIR: ZCF_CONFIG_DIR,
   ZCF_CONFIG_FILE: ZCF_CONFIG_FILE,
   getAiOutputLanguageLabel: getAiOutputLanguageLabel,
-  isCodeToolType: isCodeToolType
+  isCodeToolType: isCodeToolType,
+  resolveCodeToolType: resolveCodeToolType
 };
 
 function getDisplayWidth(str) {
@@ -825,6 +841,13 @@ function backupJsonConfig(path, backupDir) {
   }
 }
 
+const jsonConfig = {
+  __proto__: null,
+  backupJsonConfig: backupJsonConfig,
+  readJsonConfig: readJsonConfig,
+  writeJsonConfig: writeJsonConfig
+};
+
 function mergeArraysUnique(arr1, arr2) {
   const combined = [...arr1 || [], ...arr2 || []];
   return [...new Set(combined)];
@@ -1352,6 +1375,23 @@ ${ansis.blue(`\u2139 ${i18n.t("api:existingApiConfig")}`)}`);
   return choice || null;
 }
 
+const config$1 = {
+  __proto__: null,
+  applyAiLanguageDirective: applyAiLanguageDirective,
+  backupExistingConfig: backupExistingConfig,
+  configureApi: configureApi,
+  copyConfigFiles: copyConfigFiles,
+  ensureClaudeDir: ensureClaudeDir,
+  getExistingApiConfig: getExistingApiConfig,
+  getExistingModelConfig: getExistingModelConfig,
+  mergeConfigs: mergeConfigs,
+  mergeSettingsFile: mergeSettingsFile,
+  promptApiConfigurationAction: promptApiConfigurationAction,
+  switchToOfficialLogin: switchToOfficialLogin$1,
+  updateCustomModel: updateCustomModel,
+  updateDefaultModel: updateDefaultModel
+};
+
 const PROVIDER_PRESETS_URL = "https://pub-0dc3e1677e894f07bbea11b17a29e032.r2.dev/providers.json";
 async function fetchProviderPresets() {
   try {
@@ -1793,6 +1833,22 @@ async function configureCcrFeature() {
   await setupCcrConfiguration();
 }
 
+const config = {
+  __proto__: null,
+  backupCcrConfig: backupCcrConfig,
+  configureCcrFeature: configureCcrFeature,
+  configureCcrProxy: configureCcrProxy,
+  configureCcrWithPreset: configureCcrWithPreset,
+  createDefaultCcrConfig: createDefaultCcrConfig,
+  ensureCcrConfigDir: ensureCcrConfigDir,
+  readCcrConfig: readCcrConfig,
+  restartAndCheckCcrStatus: restartAndCheckCcrStatus,
+  selectCcrPreset: selectCcrPreset,
+  setupCcrConfiguration: setupCcrConfiguration,
+  showConfigurationTips: showConfigurationTips,
+  writeCcrConfig: writeCcrConfig
+};
+
 const execAsync$3 = promisify(exec$1);
 async function getInstalledVersion(command, maxRetries = 3) {
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
@@ -2149,27 +2205,6 @@ async function installCcr() {
   }
 }
 
-async function selectMcpServices() {
-  ensureI18nInitialized();
-  const mcpServices = await getMcpServices();
-  const choices = mcpServices.map((service) => ({
-    name: `${service.name} - ${ansis.gray(service.description)}`,
-    value: service.id,
-    selected: false
-  }));
-  const { services } = await inquirer.prompt({
-    type: "checkbox",
-    name: "services",
-    message: `${i18n.t("mcp:selectMcpServices")}${i18n.t("common:multiSelectHint")}`,
-    choices
-  });
-  if (services === void 0) {
-    console.log(ansis.yellow(i18n.t("common:cancelled")));
-    return void 0;
-  }
-  return services;
-}
-
 function addNumbersToChoices(choices, startFrom = 1, format = (n) => `${n}. `) {
   let currentNumber = startFrom;
   return choices.map((choice) => {
@@ -2230,7 +2265,9 @@ function createDefaultTomlConfig(preferredLang = "en", claudeCodeInstallType = "
       enabled: true,
       outputStyles: ["engineer-professional"],
       defaultOutputStyle: "engineer-professional",
-      installType: claudeCodeInstallType
+      installType: claudeCodeInstallType,
+      currentProfile: "",
+      profiles: {}
     },
     codex: {
       enabled: false,
@@ -2255,7 +2292,9 @@ function migrateFromJsonConfig(jsonConfig) {
       enabled: jsonConfig.codeToolType === "claude-code",
       outputStyles: jsonConfig.outputStyles || defaultConfig.claudeCode.outputStyles,
       defaultOutputStyle: jsonConfig.defaultOutputStyle || defaultConfig.claudeCode.defaultOutputStyle,
-      installType: claudeCodeInstallType
+      installType: claudeCodeInstallType,
+      currentProfile: jsonConfig.currentProfileId || defaultConfig.claudeCode.currentProfile,
+      profiles: jsonConfig.claudeCode?.profiles || {}
     },
     codex: {
       enabled: jsonConfig.codeToolType === "codex",
@@ -2392,6 +2431,17 @@ function writeZcfConfig(config) {
     if (nextSystemPromptStyle) {
       tomlConfig.codex.systemPromptStyle = nextSystemPromptStyle;
     }
+    if (existingTomlConfig?.claudeCode) {
+      if (existingTomlConfig.claudeCode.profiles) {
+        tomlConfig.claudeCode.profiles = existingTomlConfig.claudeCode.profiles;
+      }
+      if (existingTomlConfig.claudeCode.currentProfile !== void 0) {
+        tomlConfig.claudeCode.currentProfile = existingTomlConfig.claudeCode.currentProfile;
+      }
+      if (existingTomlConfig.claudeCode.version) {
+        tomlConfig.claudeCode.version = existingTomlConfig.claudeCode.version;
+      }
+    }
     writeTomlConfig(ZCF_CONFIG_FILE, tomlConfig);
   } catch {
   }
@@ -2498,12 +2548,15 @@ async function selectScriptLanguage(currentLang) {
   });
   return scriptLang;
 }
-async function resolveAiOutputLanguage(scriptLang, commandLineOption, savedConfig) {
+async function resolveAiOutputLanguage(scriptLang, commandLineOption, savedConfig, skipPrompt) {
   ensureI18nInitialized();
   if (commandLineOption) {
     return commandLineOption;
   }
   if (savedConfig?.aiOutputLang) {
+    if (skipPrompt) {
+      return savedConfig.aiOutputLang;
+    }
     const currentLanguageLabel = getAiOutputLanguageLabel(savedConfig.aiOutputLang) || savedConfig.aiOutputLang;
     console.log(ansis.blue(`${i18n.t("language:currentConfigFound")}: ${currentLanguageLabel}`));
     const { shouldModify } = await inquirer.prompt({
@@ -2522,6 +2575,9 @@ async function resolveAiOutputLanguage(scriptLang, commandLineOption, savedConfi
     }
     return await selectAiOutputLanguage(scriptLang);
   }
+  if (skipPrompt) {
+    return scriptLang;
+  }
   return await selectAiOutputLanguage(scriptLang);
 }
 async function selectTemplateLanguage() {
@@ -2547,12 +2603,15 @@ async function selectTemplateLanguage() {
   }
   return lang;
 }
-async function resolveTemplateLanguage(commandLineOption, savedConfig) {
+async function resolveTemplateLanguage(commandLineOption, savedConfig, skipPrompt) {
   ensureI18nInitialized();
   if (commandLineOption) {
     return commandLineOption;
   }
   if (savedConfig?.templateLang) {
+    if (skipPrompt) {
+      return savedConfig.templateLang;
+    }
     const currentLanguageLabel = LANG_LABELS[savedConfig.templateLang];
     console.log(ansis.blue(`${i18n.t("language:currentTemplateLanguageFound")}: ${currentLanguageLabel}`));
     const { shouldModify } = await inquirer.prompt({
@@ -2572,6 +2631,9 @@ async function resolveTemplateLanguage(commandLineOption, savedConfig) {
     return await selectTemplateLanguage();
   }
   if (savedConfig?.preferredLang && !savedConfig?.templateLang) {
+    if (skipPrompt) {
+      return savedConfig.preferredLang;
+    }
     console.log(ansis.yellow(`${i18n.t("language:usingFallbackTemplate")}: ${LANG_LABELS[savedConfig.preferredLang]}`));
     const { shouldModify } = await inquirer.prompt({
       type: "confirm",
@@ -2588,9 +2650,12 @@ async function resolveTemplateLanguage(commandLineOption, savedConfig) {
     }
     return await selectTemplateLanguage();
   }
+  if (skipPrompt) {
+    return "en";
+  }
   return await selectTemplateLanguage();
 }
-async function resolveSystemPromptStyle(availablePrompts, commandLineOption, savedConfig) {
+async function resolveSystemPromptStyle(availablePrompts, commandLineOption, savedConfig, skipPrompt) {
   ensureI18nInitialized();
   if (commandLineOption && availablePrompts.some((p) => p.id === commandLineOption)) {
     return commandLineOption;
@@ -2599,6 +2664,9 @@ async function resolveSystemPromptStyle(availablePrompts, commandLineOption, sav
     const currentStyleId = savedConfig.codex.systemPromptStyle;
     const currentStyle = availablePrompts.find((p) => p.id === currentStyleId);
     if (currentStyle) {
+      if (skipPrompt) {
+        return currentStyleId;
+      }
       console.log(ansis.blue(`${i18n.t("language:currentSystemPromptFound")}: ${currentStyle.name}`));
       const { shouldModify } = await inquirer.prompt({
         type: "confirm",
@@ -2616,6 +2684,9 @@ async function resolveSystemPromptStyle(availablePrompts, commandLineOption, sav
       }
     }
   }
+  if (skipPrompt) {
+    return "engineer-professional";
+  }
   const { systemPrompt } = await inquirer.prompt([{
     type: "list",
     name: "systemPrompt",
@@ -2672,6 +2743,27 @@ function detectConfigManagementMode() {
   }
 }
 
+async function selectMcpServices() {
+  ensureI18nInitialized();
+  const mcpServices = await getMcpServices();
+  const choices = mcpServices.map((service) => ({
+    name: `${service.name} - ${ansis.gray(service.description)}`,
+    value: service.id,
+    selected: false
+  }));
+  const { services } = await inquirer.prompt({
+    type: "checkbox",
+    name: "services",
+    message: `${i18n.t("mcp:selectMcpServices")}${i18n.t("common:multiSelectHint")}`,
+    choices
+  });
+  if (services === void 0) {
+    console.log(ansis.yellow(i18n.t("common:cancelled")));
+    return void 0;
+  }
+  return services;
+}
+
 function applyCodexPlatformCommand(config) {
   if (config.command === "npx" && isWindows()) {
     const mcpCmd = getMcpCommand();
@@ -2679,6 +2771,118 @@ function applyCodexPlatformCommand(config) {
     config.args = [...mcpCmd.slice(1), ...config.args || []];
   }
 }
+
+async function configureCodexMcp(options) {
+  ensureI18nInitialized();
+  const { skipPrompt = false } = options ?? {};
+  const existingConfig = readCodexConfig();
+  if (skipPrompt)
+    return;
+  const backupPath = backupCodexComplete();
+  if (backupPath)
+    console.log(ansis.gray(getBackupMessage(backupPath)));
+  const selectedIds = await selectMcpServices();
+  if (!selectedIds)
+    return;
+  const servicesMeta = await getMcpServices();
+  const baseProviders = existingConfig?.providers || [];
+  const selection = [];
+  const existingServices = existingConfig?.mcpServices || [];
+  if (selectedIds.length === 0) {
+    console.log(ansis.yellow(i18n.t("codex:noMcpConfigured")));
+    const preserved = (existingServices || []).map((svc) => {
+      if (isWindows()) {
+        const systemRoot = getSystemRoot();
+        if (systemRoot) {
+          return {
+            ...svc,
+            env: {
+              ...svc.env || {},
+              SYSTEMROOT: systemRoot
+            }
+          };
+        }
+      }
+      return svc;
+    });
+    writeCodexConfig({
+      model: existingConfig?.model || null,
+      modelProvider: existingConfig?.modelProvider || null,
+      providers: baseProviders,
+      mcpServices: preserved,
+      otherConfig: existingConfig?.otherConfig || []
+    });
+    updateZcfConfig({ codeToolType: "codex" });
+    return;
+  }
+  for (const id of selectedIds) {
+    const configInfo = MCP_SERVICE_CONFIGS.find((service) => service.id === id);
+    if (!configInfo)
+      continue;
+    const serviceMeta = servicesMeta.find((service) => service.id === id);
+    let command = configInfo.config.command || id;
+    let args = (configInfo.config.args || []).map((arg) => String(arg));
+    const serviceConfig = { id: id.toLowerCase(), command, args };
+    applyCodexPlatformCommand(serviceConfig);
+    command = serviceConfig.command;
+    args = serviceConfig.args || [];
+    const env = { ...configInfo.config.env || {} };
+    if (isWindows()) {
+      const systemRoot = getSystemRoot();
+      if (systemRoot)
+        env.SYSTEMROOT = systemRoot;
+    }
+    if (configInfo.requiresApiKey && configInfo.apiKeyEnvVar) {
+      const promptMessage = serviceMeta?.apiKeyPrompt || i18n.t("mcp:apiKeyPrompt");
+      const { apiKey } = await inquirer.prompt([{
+        type: "password",
+        name: "apiKey",
+        message: promptMessage + i18n.t("common:inputHidden"),
+        validate: (input) => !!input || i18n.t("api:keyRequired")
+      }]);
+      if (!apiKey)
+        continue;
+      env[configInfo.apiKeyEnvVar] = apiKey;
+    }
+    selection.push({
+      id: id.toLowerCase(),
+      command: serviceConfig.command,
+      args: serviceConfig.args,
+      env: Object.keys(env).length > 0 ? env : void 0,
+      startup_timeout_ms: configInfo.config.startup_timeout_ms
+    });
+  }
+  const mergedMap = /* @__PURE__ */ new Map();
+  for (const svc of existingServices)
+    mergedMap.set(svc.id.toLowerCase(), { ...svc });
+  for (const svc of selection)
+    mergedMap.set(svc.id.toLowerCase(), { ...svc });
+  const finalServices = Array.from(mergedMap.values()).map((svc) => {
+    if (isWindows()) {
+      const systemRoot = getSystemRoot();
+      if (systemRoot) {
+        return {
+          ...svc,
+          env: {
+            ...svc.env || {},
+            SYSTEMROOT: systemRoot
+          }
+        };
+      }
+    }
+    return svc;
+  });
+  writeCodexConfig({
+    model: existingConfig?.model || null,
+    modelProvider: existingConfig?.modelProvider || null,
+    providers: baseProviders,
+    mcpServices: finalServices,
+    otherConfig: existingConfig?.otherConfig || []
+  });
+  updateZcfConfig({ codeToolType: "codex" });
+  console.log(ansis.green(i18n.t("codex:mcpConfigured")));
+}
+
 const CODEX_DIR = join(homedir(), ".codex");
 const CODEX_CONFIG_FILE = join(CODEX_DIR, "config.toml");
 const CODEX_AUTH_FILE = join(CODEX_DIR, "auth.json");
@@ -2921,7 +3125,9 @@ function parseCodexConfig(content) {
       modelProviderCommented
     };
   } catch (error) {
-    console.warn("TOML parsing failed, falling back to basic parsing:", error);
+    if (process.env.NODE_ENV === "development" || process.env.DEBUG) {
+      console.warn("TOML parsing failed, falling back to basic parsing:", error);
+    }
     const cleaned = content.replace(/^\s*#\s*---\s*model provider added by ZCF\s*---\s*$/gim, "").replace(/^\s*#\s*---\s*MCP servers added by ZCF\s*---\s*$/gim, "").replace(/^\[model_providers\.[^\]]+\][\s\S]*?(?=^\[|$)/gim, "").replace(/^\[mcp_servers\.[^\]]+\][\s\S]*?(?=^\[|$)/gim, "").replace(/^\s*(?:#\s*)?model_provider\s*=.*$/gim, "").replace(/^\s*model\s*=.*$/gim, "").replace(/\n{3,}/g, "\n\n");
     const otherConfig = cleaned.split("\n").map((l) => l.replace(/\s+$/g, "")).filter((l) => l.trim().length > 0);
     return {
@@ -3115,30 +3321,25 @@ async function installCodexCli() {
   }
   await executeCodexInstallation(false);
 }
-async function runCodexWorkflowImport() {
-  ensureI18nInitialized();
-  await runCodexSystemPromptSelection();
-  await runCodexWorkflowSelection();
-  console.log(ansis.green(i18n.t("codex:workflowInstall")));
-}
 async function runCodexWorkflowImportWithLanguageSelection(options) {
   ensureI18nInitialized();
   const zcfConfig = readZcfConfig();
-  const { aiOutputLang: commandLineOption, skipPrompt } = options ?? {};
-  const aiOutputLang = skipPrompt ? commandLineOption || zcfConfig?.aiOutputLang || "en" : await resolveAiOutputLanguage(
+  const { aiOutputLang: commandLineOption, skipPrompt = false } = options ?? {};
+  const aiOutputLang = await resolveAiOutputLanguage(
     i18n.language,
     commandLineOption,
-    zcfConfig
+    zcfConfig,
+    skipPrompt
   );
   updateZcfConfig({ aiOutputLang });
   applyAiLanguageDirective(aiOutputLang);
-  await runCodexSystemPromptSelection();
+  await runCodexSystemPromptSelection(skipPrompt);
   ensureCodexAgentsLanguageDirective(aiOutputLang);
-  await runCodexWorkflowSelection();
+  await runCodexWorkflowSelection(options);
   console.log(ansis.green(i18n.t("codex:workflowInstall")));
   return aiOutputLang;
 }
-async function runCodexSystemPromptSelection() {
+async function runCodexSystemPromptSelection(skipPrompt = false) {
   ensureI18nInitialized();
   const rootDir = getRootDir$1();
   const templateRoot = join(rootDir, "templates", "codex");
@@ -3149,7 +3350,9 @@ async function runCodexSystemPromptSelection() {
   const preferredLang = await resolveTemplateLanguage(
     void 0,
     // No command line option for this function
-    zcfConfig$1
+    zcfConfig$1,
+    skipPrompt
+    // Pass skipPrompt flag
   );
   updateZcfConfig({ templateLang: preferredLang });
   let langDir = join(templateRoot, preferredLang);
@@ -3187,7 +3390,9 @@ async function runCodexSystemPromptSelection() {
     availablePrompts,
     void 0,
     // No command line option for this function
-    tomlConfig
+    tomlConfig,
+    skipPrompt
+    // Pass skipPrompt flag
   );
   if (!systemPrompt)
     return;
@@ -3211,8 +3416,9 @@ async function runCodexSystemPromptSelection() {
     console.error("Failed to update ZCF config:", error);
   }
 }
-async function runCodexWorkflowSelection() {
+async function runCodexWorkflowSelection(options) {
   ensureI18nInitialized();
+  const { skipPrompt = false, workflows: presetWorkflows = [] } = options ?? {};
   const rootDir = getRootDir$1();
   const templateRoot = join(rootDir, "templates", "codex");
   const zcfConfig = readZcfConfig();
@@ -3227,6 +3433,29 @@ async function runCodexWorkflowSelection() {
   const allWorkflows = getAllWorkflowFiles(workflowSrc);
   if (allWorkflows.length === 0)
     return;
+  if (skipPrompt) {
+    ensureDir(CODEX_PROMPTS_DIR);
+    const backupPath2 = backupCodexPrompts();
+    if (backupPath2) {
+      console.log(ansis.gray(getBackupMessage(backupPath2)));
+    }
+    let workflowsToInstall;
+    if (presetWorkflows.length > 0) {
+      const selectedWorkflows = allWorkflows.filter(
+        (workflow) => presetWorkflows.includes(workflow.name)
+      );
+      workflowsToInstall = expandSelectedWorkflowPaths(selectedWorkflows.map((w) => w.path), workflowSrc);
+    } else {
+      workflowsToInstall = expandSelectedWorkflowPaths(allWorkflows.map((w) => w.path), workflowSrc);
+    }
+    for (const workflowPath of workflowsToInstall) {
+      const content = readFile(workflowPath);
+      const filename = workflowPath.split("/").pop() || "workflow.md";
+      const targetPath = join(CODEX_PROMPTS_DIR, filename);
+      writeFile(targetPath, content);
+    }
+    return;
+  }
   const { workflows } = await inquirer.prompt([{
     type: "checkbox",
     name: "workflows",
@@ -3245,13 +3474,15 @@ async function runCodexWorkflowSelection() {
   if (backupPath) {
     console.log(ansis.gray(getBackupMessage(backupPath)));
   }
-  for (const workflowPath of workflows) {
+  const finalWorkflowPaths = expandSelectedWorkflowPaths(workflows, workflowSrc);
+  for (const workflowPath of finalWorkflowPaths) {
     const content = readFile(workflowPath);
     const filename = workflowPath.split("/").pop() || "workflow.md";
     const targetPath = join(CODEX_PROMPTS_DIR, filename);
     writeFile(targetPath, content);
   }
 }
+const GIT_GROUP_SENTINEL = "::gitGroup";
 function getAllWorkflowFiles(dirPath) {
   const workflows = [];
   const sixStepDir = join(dirPath, "sixStep", "prompts");
@@ -3264,8 +3495,43 @@ function getAllWorkflowFiles(dirPath) {
       });
     }
   }
+  const gitPromptsDir = join(dirPath, "git", "prompts");
+  if (exists(gitPromptsDir)) {
+    workflows.push({
+      name: i18n.t("workflow:workflowOption.gitWorkflow"),
+      // Use sentinel path for grouped selection; expanded later
+      path: GIT_GROUP_SENTINEL
+    });
+  }
   return workflows;
 }
+function expandSelectedWorkflowPaths(paths, workflowSrc) {
+  const expanded = [];
+  for (const p of paths) {
+    if (p === GIT_GROUP_SENTINEL) {
+      expanded.push(...getGitPromptFiles(workflowSrc));
+    } else {
+      expanded.push(p);
+    }
+  }
+  return expanded;
+}
+function getGitPromptFiles(workflowSrc) {
+  const gitDir = join(workflowSrc, "git", "prompts");
+  const files = [
+    "git-commit.md",
+    "git-rollback.md",
+    "git-cleanBranches.md",
+    "git-worktree.md"
+  ];
+  const resolved = [];
+  for (const f of files) {
+    const full = join(gitDir, f);
+    if (exists(full))
+      resolved.push(full);
+  }
+  return resolved;
+}
 function toProvidersList(providers) {
   return providers.map((provider) => ({ name: provider.name || provider.id, value: provider.id }));
 }
@@ -3285,10 +3551,59 @@ function createApiConfigChoices(providers, currentProvider, isCommented) {
   });
   return choices;
 }
-async function configureCodexApi() {
+async function applyCustomApiConfig(customApiConfig) {
+  const { type, token, baseUrl } = customApiConfig;
+  const backupPath = backupCodexComplete();
+  if (backupPath) {
+    console.log(ansis.gray(getBackupMessage(backupPath)));
+  }
+  const providers = [];
+  const authEntries = {};
+  const providerId = type === "auth_token" ? "official-auth-token" : "custom-api-key";
+  const providerName = type === "auth_token" ? "Official Auth Token" : "Custom API Key";
+  providers.push({
+    id: providerId,
+    name: providerName,
+    baseUrl: baseUrl || "https://api.anthropic.com",
+    wireApi: "claude",
+    envKey: `${providerId.toUpperCase()}_API_KEY`,
+    requiresOpenaiAuth: false
+  });
+  if (token) {
+    authEntries[providerId] = token;
+  }
+  const configData = {
+    model: "claude-3-5-sonnet-20241022",
+    modelProvider: providerId,
+    modelProviderCommented: false,
+    providers,
+    mcpServices: []};
+  writeFile(CODEX_CONFIG_FILE, renderCodexConfig(configData));
+  writeJsonConfig(CODEX_AUTH_FILE, authEntries);
+  updateZcfConfig({ codeToolType: "codex" });
+  console.log(ansis.green(`\u2714 ${i18n.t("codex:apiConfigured")}`));
+}
+async function configureCodexApi(options) {
   ensureI18nInitialized();
+  const { skipPrompt = false, apiMode, customApiConfig } = options ?? {};
   const existingConfig = readCodexConfig();
   const existingAuth = readJsonConfig(CODEX_AUTH_FILE, { defaultValue: {} }) || {};
+  if (skipPrompt) {
+    if (apiMode === "skip") {
+      return;
+    }
+    if (apiMode === "custom" && customApiConfig) {
+      await applyCustomApiConfig(customApiConfig);
+      return;
+    }
+    if (apiMode === "official") {
+      const success = await switchToOfficialLogin();
+      if (success) {
+        updateZcfConfig({ codeToolType: "codex" });
+      }
+      return;
+    }
+  }
   const hasProviders = existingConfig?.providers && existingConfig.providers.length > 0;
   const modeChoices = [
     { name: i18n.t("codex:apiModeOfficial"), value: "official" },
@@ -3477,124 +3792,12 @@ async function configureCodexApi() {
   updateZcfConfig({ codeToolType: "codex" });
   console.log(ansis.green(i18n.t("codex:apiConfigured")));
 }
-async function configureCodexMcp() {
-  ensureI18nInitialized();
-  const existingConfig = readCodexConfig();
-  const backupPath = backupCodexComplete();
-  if (backupPath) {
-    console.log(ansis.gray(getBackupMessage(backupPath)));
-  }
-  const selectedIds = await selectMcpServices();
-  if (!selectedIds)
-    return;
-  const servicesMeta = await getMcpServices();
-  const baseProviders = existingConfig?.providers || [];
-  const selection = [];
-  const existingServices = existingConfig?.mcpServices || [];
-  if (selectedIds.length === 0) {
-    console.log(ansis.yellow(i18n.t("codex:noMcpConfigured")));
-    const preserved = (existingServices || []).map((svc) => {
-      if (isWindows()) {
-        const systemRoot = getSystemRoot();
-        if (systemRoot) {
-          return {
-            ...svc,
-            env: {
-              ...svc.env || {},
-              SYSTEMROOT: systemRoot
-            }
-          };
-        }
-      }
-      return svc;
-    });
-    writeCodexConfig({
-      model: existingConfig?.model || null,
-      modelProvider: existingConfig?.modelProvider || null,
-      providers: baseProviders,
-      mcpServices: preserved,
-      otherConfig: existingConfig?.otherConfig || []
-    });
-    updateZcfConfig({ codeToolType: "codex" });
-    return;
-  }
-  for (const id of selectedIds) {
-    const configInfo = MCP_SERVICE_CONFIGS.find((service) => service.id === id);
-    if (!configInfo)
-      continue;
-    const serviceMeta = servicesMeta.find((service) => service.id === id);
-    let command = configInfo.config.command || id;
-    let args = (configInfo.config.args || []).map((arg) => String(arg));
-    const serviceConfig = { id: id.toLowerCase(), command, args };
-    applyCodexPlatformCommand(serviceConfig);
-    command = serviceConfig.command;
-    args = serviceConfig.args || [];
-    const env = { ...configInfo.config.env || {} };
-    if (isWindows()) {
-      const systemRoot = getSystemRoot();
-      if (systemRoot) {
-        env.SYSTEMROOT = systemRoot;
-      }
-    }
-    if (configInfo.requiresApiKey && configInfo.apiKeyEnvVar) {
-      const promptMessage = serviceMeta?.apiKeyPrompt || i18n.t("mcp:apiKeyPrompt");
-      const { apiKey } = await inquirer.prompt([{
-        type: "password",
-        name: "apiKey",
-        message: promptMessage + i18n.t("common:inputHidden"),
-        validate: (input) => !!input || i18n.t("api:keyRequired")
-      }]);
-      if (!apiKey)
-        continue;
-      env[configInfo.apiKeyEnvVar] = apiKey;
-    }
-    selection.push({
-      id: id.toLowerCase(),
-      // Convert to lowercase for Codex compatibility
-      command: serviceConfig.command,
-      args: serviceConfig.args,
-      env: Object.keys(env).length > 0 ? env : void 0,
-      startup_timeout_ms: configInfo.config.startup_timeout_ms
-    });
-  }
-  const mergedMap = /* @__PURE__ */ new Map();
-  for (const svc of existingServices) {
-    mergedMap.set(svc.id.toLowerCase(), { ...svc });
-  }
-  for (const svc of selection) {
-    mergedMap.set(svc.id.toLowerCase(), { ...svc });
-  }
-  const finalServices = Array.from(mergedMap.values()).map((svc) => {
-    if (isWindows()) {
-      const systemRoot = getSystemRoot();
-      if (systemRoot) {
-        return {
-          ...svc,
-          env: {
-            ...svc.env || {},
-            SYSTEMROOT: systemRoot
-          }
-        };
-      }
-    }
-    return svc;
-  });
-  writeCodexConfig({
-    model: existingConfig?.model || null,
-    modelProvider: existingConfig?.modelProvider || null,
-    providers: baseProviders,
-    mcpServices: finalServices,
-    otherConfig: existingConfig?.otherConfig || []
-  });
-  updateZcfConfig({ codeToolType: "codex" });
-  console.log(ansis.green(i18n.t("codex:mcpConfigured")));
-}
 async function runCodexFullInit(options) {
   ensureI18nInitialized();
   await installCodexCli();
   const aiOutputLang = await runCodexWorkflowImportWithLanguageSelection(options);
-  await configureCodexApi();
-  await configureCodexMcp();
+  await configureCodexApi(options);
+  await configureCodexMcp(options);
   return aiOutputLang;
 }
 function ensureCodexAgentsLanguageDirective(aiOutputLang) {
@@ -3634,7 +3837,10 @@ function normalizeLanguageLabel(label) {
 }
 async function runCodexUpdate(force = false, skipPrompt = false) {
   ensureI18nInitialized();
-  const spinner = ora(i18n.t("codex:checkingVersion")).start();
+  console.log(ansis.bold.cyan(`
+\u{1F50D} ${i18n.t("updater:checkingTools")}
+`));
+  const spinner = ora(i18n.t("updater:checkingVersion")).start();
   try {
     const { installed, currentVersion, latestVersion, needsUpdate } = await checkCodexUpdate();
     spinner.stop();
@@ -3750,10 +3956,6 @@ function displayUninstallResults(results) {
     }
   }
 }
-async function getCurrentCodexProvider() {
-  const config = readCodexConfig();
-  return config?.modelProvider || null;
-}
 async function listCodexProviders() {
   const config = readCodexConfig();
   return config?.providers || [];
@@ -3865,6 +4067,7 @@ async function switchToProvider(providerId) {
 const codex = {
   __proto__: null,
   CODEX_DIR: CODEX_DIR,
+  applyCodexPlatformCommand: applyCodexPlatformCommand,
   backupCodexAgents: backupCodexAgents,
   backupCodexComplete: backupCodexComplete,
   backupCodexConfig: backupCodexConfig,
@@ -3876,7 +4079,6 @@ const codex = {
   createBackupDirectory: createBackupDirectory,
   getBackupMessage: getBackupMessage,
   getCodexVersion: getCodexVersion,
-  getCurrentCodexProvider: getCurrentCodexProvider,
   installCodexCli: installCodexCli,
   isCodexInstalled: isCodexInstalled,
   listCodexProviders: listCodexProviders,
@@ -3887,7 +4089,6 @@ const codex = {
   runCodexSystemPromptSelection: runCodexSystemPromptSelection,
   runCodexUninstall: runCodexUninstall,
   runCodexUpdate: runCodexUpdate,
-  runCodexWorkflowImport: runCodexWorkflowImport,
   runCodexWorkflowImportWithLanguageSelection: runCodexWorkflowImportWithLanguageSelection,
   runCodexWorkflowSelection: runCodexWorkflowSelection,
   switchCodexProvider: switchCodexProvider,
@@ -3897,6 +4098,43 @@ const codex = {
   writeCodexConfig: writeCodexConfig
 };
 
+const CODE_TYPE_ABBREVIATIONS = {
+  cc: "claude-code",
+  cx: "codex"
+};
+async function resolveCodeType(codeTypeParam) {
+  if (codeTypeParam) {
+    const normalizedParam = codeTypeParam.toLowerCase().trim();
+    if (normalizedParam in CODE_TYPE_ABBREVIATIONS) {
+      return CODE_TYPE_ABBREVIATIONS[normalizedParam];
+    }
+    if (isValidCodeType(normalizedParam)) {
+      return normalizedParam;
+    }
+    const validAbbreviations = Object.keys(CODE_TYPE_ABBREVIATIONS);
+    const validFullTypes = Object.values(CODE_TYPE_ABBREVIATIONS);
+    const validOptions = [...validAbbreviations, ...validFullTypes].join(", ");
+    throw new Error(
+      i18n.t(
+        "errors:invalidCodeType",
+        `Invalid code type: "${codeTypeParam}". Valid options are: ${validOptions}.`,
+        { value: codeTypeParam, validOptions }
+      )
+    );
+  }
+  try {
+    const config = await readZcfConfigAsync();
+    if (config?.codeToolType && isValidCodeType(config.codeToolType)) {
+      return config.codeToolType;
+    }
+  } catch {
+  }
+  return DEFAULT_CODE_TOOL_TYPE;
+}
+function isValidCodeType(value) {
+  return ["claude-code", "codex"].includes(value);
+}
+
 function getPlatformStatusLineConfig() {
   return {
     type: "command",
@@ -4793,12 +5031,6 @@ function validateSkipPromptOptions(options) {
   if (!options.configAction) {
     options.configAction = "backup";
   }
-  if (!options.configLang) {
-    options.configLang = "en";
-  }
-  if (!options.aiOutputLang) {
-    options.aiOutputLang = "en";
-  }
   if (typeof options.outputStyles === "string") {
     if (options.outputStyles === "skip") {
       options.outputStyles = false;
@@ -4830,6 +5062,9 @@ function validateSkipPromptOptions(options) {
       i18n.t("errors:invalidApiType", { value: options.apiType })
     );
   }
+  if (options.apiConfigs && options.apiConfigsFile) {
+    throw new Error("Cannot specify both --api-configs and --api-configs-file at the same time");
+  }
   if (options.apiType === "api_key" && !options.apiKey) {
     throw new Error(i18n.t("errors:apiKeyRequiredForApiKey"));
   }
@@ -4893,22 +5128,20 @@ function validateSkipPromptOptions(options) {
     options.workflows = WORKFLOW_CONFIG_BASE.map((w) => w.id);
   }
 }
-function resolveCodeToolType(optionValue, savedValue) {
-  if (isCodeToolType(optionValue)) {
-    return optionValue;
-  }
-  if (savedValue && isCodeToolType(savedValue)) {
-    return savedValue;
-  }
-  return DEFAULT_CODE_TOOL_TYPE;
-}
 async function init(options = {}) {
   if (options.skipPrompt) {
     validateSkipPromptOptions(options);
   }
   try {
     const zcfConfig = readZcfConfig();
-    const codeToolType = resolveCodeToolType(options.codeType, zcfConfig?.codeToolType);
+    let codeToolType;
+    try {
+      codeToolType = await resolveCodeType(options.codeType);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error(ansis.red(`${i18n.t("errors:generalError")} ${errorMessage}`));
+      codeToolType = DEFAULT_CODE_TOOL_TYPE;
+    }
     options.codeType = codeToolType;
     async function selectApiConfigurationMode() {
       const { apiMode } = await inquirer.prompt({
@@ -4937,6 +5170,11 @@ async function init(options = {}) {
       return apiMode;
     }
     async function handleCustomApiConfiguration(existingConfig) {
+      if (codeToolType === "claude-code") {
+        const { configureIncrementalManagement } = await import('./claude-code-incremental-manager.mjs');
+        await configureIncrementalManagement();
+        return null;
+      }
       if (existingConfig) {
         const customConfigAction = await promptApiConfigurationAction();
         if (customConfigAction === "modify-partial") {
@@ -5002,23 +5240,39 @@ async function init(options = {}) {
         }
       }
     } else {
-      if (!configLang && !options.skipPrompt) {
+      if (!configLang) {
         const { resolveTemplateLanguage } = await Promise.resolve().then(function () { return prompts; });
         configLang = await resolveTemplateLanguage(
           options.configLang,
-          zcfConfig
+          zcfConfig,
+          options.skipPrompt
         );
-      } else if (!configLang && options.skipPrompt) {
-        configLang = "en";
       }
     }
     if (!configLang) {
       configLang = "en";
     }
     if (codeToolType === "codex") {
+      const apiMode = options.apiType === "auth_token" ? "official" : options.apiType === "api_key" ? "custom" : options.apiType === "skip" ? "skip" : options.skipPrompt ? "skip" : void 0;
+      const customApiConfig = options.apiType === "api_key" && options.apiKey ? {
+        type: "api_key",
+        token: options.apiKey,
+        baseUrl: options.apiUrl
+      } : void 0;
+      let selectedWorkflows;
+      if (Array.isArray(options.workflows)) {
+        selectedWorkflows = options.workflows;
+      } else if (typeof options.workflows === "string") {
+        selectedWorkflows = [options.workflows];
+      } else if (options.workflows === true) {
+        selectedWorkflows = [];
+      }
       const resolvedAiOutputLang = await runCodexFullInit({
         aiOutputLang: options.aiOutputLang,
-        skipPrompt: options.skipPrompt
+        skipPrompt: options.skipPrompt,
+        apiMode,
+        customApiConfig,
+        workflows: selectedWorkflows
       });
       updateZcfConfig({
         version,
@@ -5032,7 +5286,7 @@ async function init(options = {}) {
       console.log(ansis.green(i18n.t("codex:setupComplete")));
       return;
     }
-    const aiOutputLang = options.skipPrompt ? options.aiOutputLang || "en" : await resolveAiOutputLanguage(i18n.language, options.aiOutputLang, zcfConfig);
+    const aiOutputLang = await resolveAiOutputLanguage(i18n.language, options.aiOutputLang, zcfConfig, options.skipPrompt);
     const installationStatus = await getInstallationStatus();
     if (installationStatus.hasGlobal || installationStatus.hasLocal) {
       if (!options.skipPrompt) {
@@ -5115,7 +5369,10 @@ async function init(options = {}) {
     const isNewInstall = !existsSync(SETTINGS_FILE);
     if (action !== "docs-only" && (isNewInstall || ["backup", "merge", "new"].includes(action))) {
       if (options.skipPrompt) {
-        if (options.apiType === "auth_token" && options.apiKey) {
+        if (options.apiConfigs || options.apiConfigsFile) {
+          await handleMultiConfigurations(options, codeToolType);
+          apiConfig = null;
+        } else if (options.apiType === "auth_token" && options.apiKey) {
           apiConfig = {
             authType: "auth_token",
             key: options.apiKey,
@@ -5355,6 +5612,134 @@ ${ansis.cyan(i18n.t("common:complete"))}`);
     }
   }
 }
+async function handleMultiConfigurations(options, codeToolType) {
+  const { ensureI18nInitialized } = await Promise.resolve().then(function () { return index; });
+  ensureI18nInitialized();
+  try {
+    let configs = [];
+    if (options.apiConfigs) {
+      try {
+        configs = JSON.parse(options.apiConfigs);
+      } catch (error) {
+        throw new Error(`Invalid API configs JSON: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    if (options.apiConfigsFile) {
+      try {
+        const { readFile } = await Promise.resolve().then(function () { return fsOperations; });
+        const fileContent = readFile(options.apiConfigsFile);
+        configs = JSON.parse(fileContent);
+      } catch (error) {
+        throw new Error(`Failed to read API configs file: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    validateApiConfigs(configs);
+    if (codeToolType === "claude-code") {
+      await handleClaudeCodeConfigs(configs);
+    } else if (codeToolType === "codex") {
+      await handleCodexConfigs(configs);
+    }
+    console.log(ansis.green(`\u2714 ${i18n.t("multi-config:configsAddedSuccessfully")}`));
+  } catch (error) {
+    console.error(ansis.red(`${i18n.t("multi-config:configsFailed")}: ${error instanceof Error ? error.message : String(error)}`));
+    throw error;
+  }
+}
+function validateApiConfigs(configs) {
+  if (!Array.isArray(configs)) {
+    throw new TypeError("API configs must be an array");
+  }
+  const names = /* @__PURE__ */ new Set();
+  for (const config of configs) {
+    if (!config.name || typeof config.name !== "string" || config.name.trim() === "") {
+      throw new Error("Each config must have a valid name");
+    }
+    if (!["api_key", "auth_token", "ccr_proxy"].includes(config.type)) {
+      throw new Error(`Invalid auth type: ${config.type}`);
+    }
+    if (names.has(config.name)) {
+      throw new Error(`Duplicate config name: ${config.name}`);
+    }
+    names.add(config.name);
+    if (config.type !== "ccr_proxy" && !config.key) {
+      throw new Error(`Config "${config.name}" requires API key`);
+    }
+  }
+}
+async function handleClaudeCodeConfigs(configs) {
+  const { ClaudeCodeConfigManager } = await import('./claude-code-config-manager.mjs');
+  const addedProfiles = [];
+  for (const config of configs) {
+    if (config.type === "ccr_proxy") {
+      throw new Error(`CCR proxy type is reserved and cannot be added manually (config: "${config.name}")`);
+    }
+    const profile = await convertToClaudeCodeProfile(config);
+    const result = await ClaudeCodeConfigManager.addProfile(profile);
+    if (!result.success) {
+      throw new Error(`Failed to add profile "${config.name}": ${result.error}`);
+    }
+    const storedProfile = result.addedProfile || ClaudeCodeConfigManager.getProfileByName(config.name) || profile;
+    addedProfiles.push(storedProfile);
+    console.log(ansis.green(`\u2714 ${i18n.t("multi-config:profileAdded", { name: config.name })}`));
+  }
+  if (addedProfiles.length > 0) {
+    const summary = addedProfiles.map((profile) => `${profile.name} [${profile.authType}]`).join(", ");
+    console.log(ansis.gray(`  \u2022 ${ClaudeCodeConfigManager.CONFIG_FILE}: ${summary}`));
+  }
+  const defaultConfig = configs.find((c) => c.default);
+  if (defaultConfig) {
+    const profile = addedProfiles.find((p) => p.name === defaultConfig.name) || ClaudeCodeConfigManager.getProfileByName(defaultConfig.name);
+    if (profile && profile.id) {
+      await ClaudeCodeConfigManager.switchProfile(profile.id);
+      await ClaudeCodeConfigManager.applyProfileSettings(profile);
+      console.log(ansis.green(`\u2714 ${i18n.t("multi-config:defaultProfileSet", { name: defaultConfig.name })}`));
+    }
+  }
+  await ClaudeCodeConfigManager.syncCcrProfile();
+}
+async function handleCodexConfigs(configs) {
+  const { addProviderToExisting } = await import('./codex-provider-manager.mjs');
+  for (const config of configs) {
+    try {
+      const provider = convertToCodexProvider(config);
+      const result = await addProviderToExisting(provider, config.key || "");
+      if (!result.success) {
+        throw new Error(`Failed to add provider "${config.name}": ${result.error}`);
+      }
+      console.log(ansis.green(`\u2714 ${i18n.t("multi-config:providerAdded", { name: config.name })}`));
+    } catch (error) {
+      console.error(ansis.red(`Failed to add provider "${config.name}": ${error instanceof Error ? error.message : String(error)}`));
+      throw error;
+    }
+  }
+  const defaultConfig = configs.find((c) => c.default);
+  if (defaultConfig) {
+    const { switchCodexProvider } = await Promise.resolve().then(function () { return codex; });
+    await switchCodexProvider(defaultConfig.name);
+    console.log(ansis.green(`\u2714 ${i18n.t("multi-config:defaultProviderSet", { name: defaultConfig.name })}`));
+  }
+}
+async function convertToClaudeCodeProfile(config) {
+  const { ClaudeCodeConfigManager } = await import('./claude-code-config-manager.mjs');
+  const profile = {
+    name: config.name,
+    authType: config.type,
+    apiKey: config.key,
+    baseUrl: config.url,
+    id: ClaudeCodeConfigManager.generateProfileId(config.name)
+  };
+  return profile;
+}
+function convertToCodexProvider(config) {
+  return {
+    id: config.name.toLowerCase().replace(/[^a-z0-9]/g, "-"),
+    name: config.name,
+    baseUrl: config.url || "https://api.anthropic.com",
+    wireApi: "chat",
+    envKey: "ANTHROPIC_API_KEY",
+    requiresOpenaiAuth: false
+  };
+}
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 function getTemplateSettings() {
@@ -5434,4 +5819,4 @@ async function openSettingsJson() {
   }
 }
 
-export { removeLocalClaudeCode as $, AI_OUTPUT_LANGUAGES as A, ensureApiKeyApproved as B, CLAUDE_DIR as C, DEFAULT_CODE_TOOL_TYPE as D, removeApiKeyFromRejected as E, manageApiKeyApproval as F, setPrimaryApiKey as G, ensureClaudeDir as H, backupExistingConfig as I, copyConfigFiles as J, configureApi as K, LEGACY_ZCF_CONFIG_FILES as L, mergeConfigs as M, updateCustomModel as N, updateDefaultModel as O, mergeSettingsFile as P, getExistingModelConfig as Q, getExistingApiConfig as R, SETTINGS_FILE as S, applyAiLanguageDirective as T, switchToOfficialLogin$1 as U, promptApiConfigurationAction as V, isClaudeCodeInstalled as W, installClaudeCode as X, isLocalClaudeCodeInstalled as Y, ZCF_CONFIG_DIR as Z, getInstallationStatus as _, commandExists as a, i18n as a0, readCodexConfig as a1, backupCodexComplete as a2, writeCodexConfig as a3, writeAuthFile as a4, ensureI18nInitialized as a5, detectConfigManagementMode as a6, addNumbersToChoices as a7, readCcrConfig as a8, isCcrInstalled as a9, selectAndInstallWorkflows as aA, checkClaudeCodeVersionAndPrompt as aB, displayBannerWithInfo as aC, runCodexUninstall as aD, configureCodexMcp as aE, configureCodexApi as aF, runCodexWorkflowImport as aG, runCodexFullInit as aH, listCodexProviders as aI, getCurrentCodexProvider as aJ, switchCodexProvider as aK, switchToOfficialLogin as aL, switchToProvider as aM, readZcfConfigAsync as aN, initI18n as aO, selectScriptLanguage as aP, fsOperations as aQ, prompts as aR, codex as aS, installCcr as aa, configureCcrFeature as ab, handleExitPromptError as ac, handleGeneralError as ad, updateZcfConfig as ae, changeLanguage as af, readZcfConfig as ag, configureOutputStyle as ah, isWindows as ai, selectMcpServices as aj, getMcpServices as ak, setupCcrConfiguration as al, modifyApiConfigPartially as am, validateApiKey as an, formatApiKeyDisplay as ao, COMETIX_COMMAND_NAME as ap, COMETIX_COMMANDS as aq, installCometixLine as ar, checkAndUpdateTools as as, readJsonConfig as at, writeJsonConfig as au, displayBanner as av, runCodexUpdate as aw, version as ax, resolveAiOutputLanguage as ay, updatePromptOnly as az, importRecommendedEnv as b, cleanupPermissions as c, importRecommendedPermissions as d, CLAUDE_MD_FILE as e, ClAUDE_CONFIG_FILE as f, getPlatform as g, CLAUDE_VSC_CONFIG_FILE as h, init as i, ZCF_CONFIG_FILE as j, CODE_TOOL_TYPES as k, CODE_TOOL_BANNERS as l, mergeAndCleanPermissions as m, isCodeToolType as n, openSettingsJson as o, SUPPORTED_LANGS as p, LANG_LABELS as q, getAiOutputLanguageLabel as r, getMcpConfigPath as s, readMcpConfig as t, backupMcpConfig as u, mergeMcpServers as v, writeMcpConfig as w, buildMcpServerConfig as x, fixWindowsMcpConfig as y, addCompletedOnboarding as z };
+export { isLocalClaudeCodeInstalled as $, AI_OUTPUT_LANGUAGES as A, fixWindowsMcpConfig as B, CLAUDE_DIR as C, DEFAULT_CODE_TOOL_TYPE as D, addCompletedOnboarding as E, ensureApiKeyApproved as F, removeApiKeyFromRejected as G, manageApiKeyApproval as H, setPrimaryApiKey as I, ensureClaudeDir as J, backupExistingConfig as K, LEGACY_ZCF_CONFIG_FILES as L, copyConfigFiles as M, configureApi as N, mergeConfigs as O, updateCustomModel as P, updateDefaultModel as Q, mergeSettingsFile as R, SETTINGS_FILE as S, getExistingModelConfig as T, getExistingApiConfig as U, applyAiLanguageDirective as V, switchToOfficialLogin$1 as W, promptApiConfigurationAction as X, isClaudeCodeInstalled as Y, ZCF_CONFIG_DIR as Z, installClaudeCode as _, commandExists as a, claudeConfig as a$, getInstallationStatus as a0, removeLocalClaudeCode as a1, ensureI18nInitialized as a2, i18n as a3, addNumbersToChoices as a4, validateApiKey as a5, ensureDir as a6, readDefaultTomlConfig as a7, createDefaultTomlConfig as a8, exists as a9, installCometixLine as aA, checkAndUpdateTools as aB, runCodexUpdate as aC, resolveCodeType as aD, writeJsonConfig as aE, displayBanner as aF, version as aG, resolveAiOutputLanguage as aH, updatePromptOnly as aI, selectAndInstallWorkflows as aJ, checkClaudeCodeVersionAndPrompt as aK, displayBannerWithInfo as aL, runCodexUninstall as aM, configureCodexMcp as aN, configureCodexApi as aO, runCodexWorkflowImportWithLanguageSelection as aP, runCodexFullInit as aQ, switchCodexProvider as aR, listCodexProviders as aS, switchToOfficialLogin as aT, switchToProvider as aU, readZcfConfigAsync as aV, initI18n as aW, selectScriptLanguage as aX, index as aY, fsOperations as aZ, jsonConfig as a_, readJsonConfig as aa, writeTomlConfig as ab, copyFile as ac, detectConfigManagementMode as ad, readCodexConfig as ae, backupCodexComplete as af, writeCodexConfig as ag, writeAuthFile as ah, readCcrConfig as ai, isCcrInstalled as aj, installCcr as ak, configureCcrFeature as al, handleExitPromptError as am, handleGeneralError as an, updateZcfConfig as ao, changeLanguage as ap, readZcfConfig as aq, configureOutputStyle as ar, isWindows as as, selectMcpServices as at, getMcpServices as au, setupCcrConfiguration as av, modifyApiConfigPartially as aw, formatApiKeyDisplay as ax, COMETIX_COMMAND_NAME as ay, COMETIX_COMMANDS as az, importRecommendedEnv as b, config$1 as b0, config as b1, prompts as b2, codex as b3, cleanupPermissions as c, importRecommendedPermissions as d, CLAUDE_MD_FILE as e, ClAUDE_CONFIG_FILE as f, getPlatform as g, CLAUDE_VSC_CONFIG_FILE as h, init as i, ZCF_CONFIG_FILE as j, CODE_TOOL_TYPES as k, CODE_TOOL_BANNERS as l, mergeAndCleanPermissions as m, CODE_TOOL_ALIASES as n, openSettingsJson as o, isCodeToolType as p, SUPPORTED_LANGS as q, resolveCodeToolType as r, LANG_LABELS as s, getAiOutputLanguageLabel as t, getMcpConfigPath as u, readMcpConfig as v, writeMcpConfig as w, backupMcpConfig as x, mergeMcpServers as y, buildMcpServerConfig as z };