zcf 3.4.0 → 3.4.2

package/dist/chunks/simple-config.mjs

@@ -4,7 +4,7 @@ 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';
@@ -18,7 +18,7 @@ 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.0";
+const version = "3.4.2";
 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);
@@ -2014,6 +2130,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$3(`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$3(`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$3(`"${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$3(`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$3("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$3(`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$3("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 +2472,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() {
@@ -2120,7 +2567,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 +2595,14 @@ 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("npm update -g @anthropic-ai/claude-code");
+      if (isHomebrew) {
+        await execAsync$2("brew upgrade --cask claude-code");
+      } else {
+        await execAsync$2("claude update");
+      }
       updateSpinner.succeed(format(i18n.t("updater:updateSuccess"), { tool: "Claude Code" }));
       return true;
     } catch (error) {
@@ -2217,6 +2669,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);
@@ -2962,7 +3423,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();
@@ -3007,15 +3468,52 @@ function getRootDir$1() {
   }
   return dirname(currentFilePath);
 }
+async function detectCodexInstallMethod() {
+  try {
+    const brewResult = await x("brew", ["list", "--cask", "codex"], { throwOnError: false });
+    if (brewResult.exitCode === 0) {
+      return "homebrew";
+    }
+  } catch {
+  }
+  try {
+    const npmResult = await x("npm", ["list", "-g", "@openai/codex"], { throwOnError: false });
+    if (npmResult.exitCode === 0 && npmResult.stdout.includes("@openai/codex")) {
+      return "npm";
+    }
+  } catch {
+  }
+  return "unknown";
+}
 async function executeCodexInstallation(isUpdate, skipMethodSelection = false) {
   if (isUpdate) {
     console.log(ansis.cyan(i18n.t("codex:updatingCli")));
-    const { command, args, usedSudo } = wrapCommandWithSudo("npm", ["install", "-g", "@openai/codex@latest"]);
-    if (usedSudo)
-      console.log(ansis.yellow(i18n.t("codex:usingSudo")));
-    const result = await x(command, args);
-    if (result.exitCode !== 0) {
-      throw new Error(`Failed to update codex CLI: exit code ${result.exitCode}`);
+    const installMethod = await detectCodexInstallMethod();
+    if (installMethod === "homebrew") {
+      console.log(ansis.gray(i18n.t("codex:detectedHomebrew")));
+      const result = await x("brew", ["upgrade", "--cask", "codex"]);
+      if (result.exitCode !== 0) {
+        throw new Error(`Failed to update codex via Homebrew: exit code ${result.exitCode}`);
+      }
+    } else if (installMethod === "npm") {
+      console.log(ansis.gray(i18n.t("codex:detectedNpm")));
+      const { command, args, usedSudo } = wrapCommandWithSudo("npm", ["install", "-g", "@openai/codex@latest"]);
+      if (usedSudo)
+        console.log(ansis.yellow(i18n.t("codex:usingSudo")));
+      const result = await x(command, args);
+      if (result.exitCode !== 0) {
+        throw new Error(`Failed to update codex CLI: exit code ${result.exitCode}`);
+      }
+    } else {
+      console.log(ansis.yellow(i18n.t("codex:unknownInstallMethod")));
+      console.log(ansis.gray(i18n.t("codex:fallingBackToNpm")));
+      const { command, args, usedSudo } = wrapCommandWithSudo("npm", ["install", "-g", "@openai/codex@latest"]);
+      if (usedSudo)
+        console.log(ansis.yellow(i18n.t("codex:usingSudo")));
+      const result = await x(command, args);
+      if (result.exitCode !== 0) {
+        throw new Error(`Failed to update codex CLI: exit code ${result.exitCode}`);
+      }
     }
     console.log(ansis.green(i18n.t("codex:updateSuccess")));
   } else {
@@ -3100,9 +3598,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)
@@ -3135,7 +3715,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
@@ -3144,14 +3724,23 @@ function parseCodexConfig(content) {
     }
     const mcpServices = [];
     if (tomlData.mcp_servers) {
+      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 = {};
+        for (const [key, value] of Object.entries(mcp)) {
+          if (!KNOWN_MCP_FIELDS.has(key)) {
+            extraFields[key] = value;
+          }
+        }
         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
+          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
         });
       }
     }
@@ -3250,9 +3839,74 @@ function parseCodexConfig(content) {
     };
   }
 }
