zcf 3.4.1 → 3.4.3

package/dist/chunks/simple-config.mjs

@@ -4,21 +4,21 @@ import process from 'node:process';
 import ansis from 'ansis';
 import inquirer from 'inquirer';
 import { exec as exec$1 } from 'node:child_process';
-import { homedir, platform } from 'node:os';
+import { homedir, platform as platform$1 } from 'node:os';
 import { promisify } from 'node:util';
 import dayjs from 'dayjs';
 import { dirname, join } from 'pathe';
 import { fileURLToPath } from 'node:url';
 import toggleModule from 'inquirer-toggle';
 import ora from 'ora';
+import { exec, x } from 'tinyexec';
 import semver from 'semver';
 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.4.1";
+const version = "3.4.3";
 const homepage = "https://github.com/UfoMiao/zcf";
 
 const i18n = i18next.createInstance();
@@ -517,7 +517,7 @@ function displayBannerWithInfo(subtitle) {
 
 const WINDOWS_WRAPPED_COMMANDS = ["npx", "uvx", "uv"];
 function getPlatform() {
-  const p = platform();
+  const p = platform$1();
   if (p === "win32")
     return "windows";
   if (p === "darwin")
@@ -703,9 +703,105 @@ async function commandExists(command) {
         return true;
       }
     }
+    if (getPlatform() === "macos") {
+      const homebrewPaths = await getHomebrewCommandPaths(command);
+      for (const path of homebrewPaths) {
+        if (nodeFs.existsSync(path)) {
+          return true;
+        }
+      }
+    }
   }
   return false;
 }
