zcf 2.12.13 → 3.0.1

package/dist/chunks/simple-config.mjs

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync, rmSync, rmdirSync, readdirSync, statSync, unlinkSync } from 'node:fs';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, copyFileSync, rmSync, rmdirSync, readdirSync, statSync, unlinkSync, renameSync } from 'node:fs';
 import process from 'node:process';
 import ansis from 'ansis';
 import inquirer from 'inquirer';
@@ -10,12 +10,13 @@ import { dirname, join } from 'pathe';
 import { fileURLToPath } from 'node:url';
 import ora from 'ora';
 import semver from 'semver';
-import { exec } from 'tinyexec';
+import { parse, stringify } 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 = "2.12.13";
+const version = "3.0.1";
 const homepage = "https://github.com/UfoMiao/zcf";
 
 const i18n = i18next.createInstance();
@@ -34,7 +35,8 @@ const NAMESPACES = [
   "tools",
   "uninstall",
   "updater",
-  "workflow"
+  "workflow",
+  "codex"
 ];
 function ensureI18nInitialized() {
   if (!i18n.isInitialized) {
@@ -128,7 +130,7 @@ const MCP_SERVICE_CONFIGS = [
     config: {
       type: "stdio",
       command: "npx",
-      args: ["-y", "@upstash/context7-mcp"],
+      args: ["-y", "@upstash/context7-mcp@latest"],
       env: {}
     }
   },
@@ -183,7 +185,7 @@ const MCP_SERVICE_CONFIGS = [
     config: {
       type: "stdio",
       command: "npx",
-      args: ["-y", "exa-mcp-server"],
+      args: ["-y", "exa-mcp-server@latest"],
       env: {
         EXA_API_KEY: "YOUR_EXA_API_KEY"
       }
@@ -215,8 +217,8 @@ async function getMcpServices() {
     },
     {
       id: "Playwright",
-      name: i18n.t("mcp:services.Playwright.name"),
-      description: i18n.t("mcp:services.Playwright.description")
+      name: i18n.t("mcp:services.playwright.name"),
+      description: i18n.t("mcp:services.playwright.description")
     },
     {
       id: "exa",
@@ -353,8 +355,17 @@ const CLAUDE_DIR = join(homedir(), ".claude");
 const SETTINGS_FILE = join(CLAUDE_DIR, "settings.json");
 const CLAUDE_MD_FILE = join(CLAUDE_DIR, "CLAUDE.md");
 const ClAUDE_CONFIG_FILE = join(homedir(), ".claude.json");
-const LEGACY_ZCF_CONFIG_FILE = join(homedir(), ".zcf.json");
-const ZCF_CONFIG_FILE = join(CLAUDE_DIR, ".zcf-config.json");
+const ZCF_CONFIG_DIR = join(homedir(), ".ufomiao", "zcf");
+const ZCF_CONFIG_FILE = join(ZCF_CONFIG_DIR, "config.toml");
+const LEGACY_ZCF_CONFIG_FILES = [
+  join(CLAUDE_DIR, ".zcf-config.json"),
+  join(homedir(), ".zcf.json")
+];
+const CODE_TOOL_TYPES = ["claude-code", "codex"];
+const DEFAULT_CODE_TOOL_TYPE = "claude-code";
+function isCodeToolType(value) {
+  return CODE_TOOL_TYPES.includes(value);
+}
 const SUPPORTED_LANGS = ["zh-CN", "en"];
 const LANG_LABELS = {
   "zh-CN": "\u7B80\u4F53\u4E2D\u6587",
@@ -378,6 +389,24 @@ function getAiOutputLanguageLabel(lang) {
   return lang;
 }
 
+const constants = {
+  __proto__: null,
+  AI_OUTPUT_LANGUAGES: AI_OUTPUT_LANGUAGES,
+  CLAUDE_DIR: CLAUDE_DIR,
+  CLAUDE_MD_FILE: CLAUDE_MD_FILE,
+  CODE_TOOL_TYPES: CODE_TOOL_TYPES,
+  ClAUDE_CONFIG_FILE: ClAUDE_CONFIG_FILE,
+  DEFAULT_CODE_TOOL_TYPE: DEFAULT_CODE_TOOL_TYPE,
+  LANG_LABELS: LANG_LABELS,
+  LEGACY_ZCF_CONFIG_FILES: LEGACY_ZCF_CONFIG_FILES,
+  SETTINGS_FILE: SETTINGS_FILE,
+  SUPPORTED_LANGS: SUPPORTED_LANGS,
+  ZCF_CONFIG_DIR: ZCF_CONFIG_DIR,
+  ZCF_CONFIG_FILE: ZCF_CONFIG_FILE,
+  getAiOutputLanguageLabel: getAiOutputLanguageLabel,
+  isCodeToolType: isCodeToolType
+};
+
 function getDisplayWidth(str) {
   let width = 0;
   for (const char of str) {
@@ -398,7 +427,8 @@ function displayBanner(subtitle) {
   ensureI18nInitialized();
   const defaultSubtitle = i18n.t("cli:banner.subtitle");
   const subtitleText = subtitle || defaultSubtitle;
-  const paddedSubtitle = padToDisplayWidth(subtitleText, 60);
+  const paddedSubtitle = padToDisplayWidth(subtitleText, 30);
+  const paddedTitle = padToDisplayWidth("Zero-Config Code Flow", 60);
   console.log(
     ansis.cyan.bold(`
 \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
@@ -408,10 +438,9 @@ function displayBanner(subtitle) {
 \u2551      \u2588\u2588\u2554\u255D   \u2588\u2588\u2551      \u2588\u2588\u2588\u2588\u2588\u2557                                    \u2551
 \u2551    \u2588\u2588\u2554\u255D     \u2588\u2588\u2551      \u2588\u2588\u2554\u2550\u2550\u255D                                    \u2551
 \u2551   \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2551                                       \u2551
-\u2551   \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D   \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D                                       \u2551
+\u2551   \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D   \u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D        ${ansis.gray(paddedSubtitle)} \u2551
 \u2551                                                                \u2551
-\u2551   ${ansis.white.bold("Zero-Config Claude-Code Flow")}                                 \u2551
-\u2551   ${ansis.gray(paddedSubtitle)} \u2551
+\u2551   ${ansis.white.bold(paddedTitle)} \u2551
 \u2551                                                                \u2551
 \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
 `)
@@ -423,6 +452,118 @@ function displayBannerWithInfo(subtitle) {
 `));
 }
 
+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 isWSL() {
+  if (process.env.WSL_DISTRO_NAME) {
+    return true;
+  }
+  if (existsSync("/proc/version")) {
+    try {
+      const version = readFileSync("/proc/version", "utf8");
+      if (version.includes("Microsoft") || version.includes("WSL")) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  if (existsSync("/mnt/c")) {
+    return true;
+  }
+  return false;
+}
+function getWSLDistro() {
+  if (process.env.WSL_DISTRO_NAME) {
+    return process.env.WSL_DISTRO_NAME;
+  }
+  if (existsSync("/etc/os-release")) {
+    try {
+      const osRelease = readFileSync("/etc/os-release", "utf8");
+      const nameMatch = osRelease.match(/^PRETTY_NAME="(.+)"$/m);
+      if (nameMatch) {
+        return nameMatch[1];
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function getWSLInfo() {
+  if (!isWSL()) {
+    return null;
+  }
+  let version = null;
+  if (existsSync("/proc/version")) {
+    try {
+      version = readFileSync("/proc/version", "utf8").trim();
+    } catch {
+    }
+  }
+  return {
+    isWSL: true,
+    distro: getWSLDistro(),
+    version
+  };
+}
+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;
+}
+
 class FileSystemError extends Error {
   constructor(message, path, cause) {
     super(message);
@@ -546,7 +687,7 @@ async function isExecutable(path) {
     if (!stats.isFile()) {
       return false;
     }
-    if (process.platform !== "win32") {
+    if (!isWindows()) {
       const mode = stats.mode;
       const executePermission = 73;
       return (mode & executePermission) !== 0;
@@ -593,6 +734,23 @@ async function remove(path) {
   }
 }
 
+const fsOperations = {
+  __proto__: null,
+  FileSystemError: FileSystemError,
+  copyDir: copyDir,
+  copyFile: copyFile,
+  ensureDir: ensureDir,
+  ensureFileDir: ensureFileDir,
+  exists: exists,
+  getStats: getStats,
+  isExecutable: isExecutable,
+  readDir: readDir,
+  readFile: readFile,
+  remove: remove,
+  removeFile: removeFile,
+  writeFile: writeFile
+};
+
 function readJsonConfig(path, options = {}) {
   const { defaultValue = null, validate, sanitize } = options;
   if (!exists(path)) {
@@ -701,118 +859,6 @@ function deepClone(obj) {
   return obj;
 }
 
-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 isWSL() {
-  if (process.env.WSL_DISTRO_NAME) {
-    return true;
-  }
-  if (existsSync("/proc/version")) {
-    try {
-      const version = readFileSync("/proc/version", "utf8");
-      if (version.includes("Microsoft") || version.includes("WSL")) {
-        return true;
-      }
-    } catch {
-    }
-  }
-  if (existsSync("/mnt/c")) {
-    return true;
-  }
-  return false;
-}
-function getWSLDistro() {
-  if (process.env.WSL_DISTRO_NAME) {
-    return process.env.WSL_DISTRO_NAME;
-  }
-  if (existsSync("/etc/os-release")) {
-    try {
-      const osRelease = readFileSync("/etc/os-release", "utf8");
-      const nameMatch = osRelease.match(/^PRETTY_NAME="(.+)"$/m);
-      if (nameMatch) {
-        return nameMatch[1];
-      }
-    } catch {
-    }
-  }
-  return null;
-}
-function getWSLInfo() {
-  if (!isWSL()) {
-    return null;
-  }
-  let version = null;
-  if (existsSync("/proc/version")) {
-    try {
-      version = readFileSync("/proc/version", "utf8").trim();
-    } catch {
-    }
-  }
-  return {
-    isWSL: true,
-    distro: getWSLDistro(),
-    version
-  };
-}
-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;
 }
@@ -1008,7 +1054,7 @@ function copyConfigFiles(onlyMd = false) {
   const currentFilePath = fileURLToPath(import.meta.url);
   const distDir = dirname(dirname(currentFilePath));
   const rootDir = dirname(distDir);
-  const baseTemplateDir = join(rootDir, "templates");
+  const baseTemplateDir = join(rootDir, "templates", "claude-code");
   if (!onlyMd) {
     const baseSettingsPath = join(baseTemplateDir, "common", "settings.json");
     const destSettingsPath = join(CLAUDE_DIR, "settings.json");
@@ -1022,7 +1068,7 @@ function getDefaultSettings() {
     const currentFilePath = fileURLToPath(import.meta.url);
     const distDir = dirname(dirname(currentFilePath));
     const rootDir = dirname(distDir);
-    const templateSettingsPath = join(rootDir, "templates", "common", "settings.json");
+    const templateSettingsPath = join(rootDir, "templates", "claude-code", "common", "settings.json");
     return readJsonConfig(templateSettingsPath) || {};
   } catch (error) {
     console.error("Failed to read template settings", error);
@@ -1442,9 +1488,9 @@ async function configureCcrWithPreset(preset) {
   if (preset.requiresApiKey) {
     try {
       const { apiKey } = await inquirer.prompt({
-        type: "input",
+        type: "password",
         name: "apiKey",
-        message: i18n.t("ccr:enterApiKeyForProvider").replace("{provider}", preset.name),
+        message: i18n.t("ccr:enterApiKeyForProvider").replace("{provider}", preset.name) + i18n.t("common:inputHidden"),
         validate: async (value) => !!value || i18n.t("api:keyRequired")
       });
       provider.api_key = apiKey;
@@ -1987,29 +2033,1613 @@ async function installCcr() {
   }
 }
 
-function getPlatformStatusLineConfig() {
-  return {
-    type: "command",
-    command: isWindows() ? "%USERPROFILE%\\.claude\\ccline\\ccline.exe" : "~/.claude/ccline/ccline",
-    padding: 0
-  };
-}
-
-function addCCometixLineConfig() {
-  try {
-    const statusLineConfig = getPlatformStatusLineConfig();
-    let settings = {};
-    if (exists(SETTINGS_FILE)) {
-      settings = readJsonConfig(SETTINGS_FILE) || {};
-    }
-    settings.statusLine = statusLineConfig;
-    writeJsonConfig(SETTINGS_FILE, settings);
-    return true;
-  } catch (error) {
-    console.error("Failed to add CCometixLine configuration:", error);
-    return false;
-  }
-}
+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) => {
+    if (choice.disabled) {
+      return choice;
+    }
+    const numbered = {
+      ...choice,
+      name: `${format(currentNumber)}${choice.name}`
+    };
+    currentNumber++;
+    return numbered;
+  });
+}
+
+function isSupportedLang(value) {
+  return SUPPORTED_LANGS.includes(value);
+}
+function sanitizePreferredLang(lang) {
+  return isSupportedLang(lang) ? lang : "en";
+}
+function sanitizeCodeToolType(codeTool) {
+  return isCodeToolType(codeTool) ? codeTool : DEFAULT_CODE_TOOL_TYPE;
+}
+function readTomlConfig(configPath) {
+  try {
+    if (!exists(configPath)) {
+      return null;
+    }
+    const content = readFile(configPath);
+    const parsed = parse(content);
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function writeTomlConfig(configPath, config) {
+  try {
+    const configDir = dirname(configPath);
+    ensureDir(configDir);
+    const tomlContent = stringify(config);
+    writeFile(configPath, tomlContent);
+  } catch {
+  }
+}
+function createDefaultTomlConfig(preferredLang = "en", claudeCodeInstallType = "global") {
+  return {
+    version: "1.0.0",
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+    general: {
+      preferredLang,
+      templateLang: preferredLang,
+      // Default templateLang to preferredLang for new installations
+      aiOutputLang: preferredLang === "zh-CN" ? "zh-CN" : void 0,
+      currentTool: DEFAULT_CODE_TOOL_TYPE
+    },
+    claudeCode: {
+      enabled: true,
+      outputStyles: ["engineer-professional"],
+      defaultOutputStyle: "engineer-professional",
+      installType: claudeCodeInstallType
+    },
+    codex: {
+      enabled: false,
+      systemPromptStyle: "engineer-professional"
+    }
+  };
+}
+function migrateFromJsonConfig(jsonConfig) {
+  const claudeCodeInstallType = jsonConfig.claudeCodeInstallation?.type || "global";
+  const defaultConfig = createDefaultTomlConfig("en", claudeCodeInstallType);
+  const tomlConfig = {
+    version: jsonConfig.version || defaultConfig.version,
+    lastUpdated: jsonConfig.lastUpdated || (/* @__PURE__ */ new Date()).toISOString(),
+    general: {
+      preferredLang: jsonConfig.preferredLang || defaultConfig.general.preferredLang,
+      templateLang: jsonConfig.templateLang || jsonConfig.preferredLang || defaultConfig.general.preferredLang,
+      // Backward compatibility: use preferredLang as default
+      aiOutputLang: jsonConfig.aiOutputLang || defaultConfig.general.aiOutputLang,
+      currentTool: jsonConfig.codeToolType || defaultConfig.general.currentTool
+    },
+    claudeCode: {
+      enabled: jsonConfig.codeToolType === "claude-code",
+      outputStyles: jsonConfig.outputStyles || defaultConfig.claudeCode.outputStyles,
+      defaultOutputStyle: jsonConfig.defaultOutputStyle || defaultConfig.claudeCode.defaultOutputStyle,
+      installType: claudeCodeInstallType
+    },
+    codex: {
+      enabled: jsonConfig.codeToolType === "codex",
+      systemPromptStyle: jsonConfig.systemPromptStyle || defaultConfig.codex.systemPromptStyle
+    }
+  };
+  return tomlConfig;
+}
+function updateTomlConfig(configPath, updates) {
+  const existingConfig = readTomlConfig(configPath) || createDefaultTomlConfig();
+  const updatedConfig = {
+    version: updates.version || existingConfig.version,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+    general: {
+      ...existingConfig.general,
+      ...updates.general
+    },
+    claudeCode: {
+      ...existingConfig.claudeCode,
+      ...updates.claudeCode
+    },
+    codex: {
+      ...existingConfig.codex,
+      ...updates.codex
+    }
+  };
+  writeTomlConfig(configPath, updatedConfig);
+  return updatedConfig;
+}
+function convertTomlToLegacyConfig(tomlConfig) {
+  return {
+    version: tomlConfig.version,
+    preferredLang: tomlConfig.general.preferredLang,
+    templateLang: tomlConfig.general.templateLang,
+    aiOutputLang: tomlConfig.general.aiOutputLang,
+    outputStyles: tomlConfig.claudeCode.outputStyles,
+    defaultOutputStyle: tomlConfig.claudeCode.defaultOutputStyle,
+    codeToolType: tomlConfig.general.currentTool,
+    lastUpdated: tomlConfig.lastUpdated
+  };
+}
+function convertLegacyToTomlConfig(legacyConfig) {
+  return migrateFromJsonConfig(legacyConfig);
+}
+function normalizeZcfConfig(config) {
+  if (!config) {
+    return null;
+  }
+  return {
+    version: typeof config.version === "string" ? config.version : "1.0.0",
+    preferredLang: sanitizePreferredLang(config.preferredLang),
+    templateLang: config.templateLang ? sanitizePreferredLang(config.templateLang) : void 0,
+    aiOutputLang: config.aiOutputLang,
+    outputStyles: Array.isArray(config.outputStyles) ? config.outputStyles : void 0,
+    defaultOutputStyle: typeof config.defaultOutputStyle === "string" ? config.defaultOutputStyle : void 0,
+    codeToolType: sanitizeCodeToolType(config.codeToolType),
+    lastUpdated: typeof config.lastUpdated === "string" ? config.lastUpdated : (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function migrateZcfConfigIfNeeded() {
+  const target = ZCF_CONFIG_FILE;
+  const removed = [];
+  const targetExists = existsSync(target);
+  const legacySources = LEGACY_ZCF_CONFIG_FILES.filter((path) => existsSync(path));
+  if (!targetExists && legacySources.length > 0) {
+    const source = legacySources[0];
+    if (!existsSync(ZCF_CONFIG_DIR)) {
+      mkdirSync(ZCF_CONFIG_DIR, { recursive: true });
+    }
+    renameSync(source, target);
+    for (const leftover of legacySources.slice(1)) {
+      try {
+        rmSync(leftover, { force: true });
+        removed.push(leftover);
+      } catch {
+      }
+    }
+    return { migrated: true, source, target, removed };
+  }
+  if (targetExists && legacySources.length > 0) {
+    for (const source of legacySources) {
+      try {
+        rmSync(source, { force: true });
+        removed.push(source);
+      } catch {
+      }
+    }
+    return { migrated: false, target, removed };
+  }
+  return { migrated: false, target, removed };
+}
+function readZcfConfig() {
+  migrateZcfConfigIfNeeded();
+  const tomlConfig = readTomlConfig(ZCF_CONFIG_FILE);
+  if (tomlConfig) {
+    return convertTomlToLegacyConfig(tomlConfig);
+  }
+  const raw = readJsonConfig(ZCF_CONFIG_FILE.replace(".toml", ".json"));
+  const normalized = normalizeZcfConfig(raw || null);
+  if (normalized) {
+    return normalized;
+  }
+  for (const legacyPath of LEGACY_ZCF_CONFIG_FILES) {
+    if (existsSync(legacyPath)) {
+      const legacyRaw = readJsonConfig(legacyPath);
+      const legacyNormalized = normalizeZcfConfig(legacyRaw || null);
+      if (legacyNormalized) {
+        return legacyNormalized;
+      }
+    }
+  }
+  return null;
+}
+async function readZcfConfigAsync() {
+  return readZcfConfig();
+}
+function writeZcfConfig(config) {
+  try {
+    const sanitizedConfig = {
+      ...config,
+      codeToolType: sanitizeCodeToolType(config.codeToolType)
+    };
+    const tomlConfig = convertLegacyToTomlConfig(sanitizedConfig);
+    writeTomlConfig(ZCF_CONFIG_FILE, tomlConfig);
+  } catch {
+  }
+}
+function updateZcfConfig(updates) {
+  const existingConfig = readZcfConfig();
+  const newConfig = {
+    version: updates.version || existingConfig?.version || "1.0.0",
+    preferredLang: updates.preferredLang || existingConfig?.preferredLang || "en",
+    templateLang: updates.templateLang !== void 0 ? updates.templateLang : existingConfig?.templateLang,
+    aiOutputLang: updates.aiOutputLang || existingConfig?.aiOutputLang,
+    outputStyles: updates.outputStyles !== void 0 ? updates.outputStyles : existingConfig?.outputStyles,
+    defaultOutputStyle: updates.defaultOutputStyle !== void 0 ? updates.defaultOutputStyle : existingConfig?.defaultOutputStyle,
+    codeToolType: updates.codeToolType || existingConfig?.codeToolType || DEFAULT_CODE_TOOL_TYPE,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeZcfConfig(newConfig);
+}
+function readDefaultTomlConfig() {
+  return readTomlConfig(ZCF_CONFIG_FILE);
+}
+
+const zcfConfig = {
+  __proto__: null,
+  createDefaultTomlConfig: createDefaultTomlConfig,
+  migrateFromJsonConfig: migrateFromJsonConfig,
+  migrateZcfConfigIfNeeded: migrateZcfConfigIfNeeded,
+  readDefaultTomlConfig: readDefaultTomlConfig,
+  readTomlConfig: readTomlConfig,
+  readZcfConfig: readZcfConfig,
+  readZcfConfigAsync: readZcfConfigAsync,
+  updateTomlConfig: updateTomlConfig,
+  updateZcfConfig: updateZcfConfig,
+  writeTomlConfig: writeTomlConfig,
+  writeZcfConfig: writeZcfConfig
+};
+
+async function selectAiOutputLanguage(defaultLang) {
+  ensureI18nInitialized();
+  console.log(ansis.dim(`
+  ${i18n.t("language:aiOutputLangHint")}
+`));
+  const aiLangChoices = Object.entries(AI_OUTPUT_LANGUAGES).map(([key]) => ({
+    title: getAiOutputLanguageLabel(key),
+    value: key
+  }));
+  const defaultChoice = defaultLang || "en";
+  const { lang } = await inquirer.prompt({
+    type: "list",
+    name: "lang",
+    message: i18n.t("language:selectAiOutputLang"),
+    choices: addNumbersToChoices(aiLangChoices.map((choice) => ({
+      name: choice.title,
+      value: choice.value
+    }))),
+    default: defaultChoice
+  });
+  if (!lang) {
+    console.log(ansis.yellow(i18n.t("common:cancelled")));
+    process.exit(0);
+  }
+  const aiOutputLang = lang;
+  if (aiOutputLang === "custom") {
+    const { customLang } = await inquirer.prompt({
+      type: "input",
+      name: "customLang",
+      message: i18n.t("language:enterCustomLanguage"),
+      validate: async (value) => !!value || i18n.t("language:languageRequired") || "Language is required"
+    });
+    if (!customLang) {
+      console.log(ansis.yellow(i18n.t("common:cancelled")));
+      process.exit(0);
+    }
+    return customLang;
+  }
+  return aiOutputLang;
+}
+const LANGUAGE_SELECTION_MESSAGES = {
+  selectLanguage: "Select ZCF display language / \u9009\u62E9ZCF\u663E\u793A\u8BED\u8A00",
+  operationCancelled: "Operation cancelled / \u64CD\u4F5C\u5DF2\u53D6\u6D88"
+};
+async function selectScriptLanguage(currentLang) {
+  const zcfConfig = readZcfConfig();
+  if (zcfConfig?.preferredLang) {
+    return zcfConfig.preferredLang;
+  }
+  const { lang } = await inquirer.prompt({
+    type: "list",
+    name: "lang",
+    message: LANGUAGE_SELECTION_MESSAGES.selectLanguage,
+    choices: addNumbersToChoices(SUPPORTED_LANGS.map((l) => ({
+      name: LANG_LABELS[l],
+      value: l
+    })))
+  });
+  if (!lang) {
+    console.log(ansis.yellow(LANGUAGE_SELECTION_MESSAGES.operationCancelled));
+    process.exit(0);
+  }
+  const scriptLang = lang;
+  updateZcfConfig({
+    version,
+    preferredLang: scriptLang
+  });
+  return scriptLang;
+}
+async function resolveAiOutputLanguage(scriptLang, commandLineOption, savedConfig) {
+  ensureI18nInitialized();
+  if (commandLineOption) {
+    return commandLineOption;
+  }
+  if (savedConfig?.aiOutputLang) {
+    const currentLanguageLabel = getAiOutputLanguageLabel(savedConfig.aiOutputLang) || savedConfig.aiOutputLang;
+    console.log(ansis.blue(`${i18n.t("language:currentConfigFound")}: ${currentLanguageLabel}`));
+    const { shouldModify } = await inquirer.prompt({
+      type: "confirm",
+      name: "shouldModify",
+      message: i18n.t("language:modifyConfigPrompt"),
+      default: false
+    });
+    if (shouldModify === void 0) {
+      console.log(ansis.yellow(i18n.t("common:cancelled")));
+      process.exit(0);
+    }
+    if (!shouldModify) {
+      console.log(ansis.gray(`\u2714 ${i18n.t("language:aiOutputLangHint")}: ${currentLanguageLabel}`));
+      return savedConfig.aiOutputLang;
+    }
+    return await selectAiOutputLanguage(scriptLang);
+  }
+  return await selectAiOutputLanguage(scriptLang);
+}
+async function selectTemplateLanguage() {
+  ensureI18nInitialized();
+  const LANG_HINT_KEYS = {
+    "zh-CN": i18n.t("language:configLangHint.zh-CN"),
+    "en": i18n.t("language:configLangHint.en")
+  };
+  const { lang } = await inquirer.prompt({
+    type: "list",
+    name: "lang",
+    message: i18n.t("language:selectConfigLang"),
+    choices: addNumbersToChoices(
+      SUPPORTED_LANGS.map((l) => ({
+        name: `${LANG_LABELS[l]} - ${LANG_HINT_KEYS[l]}`,
+        value: l
+      }))
+    )
+  });
+  if (!lang) {
+    console.log(ansis.yellow(i18n.t("common:cancelled")));
+    process.exit(0);
+  }
+  return lang;
+}
+async function resolveTemplateLanguage(commandLineOption, savedConfig) {
+  ensureI18nInitialized();
+  if (commandLineOption) {
+    return commandLineOption;
+  }
+  if (savedConfig?.templateLang) {
+    const currentLanguageLabel = LANG_LABELS[savedConfig.templateLang];
+    console.log(ansis.blue(`${i18n.t("language:currentTemplateLanguageFound")}: ${currentLanguageLabel}`));
+    const { shouldModify } = await inquirer.prompt({
+      type: "confirm",
+      name: "shouldModify",
+      message: i18n.t("language:modifyTemplateLanguagePrompt"),
+      default: false
+    });
+    if (shouldModify === void 0) {
+      console.log(ansis.yellow(i18n.t("common:cancelled")));
+      process.exit(0);
+    }
+    if (!shouldModify) {
+      console.log(ansis.gray(`\u2714 ${i18n.t("language:selectConfigLang")}: ${currentLanguageLabel}`));
+      return savedConfig.templateLang;
+    }
+    return await selectTemplateLanguage();
+  }
+  if (savedConfig?.preferredLang && !savedConfig?.templateLang) {
+    console.log(ansis.yellow(`${i18n.t("language:usingFallbackTemplate")}: ${LANG_LABELS[savedConfig.preferredLang]}`));
+    const { shouldModify } = await inquirer.prompt({
+      type: "confirm",
+      name: "shouldModify",
+      message: i18n.t("language:modifyTemplateLanguagePrompt"),
+      default: false
+    });
+    if (shouldModify === void 0) {
+      console.log(ansis.yellow(i18n.t("common:cancelled")));
+      process.exit(0);
+    }
+    if (!shouldModify) {
+      return savedConfig.preferredLang;
+    }
+    return await selectTemplateLanguage();
+  }
+  return await selectTemplateLanguage();
+}
+async function resolveSystemPromptStyle(availablePrompts, commandLineOption, savedConfig) {
+  ensureI18nInitialized();
+  if (commandLineOption && availablePrompts.some((p) => p.id === commandLineOption)) {
+    return commandLineOption;
+  }
+  if (savedConfig?.codex?.systemPromptStyle) {
+    const currentStyleId = savedConfig.codex.systemPromptStyle;
+    const currentStyle = availablePrompts.find((p) => p.id === currentStyleId);
+    if (currentStyle) {
+      console.log(ansis.blue(`${i18n.t("language:currentSystemPromptFound")}: ${currentStyle.name}`));
+      const { shouldModify } = await inquirer.prompt({
+        type: "confirm",
+        name: "shouldModify",
+        message: i18n.t("language:modifySystemPromptPrompt"),
+        default: false
+      });
+      if (shouldModify === void 0) {
+        console.log(ansis.yellow(i18n.t("common:cancelled")));
+        process.exit(0);
+      }
+      if (!shouldModify) {
+        console.log(ansis.gray(`\u2714 ${i18n.t("language:currentSystemPromptFound")}: ${currentStyle.name}`));
+        return currentStyleId;
+      }
+    }
+  }
+  const { systemPrompt } = await inquirer.prompt([{
+    type: "list",
+    name: "systemPrompt",
+    message: i18n.t("codex:systemPromptPrompt"),
+    choices: addNumbersToChoices(availablePrompts.map((style) => ({
+      name: `${style.name} - ${ansis.gray(style.description)}`,
+      value: style.id
+    }))),
+    default: "engineer-professional"
+    // Default to engineer-professional
+  }]);
+  if (!systemPrompt) {
+    console.log(ansis.yellow(i18n.t("common:cancelled")));
+    process.exit(0);
+  }
+  return systemPrompt;
+}
+
+const prompts = {
+  __proto__: null,
+  resolveAiOutputLanguage: resolveAiOutputLanguage,
+  resolveSystemPromptStyle: resolveSystemPromptStyle,
+  resolveTemplateLanguage: resolveTemplateLanguage,
+  selectAiOutputLanguage: selectAiOutputLanguage,
+  selectScriptLanguage: selectScriptLanguage,
+  selectTemplateLanguage: selectTemplateLanguage
+};
+
+function detectConfigManagementMode() {
+  try {
+    const config = readCodexConfig();
+    if (!config || !config.providers || config.providers.length === 0) {
+      return {
+        mode: "initial",
+        hasProviders: false,
+        providerCount: 0
+      };
+    }
+    return {
+      mode: "management",
+      hasProviders: true,
+      providerCount: config.providers.length,
+      currentProvider: config.modelProvider,
+      providers: config.providers,
+      isUnmanaged: config.managed === false ? true : void 0
+    };
+  } catch (error) {
+    return {
+      mode: "initial",
+      hasProviders: false,
+      providerCount: 0,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+
+const CODEX_DIR = join(homedir(), ".codex");
+const CODEX_CONFIG_FILE = join(CODEX_DIR, "config.toml");
+const CODEX_AUTH_FILE = join(CODEX_DIR, "auth.json");
+const CODEX_AGENTS_FILE = join(CODEX_DIR, "AGENTS.md");
+const CODEX_PROMPTS_DIR = join(CODEX_DIR, "prompts");
+function getRootDir$1() {
+  const currentFilePath = fileURLToPath(import.meta.url);
+  let dir = dirname(currentFilePath);
+  while (dir !== dirname(dir)) {
+    if (exists(join(dir, "templates"))) {
+      return dir;
+    }
+    dir = dirname(dir);
+  }
+  return dirname(currentFilePath);
+}
+async function executeCodexInstallation(isUpdate) {
+  const action = isUpdate ? "update" : "install";
+  if (isUpdate) {
+    console.log(ansis.cyan(i18n.t("codex:updatingCli")));
+  } else {
+    console.log(ansis.cyan(i18n.t("codex:installingCli")));
+  }
+  const result = await x("npm", ["install", "-g", "@openai/codex"]);
+  if (result.exitCode !== 0) {
+    throw new Error(`Failed to ${action} codex CLI: exit code ${result.exitCode}`);
+  }
+  if (isUpdate) {
+    console.log(ansis.green(i18n.t("codex:updateSuccess")));
+  } else {
+    console.log(ansis.green(i18n.t("codex:installSuccess")));
+  }
+}
+function getUninstallOptions() {
+  return [
+    { name: i18n.t("codex:uninstallItemConfig"), value: "config" },
+    { name: i18n.t("codex:uninstallItemAuth"), value: "auth" },
+    { name: i18n.t("codex:uninstallItemApiConfig"), value: "api-config" },
+    { name: i18n.t("codex:uninstallItemMcpConfig"), value: "mcp-config" },
+    { name: i18n.t("codex:uninstallItemSystemPrompt"), value: "system-prompt" },
+    { name: i18n.t("codex:uninstallItemWorkflow"), value: "workflow" },
+    { name: i18n.t("codex:uninstallItemCliPackage"), value: "cli-package" },
+    { name: i18n.t("codex:uninstallItemBackups"), value: "backups" }
+  ];
+}
+function handleUninstallCancellation() {
+  console.log(ansis.yellow(i18n.t("codex:uninstallCancelled")));
+}
+function createBackupDirectory(timestamp) {
+  const backupBaseDir = join(CODEX_DIR, "backup");
+  const backupDir = join(backupBaseDir, `backup_${timestamp}`);
+  ensureDir(backupDir);
+  return backupDir;
+}
+function backupCodexFiles() {
+  if (!exists(CODEX_DIR))
+    return null;
+  const timestamp = dayjs().format("YYYY-MM-DD_HH-mm-ss");
+  const backupDir = createBackupDirectory(timestamp);
+  const filter = (path) => {
+    return !path.includes("/backup");
+  };
+  copyDir(CODEX_DIR, backupDir, { filter });
+  return backupDir;
+}
+function backupCodexComplete() {
+  return backupCodexFiles();
+}
+function backupCodexConfig() {
+  if (!exists(CODEX_CONFIG_FILE))
+    return null;
+  try {
+    const timestamp = dayjs().format("YYYY-MM-DD_HH-mm-ss");
+    const backupDir = createBackupDirectory(timestamp);
+    const backupPath = join(backupDir, "config.toml");
+    copyFile(CODEX_CONFIG_FILE, backupPath);
+    return backupPath;
+  } catch {
+    return null;
+  }
+}
+function backupCodexAgents() {
+  if (!exists(CODEX_AGENTS_FILE))
+    return null;
+  try {
+    const timestamp = dayjs().format("YYYY-MM-DD_HH-mm-ss");
+    const backupDir = createBackupDirectory(timestamp);
+    const backupPath = join(backupDir, "AGENTS.md");
+    copyFile(CODEX_AGENTS_FILE, backupPath);
+    return backupPath;
+  } catch {
+    return null;
+  }
+}
+function backupCodexPrompts() {
+  if (!exists(CODEX_PROMPTS_DIR))
+    return null;
+  try {
+    const timestamp = dayjs().format("YYYY-MM-DD_HH-mm-ss");
+    const backupDir = createBackupDirectory(timestamp);
+    const backupPath = join(backupDir, "prompts");
+    copyDir(CODEX_PROMPTS_DIR, backupPath);
+    return backupPath;
+  } catch {
+    return null;
+  }
+}
+function getBackupMessage(path) {
+  if (!path)
+    return "";
+  ensureI18nInitialized();
+  return i18n.t("codex:backupSuccess", { path });
+}
+function sanitizeProviderName(input) {
+  const cleaned = input.trim();
+  if (!cleaned)
+    return "";
+  return cleaned.replace(/[^\w.-]/g, "");
+}
+function parseCodexConfig(content) {
+  if (!content.trim()) {
+    return {
+      model: null,
+      modelProvider: null,
+      providers: [],
+      mcpServices: [],
+      managed: false,
+      otherConfig: [],
+      modelProviderCommented: void 0
+    };
+  }
+  try {
+    const tomlData = parse(content);
+    const providers = [];
+    if (tomlData.model_providers) {
+      for (const [id, providerData] of Object.entries(tomlData.model_providers)) {
+        const provider = providerData;
+        providers.push({
+          id,
+          name: provider.name || id,
+          baseUrl: provider.base_url || "",
+          wireApi: provider.wire_api || "responses",
+          envKey: provider.env_key || "OPENAI_API_KEY",
+          requiresOpenaiAuth: provider.requires_openai_auth !== false
+        });
+      }
+    }
+    const mcpServices = [];
+    if (tomlData.mcp_servers) {
+      for (const [id, mcpData] of Object.entries(tomlData.mcp_servers)) {
+        const mcp = mcpData;
+        mcpServices.push({
+          id,
+          command: mcp.command || id,
+          args: mcp.args || [],
+          env: Object.keys(mcp.env || {}).length > 0 ? mcp.env : void 0,
+          startup_timeout_ms: mcp.startup_timeout_ms
+        });
+      }
+    }
+    const model = tomlData.model || null;
+    let modelProvider = null;
+    let modelProviderCommented;
+    const commentedMatch = content.match(/^(\s*)#\s*model_provider\s*=\s*"([^"]+)"/m);
+    if (commentedMatch) {
+      modelProvider = commentedMatch[2];
+      modelProviderCommented = true;
+    } else {
+      const lines2 = content.split("\n");
+      let inSection = false;
+      for (const line of lines2) {
+        const trimmedLine = line.trim();
+        if (!trimmedLine)
+          continue;
+        if (trimmedLine.startsWith("[")) {
+          inSection = true;
+          continue;
+        }
+        if (trimmedLine.startsWith("#")) {
+          if (trimmedLine.includes("--- model provider added by ZCF ---")) {
+            inSection = false;
+          }
+          continue;
+        }
+        if (!inSection && trimmedLine.startsWith("model_provider")) {
+          const match = trimmedLine.match(/model_provider\s*=\s*"([^"]+)"/);
+          if (match) {
+            modelProvider = match[1];
+            modelProviderCommented = false;
+            break;
+          }
+        }
+      }
+      if (!modelProvider) {
+        modelProvider = tomlData.model_provider || null;
+        modelProviderCommented = false;
+      }
+    }
+    const otherConfig = [];
+    const lines = content.split("\n");
+    let skipCurrentSection = false;
+    let currentSection = "";
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      if (trimmedLine.includes("--- model provider added by ZCF ---") || trimmedLine.includes("--- MCP servers added by ZCF ---") || trimmedLine.includes("Managed by ZCF")) {
+        continue;
+      }
+      const sectionMatch = trimmedLine.match(/^\[([^\]]+)\]/);
+      if (sectionMatch) {
+        currentSection = sectionMatch[1];
+        skipCurrentSection = currentSection.startsWith("model_providers.") || currentSection.startsWith("mcp_servers.");
+      }
+      if (!skipCurrentSection && (trimmedLine.startsWith("model_provider") || trimmedLine.startsWith("# model_provider") || /^model\s*=/.test(trimmedLine))) {
+        continue;
+      }
+      if (!skipCurrentSection && trimmedLine) {
+        otherConfig.push(line);
+      }
+    }
+    const managed = providers.length > 0 || mcpServices.length > 0 || modelProvider !== null || model !== null;
+    return {
+      model,
+      modelProvider,
+      providers,
+      mcpServices,
+      managed,
+      otherConfig,
+      modelProviderCommented
+    };
+  } catch (error) {
+    console.warn("TOML parsing failed, falling back to basic parsing:", error);
+    return {
+      model: null,
+      modelProvider: null,
+      providers: [],
+      mcpServices: [],
+      managed: false,
+      otherConfig: content.split("\n"),
+      modelProviderCommented: void 0
+    };
+  }
+}
+function readCodexConfig() {
+  if (!exists(CODEX_CONFIG_FILE))
+    return null;
+  try {
+    const content = readFile(CODEX_CONFIG_FILE);
+    return parseCodexConfig(content);
+  } catch {
+    return null;
+  }
+}
+function renderCodexConfig(data) {
+  const lines = [];
+  if (data.model || data.modelProvider || data.providers.length > 0 || data.modelProviderCommented) {
+    lines.push("# --- model provider added by ZCF ---");
+    if (data.model) {
+      lines.push(`model = "${data.model}"`);
+    }
+    if (data.modelProvider) {
+      const commentPrefix = data.modelProviderCommented ? "# " : "";
+      lines.push(`${commentPrefix}model_provider = "${data.modelProvider}"`);
+    }
+    lines.push("");
+  }
+  if (data.otherConfig && data.otherConfig.length > 0) {
+    lines.push(...data.otherConfig);
+    if (data.providers.length > 0 || data.mcpServices.length > 0) {
+      lines.push("");
+    }
+  }
+  if (data.providers.length > 0) {
+    for (const provider of data.providers) {
+      lines.push("");
+      lines.push(`[model_providers.${provider.id}]`);
+      lines.push(`name = "${provider.name}"`);
+      lines.push(`base_url = "${provider.baseUrl}"`);
+      lines.push(`wire_api = "${provider.wireApi}"`);
+      lines.push(`env_key = "${provider.envKey}"`);
+      lines.push(`requires_openai_auth = ${provider.requiresOpenaiAuth}`);
+    }
+  }
+  if (data.mcpServices.length > 0) {
+    lines.push("");
+    lines.push("# --- MCP servers added by ZCF ---");
+    for (const service of data.mcpServices) {
+      lines.push(`[mcp_servers.${service.id}]`);
+      lines.push(`command = "${service.command}"`);
+      const argsString = service.args.length > 0 ? service.args.map((arg) => `"${arg}"`).join(", ") : "";
+      lines.push(`args = [${argsString}]`);
+      if (service.env && Object.keys(service.env).length > 0) {
+        const envEntries = Object.entries(service.env).map(([key, value]) => `${key} = "${value}"`).join(", ");
+        lines.push(`env = {${envEntries}}`);
+      }
+      if (service.startup_timeout_ms) {
+        lines.push(`startup_timeout_ms = ${service.startup_timeout_ms}`);
+      }
+      lines.push("");
+    }
+    if (lines[lines.length - 1] === "") {
+      lines.pop();
+    }
+  }
+  let result = lines.join("\n");
+  if (result && !result.endsWith("\n")) {
+    result += "\n";
+  }
+  return result;
+}
+function writeCodexConfig(data) {
+  ensureDir(CODEX_DIR);
+  writeFile(CODEX_CONFIG_FILE, renderCodexConfig(data));
+}
+function writeAuthFile(newEntries) {
+  ensureDir(CODEX_DIR);
+  const existing = readJsonConfig(CODEX_AUTH_FILE, { defaultValue: {} }) || {};
+  const merged = { ...existing, ...newEntries };
+  writeJsonConfig(CODEX_AUTH_FILE, merged, { pretty: true });
+}
+async function isCodexInstalled() {
+  try {
+    const result = await x("npm", ["list", "-g", "--depth=0"]);
+    if (result.exitCode !== 0) {
+      return false;
+    }
+    return result.stdout.includes("@openai/codex@");
+  } catch {
+    return false;
+  }
+}
+async function getCodexVersion() {
+  try {
+    const result = await x("npm", ["list", "-g", "--depth=0"]);
+    if (result.exitCode !== 0) {
+      return null;
+    }
+    const match = result.stdout.match(/@openai\/codex@(\S+)/);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+async function checkCodexUpdate() {
+  try {
+    const currentVersion = await getCodexVersion();
+    if (!currentVersion) {
+      return {
+        installed: false,
+        currentVersion: null,
+        latestVersion: null,
+        needsUpdate: false
+      };
+    }
+    const result = await x("npm", ["view", "@openai/codex", "--json"]);
+    if (result.exitCode !== 0) {
+      return {
+        installed: true,
+        currentVersion,
+        latestVersion: null,
+        needsUpdate: false
+      };
+    }
+    const packageInfo = JSON.parse(result.stdout);
+    const latestVersion = packageInfo["dist-tags"]?.latest;
+    if (!latestVersion) {
+      return {
+        installed: true,
+        currentVersion,
+        latestVersion: null,
+        needsUpdate: false
+      };
+    }
+    const needsUpdate = semver.gt(latestVersion, currentVersion);
+    return {
+      installed: true,
+      currentVersion,
+      latestVersion,
+      needsUpdate
+    };
+  } catch {
+    return {
+      installed: false,
+      currentVersion: null,
+      latestVersion: null,
+      needsUpdate: false
+    };
+  }
+}
+async function installCodexCli() {
+  ensureI18nInitialized();
+  if (await isCodexInstalled()) {
+    const { needsUpdate } = await checkCodexUpdate();
+    if (needsUpdate) {
+      await executeCodexInstallation(true);
+      return;
+    } else {
+      console.log(ansis.yellow(i18n.t("codex:alreadyInstalled")));
+      return;
+    }
+  }
+  await executeCodexInstallation(false);
+}
+async function runCodexWorkflowImport() {
+  ensureI18nInitialized();
+  await runCodexSystemPromptSelection();
+  await runCodexWorkflowSelection();
+  console.log(ansis.green(i18n.t("codex:workflowInstall")));
+}
+async function runCodexSystemPromptSelection() {
+  ensureI18nInitialized();
+  const rootDir = getRootDir$1();
+  const templateRoot = join(rootDir, "templates", "codex");
+  const zcfConfig$1 = readZcfConfig();
+  const { readDefaultTomlConfig } = await Promise.resolve().then(function () { return zcfConfig; });
+  const tomlConfig = readDefaultTomlConfig();
+  const { resolveTemplateLanguage } = await Promise.resolve().then(function () { return prompts; });
+  const preferredLang = await resolveTemplateLanguage(
+    void 0,
+    // No command line option for this function
+    zcfConfig$1
+  );
+  let langDir = join(templateRoot, preferredLang);
+  if (!exists(langDir))
+    langDir = join(templateRoot, "zh-CN");
+  const systemPromptSrc = join(langDir, "system-prompt");
+  if (!exists(systemPromptSrc))
+    return;
+  const availablePrompts = [
+    {
+      id: "engineer-professional",
+      name: i18n.t("configuration:outputStyles.engineer-professional.name"),
+      description: i18n.t("configuration:outputStyles.engineer-professional.description")
+    },
+    {
+      id: "laowang-engineer",
+      name: i18n.t("configuration:outputStyles.laowang-engineer.name"),
+      description: i18n.t("configuration:outputStyles.laowang-engineer.description")
+    },
+    {
+      id: "nekomata-engineer",
+      name: i18n.t("configuration:outputStyles.nekomata-engineer.name"),
+      description: i18n.t("configuration:outputStyles.nekomata-engineer.description")
+    }
+  ].filter((style) => exists(join(systemPromptSrc, `${style.id}.md`)));
+  if (availablePrompts.length === 0)
+    return;
+  const { resolveSystemPromptStyle } = await Promise.resolve().then(function () { return prompts; });
+  const systemPrompt = await resolveSystemPromptStyle(
+    availablePrompts,
+    void 0,
+    // No command line option for this function
+    tomlConfig
+  );
+  if (!systemPrompt)
+    return;
+  const promptFile = join(systemPromptSrc, `${systemPrompt}.md`);
+  const content = readFile(promptFile);
+  ensureDir(CODEX_DIR);
+  const backupPath = backupCodexAgents();
+  if (backupPath) {
+    console.log(ansis.gray(getBackupMessage(backupPath)));
+  }
+  writeFile(CODEX_AGENTS_FILE, content);
+  try {
+    const { updateTomlConfig } = await Promise.resolve().then(function () { return zcfConfig; });
+    const { ZCF_CONFIG_FILE } = await Promise.resolve().then(function () { return constants; });
+    updateTomlConfig(ZCF_CONFIG_FILE, {
+      codex: {
+        systemPromptStyle: systemPrompt
+      }
+    });
+  } catch (error) {
+    console.error("Failed to update ZCF config:", error);
+  }
+}
+async function runCodexWorkflowSelection() {
+  ensureI18nInitialized();
+  const rootDir = getRootDir$1();
+  const templateRoot = join(rootDir, "templates", "codex");
+  const zcfConfig = readZcfConfig();
+  const templateLang = zcfConfig?.templateLang || zcfConfig?.preferredLang || "en";
+  const preferredLang = templateLang === "en" ? "en" : "zh-CN";
+  let langDir = join(templateRoot, preferredLang);
+  if (!exists(langDir))
+    langDir = join(templateRoot, "zh-CN");
+  const workflowSrc = join(langDir, "workflow");
+  if (!exists(workflowSrc))
+    return;
+  const allWorkflows = getAllWorkflowFiles(workflowSrc);
+  if (allWorkflows.length === 0)
+    return;
+  const { workflows } = await inquirer.prompt([{
+    type: "checkbox",
+    name: "workflows",
+    message: i18n.t("codex:workflowSelectionPrompt"),
+    choices: addNumbersToChoices(allWorkflows.map((workflow) => ({
+      name: workflow.name,
+      value: workflow.path,
+      checked: true
+      // Default all selected
+    })))
+  }]);
+  if (!workflows || workflows.length === 0)
+    return;
+  ensureDir(CODEX_PROMPTS_DIR);
+  const backupPath = backupCodexPrompts();
+  if (backupPath) {
+    console.log(ansis.gray(getBackupMessage(backupPath)));
+  }
+  for (const workflowPath of workflows) {
+    const content = readFile(workflowPath);
+    const filename = workflowPath.split("/").pop() || "workflow.md";
+    const targetPath = join(CODEX_PROMPTS_DIR, filename);
+    writeFile(targetPath, content);
+  }
+}
+function getAllWorkflowFiles(dirPath) {
+  const workflows = [];
+  const sixStepDir = join(dirPath, "sixStep", "prompts");
+  if (exists(sixStepDir)) {
+    const workflowFile = join(sixStepDir, "workflow.md");
+    if (exists(workflowFile)) {
+      workflows.push({
+        name: i18n.t("workflow:workflowOption.sixStepsWorkflow"),
+        path: workflowFile
+      });
+    }
+  }
+  return workflows;
+}
+function toProvidersList(providers) {
+  return providers.map((provider) => ({ name: provider.name || provider.id, value: provider.id }));
+}
+function createApiConfigChoices(providers, currentProvider, isCommented) {
+  const choices = [];
+  const isOfficialMode = !currentProvider || isCommented;
+  choices.push({
+    name: isOfficialMode ? `${ansis.green("\u25CF ")}${i18n.t("codex:useOfficialLogin")} ${ansis.yellow("(\u5F53\u524D)")}` : `  ${i18n.t("codex:useOfficialLogin")}`,
+    value: "official"
+  });
+  providers.forEach((provider) => {
+    const isCurrent = currentProvider === provider.id && !isCommented;
+    choices.push({
+      name: isCurrent ? `${ansis.green("\u25CF ")}${provider.name} - ${ansis.gray(provider.id)} ${ansis.yellow("(\u5F53\u524D)")}` : `  ${provider.name} - ${ansis.gray(provider.id)}`,
+      value: provider.id
+    });
+  });
+  return choices;
+}
+async function configureCodexApi() {
+  ensureI18nInitialized();
+  const existingConfig = readCodexConfig();
+  const existingAuth = readJsonConfig(CODEX_AUTH_FILE, { defaultValue: {} }) || {};
+  const hasProviders = existingConfig?.providers && existingConfig.providers.length > 0;
+  const modeChoices = [
+    { name: i18n.t("codex:apiModeOfficial"), value: "official" },
+    { name: i18n.t("codex:apiModeCustom"), value: "custom" }
+  ];
+  if (hasProviders) {
+    modeChoices.push({ name: i18n.t("codex:configSwitchMode"), value: "switch" });
+  }
+  const { mode } = await inquirer.prompt([{
+    type: "list",
+    name: "mode",
+    message: i18n.t("codex:apiModePrompt"),
+    choices: addNumbersToChoices(modeChoices),
+    default: "custom"
+  }]);
+  if (!mode) {
+    console.log(ansis.yellow(i18n.t("common:cancelled")));
+    return;
+  }
+  if (mode === "official") {
+    const success = await switchToOfficialLogin();
+    if (success) {
+      updateZcfConfig({ codeToolType: "codex" });
+    }
+    return;
+  }
+  if (mode === "switch") {
+    if (!hasProviders) {
+      console.log(ansis.yellow(i18n.t("codex:noProvidersAvailable")));
+      return;
+    }
+    const currentProvider = existingConfig?.modelProvider;
+    const isCommented = existingConfig?.modelProviderCommented;
+    const choices = createApiConfigChoices(existingConfig.providers, currentProvider, isCommented);
+    const { selectedConfig } = await inquirer.prompt([{
+      type: "list",
+      name: "selectedConfig",
+      message: i18n.t("codex:apiConfigSwitchPrompt"),
+      choices: addNumbersToChoices(choices)
+    }]);
+    if (!selectedConfig) {
+      console.log(ansis.yellow(i18n.t("common:cancelled")));
+      return;
+    }
+    let success = false;
+    if (selectedConfig === "official") {
+      success = await switchToOfficialLogin();
+    } else {
+      success = await switchToProvider(selectedConfig);
+    }
+    if (success) {
+      updateZcfConfig({ codeToolType: "codex" });
+    }
+    return;
+  }
+  const managementMode = detectConfigManagementMode();
+  if (managementMode.mode === "management" && managementMode.hasProviders) {
+    const { default: { configureIncrementalManagement } } = await import('./codex-config-switch.mjs');
+    await configureIncrementalManagement();
+    return;
+  }
+  const backupPath = backupCodexComplete();
+  if (backupPath) {
+    console.log(ansis.gray(getBackupMessage(backupPath)));
+  }
+  const providers = [];
+  const authEntries = {};
+  const existingMap = new Map(existingConfig?.providers.map((provider) => [provider.id, provider]));
+  const currentSessionProviders = /* @__PURE__ */ new Map();
+  let addMore = true;
+  const existingValues = existingMap.size ? Array.from(existingMap.values()) : [];
+  const firstExisting = existingValues.length === 1 ? existingValues[0] : void 0;
+  while (addMore) {
+    const answers = await inquirer.prompt([
+      {
+        type: "input",
+        name: "providerName",
+        message: i18n.t("codex:providerNamePrompt"),
+        default: firstExisting?.name,
+        validate: (input) => {
+          const sanitized = sanitizeProviderName(input);
+          if (!sanitized)
+            return i18n.t("codex:providerNameRequired");
+          if (sanitized !== input.trim())
+            return i18n.t("codex:providerNameInvalid");
+          return true;
+        }
+      },
+      {
+        type: "input",
+        name: "baseUrl",
+        message: i18n.t("codex:providerBaseUrlPrompt"),
+        default: (answers2) => existingMap.get(answers2.providerId)?.baseUrl || "https://api.openai.com/v1",
+        validate: (input) => !!input || i18n.t("codex:providerBaseUrlRequired")
+      },
+      {
+        type: "list",
+        name: "wireApi",
+        message: i18n.t("codex:providerProtocolPrompt"),
+        choices: [
+          { name: i18n.t("codex:protocolResponses"), value: "responses" },
+          { name: i18n.t("codex:protocolChat"), value: "chat" }
+        ],
+        default: (answers2) => existingMap.get(sanitizeProviderName(answers2.providerName))?.wireApi || "responses"
+      },
+      {
+        type: "password",
+        name: "apiKey",
+        message: i18n.t("codex:providerApiKeyPrompt") + i18n.t("common:inputHidden"),
+        validate: (input) => !!input || i18n.t("codex:providerApiKeyRequired")
+      }
+    ]);
+    const providerId = sanitizeProviderName(answers.providerName);
+    const envKey = `${providerId.toUpperCase().replace(/-/g, "_")}_API_KEY`;
+    const existingProvider = existingMap.get(providerId);
+    const sessionProvider = currentSessionProviders.get(providerId);
+    if (existingProvider || sessionProvider) {
+      const sourceType = existingProvider ? "existing" : "session";
+      const sourceProvider = existingProvider || sessionProvider;
+      const { shouldOverwrite } = await inquirer.prompt([{
+        type: "confirm",
+        name: "shouldOverwrite",
+        message: i18n.t("codex:providerDuplicatePrompt", {
+          name: sourceProvider.name,
+          source: sourceType === "existing" ? i18n.t("codex:existingConfig") : i18n.t("codex:currentSession")
+        }),
+        default: false
+      }]);
+      if (!shouldOverwrite) {
+        console.log(ansis.yellow(i18n.t("codex:providerDuplicateSkipped")));
+        continue;
+      }
+      if (sessionProvider) {
+        currentSessionProviders.delete(providerId);
+        const sessionIndex = providers.findIndex((p) => p.id === providerId);
+        if (sessionIndex !== -1) {
+          providers.splice(sessionIndex, 1);
+        }
+      }
+    }
+    const newProvider = {
+      id: providerId,
+      name: answers.providerName,
+      baseUrl: answers.baseUrl,
+      wireApi: answers.wireApi || "responses",
+      envKey,
+      requiresOpenaiAuth: true
+    };
+    providers.push(newProvider);
+    currentSessionProviders.set(providerId, newProvider);
+    authEntries[envKey] = answers.apiKey;
+    const { addAnother } = await inquirer.prompt([{
+      type: "confirm",
+      name: "addAnother",
+      message: i18n.t("codex:addProviderPrompt"),
+      default: false
+    }]);
+    addMore = addAnother;
+  }
+  if (providers.length === 0) {
+    console.log(ansis.yellow(i18n.t("codex:noProvidersConfigured")));
+    return;
+  }
+  const { defaultProvider } = await inquirer.prompt([{
+    type: "list",
+    name: "defaultProvider",
+    message: i18n.t("codex:selectDefaultProviderPrompt"),
+    choices: addNumbersToChoices(toProvidersList(providers)),
+    default: existingConfig?.modelProvider || providers[0].id
+  }]);
+  const selectedProvider = providers.find((provider) => provider.id === defaultProvider);
+  if (selectedProvider) {
+    const envKey = selectedProvider.envKey;
+    const defaultApiKey = authEntries[envKey] ?? existingAuth[envKey] ?? null;
+    if (defaultApiKey)
+      authEntries.OPENAI_API_KEY = defaultApiKey;
+  }
+  writeCodexConfig({
+    model: existingConfig?.model || null,
+    modelProvider: defaultProvider,
+    providers,
+    mcpServices: existingConfig?.mcpServices || [],
+    otherConfig: existingConfig?.otherConfig || []
+  });
+  writeAuthFile(authEntries);
+  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 existingMap = new Map((existingConfig?.mcpServices || []).map((service) => [service.id, service]));
+  if (selectedIds.length === 0) {
+    console.log(ansis.yellow(i18n.t("codex:noMcpConfigured")));
+    writeCodexConfig({
+      model: existingConfig?.model || null,
+      modelProvider: existingConfig?.modelProvider || null,
+      providers: baseProviders,
+      mcpServices: Array.from(existingMap.values()),
+      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;
+    const args = (configInfo.config.args || []).map((arg) => String(arg));
+    if (isWindows() && command === "npx")
+      command = "npx.cmd";
+    const env = { ...configInfo.config.env || {} };
+    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,
+      args,
+      env: Object.keys(env).length > 0 ? env : void 0,
+      startup_timeout_ms: configInfo.config.startup_timeout_ms
+    });
+  }
+  const selectionMap = new Map(selection.map((service) => [service.id, service]));
+  const mergedMap = new Map(existingMap);
+  for (const service of selectionMap.values())
+    mergedMap.set(service.id, service);
+  writeCodexConfig({
+    model: existingConfig?.model || null,
+    modelProvider: existingConfig?.modelProvider || null,
+    providers: baseProviders,
+    mcpServices: Array.from(mergedMap.values()),
+    otherConfig: existingConfig?.otherConfig || []
+  });
+  updateZcfConfig({ codeToolType: "codex" });
+  console.log(ansis.green(i18n.t("codex:mcpConfigured")));
+}
+async function runCodexFullInit() {
+  ensureI18nInitialized();
+  await installCodexCli();
+  await runCodexWorkflowImport();
+  await configureCodexApi();
+  await configureCodexMcp();
+}
+async function runCodexUpdate(force = false, skipPrompt = false) {
+  ensureI18nInitialized();
+  const spinner = ora(i18n.t("codex:checkingVersion")).start();
+  try {
+    const { installed, currentVersion, latestVersion, needsUpdate } = await checkCodexUpdate();
+    spinner.stop();
+    if (!installed) {
+      console.log(ansis.yellow(i18n.t("codex:notInstalled")));
+      return false;
+    }
+    if (!needsUpdate && !force) {
+      console.log(ansis.green(format(i18n.t("codex:upToDate"), { version: currentVersion || "" })));
+      return true;
+    }
+    if (!latestVersion) {
+      console.log(ansis.yellow(i18n.t("codex:cannotCheckVersion")));
+      return false;
+    }
+    console.log(ansis.cyan(format(i18n.t("codex:currentVersion"), { version: currentVersion || "" })));
+    console.log(ansis.cyan(format(i18n.t("codex:latestVersion"), { version: latestVersion })));
+    if (!skipPrompt) {
+      const { confirm } = await inquirer.prompt({
+        type: "confirm",
+        name: "confirm",
+        message: i18n.t("codex:confirmUpdate"),
+        default: true
+      });
+      if (!confirm) {
+        console.log(ansis.gray(i18n.t("codex:updateSkipped")));
+        return true;
+      }
+    } else {
+      console.log(ansis.cyan(i18n.t("codex:autoUpdating")));
+    }
+    const updateSpinner = ora(i18n.t("codex:updating")).start();
+    try {
+      await executeCodexInstallation(true);
+      updateSpinner.succeed(i18n.t("codex:updateSuccess"));
+      return true;
+    } catch (error) {
+      updateSpinner.fail(i18n.t("codex:updateFailed"));
+      console.error(ansis.red(error instanceof Error ? error.message : String(error)));
+      return false;
+    }
+  } catch (error) {
+    spinner.fail(i18n.t("codex:checkFailed"));
+    console.error(ansis.red(error instanceof Error ? error.message : String(error)));
+    return false;
+  }
+}
+async function runCodexUninstall() {
+  ensureI18nInitialized();
+  const { CodexUninstaller } = await import('./codex-uninstaller.mjs');
+  const uninstaller = new CodexUninstaller("en");
+  const { mode } = await inquirer.prompt([{
+    type: "list",
+    name: "mode",
+    message: i18n.t("codex:uninstallModePrompt"),
+    choices: addNumbersToChoices([
+      { name: i18n.t("codex:uninstallModeComplete"), value: "complete" },
+      { name: i18n.t("codex:uninstallModeCustom"), value: "custom" }
+    ]),
+    default: "complete"
+  }]);
+  if (!mode) {
+    handleUninstallCancellation();
+    return;
+  }
+  try {
+    if (mode === "complete") {
+      const { confirm } = await inquirer.prompt([{
+        type: "confirm",
+        name: "confirm",
+        message: i18n.t("codex:uninstallPrompt"),
+        default: false
+      }]);
+      if (!confirm) {
+        handleUninstallCancellation();
+        return;
+      }
+      const result = await uninstaller.completeUninstall();
+      displayUninstallResults([result]);
+    } else if (mode === "custom") {
+      const { items } = await inquirer.prompt([{
+        type: "checkbox",
+        name: "items",
+        message: i18n.t("codex:customUninstallPrompt"),
+        choices: addNumbersToChoices(getUninstallOptions())
+      }]);
+      if (!items || items.length === 0) {
+        handleUninstallCancellation();
+        return;
+      }
+      const results = await uninstaller.customUninstall(items);
+      displayUninstallResults(results);
+    }
+    console.log(ansis.green(i18n.t("codex:uninstallSuccess")));
+  } catch (error) {
+    console.error(ansis.red(`Error during uninstall: ${error.message}`));
+    throw error;
+  }
+}
+function displayUninstallResults(results) {
+  for (const result of results) {
+    for (const item of result.removed) {
+      console.log(ansis.green(`\u2714 ${i18n.t("codex:removedItem", { item })}`));
+    }
+    for (const config of result.removedConfigs) {
+      console.log(ansis.green(`\u2714 ${i18n.t("codex:removedConfig", { config })}`));
+    }
+    for (const warning of result.warnings) {
+      console.log(ansis.yellow(`\u26A0\uFE0F ${warning}`));
+    }
+    for (const error of result.errors) {
+      console.log(ansis.red(`\u274C ${error}`));
+    }
+  }
+}
+async function getCurrentCodexProvider() {
+  const config = readCodexConfig();
+  return config?.modelProvider || null;
+}
+async function listCodexProviders() {
+  const config = readCodexConfig();
+  return config?.providers || [];
+}
+async function switchCodexProvider(providerId) {
+  ensureI18nInitialized();
+  const existingConfig = readCodexConfig();
+  if (!existingConfig) {
+    console.log(ansis.red(i18n.t("codex:configNotFound")));
+    return false;
+  }
+  const providerExists = existingConfig.providers.some((provider) => provider.id === providerId);
+  if (!providerExists) {
+    console.log(ansis.red(i18n.t("codex:providerNotFound", { provider: providerId })));
+    return false;
+  }
+  const backupPath = backupCodexComplete();
+  if (backupPath) {
+    console.log(ansis.gray(getBackupMessage(backupPath)));
+  }
+  const updatedConfig = {
+    ...existingConfig,
+    modelProvider: providerId
+  };
+  try {
+    writeCodexConfig(updatedConfig);
+    console.log(ansis.green(i18n.t("codex:providerSwitchSuccess", { provider: providerId })));
+    return true;
+  } catch (error) {
+    console.error(ansis.red(`Error switching provider: ${error.message}`));
+    return false;
+  }
+}
+async function switchToOfficialLogin() {
+  ensureI18nInitialized();
+  const existingConfig = readCodexConfig();
+  if (!existingConfig) {
+    console.log(ansis.red(i18n.t("codex:configNotFound")));
+    return false;
+  }
+  const backupPath = backupCodexComplete();
+  if (backupPath) {
+    console.log(ansis.gray(getBackupMessage(backupPath)));
+  }
+  try {
+    const updatedConfig = {
+      ...existingConfig,
+      modelProvider: existingConfig.modelProvider,
+      // Keep the current provider value
+      modelProviderCommented: true
+      // Mark as commented
+    };
+    writeCodexConfig(updatedConfig);
+    const auth = readJsonConfig(CODEX_AUTH_FILE, { defaultValue: {} }) || {};
+    auth.OPENAI_API_KEY = null;
+    writeJsonConfig(CODEX_AUTH_FILE, auth, { pretty: true });
+    console.log(ansis.green(i18n.t("codex:officialConfigured")));
+    return true;
+  } catch (error) {
+    console.error(ansis.red(`Error switching to official login: ${error.message}`));
+    return false;
+  }
+}
+async function switchToProvider(providerId) {
+  ensureI18nInitialized();
+  const existingConfig = readCodexConfig();
+  if (!existingConfig) {
+    console.log(ansis.red(i18n.t("codex:configNotFound")));
+    return false;
+  }
+  const provider = existingConfig.providers.find((p) => p.id === providerId);
+  if (!provider) {
+    console.log(ansis.red(i18n.t("codex:providerNotFound", { provider: providerId })));
+    return false;
+  }
+  const backupPath = backupCodexComplete();
+  if (backupPath) {
+    console.log(ansis.gray(getBackupMessage(backupPath)));
+  }
+  try {
+    const updatedConfig = {
+      ...existingConfig,
+      modelProvider: providerId,
+      modelProviderCommented: false
+      // Ensure it's not commented
+    };
+    writeCodexConfig(updatedConfig);
+    const auth = readJsonConfig(CODEX_AUTH_FILE, { defaultValue: {} }) || {};
+    const envValue = auth[provider.envKey] || null;
+    auth.OPENAI_API_KEY = envValue;
+    writeJsonConfig(CODEX_AUTH_FILE, auth, { pretty: true });
+    console.log(ansis.green(i18n.t("codex:providerSwitchSuccess", { provider: providerId })));
+    return true;
+  } catch (error) {
+    console.error(ansis.red(`Error switching to provider: ${error.message}`));
+    return false;
+  }
+}
+
+const codex = {
+  __proto__: null,
+  CODEX_DIR: CODEX_DIR,
+  backupCodexAgents: backupCodexAgents,
+  backupCodexComplete: backupCodexComplete,
+  backupCodexConfig: backupCodexConfig,
+  backupCodexFiles: backupCodexFiles,
+  backupCodexPrompts: backupCodexPrompts,
+  checkCodexUpdate: checkCodexUpdate,
+  configureCodexApi: configureCodexApi,
+  configureCodexMcp: configureCodexMcp,
+  createBackupDirectory: createBackupDirectory,
+  getBackupMessage: getBackupMessage,
+  getCodexVersion: getCodexVersion,
+  getCurrentCodexProvider: getCurrentCodexProvider,
+  installCodexCli: installCodexCli,
+  isCodexInstalled: isCodexInstalled,
+  listCodexProviders: listCodexProviders,
+  parseCodexConfig: parseCodexConfig,
+  readCodexConfig: readCodexConfig,
+  renderCodexConfig: renderCodexConfig,
+  runCodexFullInit: runCodexFullInit,
+  runCodexSystemPromptSelection: runCodexSystemPromptSelection,
+  runCodexUninstall: runCodexUninstall,
+  runCodexUpdate: runCodexUpdate,
+  runCodexWorkflowImport: runCodexWorkflowImport,
+  runCodexWorkflowSelection: runCodexWorkflowSelection,
+  switchCodexProvider: switchCodexProvider,
+  switchToOfficialLogin: switchToOfficialLogin,
+  switchToProvider: switchToProvider,
+  writeAuthFile: writeAuthFile,
+  writeCodexConfig: writeCodexConfig
+};
+
+function getPlatformStatusLineConfig() {
+  return {
+    type: "command",
+    command: isWindows() ? "%USERPROFILE%\\.claude\\ccline\\ccline.exe" : "~/.claude/ccline/ccline",
+    padding: 0
+  };
+}
+
+function addCCometixLineConfig() {
+  try {
+    const statusLineConfig = getPlatformStatusLineConfig();
+    let settings = {};
+    if (exists(SETTINGS_FILE)) {
+      settings = readJsonConfig(SETTINGS_FILE) || {};
+    }
+    settings.statusLine = statusLineConfig;
+    writeJsonConfig(SETTINGS_FILE, settings);
+    return true;
+  } catch (error) {
+    console.error("Failed to add CCometixLine configuration:", error);
+    return false;
+  }
+}
 function hasCCometixLineConfig() {
   try {
     if (!exists(SETTINGS_FILE)) {
@@ -2082,59 +3712,6 @@ async function installCometixLine() {
   }
 }
 
-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;
-  });
-}
-
-function readZcfConfig() {
-  let config = readJsonConfig(ZCF_CONFIG_FILE);
-  if (!config && existsSync(LEGACY_ZCF_CONFIG_FILE)) {
-    config = readJsonConfig(LEGACY_ZCF_CONFIG_FILE);
-  }
-  return config;
-}
-async function readZcfConfigAsync() {
-  return readZcfConfig();
-}
-function writeZcfConfig(config) {
-  try {
-    writeJsonConfig(ZCF_CONFIG_FILE, config);
-  } catch {
-  }
-}
-function updateZcfConfig(updates) {
-  const existingConfig = readZcfConfig();
-  const newConfig = {
-    version: updates.version || existingConfig?.version || "1.0.0",
-    preferredLang: updates.preferredLang || existingConfig?.preferredLang || "en",
-    aiOutputLang: updates.aiOutputLang || existingConfig?.aiOutputLang,
-    outputStyles: updates.outputStyles !== void 0 ? updates.outputStyles : existingConfig?.outputStyles,
-    defaultOutputStyle: updates.defaultOutputStyle !== void 0 ? updates.defaultOutputStyle : existingConfig?.defaultOutputStyle,
-    claudeCodeInstallation: updates.claudeCodeInstallation !== void 0 ? updates.claudeCodeInstallation : existingConfig?.claudeCodeInstallation,
-    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  writeZcfConfig(newConfig);
-}
-function getZcfConfig() {
-  const config = readZcfConfig();
-  return config || {
-    version: "1.0.0",
-    preferredLang: "en",
-    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-
 const OUTPUT_STYLES = [
   // Custom styles (have template files)
   {
@@ -2176,7 +3753,7 @@ async function copyOutputStyles(selectedStyles, lang) {
   const currentFilePath = fileURLToPath(import.meta.url);
   const distDir = dirname(dirname(currentFilePath));
   const rootDir = dirname(distDir);
-  const templateDir = join(rootDir, "templates", lang, "output-styles");
+  const templateDir = join(rootDir, "templates", "claude-code", lang, "output-styles");
   for (const styleId of selectedStyles) {
     const style = OUTPUT_STYLES.find((s) => s.id === styleId);
     if (!style || !style.isCustom || !style.filePath) {
@@ -2392,9 +3969,9 @@ async function configureApiCompletely(preselectedAuthType) {
     console.log(ansis.yellow(i18n.t("common:cancelled")));
     return null;
   }
-  const keyMessage = authType === "auth_token" ? i18n.t("api:enterAuthToken") : i18n.t("api:enterApiKey");
+  const keyMessage = authType === "auth_token" ? i18n.t("api:enterAuthToken") + i18n.t("common:inputHidden") : i18n.t("api:enterApiKey") + i18n.t("common:inputHidden");
   const { key } = await inquirer.prompt({
-    type: "input",
+    type: "password",
     name: "key",
     message: keyMessage,
     validate: async (value) => {
@@ -2465,9 +4042,9 @@ async function modifyApiConfigPartially(existingConfig) {
     }
   } else if (item === "key") {
     const authType = currentConfig.authType || "auth_token";
-    const keyMessage = authType === "auth_token" ? i18n.t("api:enterNewApiKey").replace("{key}", currentConfig.key ? formatApiKeyDisplay(currentConfig.key) : i18n.t("common:none")) : i18n.t("api:enterNewApiKey").replace("{key}", currentConfig.key ? formatApiKeyDisplay(currentConfig.key) : i18n.t("common:none"));
+    const keyMessage = authType === "auth_token" ? i18n.t("api:enterNewApiKey").replace("{key}", currentConfig.key ? formatApiKeyDisplay(currentConfig.key) : i18n.t("common:none")) + i18n.t("common:inputHidden") : i18n.t("api:enterNewApiKey").replace("{key}", currentConfig.key ? formatApiKeyDisplay(currentConfig.key) : i18n.t("common:none")) + i18n.t("common:inputHidden");
     const { key } = await inquirer.prompt({
-      type: "input",
+      type: "password",
       name: "key",
       message: keyMessage,
       validate: async (value) => {
@@ -2661,14 +4238,16 @@ async function chooseInstallationMethod() {
 }
 async function handleMultipleInstallations(status) {
   ensureI18nInitialized();
-  const existingConfig = getZcfConfig();
-  const previousChoice = existingConfig.claudeCodeInstallation;
-  if (previousChoice) {
-    if (previousChoice.type === "global" && status.hasGlobal) {
-      return "global";
-    }
-    if (previousChoice.type === "local" && status.hasLocal) {
-      return "local";
+  const tomlConfig = readTomlConfig(ZCF_CONFIG_FILE);
+  if (tomlConfig && tomlConfig.general?.currentTool === "claude-code") {
+    const previousChoice = tomlConfig.claudeCode?.installType;
+    if (previousChoice) {
+      if (previousChoice === "global" && status.hasGlobal) {
+        return "global";
+      }
+      if (previousChoice === "local" && status.hasLocal) {
+        return "local";
+      }
     }
   }
   if (!status.hasGlobal && !status.hasLocal) {
@@ -2704,17 +4283,17 @@ async function handleMultipleInstallations(status) {
         await removeLocalClaudeCode();
         console.log(ansis.green(`\u2714 ${i18n.t("installation:localInstallationRemoved")}`));
       }
-      await saveInstallationConfig({
-        type: "global",
-        path: "claude",
-        configDir: CLAUDE_DIR
+      updateTomlConfig(ZCF_CONFIG_FILE, {
+        claudeCode: {
+          installType: "global"
+        }
       });
     } else {
       console.log(ansis.green(`\u2714 ${i18n.t("installation:usingLocalInstallation")}`));
-      await saveInstallationConfig({
-        type: "local",
-        path: status.localPath,
-        configDir: join(homedir(), ".claude")
+      updateTomlConfig(ZCF_CONFIG_FILE, {
+        claudeCode: {
+          installType: "local"
+        }
       });
     }
     return choice;
@@ -2728,130 +4307,13 @@ async function handleMultipleInstallations(status) {
     }
   }
 }
-async function saveInstallationConfig(installation) {
-  try {
-    updateZcfConfig({
-      claudeCodeInstallation: installation
-    });
-  } catch (error) {
-    console.error(ansis.red(`\u2716 ${i18n.t("installation:failedToSaveInstallationConfig")}: ${error}`));
-  }
-}
-
-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;
-}
-
-async function selectAiOutputLanguage(defaultLang) {
-  ensureI18nInitialized();
-  console.log(ansis.dim(`
-  ${i18n.t("language:aiOutputLangHint")}
-`));
-  const aiLangChoices = Object.entries(AI_OUTPUT_LANGUAGES).map(([key]) => ({
-    title: getAiOutputLanguageLabel(key),
-    value: key
-  }));
-  const defaultChoice = defaultLang || "en";
-  const { lang } = await inquirer.prompt({
-    type: "list",
-    name: "lang",
-    message: i18n.t("language:selectAiOutputLang"),
-    choices: addNumbersToChoices(aiLangChoices.map((choice) => ({
-      name: choice.title,
-      value: choice.value
-    }))),
-    default: defaultChoice
-  });
-  if (!lang) {
-    console.log(ansis.yellow(i18n.t("common:cancelled")));
-    process.exit(0);
-  }
-  const aiOutputLang = lang;
-  if (aiOutputLang === "custom") {
-    const { customLang } = await inquirer.prompt({
-      type: "input",
-      name: "customLang",
-      message: i18n.t("language:enterCustomLanguage"),
-      validate: async (value) => !!value || i18n.t("language:languageRequired") || "Language is required"
-    });
-    if (!customLang) {
-      console.log(ansis.yellow(i18n.t("common:cancelled")));
-      process.exit(0);
-    }
-    return customLang;
-  }
-  return aiOutputLang;
-}
-const LANGUAGE_SELECTION_MESSAGES = {
-  selectLanguage: "Select ZCF display language / \u9009\u62E9ZCF\u663E\u793A\u8BED\u8A00",
-  operationCancelled: "Operation cancelled / \u64CD\u4F5C\u5DF2\u53D6\u6D88"
-};
-async function selectScriptLanguage(currentLang) {
-  const zcfConfig = readZcfConfig();
-  if (zcfConfig?.preferredLang) {
-    return zcfConfig.preferredLang;
-  }
-  const { lang } = await inquirer.prompt({
-    type: "list",
-    name: "lang",
-    message: LANGUAGE_SELECTION_MESSAGES.selectLanguage,
-    choices: addNumbersToChoices(SUPPORTED_LANGS.map((l) => ({
-      name: LANG_LABELS[l],
-      value: l
-    })))
-  });
-  if (!lang) {
-    console.log(ansis.yellow(LANGUAGE_SELECTION_MESSAGES.operationCancelled));
-    process.exit(0);
-  }
-  const scriptLang = lang;
-  updateZcfConfig({
-    version,
-    preferredLang: scriptLang
-  });
-  return scriptLang;
-}
-async function resolveAiOutputLanguage(scriptLang, commandLineOption, savedConfig) {
-  ensureI18nInitialized();
-  if (commandLineOption) {
-    return commandLineOption;
-  }
-  if (savedConfig?.aiOutputLang) {
-    console.log(ansis.gray(`\u2714 ${i18n.t("language:aiOutputLangHint")}: ${savedConfig.aiOutputLang}`));
-    return savedConfig.aiOutputLang;
-  }
-  return await selectAiOutputLanguage(scriptLang);
-}
-
-const prompts = {
-  __proto__: null,
-  resolveAiOutputLanguage: resolveAiOutputLanguage,
-  selectAiOutputLanguage: selectAiOutputLanguage,
-  selectScriptLanguage: selectScriptLanguage
-};
 
 function getRootDir() {
   const currentFilePath = fileURLToPath(import.meta.url);
   const distDir = dirname(dirname(currentFilePath));
   return dirname(distDir);
 }
+const DEFAULT_CODE_TOOL_TEMPLATE = "claude-code";
 async function selectAndInstallWorkflows(configLang, preselectedWorkflows) {
   ensureI18nInitialized();
   const workflows = getOrderedWorkflows();
@@ -2911,7 +4373,16 @@ async function installWorkflowWithDependencies(config, configLang) {
     await mkdir(commandsDir, { recursive: true });
   }
   for (const commandFile of config.commands) {
-    const commandSource = join(rootDir, "templates", configLang, "workflow", config.category, "commands", commandFile);
+    const commandSource = join(
+      rootDir,
+      "templates",
+      DEFAULT_CODE_TOOL_TEMPLATE,
+      configLang,
+      "workflow",
+      config.category,
+      "commands",
+      commandFile
+    );
     const destFileName = commandFile;
     const commandDest = join(commandsDir, destFileName);
     if (existsSync(commandSource)) {
@@ -2933,7 +4404,16 @@ async function installWorkflowWithDependencies(config, configLang) {
       await mkdir(agentsCategoryDir, { recursive: true });
     }
     for (const agent of config.agents) {
-      const agentSource = join(rootDir, "templates", configLang, "workflow", config.category, "agents", agent.filename);
+      const agentSource = join(
+        rootDir,
+        "templates",
+        DEFAULT_CODE_TOOL_TEMPLATE,
+        configLang,
+        "workflow",
+        config.category,
+        "agents",
+        agent.filename
+      );
       const agentDest = join(agentsCategoryDir, agent.filename);
       if (existsSync(agentSource)) {
         try {
@@ -3109,6 +4589,15 @@ 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);
@@ -3122,32 +4611,34 @@ async function init(options = {}) {
 \u2139 ${i18n.t("installation:termuxDetected")}`));
       console.log(ansis.gray(i18n.t("installation:termuxEnvironmentInfo")));
     }
+    const zcfConfig = readZcfConfig();
     let configLang = options.configLang;
     if (!configLang && !options.skipPrompt) {
-      const LANG_HINT_KEYS = {
-        "zh-CN": i18n.t("language:configLangHint.zh-CN"),
-        "en": i18n.t("language:configLangHint.en")
-      };
-      const { lang } = await inquirer.prompt({
-        type: "list",
-        name: "lang",
-        message: i18n.t("language:selectConfigLang"),
-        choices: addNumbersToChoices(
-          SUPPORTED_LANGS.map((l) => ({
-            name: `${LANG_LABELS[l]} - ${LANG_HINT_KEYS[l]}`,
-            value: l
-          }))
-        )
-      });
-      if (!lang) {
-        console.log(ansis.yellow(i18n.t("common:cancelled")));
-        process.exit(0);
-      }
-      configLang = lang;
+      const { resolveTemplateLanguage } = await Promise.resolve().then(function () { return prompts; });
+      configLang = await resolveTemplateLanguage(
+        options.configLang,
+        // Command line option
+        zcfConfig
+      );
     } else if (!configLang && options.skipPrompt) {
       configLang = "en";
     }
-    const zcfConfig = readZcfConfig();
+    const codeToolType = resolveCodeToolType(options.codeType, zcfConfig?.codeToolType);
+    options.codeType = codeToolType;
+    if (codeToolType === "codex") {
+      await runCodexFullInit();
+      updateZcfConfig({
+        version,
+        preferredLang: i18n.language,
+        // ZCF界面语言
+        templateLang: configLang,
+        // 模板语言
+        aiOutputLang: options.aiOutputLang || "en",
+        codeToolType
+      });
+      console.log(ansis.green(i18n.t("codex:setupComplete")));
+      return;
+    }
     const aiOutputLang = options.skipPrompt ? options.aiOutputLang || "en" : await resolveAiOutputLanguage(i18n.language, options.aiOutputLang, zcfConfig);
     const installationStatus = await getInstallationStatus();
     if (installationStatus.hasGlobal || installationStatus.hasLocal) {
@@ -3468,9 +4959,9 @@ ${ansis.blue(`\u2139 ${i18n.t("api:existingApiConfig")}`)}`);
                 continue;
               } else {
                 const response = await inquirer.prompt({
-                  type: "input",
+                  type: "password",
                   name: "apiKey",
-                  message: service.apiKeyPrompt,
+                  message: service.apiKeyPrompt + i18n.t("common:inputHidden"),
                   validate: (value) => !!value || i18n.t("api:keyRequired")
                 });
                 if (!response.apiKey) {
@@ -3523,7 +5014,11 @@ ${ansis.blue(`\u2139 ${i18n.t("api:existingApiConfig")}`)}`);
     updateZcfConfig({
       version,
       preferredLang: i18n.language,
-      aiOutputLang
+      // ZCF界面语言
+      templateLang: configLang,
+      // 模板语言
+      aiOutputLang,
+      codeToolType
     });
     console.log(ansis.green(`\u2714 ${i18n.t("configuration:configSuccess")} ${CLAUDE_DIR}`));
     console.log(`
@@ -3537,7 +5032,7 @@ ${ansis.cyan(i18n.t("common:complete"))}`);
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 function getTemplateSettings() {
-  const templatePath = join(__dirname, "../../templates/common/settings.json");
+  const templatePath = join(__dirname, "../../templates/claude-code/common/settings.json");
   const content = readFileSync(templatePath, "utf-8");
   return JSON.parse(content);
 }
@@ -3613,4 +5108,4 @@ async function openSettingsJson() {
   }
 }
 
-export { addNumbersToChoices as $, AI_OUTPUT_LANGUAGES as A, copyConfigFiles as B, CLAUDE_DIR as C, configureApi as D, mergeConfigs as E, updateCustomModel as F, updateDefaultModel as G, mergeSettingsFile as H, getExistingModelConfig as I, getExistingApiConfig as J, applyAiLanguageDirective as K, LEGACY_ZCF_CONFIG_FILE as L, isClaudeCodeInstalled as M, installClaudeCode as N, isLocalClaudeCodeInstalled as O, getInstallationStatus as P, removeLocalClaudeCode as Q, ensureI18nInitialized as R, SETTINGS_FILE as S, i18n as T, readCcrConfig as U, isCcrInstalled as V, installCcr as W, configureCcrFeature as X, handleExitPromptError as Y, ZCF_CONFIG_FILE as Z, handleGeneralError as _, commandExists as a, updateZcfConfig as a0, changeLanguage as a1, readZcfConfig as a2, configureOutputStyle as a3, isWindows as a4, selectMcpServices as a5, getMcpServices as a6, formatApiKeyDisplay as a7, modifyApiConfigPartially as a8, setupCcrConfiguration as a9, validateApiKey as aa, COMETIX_COMMAND_NAME as ab, COMETIX_COMMANDS as ac, installCometixLine as ad, checkAndUpdateTools as ae, readJsonConfig as af, writeJsonConfig as ag, displayBanner as ah, resolveAiOutputLanguage as ai, updatePromptOnly as aj, selectAndInstallWorkflows as ak, checkClaudeCodeVersionAndPrompt as al, version as am, displayBannerWithInfo as an, readZcfConfigAsync as ao, initI18n as ap, selectScriptLanguage as aq, prompts as ar, importRecommendedEnv as b, cleanupPermissions as c, importRecommendedPermissions 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, getAiOutputLanguageLabel as k, getMcpConfigPath as l, mergeAndCleanPermissions as m, backupMcpConfig as n, openSettingsJson as o, mergeMcpServers as p, buildMcpServerConfig as q, readMcpConfig as r, fixWindowsMcpConfig as s, addCompletedOnboarding as t, ensureApiKeyApproved as u, removeApiKeyFromRejected as v, writeMcpConfig as w, manageApiKeyApproval as x, ensureClaudeDir as y, backupExistingConfig as z };
+export { writeAuthFile as $, AI_OUTPUT_LANGUAGES as A, manageApiKeyApproval as B, CLAUDE_DIR as C, DEFAULT_CODE_TOOL_TYPE as D, ensureClaudeDir as E, backupExistingConfig as F, copyConfigFiles as G, configureApi as H, mergeConfigs as I, updateCustomModel as J, updateDefaultModel as K, LEGACY_ZCF_CONFIG_FILES as L, mergeSettingsFile as M, getExistingModelConfig as N, getExistingApiConfig as O, applyAiLanguageDirective as P, isClaudeCodeInstalled as Q, installClaudeCode as R, SETTINGS_FILE as S, isLocalClaudeCodeInstalled as T, getInstallationStatus as U, removeLocalClaudeCode as V, i18n as W, readCodexConfig as X, backupCodexComplete as Y, ZCF_CONFIG_DIR as Z, writeCodexConfig as _, commandExists as a, ensureI18nInitialized as a0, detectConfigManagementMode as a1, addNumbersToChoices as a2, readCcrConfig as a3, isCcrInstalled as a4, installCcr as a5, configureCcrFeature as a6, handleExitPromptError as a7, handleGeneralError as a8, updateZcfConfig as a9, configureCodexApi as aA, runCodexWorkflowImport as aB, runCodexFullInit as aC, listCodexProviders as aD, getCurrentCodexProvider as aE, switchCodexProvider as aF, switchToOfficialLogin as aG, switchToProvider as aH, readZcfConfigAsync as aI, initI18n as aJ, selectScriptLanguage as aK, fsOperations as aL, prompts as aM, codex as aN, changeLanguage as aa, readZcfConfig as ab, configureOutputStyle as ac, isWindows as ad, selectMcpServices as ae, getMcpServices as af, formatApiKeyDisplay as ag, modifyApiConfigPartially as ah, setupCcrConfiguration as ai, validateApiKey as aj, COMETIX_COMMAND_NAME as ak, COMETIX_COMMANDS as al, installCometixLine as am, checkAndUpdateTools as an, readJsonConfig as ao, writeJsonConfig as ap, displayBanner as aq, runCodexUpdate as ar, version as as, resolveAiOutputLanguage as at, updatePromptOnly as au, selectAndInstallWorkflows as av, checkClaudeCodeVersionAndPrompt as aw, displayBannerWithInfo as ax, runCodexUninstall as ay, configureCodexMcp as az, importRecommendedEnv as b, cleanupPermissions as c, importRecommendedPermissions as d, CLAUDE_MD_FILE as e, ClAUDE_CONFIG_FILE as f, getPlatform as g, ZCF_CONFIG_FILE as h, init as i, CODE_TOOL_TYPES as j, isCodeToolType as k, SUPPORTED_LANGS as l, mergeAndCleanPermissions as m, LANG_LABELS as n, openSettingsJson as o, getAiOutputLanguageLabel as p, getMcpConfigPath as q, readMcpConfig as r, backupMcpConfig as s, mergeMcpServers as t, buildMcpServerConfig as u, fixWindowsMcpConfig as v, writeMcpConfig as w, addCompletedOnboarding as x, ensureApiKeyApproved as y, removeApiKeyFromRejected as z };