+function formatInlineTableValue(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof value === "string") {
+    const normalized = normalizeTomlPath(value);
+    return `'${normalized}'`;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    const items = value.map((item) => {
+      if (typeof item === "string") {
+        const normalized = normalizeTomlPath(item);
+        return `'${normalized}'`;
+      }
+      if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+        return formatInlineTable(item);
+      }
+      return String(item);
+    }).join(", ");
+    return `[${items}]`;
+  }
+  if (typeof value === "object") {
+    return formatInlineTable(value);
+  }
+  return String(value);
+}
+function formatInlineTable(obj) {
+  const entries = Object.entries(obj).filter(([_, v]) => v !== null && v !== void 0).map(([k, v]) => `${k} = ${formatInlineTableValue(v)}`).join(", ");
+  return `{${entries}}`;
+}
+function formatTomlField(key, value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  if (typeof value === "string") {
+    const normalized = normalizeTomlPath(value);
+    const escaped = normalized.replace(/"/g, '\\"');
+    return `${key} = "${escaped}"`;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return `${key} = ${value}`;
+  }
+  if (Array.isArray(value)) {
+    const items = value.map((item) => {
+      if (typeof item === "string") {
+        const normalized = normalizeTomlPath(item);
+        const escaped = normalized.replace(/"/g, '\\"');
+        return `"${escaped}"`;
+      }
+      if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+        return formatInlineTable(item);
+      }
+      return String(item);
+    }).join(", ");
+    return `${key} = [${items}]`;
+  }
+  if (typeof value === "object") {
+    return `${key} = ${formatInlineTable(value)}`;
+  }
+  return "";
+}
 function readCodexConfig() {
   if (!exists(CODEX_CONFIG_FILE))
     return null;
+  ensureEnvKeyMigration();
   try {
     const content = readFile(CODEX_CONFIG_FILE);
     return parseCodexConfig(content);
@@ -3306,7 +3960,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}"`);
@@ -3326,8 +3980,16 @@ 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)) {
+          const formatted = formatTomlField(key, value);
+          if (formatted) {
+            lines.push(formatted);
+          }
+        }
       }
       lines.push("");
     }
@@ -3342,6 +4004,7 @@ function renderCodexConfig(data) {
   return result;
 }
 function writeCodexConfig(data) {
+  ensureEnvKeyMigration();
   ensureDir(CODEX_DIR);
   writeFile(CODEX_CONFIG_FILE, renderCodexConfig(data));
 }
@@ -3353,26 +4016,46 @@ function writeAuthFile(newEntries) {
 }
 async function isCodexInstalled$1() {
   try {
-    const result = await x("npm", ["list", "-g", "--depth=0"]);
-    if (result.exitCode !== 0) {
-      return false;
+    const npmResult = await x("npm", ["list", "-g", "--depth=0"]);
+    if (npmResult.exitCode === 0 && npmResult.stdout.includes("@openai/codex@")) {
+      return true;
     }
-    return result.stdout.includes("@openai/codex@");
   } catch {
-    return false;
   }
+  try {
+    const brewResult = await x("brew", ["list", "--cask", "codex"], { throwOnError: false });
+    if (brewResult.exitCode === 0) {
+      return true;
+    }
+  } catch {
+  }
+  return false;
 }
 async function getCodexVersion() {
   try {
-    const result = await x("npm", ["list", "-g", "--depth=0"]);
-    if (result.exitCode !== 0) {
-      return null;
+    const npmResult = await x("npm", ["list", "-g", "--depth=0"]);
+    if (npmResult.exitCode === 0) {
+      const match = npmResult.stdout.match(/@openai\/codex@(\S+)/);
+      if (match) {
+        return match[1];
+      }
+    }
+  } catch {
+  }
+  try {
+    const brewResult = await x("brew", ["info", "--cask", "codex", "--json=v2"], { throwOnError: false });
+    if (brewResult.exitCode === 0) {
+      const info = JSON.parse(brewResult.stdout);
+      if (info.casks && Array.isArray(info.casks) && info.casks.length > 0) {
+        const cask = info.casks[0];
+        if (cask.installed && typeof cask.installed === "string") {
+          return cask.installed;
+        }
+      }
     }
-    const match = result.stdout.match(/@openai\/codex@(\S+)/);
-    return match ? match[1] : null;
   } catch {
-    return null;
   }
+  return null;
 }
 async function checkCodexUpdate() {
   try {
@@ -3457,8 +4140,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,
@@ -3518,9 +4201,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
       }
@@ -3679,7 +4362,7 @@ async function applyCustomApiConfig(customApiConfig) {
     name: providerName,
     baseUrl: baseUrl || "https://api.anthropic.com",
     wireApi: "claude",
-    envKey: `${providerId.toUpperCase()}_API_KEY`,
+    tempEnvKey: `${providerId.toUpperCase()}_API_KEY`,
     requiresOpenaiAuth: false
   });
   if (token) {
@@ -3870,7 +4553,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) {
@@ -3900,14 +4583,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
@@ -3927,8 +4610,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;
   }
@@ -4213,7 +4896,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 })));
@@ -4237,11 +4920,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,
@@ -4851,6 +5538,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;
   }