+async function getHomebrewCommandPaths(command) {
+  const paths = [];
+  const homebrewPrefixes = [
+    "/opt/homebrew",
+    // Apple Silicon (M1/M2)
+    "/usr/local"
+    // Intel Mac
+  ];
+  for (const prefix of homebrewPrefixes) {
+    paths.push(`${prefix}/bin/${command}`);
+  }
+  for (const prefix of homebrewPrefixes) {
+    const cellarNodePath = `${prefix}/Cellar/node`;
+    if (nodeFs.existsSync(cellarNodePath)) {
+      try {
+        const versions = nodeFs.readdirSync(cellarNodePath);
+        for (const version of versions) {
+          const binPath = `${cellarNodePath}/${version}/bin/${command}`;
+          paths.push(binPath);
+        }
+      } catch {
+      }
+    }
+  }
+  const caskNameMap = {
+    claude: "claude-code",
+    codex: "codex"
+  };
+  const caskName = caskNameMap[command];
+  if (caskName) {
+    for (const prefix of homebrewPrefixes) {
+      const caskroomPath = `${prefix}/Caskroom/${caskName}`;
+      if (nodeFs.existsSync(caskroomPath)) {
+        try {
+          const versions = nodeFs.readdirSync(caskroomPath).filter((v) => !v.startsWith("."));
+          for (const version of versions) {
+            const binPath = `${caskroomPath}/${version}/${command}`;
+            paths.push(binPath);
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  return paths;
+}
+async function findCommandPath(command) {
+  try {
+    const cmd = getPlatform() === "windows" ? "where" : "which";
+    const res = await exec(cmd, [command]);
+    if (res.exitCode === 0 && res.stdout) {
+      return res.stdout.trim().split("\n")[0];
+    }
+  } catch {
+  }
+  const commonPaths = [
+    `/usr/local/bin/${command}`,
+    `/usr/bin/${command}`,
+    `/bin/${command}`,
+    `${process.env.HOME}/.local/bin/${command}`
+  ];
+  for (const path of commonPaths) {
+    if (nodeFs.existsSync(path)) {
+      return path;
+    }
+  }
+  if (getPlatform() === "macos") {
+    const homebrewPaths = await getHomebrewCommandPaths(command);
+    for (const path of homebrewPaths) {
+      if (nodeFs.existsSync(path)) {
+        return path;
+      }
+    }
+  }
+  if (isTermux()) {
+    const termuxPrefix = getTermuxPrefix();
+    const termuxPaths = [
+      `${termuxPrefix}/bin/${command}`,
+      `${termuxPrefix}/usr/bin/${command}`
+    ];
+    for (const path of termuxPaths) {
+      if (nodeFs.existsSync(path)) {
+        return path;
+      }
+    }
+  }
+  return null;
+}
 function getRecommendedInstallMethods(codeType) {
   const platform2 = getPlatform();
   const wsl = isWSL();
@@ -731,6 +827,26 @@ function getRecommendedInstallMethods(codeType) {
   return ["npm"];
 }
 
+const platform = {
+  __proto__: null,
+  commandExists: commandExists,
+  findCommandPath: findCommandPath,
+  getHomebrewCommandPaths: getHomebrewCommandPaths,
+  getMcpCommand: getMcpCommand,
+  getPlatform: getPlatform,
+  getRecommendedInstallMethods: getRecommendedInstallMethods,
+  getSystemRoot: getSystemRoot,
+  getTermuxPrefix: getTermuxPrefix,
+  getWSLDistro: getWSLDistro,
+  getWSLInfo: getWSLInfo,
+  isTermux: isTermux,
+  isWSL: isWSL,
+  isWindows: isWindows,
+  normalizeTomlPath: normalizeTomlPath,
+  shouldUseSudoForGlobalInstall: shouldUseSudoForGlobalInstall,
+  wrapCommandWithSudo: wrapCommandWithSudo
+};
+
 class FileSystemError extends Error {
   constructor(message, path, cause) {
     super(message);
@@ -1193,6 +1309,20 @@ const claudeConfig = {
   writeMcpConfig: writeMcpConfig
 };
 
+const MODEL_ENV_KEYS = [
+  "ANTHROPIC_MODEL",
+  "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+  "ANTHROPIC_DEFAULT_SONNET_MODEL",
+  "ANTHROPIC_DEFAULT_OPUS_MODEL",
+  // Deprecated but still cleaned to avoid stale values
+  "ANTHROPIC_SMALL_FAST_MODEL"
+];
+function clearModelEnv(env) {
+  for (const key of MODEL_ENV_KEYS) {
+    delete env[key];
+  }
+}
+
 function cleanupPermissions(templatePermissions, userPermissions) {
   const templateSet = new Set(templatePermissions);
   const cleanedPermissions = userPermissions.filter((permission) => {
@@ -1310,8 +1440,8 @@ function mergeConfigs(sourceFile, targetFile) {
   const merged = deepMerge(target, source);
   writeJsonConfig(targetFile, merged);
 }
-function updateCustomModel(primaryModel, fastModel) {
-  if (!primaryModel?.trim() && !fastModel?.trim()) {
+function updateCustomModel(primaryModel, haikuModel, sonnetModel, opusModel) {
+  if (!primaryModel?.trim() && !haikuModel?.trim() && !sonnetModel?.trim() && !opusModel?.trim()) {
     return;
   }
   let settings = getDefaultSettings();
@@ -1321,12 +1451,16 @@ function updateCustomModel(primaryModel, fastModel) {
   }
   delete settings.model;
   settings.env = settings.env || {};
+  clearModelEnv(settings.env);
   if (primaryModel?.trim()) {
     settings.env.ANTHROPIC_MODEL = primaryModel.trim();
   }
-  if (fastModel?.trim()) {
-    settings.env.ANTHROPIC_SMALL_FAST_MODEL = fastModel.trim();
-  }
+  if (haikuModel?.trim())
+    settings.env.ANTHROPIC_DEFAULT_HAIKU_MODEL = haikuModel.trim();
+  if (sonnetModel?.trim())
+    settings.env.ANTHROPIC_DEFAULT_SONNET_MODEL = sonnetModel.trim();
+  if (opusModel?.trim())
+    settings.env.ANTHROPIC_DEFAULT_OPUS_MODEL = opusModel.trim();
   writeJsonConfig(SETTINGS_FILE, settings);
 }
 function updateDefaultModel(model) {
@@ -1338,13 +1472,10 @@ function updateDefaultModel(model) {
   if (!settings.env) {
     settings.env = {};
   }
-  if (model !== "custom" && settings.env) {
-    delete settings.env.ANTHROPIC_MODEL;
-    delete settings.env.ANTHROPIC_SMALL_FAST_MODEL;
+  if (model !== "custom") {
+    clearModelEnv(settings.env);
   }
-  if (model === "default") {
-    delete settings.model;
-  } else if (model === "custom") {
+  if (model === "default" || model === "custom") {
     delete settings.model;
   } else {
     settings.model = model;
@@ -1395,13 +1526,18 @@ function getExistingModelConfig() {
   if (!settings) {
     return null;
   }
-  if (settings.env && (settings.env.ANTHROPIC_MODEL || settings.env.ANTHROPIC_SMALL_FAST_MODEL)) {
+  const hasModelEnv = MODEL_ENV_KEYS.some((key) => settings.env?.[key]);
+  if (hasModelEnv) {
     return "custom";
   }
   if (!settings.model) {
     return "default";
   }
-  return settings.model;
+  const validModels = ["opus", "sonnet", "sonnet[1m]"];
+  if (validModels.includes(settings.model)) {
+    return settings.model;
+  }
+  return "default";
 }
 function getExistingApiConfig() {
   const settings = readJsonConfig(SETTINGS_FILE);
@@ -1671,7 +1807,7 @@ function getFallbackPresets() {
   ];
 }
 
-const execAsync$4 = promisify(exec$1);
+const execAsync$3 = promisify(exec$1);
 const CCR_CONFIG_DIR = join(homedir(), ".claude-code-router");
 const CCR_CONFIG_FILE = join(CCR_CONFIG_DIR, "config.json");
 const CCR_BACKUP_DIR = CCR_CONFIG_DIR;
@@ -1837,10 +1973,10 @@ async function restartAndCheckCcrStatus() {
   ensureI18nInitialized();
   try {
     console.log(ansis.cyan(`${i18n.t("ccr:restartingCcr")}`));
-    await execAsync$4("ccr restart");
+    await execAsync$3("ccr restart");
     console.log(ansis.green(`\u2714 ${i18n.t("ccr:ccrRestartSuccess")}`));
     console.log(ansis.cyan(`${i18n.t("ccr:checkingCcrStatus")}`));
-    const { stdout } = await execAsync$4("ccr status");
+    const { stdout } = await execAsync$3("ccr status");
     console.log(ansis.gray(stdout));
   } catch (error) {
     console.error(ansis.red(`${i18n.t("ccr:ccrRestartFailed")}:`), error.message || error);
@@ -1977,16 +2113,16 @@ const config = {
   writeCcrConfig: writeCcrConfig
 };
 
-const execAsync$3 = promisify(exec$1);
+const execAsync$2 = promisify(exec$1);
 async function getInstalledVersion(command, maxRetries = 3) {
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
     try {
       let stdout;
       try {
-        const result = await execAsync$3(`${command} -v`);
+        const result = await execAsync$2(`${command} -v`);
         stdout = result.stdout;
       } catch {
-        const result = await execAsync$3(`${command} --version`);
+        const result = await execAsync$2(`${command} --version`);
         stdout = result.stdout;
       }
       const versionMatch = stdout.match(/(\d+\.\d+\.\d+(?:-[\w.]+)?)/);
@@ -2003,7 +2139,7 @@ async function getInstalledVersion(command, maxRetries = 3) {
 async function getLatestVersion(packageName, maxRetries = 3) {
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
     try {
-      const { stdout } = await execAsync$3(`npm view ${packageName} version`);
+      const { stdout } = await execAsync$2(`npm view ${packageName} version`);
       return stdout.trim();
     } catch {
       if (attempt === maxRetries) {
@@ -2014,6 +2150,327 @@ async function getLatestVersion(packageName, maxRetries = 3) {
   }
   return null;
 }
+async function getClaudeCodeInstallationSource() {
+  if (getPlatform() !== "macos") {
+    const commandPath2 = await findCommandPath("claude");
+    return {
+      isHomebrew: false,
+      commandPath: commandPath2,
+      source: commandPath2 ? "other" : "not-found"
+    };
+  }
+  const commandPath = await findCommandPath("claude");
+  if (!commandPath) {
+    return { isHomebrew: false, commandPath: null, source: "not-found" };
+  }
+  const isFromCaskroom = commandPath.includes("/Caskroom/claude-code/");
+  if (isFromCaskroom) {
+    return { isHomebrew: true, commandPath, source: "homebrew-cask" };
+  }
+  try {
+    const { stdout: realPath } = await execAsync$2(`readlink -f "${commandPath}" 2>/dev/null || realpath "${commandPath}" 2>/dev/null || echo "${commandPath}"`);
+    const resolvedPath = realPath.trim();
+    if (resolvedPath.includes("/Caskroom/claude-code/")) {
+      return { isHomebrew: true, commandPath, source: "homebrew-cask" };
+    }
+  } catch {
+  }
+  if (commandPath.includes("/node_modules/") || commandPath.includes("/npm/") || commandPath.includes("/Cellar/node/")) {
+    return { isHomebrew: false, commandPath, source: "npm" };
+  }
+  return { isHomebrew: false, commandPath, source: "other" };
+}
+async function detectAllClaudeCodeInstallations() {
+  const installations = [];
+  const checkedPaths = /* @__PURE__ */ new Set();
+  const activeCommandPath = await findCommandPath("claude");
+  let activeResolvedPath = null;
+  if (activeCommandPath) {
+    try {
+      const { stdout } = await execAsync$2(`readlink -f "${activeCommandPath}" 2>/dev/null || realpath "${activeCommandPath}" 2>/dev/null || echo "${activeCommandPath}"`);
+      activeResolvedPath = stdout.trim();
+    } catch {
+      activeResolvedPath = activeCommandPath;
+    }
+  }
+  async function getVersionFromPath(path) {
+    try {
+      const { stdout } = await execAsync$2(`"${path}" -v 2>/dev/null || "${path}" --version 2>/dev/null`);
+      const versionMatch = stdout.match(/(\d+\.\d+\.\d+(?:-[\w.]+)?)/);
+      return versionMatch ? versionMatch[1] : null;
+    } catch {
+      return null;
+    }
+  }
+  function isActivePath(path) {
+    if (!activeResolvedPath)
+      return false;
+    return path === activeResolvedPath || path === activeCommandPath;
+  }
+  async function addInstallation(path, source) {
+    let resolvedPath = path;
+    try {
+      const { stdout } = await execAsync$2(`readlink -f "${path}" 2>/dev/null || realpath "${path}" 2>/dev/null || echo "${path}"`);
+      resolvedPath = stdout.trim();
+    } catch {
+    }
+    if (checkedPaths.has(resolvedPath))
+      return;
+    checkedPaths.add(resolvedPath);
+    if (!nodeFs.existsSync(path))
+      return;
+    const version = await getVersionFromPath(path);
+    installations.push({
+      source,
+      path,
+      version,
+      isActive: isActivePath(path) || isActivePath(resolvedPath)
+    });
+  }
+  if (activeCommandPath && nodeFs.existsSync(activeCommandPath)) {
+    let activeSource = "other";
+    if (activeResolvedPath?.includes("/Caskroom/claude-code/")) {
+      activeSource = "homebrew-cask";
+    } else if (activeResolvedPath?.includes("/node_modules/") || activeResolvedPath?.includes("/npm/") || activeResolvedPath?.includes("/fnm_multishells/") || activeResolvedPath?.includes("/.nvm/") || activeResolvedPath?.includes("/Cellar/node/") || activeCommandPath.includes("/fnm_multishells/") || activeCommandPath.includes("/.nvm/")) {
+      activeSource = "npm";
+    }
+    await addInstallation(activeCommandPath, activeSource);
+  }
+  if (getPlatform() === "macos") {
+    const homebrewPaths = await getHomebrewCommandPaths("claude");
+    for (const path of homebrewPaths) {
+      if (path.includes("/Caskroom/claude-code/")) {
+        await addInstallation(path, "homebrew-cask");
+      } else if (path.includes("/Cellar/node/")) {
+        await addInstallation(path, "npm-homebrew-node");
+      }
+    }
+    try {
+      await execAsync$2("brew list --cask claude-code");
+      const homebrewPrefixes = ["/opt/homebrew", "/usr/local"];
+      for (const prefix of homebrewPrefixes) {
+        const caskroomPath = `${prefix}/Caskroom/claude-code`;
+        if (nodeFs.existsSync(caskroomPath)) {
+          const versions = nodeFs.readdirSync(caskroomPath).filter((v) => !v.startsWith("."));
+          for (const version of versions) {
+            const claudePath = `${caskroomPath}/${version}/claude`;
+            await addInstallation(claudePath, "homebrew-cask");
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const npmGlobalPaths = [
+    "/usr/local/bin/claude",
+    "/usr/bin/claude",
+    `${process.env.HOME}/.npm-global/bin/claude`,
+    `${process.env.HOME}/.local/bin/claude`
+  ];
+  for (const path of npmGlobalPaths) {
+    if (nodeFs.existsSync(path)) {
+      let resolvedPath = path;
+      try {
+        const { stdout } = await execAsync$2(`readlink -f "${path}" 2>/dev/null || realpath "${path}" 2>/dev/null || echo "${path}"`);
+        resolvedPath = stdout.trim();
+      } catch {
+      }
+      if (resolvedPath.includes("/node_modules/") || resolvedPath.includes("/npm/")) {
+        await addInstallation(path, "npm");
+      } else if (resolvedPath.includes("/Caskroom/")) ; else {
+        await addInstallation(path, "other");
+      }
+    }
+  }
+  if (getPlatform() === "macos") {
+    const homebrewPrefixes = ["/opt/homebrew", "/usr/local"];
+    for (const prefix of homebrewPrefixes) {
+      const cellarNodePath = `${prefix}/Cellar/node`;
+      if (nodeFs.existsSync(cellarNodePath)) {
+        try {
+          const versions = nodeFs.readdirSync(cellarNodePath);
+          for (const version of versions) {
+            const claudePath = `${cellarNodePath}/${version}/bin/claude`;
+            await addInstallation(claudePath, "npm-homebrew-node");
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  return installations;
+}
+async function checkDuplicateInstallations() {
+  const installations = await detectAllClaudeCodeInstallations();
+  const activeInstallation = installations.find((i) => i.isActive) || null;
+  const inactiveInstallations = installations.filter((i) => !i.isActive);
+  const homebrewInstallation = installations.find((i) => i.source === "homebrew-cask") || null;
+  const npmInstallation = installations.find((i) => i.source === "npm" || i.source === "npm-homebrew-node") || null;
+  const hasDuplicates = homebrewInstallation !== null && npmInstallation !== null;
+  const recommendation = hasDuplicates ? "remove-npm" : "none";
+  return {
+    hasDuplicates,
+    installations,
+    activeInstallation,
+    inactiveInstallations,
+    homebrewInstallation,
+    npmInstallation,
+    recommendation
+  };
+}
+function getSourceDisplayName(source, i18n) {
+  const sourceMap = {
+    "homebrew-cask": i18n.t("installation:sourceHomebrewCask"),
+    "npm": i18n.t("installation:sourceNpm"),
+    "npm-homebrew-node": i18n.t("installation:sourceNpmHomebrewNode"),
+    "curl": i18n.t("installation:sourceCurl"),
+    "other": i18n.t("installation:sourceOther")
+  };
+  return sourceMap[source] || source;
+}
+async function performNpmRemovalAndActivateHomebrew(_npmInstallation, homebrewInstallation, tinyExec, i18n, ansis) {
+  const ora = (await import('ora')).default;
+  const spinner = ora(i18n.t("installation:removingDuplicateInstallation")).start();
+  try {
+    const { wrapCommandWithSudo } = await Promise.resolve().then(function () { return platform; });
+    const { command, args, usedSudo } = wrapCommandWithSudo("npm", ["uninstall", "-g", "@anthropic-ai/claude-code"]);
+    if (usedSudo) {
+      spinner.info(i18n.t("installation:usingSudo"));
+      spinner.start();
+    }
+    await tinyExec(command, args);
+    spinner.succeed(i18n.t("installation:duplicateRemoved"));
+    if (homebrewInstallation && !homebrewInstallation.isActive) {
+      console.log("");
+      console.log(ansis.cyan(`\u{1F517} ${i18n.t("installation:activatingHomebrew")}`));
+      const { createHomebrewSymlink } = await Promise.resolve().then(function () { return installer; });
+      const symlinkResult = await createHomebrewSymlink("claude", homebrewInstallation.path);
+      if (symlinkResult.success) {
+        console.log(ansis.green(`\u2714 ${i18n.t("installation:symlinkCreated", { path: symlinkResult.symlinkPath || "/usr/local/bin/claude" })}`));
+      } else {
+        console.log(ansis.yellow(`\u26A0 ${i18n.t("installation:manualSymlinkHint")}`));
+        if (symlinkResult.error) {
+          console.log(ansis.gray(`   ${symlinkResult.error}`));
+        } else {
+          const homebrewBin = nodeFs.existsSync("/opt/homebrew/bin") ? "/opt/homebrew/bin" : "/usr/local/bin";
+          console.log(ansis.gray(`   sudo ln -sf "${homebrewInstallation.path}" ${homebrewBin}/claude`));
+        }
+      }
+    }
+    return { hadDuplicates: true, resolved: true, action: "removed-npm" };
+  } catch (error) {
+    spinner.fail(i18n.t("installation:duplicateRemovalFailed"));
+    if (error instanceof Error) {
+      console.error(ansis.gray(error.message));
+    }
+    return { hadDuplicates: true, resolved: false, action: "kept-both" };
+  }
+}
+async function handleDuplicateInstallations(skipPrompt = false) {
+  const { ensureI18nInitialized, format, i18n } = await Promise.resolve().then(function () { return index; });
+  const ansis = (await import('ansis')).default;
+  ensureI18nInitialized();
+  const duplicateInfo = await checkDuplicateInstallations();
+  if (!duplicateInfo.hasDuplicates) {
+    return { hadDuplicates: false, resolved: true, action: "no-duplicates" };
+  }
+  const { npmInstallation, homebrewInstallation } = duplicateInfo;
+  console.log("");
+  console.log(ansis.yellow.bold(i18n.t("installation:duplicateInstallationsDetected")));
+  console.log(ansis.gray(i18n.t("installation:duplicateInstallationsWarning")));
+  console.log("");
+  if (homebrewInstallation) {
+    const isActive = homebrewInstallation.isActive;
+    const statusIcon = isActive ? "\u2705" : "\u26A0\uFE0F";
+    const statusColor = isActive ? ansis.green : ansis.yellow;
+    console.log(ansis.cyan.bold(`\u{1F37A} Homebrew Cask ${i18n.t("installation:recommendedMethod")}:`));
+    console.log(ansis.white(`   ${i18n.t("installation:installationSource")}: ${statusColor(getSourceDisplayName(homebrewInstallation.source, i18n))}`));
+    console.log(ansis.white(`   ${i18n.t("installation:installationPath")}: ${ansis.gray(homebrewInstallation.path)}`));
+    if (homebrewInstallation.version) {
+      console.log(ansis.white(`   ${i18n.t("installation:installationVersion")}: ${ansis.cyan(homebrewInstallation.version)}`));
+    }
+    console.log(ansis.white(`   ${statusIcon} ${isActive ? i18n.t("installation:currentActiveInstallation") : i18n.t("installation:inactiveInstallations")}`));
+    console.log("");
+  }
+  if (npmInstallation) {
+    const isActive = npmInstallation.isActive;
+    console.log(ansis.yellow.bold(`\u{1F4E6} npm ${i18n.t("installation:notRecommended")}:`));
+    console.log(ansis.white(`   ${i18n.t("installation:installationSource")}: ${ansis.yellow(getSourceDisplayName(npmInstallation.source, i18n))}`));
+    console.log(ansis.white(`   ${i18n.t("installation:installationPath")}: ${ansis.gray(npmInstallation.path)}`));
+    if (npmInstallation.version) {
+      console.log(ansis.white(`   ${i18n.t("installation:installationVersion")}: ${ansis.cyan(npmInstallation.version)}`));
+      if (homebrewInstallation?.version && npmInstallation.version !== homebrewInstallation.version) {
+        console.log(ansis.red(`   ${format(i18n.t("installation:versionMismatchWarning"), {
+          npmVersion: npmInstallation.version,
+          homebrewVersion: homebrewInstallation.version
+        })}`));
+      }
+    }
+    if (isActive) {
+      console.log(ansis.white(`   \u26A0\uFE0F ${i18n.t("installation:currentActiveInstallation")}`));
+    }
+    console.log("");
+  }
+  console.log(ansis.cyan(`\u{1F4A1} ${i18n.t("installation:recommendRemoveNpm")}`));
+  console.log("");
+  if (!npmInstallation) {
+    return { hadDuplicates: true, resolved: false, action: "kept-both" };
+  }
+  const { exec: tinyExec } = await import('tinyexec');
+  if (skipPrompt) {
+    console.log(ansis.cyan(`\u{1F504} ${i18n.t("installation:autoRemovingNpm")}`));
+    return await performNpmRemovalAndActivateHomebrew(
+      npmInstallation,
+      homebrewInstallation,
+      tinyExec,
+      i18n,
+      ansis
+    );
+  }
+  const inquirer = (await import('inquirer')).default;
+  const sourceDisplayName = getSourceDisplayName(npmInstallation.source, i18n);
+  const confirmMessage = format(i18n.t("installation:confirmRemoveDuplicate"), { source: sourceDisplayName });
+  const { action } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "action",
+      message: confirmMessage,
+      choices: [
+        {
+          name: `\u2705 ${i18n.t("common:yes")} - ${i18n.t("installation:removingDuplicateInstallation")}`,
+          value: "remove"
+        },
+        {
+          name: `\u274C ${i18n.t("installation:keepBothInstallations")}`,
+          value: "keep"
+        }
+      ]
+    }
+  ]);
+  if (action === "keep") {
+    console.log(ansis.gray(i18n.t("installation:duplicateWarningContinue")));
+    return { hadDuplicates: true, resolved: false, action: "kept-both" };
+  }
+  return await performNpmRemovalAndActivateHomebrew(
+    npmInstallation,
+    homebrewInstallation,
+    tinyExec,
+    i18n,
+    ansis
+  );
+}
+async function getHomebrewClaudeCodeVersion() {
+  try {
+    const { stdout } = await execAsync$2("brew info --cask claude-code --json=v2");
+    const info = JSON.parse(stdout);
+    if (info.casks && info.casks.length > 0) {
+      return info.casks[0].version;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
 function compareVersions(current, latest) {
   if (!semver.valid(current) || !semver.valid(latest)) {
     return -1;
@@ -2035,12 +2492,22 @@ async function checkCcrVersion() {
 }
 async function checkClaudeCodeVersion() {
   const currentVersion = await getInstalledVersion("claude");
-  const latestVersion = await getLatestVersion("@anthropic-ai/claude-code");
+  const installationInfo = await getClaudeCodeInstallationSource();
+  const { isHomebrew, commandPath, source: installationSource } = installationInfo;
+  let latestVersion;
+  if (isHomebrew) {
+    latestVersion = await getHomebrewClaudeCodeVersion();
+  } else {
+    latestVersion = await getLatestVersion("@anthropic-ai/claude-code");
+  }
   return {
     installed: currentVersion !== null,
     currentVersion,
     latestVersion,
-    needsUpdate: currentVersion && latestVersion ? shouldUpdate(currentVersion, latestVersion) : false
+    needsUpdate: currentVersion && latestVersion ? shouldUpdate(currentVersion, latestVersion) : false,
+    isHomebrew,
+    commandPath,
+    installationSource
   };
 }
 async function checkCometixLineVersion() {
@@ -2067,7 +2534,24 @@ async function checkClaudeCodeVersionAndPrompt(skipPrompt = false) {
   }
 }
 
-const execAsync$2 = promisify(exec$1);
+async function execWithSudoIfNeeded(command, args) {
+  const needsSudo = shouldUseSudoForGlobalInstall();
+  if (needsSudo) {
+    console.log(ansis.yellow(`
+${i18n.t("updater:usingSudo")}`));
+    const result = await exec("sudo", [command, ...args]);
+    if (result.exitCode !== 0) {
+      throw new Error(result.stderr || `Command failed with exit code ${result.exitCode}`);
+    }
+    return { usedSudo: true };
+  } else {
+    const result = await exec(command, args);
+    if (result.exitCode !== 0) {
+      throw new Error(result.stderr || `Command failed with exit code ${result.exitCode}`);
+    }
+    return { usedSudo: false };
+  }
+}
 async function updateCcr(force = false, skipPrompt = false) {
   ensureI18nInitialized();
   const spinner = ora(i18n.t("updater:checkingVersion")).start();
@@ -2102,7 +2586,7 @@ async function updateCcr(force = false, skipPrompt = false) {
     }
     const updateSpinner = ora(format(i18n.t("updater:updating"), { tool: "CCR" })).start();
     try {
-      await execAsync$2("npm update -g @musistudio/claude-code-router");
+      await execWithSudoIfNeeded("npm", ["update", "-g", "@musistudio/claude-code-router"]);
       updateSpinner.succeed(format(i18n.t("updater:updateSuccess"), { tool: "CCR" }));
       return true;
     } catch (error) {
@@ -2120,7 +2604,7 @@ async function updateClaudeCode(force = false, skipPrompt = false) {
   ensureI18nInitialized();
   const spinner = ora(i18n.t("updater:checkingVersion")).start();
   try {
-    const { installed, currentVersion, latestVersion, needsUpdate } = await checkClaudeCodeVersion();
+    const { installed, currentVersion, latestVersion, needsUpdate, isHomebrew } = await checkClaudeCodeVersion();
     spinner.stop();
     if (!installed) {
       console.log(ansis.yellow(i18n.t("updater:claudeCodeNotInstalled")));
@@ -2148,9 +2632,17 @@ async function updateClaudeCode(force = false, skipPrompt = false) {
     } else {
       console.log(ansis.cyan(format(i18n.t("updater:autoUpdating"), { tool: "Claude Code" })));
     }
-    const updateSpinner = ora(format(i18n.t("updater:updating"), { tool: "Claude Code" })).start();
+    const toolName = isHomebrew ? "Claude Code (Homebrew)" : "Claude Code";
+    const updateSpinner = ora(format(i18n.t("updater:updating"), { tool: toolName })).start();
     try {
-      await execAsync$2("claude update");
+      if (isHomebrew) {
+        const result = await exec("brew", ["upgrade", "--cask", "claude-code"]);
+        if (result.exitCode !== 0) {
+          throw new Error(result.stderr || `Command failed with exit code ${result.exitCode}`);
+        }
+      } else {
+        await execWithSudoIfNeeded("claude", ["update"]);
+      }
       updateSpinner.succeed(format(i18n.t("updater:updateSuccess"), { tool: "Claude Code" }));
       return true;
     } catch (error) {
@@ -2198,7 +2690,7 @@ async function updateCometixLine(force = false, skipPrompt = false) {
     }
     const updateSpinner = ora(format(i18n.t("updater:updating"), { tool: "CCometixLine" })).start();
     try {
-      await execAsync$2("npm update -g @cometix/ccline");
+      await execWithSudoIfNeeded("npm", ["update", "-g", "@cometix/ccline"]);
       updateSpinner.succeed(format(i18n.t("updater:updateSuccess"), { tool: "CCometixLine" }));
       return true;
     } catch (error) {
@@ -2217,6 +2709,15 @@ async function checkAndUpdateTools(skipPrompt = false) {
   console.log(ansis.bold.cyan(`
 \u{1F50D} ${i18n.t("updater:checkingTools")}
 `));
+  try {
+    const duplicateResult = await handleDuplicateInstallations(skipPrompt);
+    if (duplicateResult.hadDuplicates) {
+      console.log();
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.warn(ansis.yellow(`\u26A0 Duplicate installation check failed: ${errorMessage}`));
+  }
   const results = [];
   try {
     const success = await updateCcr(false, skipPrompt);
@@ -2260,6 +2761,7 @@ async function checkAndUpdateTools(skipPrompt = false) {
 const autoUpdater = {
   __proto__: null,
   checkAndUpdateTools: checkAndUpdateTools,
+  execWithSudoIfNeeded: execWithSudoIfNeeded,
   updateCcr: updateCcr,
   updateClaudeCode: updateClaudeCode,
   updateCometixLine: updateCometixLine
@@ -2881,11 +3383,83 @@ 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)));
+  if (skipPrompt) {
+    const { runCodexWorkflowSelection } = await Promise.resolve().then(function () { return codex; });
+    await runCodexWorkflowSelection({ skipPrompt: true, workflows: options?.workflows ?? [] });
+    if (options?.mcpServices === false) {
+      updateZcfConfig({ codeToolType: "codex" });
+      console.log(ansis.green(i18n.t("codex:mcpConfigured")));
+      return;
+    }
+    const defaultServiceIds = Array.isArray(options?.mcpServices) ? options.mcpServices : MCP_SERVICE_CONFIGS.filter((service) => !service.requiresApiKey).map((service) => service.id);
+    const baseProviders2 = existingConfig?.providers || [];
+    const existingServices2 = existingConfig?.mcpServices || [];
+    const selection2 = [];
+    for (const id of defaultServiceIds) {
+      const configInfo = MCP_SERVICE_CONFIGS.find((service) => service.id === id);
+      if (!configInfo)
+        continue;
+      let command = configInfo.config.command || id;
+      let args = (configInfo.config.args || []).map((arg) => String(arg));
+      if (id === "serena") {
+        const idx = args.indexOf("--context");
+        if (idx >= 0 && idx + 1 < args.length)
+          args[idx + 1] = "codex";
+        else
+          args.push("--context", "codex");
+      }
+      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;
+      }
+      selection2.push({
+        id: id.toLowerCase(),
+        command,
+        args,
+        env: Object.keys(env).length > 0 ? env : void 0,
+        startup_timeout_sec: 30
+      });
+    }
+    const mergedMap2 = /* @__PURE__ */ new Map();
+    for (const svc of existingServices2)
+      mergedMap2.set(svc.id.toLowerCase(), { ...svc });
+    for (const svc of selection2)
+      mergedMap2.set(svc.id.toLowerCase(), { ...svc });
+    const finalServices2 = Array.from(mergedMap2.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: baseProviders2,
+      mcpServices: finalServices2,
+      otherConfig: existingConfig?.otherConfig || []
+    });
+    updateZcfConfig({ codeToolType: "codex" });
+    console.log(ansis.green(i18n.t("codex:mcpConfigured")));
+    return;
+  }
   const selectedIds = await selectMcpServices();
   if (!selectedIds)
     return;
@@ -2962,7 +3536,7 @@ async function configureCodexMcp(options) {
       command: serviceConfig.command,
       args: serviceConfig.args,
       env: Object.keys(env).length > 0 ? env : void 0,
-      startup_timeout_ms: configInfo.config.startup_timeout_ms
+      startup_timeout_sec: 30
     });
   }
   const mergedMap = /* @__PURE__ */ new Map();
@@ -2996,6 +3570,7 @@ async function configureCodexMcp(options) {
   console.log(ansis.green(i18n.t("codex:mcpConfigured")));
 }
 
+let cachedSkipPromptBackup = null;
 function getRootDir$1() {
   const currentFilePath = fileURLToPath(import.meta.url);
   let dir = dirname(currentFilePath);
@@ -3084,12 +3659,16 @@ function createBackupDirectory(timestamp) {
 function backupCodexFiles() {
   if (!exists(CODEX_DIR))
     return null;
+  if (process.env.ZCF_CODEX_SKIP_PROMPT_SINGLE_BACKUP === "true" && cachedSkipPromptBackup)
+    return cachedSkipPromptBackup;
   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 });
+  if (process.env.ZCF_CODEX_SKIP_PROMPT_SINGLE_BACKUP === "true")
+    cachedSkipPromptBackup = backupDir;
   return backupDir;
 }
 function backupCodexComplete() {
@@ -3109,6 +3688,8 @@ function backupCodexConfig() {
   }
 }
 function backupCodexAgents() {
+  if (process.env.ZCF_CODEX_SKIP_PROMPT_SINGLE_BACKUP === "true" && cachedSkipPromptBackup)
+    return cachedSkipPromptBackup;
   if (!exists(CODEX_AGENTS_FILE))
     return null;
   try {
@@ -3122,6 +3703,8 @@ function backupCodexAgents() {
   }
 }
 function backupCodexPrompts() {
+  if (process.env.ZCF_CODEX_SKIP_PROMPT_SINGLE_BACKUP === "true" && cachedSkipPromptBackup)
+    return cachedSkipPromptBackup;
   if (!exists(CODEX_PROMPTS_DIR))
     return null;
   try {
@@ -3137,9 +3720,91 @@ function backupCodexPrompts() {
 function getBackupMessage(path) {
   if (!path)
     return "";
-  ensureI18nInitialized();
+  if (!i18n.isInitialized) {
+    return `Backup created: ${path}`;
+  }
   return i18n.t("codex:backupSuccess", { path });
 }
+function needsEnvKeyMigration() {
+  if (!exists(CODEX_CONFIG_FILE))
+    return false;
+  try {
+    const content = readFile(CODEX_CONFIG_FILE);
+    const hasOldEnvKey = /^\s*env_key\s*=/m.test(content);
+    return hasOldEnvKey;
+  } catch {
+    return false;
+  }
+}
+function migrateEnvKeyToTempEnvKey() {
+  if (!exists(CODEX_CONFIG_FILE))
+    return false;
+  try {
+    const content = readFile(CODEX_CONFIG_FILE);
+    if (!needsEnvKeyMigration())
+      return false;
+    const backupPath = backupCodexConfig();
+    if (backupPath) {
+      console.log(ansis.gray(getBackupMessage(backupPath)));
+    }
+    const migratedContent = migrateEnvKeyInContent(content);
+    writeFile(CODEX_CONFIG_FILE, migratedContent);
+    updateTomlConfig(ZCF_CONFIG_FILE, {
+      codex: {
+        envKeyMigrated: true
+      }
+    });
+    const message = i18n.isInitialized ? i18n.t("codex:envKeyMigrationComplete") : "\u2714 env_key to temp_env_key migration completed";
+    console.log(ansis.green(message));
+    return true;
+  } catch (error) {
+    console.error(ansis.yellow(`env_key migration warning: ${error.message}`));
+    return false;
+  }
+}
+function migrateEnvKeyInContent(content) {
+  const lines = content.split("\n");
+  const result = [];
+  let currentSectionHasTempEnvKey = false;
+  let currentSection = "";
+  const sectionHasTempEnvKey = /* @__PURE__ */ new Map();
+  let tempSection = "";
+  for (const line of lines) {
+    const sectionMatch = line.match(/^\s*\[([^\]]+)\]/);
+    if (sectionMatch) {
+      tempSection = sectionMatch[1];
+    }
+    if (tempSection && /^\s*temp_env_key\s*=/.test(line)) {
+      sectionHasTempEnvKey.set(tempSection, true);
+    }
+  }
+  for (const line of lines) {
+    const sectionMatch = line.match(/^\s*\[([^\]]+)\]/);
+    if (sectionMatch) {
+      currentSection = sectionMatch[1];
+      currentSectionHasTempEnvKey = sectionHasTempEnvKey.get(currentSection) || false;
+    }
+    const envKeyMatch = line.match(/^(\s*)env_key(\s*=.*)$/);
+    if (envKeyMatch) {
+      if (currentSectionHasTempEnvKey) {
+        continue;
+      } else {
+        result.push(`${envKeyMatch[1]}temp_env_key${envKeyMatch[2]}`);
+        continue;
+      }
+    }
+    result.push(line);
+  }
+  return result.join("\n");
+}
+function ensureEnvKeyMigration() {
+  const tomlConfig = readDefaultTomlConfig();
+  if (tomlConfig?.codex?.envKeyMigrated)
+    return;
+  if (needsEnvKeyMigration()) {
+    migrateEnvKeyToTempEnvKey();
+  }
+}
 function sanitizeProviderName(input) {
   const cleaned = input.trim();
   if (!cleaned)
@@ -3172,7 +3837,7 @@ function parseCodexConfig(content) {
           name: provider.name || id,
           baseUrl: provider.base_url || "",
           wireApi: provider.wire_api || "responses",
-          envKey: provider.env_key || "OPENAI_API_KEY",
+          tempEnvKey: provider.temp_env_key || "OPENAI_API_KEY",
           requiresOpenaiAuth: provider.requires_openai_auth !== false,
           model: provider.model || void 0
           // Parse model field from provider
@@ -3181,7 +3846,7 @@ function parseCodexConfig(content) {
     }
     const mcpServices = [];
     if (tomlData.mcp_servers) {
-      const KNOWN_MCP_FIELDS = /* @__PURE__ */ new Set(["command", "args", "env", "startup_timeout_ms"]);
+      const KNOWN_MCP_FIELDS = /* @__PURE__ */ new Set(["command", "args", "env", "startup_timeout_sec"]);
       for (const [id, mcpData] of Object.entries(tomlData.mcp_servers)) {
         const mcp = mcpData;
         const extraFields = {};
@@ -3195,7 +3860,7 @@ function parseCodexConfig(content) {
           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,
+          startup_timeout_sec: mcp.startup_timeout_sec,
           // Only add extraFields if there are any extra fields
           extraFields: Object.keys(extraFields).length > 0 ? extraFields : void 0
         });
@@ -3363,6 +4028,7 @@ function formatTomlField(key, value) {
 function readCodexConfig() {
   if (!exists(CODEX_CONFIG_FILE))
     return null;
+  ensureEnvKeyMigration();
   try {
     const content = readFile(CODEX_CONFIG_FILE);
     return parseCodexConfig(content);
@@ -3416,7 +4082,7 @@ function renderCodexConfig(data) {
       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(`temp_env_key = "${provider.tempEnvKey}"`);
       lines.push(`requires_openai_auth = ${provider.requiresOpenaiAuth}`);
       if (provider.model) {
         lines.push(`model = "${provider.model}"`);
@@ -3436,8 +4102,8 @@ function renderCodexConfig(data) {
         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}`);
+      if (service.startup_timeout_sec) {
+        lines.push(`startup_timeout_sec = ${service.startup_timeout_sec}`);
       }
       if (service.extraFields) {
         for (const [key, value] of Object.entries(service.extraFields)) {
@@ -3460,6 +4126,7 @@ function renderCodexConfig(data) {
   return result;
 }
 function writeCodexConfig(data) {
+  ensureEnvKeyMigration();
   ensureDir(CODEX_DIR);
   writeFile(CODEX_CONFIG_FILE, renderCodexConfig(data));
 }
@@ -3595,8 +4262,8 @@ async function runCodexSystemPromptSelection(skipPrompt = false) {
   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 { readDefaultTomlConfig: readDefaultTomlConfig2 } = await Promise.resolve().then(function () { return zcfConfig; });
+  const tomlConfig = readDefaultTomlConfig2();
   const { resolveTemplateLanguage } = await Promise.resolve().then(function () { return prompts; });
   const preferredLang = await resolveTemplateLanguage(
     void 0,
@@ -3656,9 +4323,9 @@ async function runCodexSystemPromptSelection(skipPrompt = false) {
   }
   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, {
+    const { updateTomlConfig: updateTomlConfig2 } = await Promise.resolve().then(function () { return zcfConfig; });
+    const { ZCF_CONFIG_FILE: ZCF_CONFIG_FILE2 } = await Promise.resolve().then(function () { return constants; });
+    updateTomlConfig2(ZCF_CONFIG_FILE2, {
       codex: {
         systemPromptStyle: systemPrompt
       }
@@ -3808,29 +4475,39 @@ async function applyCustomApiConfig(customApiConfig) {
   if (backupPath) {
     console.log(ansis.gray(getBackupMessage(backupPath)));
   }
+  const existingConfig = readCodexConfig();
+  const existingAuth = readJsonConfig(CODEX_AUTH_FILE, { defaultValue: {} }) || {};
   const providers = [];
-  const authEntries = {};
+  const authEntries = { ...existingAuth };
   const providerId = type === "auth_token" ? "official-auth-token" : "custom-api-key";
   const providerName = type === "auth_token" ? "Official Auth Token" : "Custom API Key";
+  const existingProvider = existingConfig?.providers.find((p) => p.id === providerId);
   providers.push({
     id: providerId,
     name: providerName,
-    baseUrl: baseUrl || "https://api.anthropic.com",
-    wireApi: "claude",
-    envKey: `${providerId.toUpperCase()}_API_KEY`,
-    requiresOpenaiAuth: false
+    baseUrl: baseUrl || existingProvider?.baseUrl || "https://api.anthropic.com",
+    wireApi: existingProvider?.wireApi || "responses",
+    tempEnvKey: existingProvider?.tempEnvKey || `${providerId.toUpperCase()}_API_KEY`,
+    requiresOpenaiAuth: existingProvider?.requiresOpenaiAuth ?? false,
+    model: model || existingProvider?.model
   });
+  if (existingConfig?.providers) {
+    providers.push(...existingConfig.providers.filter((p) => p.id !== providerId));
+  }
   if (token) {
     authEntries[providerId] = token;
+    authEntries.OPENAI_API_KEY = token;
   }
   const configData = {
-    model: model || "claude-3-5-sonnet-20241022",
-    // Use provided model or default
+    model: model || existingConfig?.model || "claude-3-5-sonnet-20241022",
+    // Prefer provided model, then existing, fallback default
     modelProvider: providerId,
     modelProviderCommented: false,
     providers,
-    mcpServices: []};
-  writeFile(CODEX_CONFIG_FILE, renderCodexConfig(configData));
+    mcpServices: existingConfig?.mcpServices || [],
+    otherConfig: existingConfig?.otherConfig || []
+  };
+  writeCodexConfig(configData);
   writeJsonConfig(CODEX_AUTH_FILE, authEntries);
   updateZcfConfig({ codeToolType: "codex" });
   console.log(ansis.green(`\u2714 ${i18n.t("codex:apiConfigured")}`));
@@ -4008,7 +4685,7 @@ async function configureCodexApi(options) {
       }
     }
     const providerId = sanitizeProviderName(answers.providerName);
-    const envKey = `${providerId.toUpperCase().replace(/-/g, "_")}_API_KEY`;
+    const tempEnvKey = `${providerId.toUpperCase().replace(/-/g, "_")}_API_KEY`;
     const existingProvider = existingMap.get(providerId);
     const sessionProvider = currentSessionProviders.get(providerId);
     if (existingProvider || sessionProvider) {
@@ -4038,14 +4715,14 @@ async function configureCodexApi(options) {
       name: answers.providerName,
       baseUrl: selectedProvider2 === "custom" ? answers.baseUrl : prefilledBaseUrl,
       wireApi: selectedProvider2 === "custom" ? answers.wireApi || "responses" : prefilledWireApi,
-      envKey,
+      tempEnvKey,
       requiresOpenaiAuth: true,
       model: customModel || prefilledModel || "gpt-5-codex"
       // Use custom model, provider's default model, or fallback
     };
     providers.push(newProvider);
     currentSessionProviders.set(providerId, newProvider);
-    authEntries[envKey] = answers.apiKey;
+    authEntries[tempEnvKey] = answers.apiKey;
     const addAnother = await promptBoolean({
       message: i18n.t("codex:addProviderPrompt"),
       defaultValue: false
@@ -4065,8 +4742,8 @@ async function configureCodexApi(options) {
   }]);
   const selectedProvider = providers.find((provider) => provider.id === defaultProvider);
   if (selectedProvider) {
-    const envKey = selectedProvider.envKey;
-    const defaultApiKey = authEntries[envKey] ?? existingAuth[envKey] ?? null;
+    const tempEnvKey = selectedProvider.tempEnvKey;
+    const defaultApiKey = authEntries[tempEnvKey] ?? existingAuth[tempEnvKey] ?? null;
     if (defaultApiKey)
       authEntries.OPENAI_API_KEY = defaultApiKey;
   }
@@ -4351,7 +5028,7 @@ async function switchToProvider(providerId) {
     };
     writeCodexConfig(updatedConfig);
     const auth = readJsonConfig(CODEX_AUTH_FILE, { defaultValue: {} }) || {};
-    const envValue = auth[provider.envKey] || null;
+    const envValue = auth[provider.tempEnvKey] || null;
     auth.OPENAI_API_KEY = envValue;
     writeJsonConfig(CODEX_AUTH_FILE, auth, { pretty: true });
     console.log(ansis.green(i18n.t("codex:providerSwitchSuccess", { provider: providerId })));
@@ -4375,11 +5052,15 @@ const codex = {
   configureCodexApi: configureCodexApi,
   configureCodexMcp: configureCodexMcp,
   createBackupDirectory: createBackupDirectory,
+  ensureEnvKeyMigration: ensureEnvKeyMigration,
   getBackupMessage: getBackupMessage,
   getCodexVersion: getCodexVersion,
   installCodexCli: installCodexCli,
   isCodexInstalled: isCodexInstalled$1,
   listCodexProviders: listCodexProviders,
+  migrateEnvKeyInContent: migrateEnvKeyInContent,
+  migrateEnvKeyToTempEnvKey: migrateEnvKeyToTempEnvKey,
+  needsEnvKeyMigration: needsEnvKeyMigration,
   parseCodexConfig: parseCodexConfig,
   readCodexConfig: readCodexConfig,
   renderCodexConfig: renderCodexConfig,
@@ -4989,6 +5670,10 @@ async function installClaudeCode(skipMethodSelection = false) {
     if (version) {
       console.log(ansis.gray(`  ${i18n.t("installation:detectedVersion", { version })}`));
     }
+    const verification = await verifyInstallation(codeType);
+    if (verification.symlinkCreated) {
+      displayVerificationResult(verification, codeType);
+    }
     await updateClaudeCode();
     return;
   }
@@ -5011,13 +5696,15 @@ async function installClaudeCode(skipMethodSelection = false) {
   if (skipMethodSelection) {
     console.log(i18n.t("installation:installing"));
     try {
-      const { command, args, usedSudo } = wrapCommandWithSudo("npm", ["install", "-g", "@anthropic-ai/claude-code"]);
+      const { command, args, usedSudo } = wrapCommandWithSudo("npm", ["install", "-g", "@anthropic-ai/claude-code", "--force"]);
       if (usedSudo) {
         console.log(ansis.yellow(`\u2139 ${i18n.t("installation:usingSudo")}`));
       }
       await exec(command, args);
       console.log(`\u2714 ${i18n.t("installation:installSuccess")}`);
       await setInstallMethod("npm");
+      const verification = await verifyInstallation(codeType);
+      displayVerificationResult(verification, codeType);
       if (isTermux()) {
         console.log(ansis.gray(`
 Claude Code installed to: ${getTermuxPrefix()}/bin/claude`));
@@ -5078,12 +5765,14 @@ async function installCodex(skipMethodSelection = false) {
   if (skipMethodSelection) {
     console.log(i18n.t("installation:installingWith", { method: "npm", codeType: codeTypeName }));
     try {
-      const { command, args, usedSudo } = wrapCommandWithSudo("npm", ["install", "-g", "@openai/codex"]);
+      const { command, args, usedSudo } = wrapCommandWithSudo("npm", ["install", "-g", "@openai/codex", "--force"]);
       if (usedSudo) {
         console.log(ansis.yellow(`\u2139 ${i18n.t("installation:usingSudo")}`));
       }
       await exec(command, args);
       console.log(ansis.green(`\u2714 ${codeTypeName} ${i18n.t("installation:installSuccess")}`));
+      const verification = await verifyInstallation(codeType);
+      displayVerificationResult(verification, codeType);
     } catch (error) {
       console.error(ansis.red(`\u2716 ${codeTypeName} ${i18n.t("installation:installFailed")}`));
       throw error;
@@ -5161,7 +5850,7 @@ async function uninstallCodeTool(codeType) {
       }
     } else if (codeType === "codex") {
       try {
-        const result = await exec("brew", ["list", "codex"]);
+        const result = await exec("brew", ["list", "--cask", "codex"]);
         if (result.exitCode === 0) {
           method = "homebrew";
         }
@@ -5176,7 +5865,7 @@ async function uninstallCodeTool(codeType) {
     const platform = getPlatform();
     if (platform === "macos" || platform === "linux") {
       try {
-        const testResult = codeType === "claude-code" ? await exec("brew", ["list", "--cask", "claude-code"]) : await exec("brew", ["list", "codex"]);
+        const testResult = codeType === "claude-code" ? await exec("brew", ["list", "--cask", "claude-code"]) : await exec("brew", ["list", "--cask", "codex"]);
         if (testResult.exitCode === 0) {
           method = "homebrew";
         }
@@ -5205,7 +5894,7 @@ async function uninstallCodeTool(codeType) {
         if (codeType === "claude-code") {
           await exec("brew", ["uninstall", "--cask", "claude-code"]);
         } else {
-          await exec("brew", ["uninstall", "codex"]);
+          await exec("brew", ["uninstall", "--cask", "codex"]);
         }
         break;
       }
@@ -5276,6 +5965,22 @@ async function detectInstalledVersion(codeType) {
   }
   return null;
 }
+function getInstallMethodLabel(method) {
+  switch (method) {
+    case "npm":
+      return i18n.t("installation:installMethodNpm");
+    case "homebrew":
+      return i18n.t("installation:installMethodHomebrew");
+    case "curl":
+      return i18n.t("installation:installMethodCurl");
+    case "powershell":
+      return i18n.t("installation:installMethodPowershell");
+    case "cmd":
+      return i18n.t("installation:installMethodCmd");
+    default:
+      return method;
+  }
+}
 function getInstallMethodOptions(codeType, recommendedMethods) {
   const allMethods = ["npm", "homebrew", "curl", "powershell", "cmd"];
   const platform = getPlatform();
@@ -5294,7 +5999,8 @@ function getInstallMethodOptions(codeType, recommendedMethods) {
   const topRecommended = recommendedMethods.length > 0 ? recommendedMethods[0] : null;
   return availableMethods.map((method) => {
     const isTopRecommended = method === topRecommended;
-    const title = isTopRecommended ? `${i18n.t(`installation:installMethod${method.charAt(0).toUpperCase() + method.slice(1)}`)} ${ansis.green(`[${i18n.t("installation:recommendedMethod")}]`)}` : i18n.t(`installation:installMethod${method.charAt(0).toUpperCase() + method.slice(1)}`);
+    const methodLabel = getInstallMethodLabel(method);
+    const title = isTopRecommended ? `${methodLabel} ${ansis.green(`[${i18n.t("installation:recommendedMethod")}]`)}` : methodLabel;
     return {
       title,
       value: method
@@ -5329,7 +6035,7 @@ async function executeInstallMethod(method, codeType) {
     switch (method) {
       case "npm": {
         const packageName = codeType === "claude-code" ? "@anthropic-ai/claude-code" : "@openai/codex";
-        const { command, args, usedSudo } = wrapCommandWithSudo("npm", ["install", "-g", packageName]);
+        const { command, args, usedSudo } = wrapCommandWithSudo("npm", ["install", "-g", packageName, "--force"]);
         if (usedSudo) {
           spinner.info(i18n.t("installation:usingSudo"));
           spinner.start();
@@ -5342,7 +6048,7 @@ async function executeInstallMethod(method, codeType) {
         if (codeType === "claude-code") {
           await exec("brew", ["install", "--cask", "claude-code"]);
         } else {
-          await exec("brew", ["install", "codex"]);
+          await exec("brew", ["install", "--cask", "codex"]);
         }
         await setInstallMethod("homebrew", codeType);
         break;
@@ -5381,6 +6087,8 @@ async function executeInstallMethod(method, codeType) {
         throw new Error(`Unsupported install method: ${method}`);
     }
     spinner.succeed(i18n.t("installation:installMethodSuccess", { method }));
+    const verification = await verifyInstallation(codeType);
+    displayVerificationResult(verification, codeType);
     return true;
   } catch (error) {
     spinner.fail(i18n.t("installation:installMethodFailed", { method }));
@@ -5411,10 +6119,187 @@ async function handleInstallFailure(codeType, failedMethods) {
   }
   return await handleInstallFailure(codeType, [...failedMethods, newMethod]);
 }
+async function isCommandInPath(command) {
+  try {
+    const cmd = getPlatform() === "windows" ? "where" : "which";
+    const res = await exec(cmd, [command]);
+    return res.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function verifyInstallation(codeType) {
+  const command = codeType === "claude-code" ? "claude" : "codex";
+  const commandInPath = await isCommandInPath(command);
+  if (commandInPath) {
+    const version = await detectInstalledVersion(codeType);
+    return {
+      success: true,
+      commandPath: await findCommandPath(command),
+      version,
+      needsSymlink: false,
+      symlinkCreated: false
+    };
+  }
+  if (getPlatform() === "macos") {
+    const homebrewPaths = await getHomebrewCommandPaths(command);
+    let foundPath = null;
+    for (const path of homebrewPaths) {
+      if (exists(path)) {
+        foundPath = path;
+        break;
+      }
+    }
+    if (foundPath) {
+      const symlinkResult = await createHomebrewSymlink(command, foundPath);
+      if (symlinkResult.success) {
+        const version = await detectInstalledVersion(codeType);
+        return {
+          success: true,
+          commandPath: symlinkResult.symlinkPath,
+          version,
+          needsSymlink: true,
+          symlinkCreated: true
+        };
+      }
+      return {
+        success: false,
+        commandPath: foundPath,
+        version: null,
+        needsSymlink: true,
+        symlinkCreated: false,
+        error: symlinkResult.error
+      };
+    }
+  }
+  if (isTermux()) {
+    const termuxPrefix = getTermuxPrefix();
+    const termuxPaths = [
+      `${termuxPrefix}/bin/${command}`,
+      `${termuxPrefix}/usr/bin/${command}`
+    ];
+    for (const path of termuxPaths) {
+      if (exists(path)) {
+        const version = await detectInstalledVersion(codeType);
+        return {
+          success: true,
+          commandPath: path,
+          version,
+          needsSymlink: false,
+          symlinkCreated: false
+        };
+      }
+    }
+  }
+  return {
+    success: false,
+    commandPath: null,
+    version: null,
+    needsSymlink: false,
+    symlinkCreated: false,
+    error: "Command not found in any known location"
+  };
+}
+async function createHomebrewSymlink(command, sourcePath) {
+  const homebrewBinPaths = [
+    "/opt/homebrew/bin",
+    // Apple Silicon (M1/M2)
+    "/usr/local/bin"
+    // Intel Mac
+  ];
+  let targetDir = null;
+  for (const binPath of homebrewBinPaths) {
+    if (nodeFs.existsSync(binPath)) {
+      targetDir = binPath;
+      break;
+    }
+  }
+  if (!targetDir) {
+    return {
+      success: false,
+      symlinkPath: null,
+      error: "No suitable Homebrew bin directory found"
+    };
+  }
+  const symlinkPath = join(targetDir, command);
+  try {
+    const stats = nodeFs.lstatSync(symlinkPath);
+    if (stats.isSymbolicLink()) {
+      const existingTarget = nodeFs.readlinkSync(symlinkPath);
+      if (existingTarget === sourcePath) {
+        return {
+          success: true,
+          symlinkPath
+        };
+      }
+      nodeFs.unlinkSync(symlinkPath);
+    } else {
+      return {
+        success: false,
+        symlinkPath: null,
+        error: `File already exists at ${symlinkPath} and is not a symlink`
+      };
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      return {
+        success: false,
+        symlinkPath: null,
+        error: `Failed to check existing file: ${error}`
+      };
+    }
+  }
+  try {
+    nodeFs.symlinkSync(sourcePath, symlinkPath);
+    return {
+      success: true,
+      symlinkPath
+    };
+  } catch (error) {
+    if (error.code === "EACCES") {
+      return {
+        success: false,
+        symlinkPath: null,
+        error: `Permission denied. Try running: sudo ln -sf ${sourcePath} ${symlinkPath}`
+      };
+    }
+    return {
+      success: false,
+      symlinkPath: null,
+      error: `Failed to create symlink: ${error.message}`
+    };
+  }
+}
+function displayVerificationResult(result, codeType) {
+  ensureI18nInitialized();
+  const codeTypeName = codeType === "claude-code" ? i18n.t("common:claudeCode") : i18n.t("common:codex");
+  if (result.success) {
+    if (result.symlinkCreated) {
+      console.log(ansis.green(`\u2714 ${codeTypeName} ${i18n.t("installation:verificationSuccess")}`));
+      console.log(ansis.gray(`  ${i18n.t("installation:symlinkCreated", { path: result.commandPath })}`));
+    }
+    if (result.version) {
+      console.log(ansis.gray(`  ${i18n.t("installation:detectedVersion", { version: result.version })}`));
+    }
+  } else {
+    console.log(ansis.yellow(`\u26A0 ${codeTypeName} ${i18n.t("installation:verificationFailed")}`));
+    if (result.commandPath) {
+      console.log(ansis.gray(`  ${i18n.t("installation:foundAtPath", { path: result.commandPath })}`));
+    }
+    if (result.error) {
+      console.log(ansis.gray(`  ${result.error}`));
+    }
+    if (result.needsSymlink && !result.symlinkCreated) {
+      console.log(ansis.yellow(`  ${i18n.t("installation:manualSymlinkHint")}`));
+    }
+  }
+}
 
 const installer = {
   __proto__: null,
+  createHomebrewSymlink: createHomebrewSymlink,
   detectInstalledVersion: detectInstalledVersion,
+  displayVerificationResult: displayVerificationResult,
   executeInstallMethod: executeInstallMethod,
   getInstallationStatus: getInstallationStatus,
   handleInstallFailure: handleInstallFailure,
@@ -5426,7 +6311,8 @@ const installer = {
   removeLocalClaudeCode: removeLocalClaudeCode,
   selectInstallMethod: selectInstallMethod,
   setInstallMethod: setInstallMethod,
-  uninstallCodeTool: uninstallCodeTool
+  uninstallCodeTool: uninstallCodeTool,
+  verifyInstallation: verifyInstallation
 };
 
 async function chooseInstallationMethod() {
@@ -5754,15 +6640,18 @@ async function validateSkipPromptOptions(options) {
   if (options.apiConfigs && options.apiConfigsFile) {
     throw new Error(i18n.t("multi-config:conflictingParams"));
   }
-  if (options.apiModel && typeof options.apiModel !== "string") {
-    throw new Error(
-      i18n.t("errors:invalidApiModel", { value: options.apiModel })
-    );
-  }
-  if (options.apiFastModel && typeof options.apiFastModel !== "string") {
-    throw new Error(
-      i18n.t("errors:invalidApiFastModel", { value: options.apiFastModel })
-    );
+  const modelParams = [
+    ["apiModel", options.apiModel],
+    ["apiHaikuModel", options.apiHaikuModel],
+    ["apiSonnetModel", options.apiSonnetModel],
+    ["apiOpusModel", options.apiOpusModel]
+  ];
+  for (const [key, value] of modelParams) {
+    if (value !== void 0 && typeof value !== "string") {
+      if (key === "apiModel")
+        throw new Error(i18n.t("errors:invalidApiModel", { value }));
+      throw new Error(i18n.t("errors:invalidModelParam", { key, value }));
+    }
   }
   if (options.apiType === "api_key" && !options.apiKey) {
     throw new Error(i18n.t("errors:apiKeyRequiredForApiKey"));
@@ -5952,8 +6841,11 @@ async function init(options = {}) {
       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 ? {
+      if (options.skipPrompt)
+        process.env.ZCF_CODEX_SKIP_PROMPT_SINGLE_BACKUP = "true";
+      const hasApiConfigs = Boolean(options.apiConfigs || options.apiConfigsFile);
+      const apiMode = hasApiConfigs ? "skip" : options.apiType === "auth_token" ? "official" : options.apiType === "api_key" ? "custom" : options.apiType === "skip" ? "skip" : options.skipPrompt ? "skip" : void 0;
+      const customApiConfig = !hasApiConfigs && options.apiType === "api_key" && options.apiKey ? {
         type: "api_key",
         token: options.apiKey,
         baseUrl: options.apiUrl,
@@ -5968,6 +6860,9 @@ async function init(options = {}) {
       } else if (options.workflows === true) {
         selectedWorkflows = [];
       }
+      if (hasApiConfigs) {
+        await handleMultiConfigurations(options, "codex");
+      }
       const resolvedAiOutputLang = await runCodexFullInit({
         aiOutputLang: options.aiOutputLang,
         skipPrompt: options.skipPrompt,
@@ -6008,6 +6903,17 @@ async function init(options = {}) {
           console.log(ansis.green(`\u2714 ${i18n.t("installation:localInstallationRemoved")}`));
         }
       }
+      const { verifyInstallation, displayVerificationResult } = await Promise.resolve().then(function () { return installer; });
+      const verification = await verifyInstallation("claude-code");
+      if (verification.symlinkCreated) {
+        console.log(ansis.green(`\u2714 ${i18n.t("installation:alreadyInstalled")}`));
+        displayVerificationResult(verification, "claude-code");
+      } else if (!verification.success) {
+        console.log(ansis.yellow(`\u26A0 ${i18n.t("installation:verificationFailed")}`));
+        if (verification.error) {
+          console.log(ansis.gray(`  ${verification.error}`));
+        }
+      }
     } else {
       if (options.skipPrompt) {
         await installClaudeCode(true);
@@ -6075,9 +6981,12 @@ async function init(options = {}) {
             key: options.apiKey,
             url: preset?.claudeCode?.baseUrl || options.apiUrl || API_DEFAULT_URL
           };
-          if (preset?.claudeCode?.defaultModels && preset.claudeCode.defaultModels.length >= 2) {
-            options.apiModel = options.apiModel || preset.claudeCode.defaultModels[0];
-            options.apiFastModel = options.apiFastModel || preset.claudeCode.defaultModels[1];
+          if (preset?.claudeCode?.defaultModels && preset.claudeCode.defaultModels.length > 0) {
+            const [primary, haiku, sonnet, opus] = preset.claudeCode.defaultModels;
+            options.apiModel = options.apiModel || primary;
+            options.apiHaikuModel = options.apiHaikuModel || haiku;
+            options.apiSonnetModel = options.apiSonnetModel || sonnet;
+            options.apiOpusModel = options.apiOpusModel || opus;
           }
           await saveSingleConfigToToml(apiConfig, options.provider, options);
         } else if (options.apiType === "auth_token" && options.apiKey) {
@@ -6204,20 +7113,26 @@ async function init(options = {}) {
         console.log(ansis.gray(`  Key: ${formatApiKeyDisplay(configuredApi.key)}`));
       }
     }
-    if ((options.apiModel || options.apiFastModel) && action !== "docs-only" && codeToolType === "claude-code") {
+    const hasModelParams = options.apiModel || options.apiHaikuModel || options.apiSonnetModel || options.apiOpusModel;
+    if (hasModelParams && action !== "docs-only" && codeToolType === "claude-code") {
       if (options.skipPrompt) {
         const { updateCustomModel } = await Promise.resolve().then(function () { return config$1; });
         updateCustomModel(
           options.apiModel || void 0,
-          options.apiFastModel || void 0
+          options.apiHaikuModel || void 0,
+          options.apiSonnetModel || void 0,
+          options.apiOpusModel || void 0
         );
         console.log(ansis.green(`\u2714 ${i18n.t("api:modelConfigSuccess")}`));
         if (options.apiModel) {
           console.log(ansis.gray(`  ${i18n.t("api:primaryModel")}: ${options.apiModel}`));
         }
-        if (options.apiFastModel) {
-          console.log(ansis.gray(`  ${i18n.t("api:fastModel")}: ${options.apiFastModel}`));
-        }
+        if (options.apiHaikuModel)
+          console.log(ansis.gray(`  Haiku: ${options.apiHaikuModel}`));
+        if (options.apiSonnetModel)
+          console.log(ansis.gray(`  Sonnet: ${options.apiSonnetModel}`));
+        if (options.apiOpusModel)
+          console.log(ansis.gray(`  Opus: ${options.apiOpusModel}`));
       }
     }
     if (action !== "docs-only") {
@@ -6440,6 +7355,7 @@ async function handleClaudeCodeConfigs(configs) {
 }
 async function handleCodexConfigs(configs) {
   const { addProviderToExisting } = await import('./codex-provider-manager.mjs');
+  const addedProviderIds = [];
   for (const config of configs) {
     try {
       const provider = await convertToCodexProvider(config);
@@ -6447,6 +7363,7 @@ async function handleCodexConfigs(configs) {
       if (!result.success) {
         throw new Error(i18n.t("multi-config:providerAddFailed", { name: config.name, error: result.error }));
       }
+      addedProviderIds.push(provider.id);
       console.log(ansis.green(`\u2714 ${i18n.t("multi-config:providerAdded", { name: config.name })}`));
     } catch (error) {
       console.error(ansis.red(i18n.t("multi-config:providerAddFailed", {
@@ -6459,8 +7376,14 @@ async function handleCodexConfigs(configs) {
   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 })}`));
+    const displayName = defaultConfig.name || defaultConfig.provider || "custom";
+    const providerId = displayName.toLowerCase().replace(/[^a-z0-9]/g, "-");
+    if (addedProviderIds.includes(providerId)) {
+      await switchCodexProvider(providerId);
+      console.log(ansis.green(`\u2714 ${i18n.t("multi-config:defaultProviderSet", { name: displayName })}`));
+    } else {
+      console.log(ansis.red(i18n.t("multi-config:providerAddFailed", { name: displayName, error: "provider not added" })));
+    }
   }
 }
 async function saveSingleConfigToToml(apiConfig, provider, options) {
@@ -6487,7 +7410,9 @@ async function convertSingleConfigToProfile(apiConfig, provider, options) {
   const configName = provider && provider !== "custom" ? provider : "custom-config";
   let baseUrl = apiConfig.url || API_DEFAULT_URL;
   let primaryModel = options?.apiModel;
-  let fastModel = options?.apiFastModel;
+  let defaultHaikuModel = options?.apiHaikuModel;
+  let defaultSonnetModel = options?.apiSonnetModel;
+  let defaultOpusModel = options?.apiOpusModel;
   let authType = apiConfig.authType;
   if (provider && provider !== "custom") {
     const { getProviderPreset } = await import('./api-providers.mjs');
@@ -6495,9 +7420,12 @@ async function convertSingleConfigToProfile(apiConfig, provider, options) {
     if (preset?.claudeCode) {
       baseUrl = apiConfig.url || preset.claudeCode.baseUrl;
       authType = preset.claudeCode.authType;
-      if (preset.claudeCode.defaultModels && preset.claudeCode.defaultModels.length >= 2) {
-        primaryModel = primaryModel || preset.claudeCode.defaultModels[0];
-        fastModel = fastModel || preset.claudeCode.defaultModels[1];
+      if (preset.claudeCode.defaultModels && preset.claudeCode.defaultModels.length > 0) {
+        const [p, h, s, o] = preset.claudeCode.defaultModels;
+        primaryModel = primaryModel || p;
+        defaultHaikuModel = defaultHaikuModel || h;
+        defaultSonnetModel = defaultSonnetModel || s;
+        defaultOpusModel = defaultOpusModel || o;
       }
     }
   }
@@ -6507,7 +7435,9 @@ async function convertSingleConfigToProfile(apiConfig, provider, options) {
     apiKey: apiConfig.key,
     baseUrl,
     primaryModel,
-    fastModel,
+    defaultHaikuModel,
+    defaultSonnetModel,
+    defaultOpusModel,
     id: ClaudeCodeConfigManager.generateProfileId(configName)
   };
   return profile;
@@ -6516,7 +7446,9 @@ async function convertToClaudeCodeProfile(config) {
   const { ClaudeCodeConfigManager } = await import('./claude-code-config-manager.mjs');
   let baseUrl = config.url;
   let primaryModel = config.primaryModel;
-  let fastModel = config.fastModel;
+  let defaultHaikuModel = config.defaultHaikuModel;
+  let defaultSonnetModel = config.defaultSonnetModel;
+  let defaultOpusModel = config.defaultOpusModel;
   let authType = config.type || "api_key";
   if (config.provider && config.provider !== "custom") {
     const { getProviderPreset } = await import('./api-providers.mjs');
@@ -6524,9 +7456,12 @@ async function convertToClaudeCodeProfile(config) {
     if (preset?.claudeCode) {
       baseUrl = baseUrl || preset.claudeCode.baseUrl;
       authType = preset.claudeCode.authType;
-      if (preset.claudeCode.defaultModels && preset.claudeCode.defaultModels.length >= 2) {
-        primaryModel = primaryModel || preset.claudeCode.defaultModels[0];
-        fastModel = fastModel || preset.claudeCode.defaultModels[1];
+      if (preset.claudeCode.defaultModels && preset.claudeCode.defaultModels.length > 0) {
+        const [p, h, s, o] = preset.claudeCode.defaultModels;
+        primaryModel = primaryModel || p;
+        defaultHaikuModel = defaultHaikuModel || h;
+        defaultSonnetModel = defaultSonnetModel || s;
+        defaultOpusModel = defaultOpusModel || o;
       }
     }
   }
@@ -6536,15 +7471,19 @@ async function convertToClaudeCodeProfile(config) {
     apiKey: config.key,
     baseUrl,
     primaryModel,
-    fastModel,
+    defaultHaikuModel,
+    defaultSonnetModel,
+    defaultOpusModel,
     id: ClaudeCodeConfigManager.generateProfileId(config.name)
   };
   return profile;
 }
 async function convertToCodexProvider(config) {
+  const displayName = config.name || config.provider || "custom";
+  const providerId = displayName.toLowerCase().replace(/[^a-z0-9]/g, "-");
   let baseUrl = config.url || API_DEFAULT_URL;
   let model = config.primaryModel || "gpt-5-codex";
-  let wireApi = "chat";
+  let wireApi = "responses";
   if (config.provider && config.provider !== "custom") {
     const { getProviderPreset } = await import('./api-providers.mjs');
     const preset = getProviderPreset(config.provider);
@@ -6555,11 +7494,11 @@ async function convertToCodexProvider(config) {
     }
   }
   return {
-    id: config.name.toLowerCase().replace(/[^a-z0-9]/g, "-"),
-    name: config.name,
+    id: providerId,
+    name: displayName,
     baseUrl,
     wireApi,
-    envKey: API_ENV_KEY,
+    tempEnvKey: `${displayName}_API_KEY`.replace(/\W/g, "_").toUpperCase(),
     requiresOpenaiAuth: false,
     model
   };
@@ -6643,4 +7582,4 @@ async function openSettingsJson() {
   }
 }
 
-export { getExistingModelConfig as $, API_DEFAULT_URL as A, getAiOutputLanguageLabel as B, CLAUDE_DIR as C, DEFAULT_CODE_TOOL_TYPE as D, getMcpConfigPath as E, readMcpConfig as F, writeMcpConfig as G, backupMcpConfig as H, mergeMcpServers as I, buildMcpServerConfig as J, fixWindowsMcpConfig as K, LEGACY_ZCF_CONFIG_FILES as L, addCompletedOnboarding as M, ensureApiKeyApproved as N, removeApiKeyFromRejected as O, manageApiKeyApproval as P, setPrimaryApiKey as Q, ensureClaudeDir as R, SETTINGS_FILE as S, backupExistingConfig as T, copyConfigFiles as U, configureApi as V, mergeConfigs as W, updateCustomModel as X, updateDefaultModel as Y, ZCF_CONFIG_DIR as Z, mergeSettingsFile as _, commandExists as a, displayBannerWithInfo as a$, getExistingApiConfig as a0, applyAiLanguageDirective as a1, switchToOfficialLogin$1 as a2, promptApiConfigurationAction as a3, isClaudeCodeInstalled as a4, installClaudeCode as a5, isCodexInstalled as a6, installCodex as a7, isLocalClaudeCodeInstalled as a8, getInstallationStatus as a9, readZcfConfig as aA, configureOutputStyle as aB, isWindows as aC, selectMcpServices as aD, getMcpServices as aE, isCcrInstalled as aF, installCcr as aG, setupCcrConfiguration as aH, modifyApiConfigPartially as aI, formatApiKeyDisplay as aJ, readCcrConfig as aK, configureCcrFeature as aL, handleExitPromptError as aM, handleGeneralError as aN, COMETIX_COMMAND_NAME as aO, COMETIX_COMMANDS as aP, installCometixLine as aQ, checkAndUpdateTools as aR, runCodexUpdate as aS, resolveCodeType as aT, writeJsonConfig as aU, displayBanner as aV, version as aW, resolveAiOutputLanguage as aX, updatePromptOnly as aY, selectAndInstallWorkflows as aZ, checkClaudeCodeVersionAndPrompt as a_, removeLocalClaudeCode as aa, uninstallCodeTool as ab, setInstallMethod as ac, detectInstalledVersion as ad, selectInstallMethod as ae, executeInstallMethod as af, handleInstallFailure as ag, ensureI18nInitialized as ah, i18n as ai, addNumbersToChoices as aj, validateApiKey as ak, promptBoolean as al, ensureDir as am, readDefaultTomlConfig as an, createDefaultTomlConfig as ao, exists as ap, readJsonConfig as aq, writeTomlConfig as ar, copyFile as as, detectConfigManagementMode as at, readCodexConfig as au, backupCodexComplete as av, writeCodexConfig as aw, writeAuthFile as ax, updateZcfConfig as ay, changeLanguage as az, importRecommendedEnv as b, runCodexUninstall as b0, configureCodexMcp as b1, configureCodexApi as b2, runCodexWorkflowImportWithLanguageSelection as b3, runCodexFullInit as b4, switchCodexProvider as b5, listCodexProviders as b6, switchToOfficialLogin as b7, switchToProvider as b8, readZcfConfigAsync as b9, initI18n as ba, selectScriptLanguage as bb, index as bc, fsOperations as bd, jsonConfig as be, claudeConfig as bf, config$1 as bg, config as bh, prompts as bi, codex as bj, installer as bk, 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, CODEX_DIR as j, CODEX_CONFIG_FILE as k, CODEX_AUTH_FILE as l, mergeAndCleanPermissions as m, CODEX_AGENTS_FILE as n, openSettingsJson as o, CODEX_PROMPTS_DIR as p, ZCF_CONFIG_FILE as q, CODE_TOOL_TYPES as r, CODE_TOOL_BANNERS as s, CODE_TOOL_ALIASES as t, isCodeToolType as u, API_ENV_KEY as v, resolveCodeToolType as w, SUPPORTED_LANGS as x, LANG_LABELS as y, AI_OUTPUT_LANGUAGES as z };
+export { getExistingModelConfig as $, API_DEFAULT_URL as A, getAiOutputLanguageLabel as B, CLAUDE_DIR as C, DEFAULT_CODE_TOOL_TYPE as D, getMcpConfigPath as E, readMcpConfig as F, writeMcpConfig as G, backupMcpConfig as H, mergeMcpServers as I, buildMcpServerConfig as J, fixWindowsMcpConfig as K, LEGACY_ZCF_CONFIG_FILES as L, addCompletedOnboarding as M, ensureApiKeyApproved as N, removeApiKeyFromRejected as O, manageApiKeyApproval as P, setPrimaryApiKey as Q, ensureClaudeDir as R, SETTINGS_FILE as S, backupExistingConfig as T, copyConfigFiles as U, configureApi as V, mergeConfigs as W, updateCustomModel as X, updateDefaultModel as Y, ZCF_CONFIG_DIR as Z, mergeSettingsFile as _, commandExists as a, resolveAiOutputLanguage as a$, getExistingApiConfig as a0, applyAiLanguageDirective as a1, switchToOfficialLogin$1 as a2, promptApiConfigurationAction as a3, isClaudeCodeInstalled as a4, installClaudeCode as a5, isCodexInstalled as a6, installCodex as a7, isLocalClaudeCodeInstalled as a8, getInstallationStatus as a9, writeCodexConfig as aA, writeAuthFile as aB, updateZcfConfig as aC, changeLanguage as aD, readZcfConfig as aE, configureOutputStyle as aF, isWindows as aG, selectMcpServices as aH, getMcpServices as aI, isCcrInstalled as aJ, installCcr as aK, setupCcrConfiguration as aL, modifyApiConfigPartially as aM, formatApiKeyDisplay as aN, readCcrConfig as aO, configureCcrFeature as aP, handleExitPromptError as aQ, handleGeneralError as aR, COMETIX_COMMAND_NAME as aS, COMETIX_COMMANDS as aT, installCometixLine as aU, checkAndUpdateTools as aV, runCodexUpdate as aW, resolveCodeType as aX, writeJsonConfig as aY, displayBanner as aZ, version as a_, removeLocalClaudeCode as aa, uninstallCodeTool as ab, setInstallMethod as ac, detectInstalledVersion as ad, selectInstallMethod as ae, executeInstallMethod as af, handleInstallFailure as ag, verifyInstallation as ah, createHomebrewSymlink as ai, displayVerificationResult as aj, ensureI18nInitialized as ak, i18n as al, addNumbersToChoices as am, validateApiKey as an, promptBoolean as ao, ensureDir as ap, readDefaultTomlConfig as aq, createDefaultTomlConfig as ar, exists as as, readJsonConfig as at, writeTomlConfig as au, clearModelEnv as av, copyFile as aw, detectConfigManagementMode as ax, readCodexConfig as ay, backupCodexComplete as az, importRecommendedEnv as b, updatePromptOnly as b0, selectAndInstallWorkflows as b1, checkClaudeCodeVersionAndPrompt as b2, displayBannerWithInfo as b3, runCodexUninstall as b4, configureCodexMcp as b5, configureCodexApi as b6, runCodexWorkflowImportWithLanguageSelection as b7, runCodexFullInit as b8, switchCodexProvider as b9, listCodexProviders as ba, switchToOfficialLogin as bb, switchToProvider as bc, readZcfConfigAsync as bd, initI18n as be, selectScriptLanguage as bf, index as bg, fsOperations as bh, jsonConfig as bi, claudeConfig as bj, config$1 as bk, config as bl, prompts as bm, codex as bn, installer as bo, 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, CODEX_DIR as j, CODEX_CONFIG_FILE as k, CODEX_AUTH_FILE as l, mergeAndCleanPermissions as m, CODEX_AGENTS_FILE as n, openSettingsJson as o, CODEX_PROMPTS_DIR as p, ZCF_CONFIG_FILE as q, CODE_TOOL_TYPES as r, CODE_TOOL_BANNERS as s, CODE_TOOL_ALIASES as t, isCodeToolType as u, API_ENV_KEY as v, resolveCodeToolType as w, SUPPORTED_LANGS as x, LANG_LABELS as y, AI_OUTPUT_LANGUAGES as z };