@@ -4873,13 +5564,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`));
@@ -4940,12 +5633,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;
@@ -5023,7 +5718,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";
         }
@@ -5038,7 +5733,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";
         }
@@ -5052,7 +5747,8 @@ async function uninstallCodeTool(codeType) {
   const spinner = ora(i18n.t("installation:uninstallingWith", { method, codeType: codeTypeName })).start();
   try {
     switch (method) {
-      case "npm": {
+      case "npm":
+      case "npm-global": {
         const packageName = codeType === "claude-code" ? "@anthropic-ai/claude-code" : "@openai/codex";
         const { command, args, usedSudo } = wrapCommandWithSudo("npm", ["uninstall", "-g", packageName]);
         if (usedSudo) {
@@ -5066,7 +5762,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;
       }
@@ -5110,7 +5806,7 @@ async function uninstallCodeTool(codeType) {
     return false;
   }
 }
-async function setInstallMethod(method = "npm", codeType = "claude-code") {
+async function setInstallMethod(method, codeType = "claude-code") {
   try {
     if (codeType === "claude-code") {
       const { readMcpConfig, writeMcpConfig } = await Promise.resolve().then(function () { return claudeConfig; });
@@ -5118,7 +5814,7 @@ async function setInstallMethod(method = "npm", codeType = "claude-code") {
       if (!config) {
         config = { mcpServers: {} };
       }
-      config.installMethod = method === "npm" ? "npm" : "native";
+      config.installMethod = method === "npm" ? "npm-global" : method;
       writeMcpConfig(config);
     }
   } catch (error) {
@@ -5137,6 +5833,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();
@@ -5155,7 +5867,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
@@ -5190,7 +5903,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();
@@ -5203,7 +5916,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;
@@ -5242,6 +5955,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 }));
@@ -5272,10 +5987,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,
@@ -5287,7 +6179,8 @@ const installer = {
   removeLocalClaudeCode: removeLocalClaudeCode,
   selectInstallMethod: selectInstallMethod,
   setInstallMethod: setInstallMethod,
-  uninstallCodeTool: uninstallCodeTool
+  uninstallCodeTool: uninstallCodeTool,
+  verifyInstallation: verifyInstallation
 };
 
 async function chooseInstallationMethod() {
@@ -5869,6 +6762,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);
@@ -5940,18 +6844,21 @@ async function init(options = {}) {
             options.apiModel = options.apiModel || preset.claudeCode.defaultModels[0];
             options.apiFastModel = options.apiFastModel || preset.claudeCode.defaultModels[1];
           }
+          await saveSingleConfigToToml(apiConfig, options.provider, options);
         } else if (options.apiType === "auth_token" && options.apiKey) {
           apiConfig = {
             authType: "auth_token",
             key: options.apiKey,
             url: options.apiUrl || API_DEFAULT_URL
           };
+          await saveSingleConfigToToml(apiConfig, void 0, options);
         } else if (options.apiType === "api_key" && options.apiKey) {
           apiConfig = {
             authType: "api_key",
             key: options.apiKey,
             url: options.apiUrl || API_DEFAULT_URL
           };
+          await saveSingleConfigToToml(apiConfig, void 0, options);
         } else if (options.apiType === "ccr_proxy") {
           const ccrStatus = await isCcrInstalled();
           if (!ccrStatus.hasCorrectPackage) {
@@ -6321,6 +7228,55 @@ async function handleCodexConfigs(configs) {
     console.log(ansis.green(`\u2714 ${i18n.t("multi-config:defaultProviderSet", { name: defaultConfig.name })}`));
   }
 }
+async function saveSingleConfigToToml(apiConfig, provider, options) {
+  try {
+    const { ClaudeCodeConfigManager } = await import('./claude-code-config-manager.mjs');
+    const profile = await convertSingleConfigToProfile(apiConfig, provider, options);
+    const result = await ClaudeCodeConfigManager.addProfile(profile);
+    if (result.success) {
+      const savedProfile = result.addedProfile || ClaudeCodeConfigManager.getProfileByName(profile.name) || profile;
+      if (savedProfile.id) {
+        await ClaudeCodeConfigManager.switchProfile(savedProfile.id);
+        await ClaudeCodeConfigManager.applyProfileSettings(savedProfile);
+      }
+      console.log(ansis.green(`\u2714 ${i18n.t("configuration:singleConfigSaved", { name: profile.name })}`));
+    } else {
+      console.warn(ansis.yellow(`${i18n.t("configuration:singleConfigSaveFailed")}: ${result.error}`));
+    }
+  } catch (error) {
+    console.warn(ansis.yellow(`${i18n.t("configuration:singleConfigSaveFailed")}: ${error instanceof Error ? error.message : String(error)}`));
+  }
+}
+async function convertSingleConfigToProfile(apiConfig, provider, options) {
+  const { ClaudeCodeConfigManager } = await import('./claude-code-config-manager.mjs');
+  const configName = provider && provider !== "custom" ? provider : "custom-config";
+  let baseUrl = apiConfig.url || API_DEFAULT_URL;
+  let primaryModel = options?.apiModel;
+  let fastModel = options?.apiFastModel;
+  let authType = apiConfig.authType;
+  if (provider && provider !== "custom") {
+    const { getProviderPreset } = await import('./api-providers.mjs');
+    const preset = getProviderPreset(provider);
+    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];
+      }
+    }
+  }
+  const profile = {
+    name: configName,
+    authType,
+    apiKey: apiConfig.key,
+    baseUrl,
+    primaryModel,
+    fastModel,
+    id: ClaudeCodeConfigManager.generateProfileId(configName)
+  };
+  return profile;
+}
 async function convertToClaudeCodeProfile(config) {
   const { ClaudeCodeConfigManager } = await import('./claude-code-config-manager.mjs');
   let baseUrl = config.url;
@@ -6368,7 +7324,7 @@ async function convertToCodexProvider(config) {
     name: config.name,
     baseUrl,
     wireApi,
-    envKey: API_ENV_KEY,
+    tempEnvKey: API_ENV_KEY,
     requiresOpenaiAuth: false,
     model
   };
@@ -6452,4 +7408,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, updatePromptOnly 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, writeAuthFile as aA, updateZcfConfig as aB, changeLanguage as aC, readZcfConfig as aD, configureOutputStyle as aE, isWindows as aF, selectMcpServices as aG, getMcpServices as aH, isCcrInstalled as aI, installCcr as aJ, setupCcrConfiguration as aK, modifyApiConfigPartially as aL, formatApiKeyDisplay as aM, readCcrConfig as aN, configureCcrFeature as aO, handleExitPromptError as aP, handleGeneralError as aQ, COMETIX_COMMAND_NAME as aR, COMETIX_COMMANDS as aS, installCometixLine as aT, checkAndUpdateTools as aU, runCodexUpdate as aV, resolveCodeType as aW, writeJsonConfig as aX, displayBanner as aY, version as aZ, resolveAiOutputLanguage 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, copyFile as av, detectConfigManagementMode as aw, readCodexConfig as ax, backupCodexComplete as ay, writeCodexConfig as az, importRecommendedEnv as b, selectAndInstallWorkflows as b0, checkClaudeCodeVersionAndPrompt as b1, displayBannerWithInfo as b2, runCodexUninstall as b3, configureCodexMcp as b4, configureCodexApi as b5, runCodexWorkflowImportWithLanguageSelection as b6, runCodexFullInit as b7, switchCodexProvider as b8, listCodexProviders as b9, switchToOfficialLogin as ba, switchToProvider as bb, readZcfConfigAsync as bc, initI18n as bd, selectScriptLanguage as be, index as bf, fsOperations as bg, jsonConfig as bh, claudeConfig as bi, config$1 as bj, config as bk, prompts as bl, codex as bm, installer as bn, 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 };