ccjk 10.1.0 → 10.2.0

package/dist/chunks/installer.mjs

@@ -1,178 +1,680 @@
-import { existsSync } from 'node:fs';
+import * as nodeFs from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import process__default from 'node:process';
 import ansis from 'ansis';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { join } from 'pathe';
+import { exec } from 'tinyexec';
+import { ensureI18nInitialized, i18n } from './index2.mjs';
+import { updateClaudeCode } from './auto-updater.mjs';
+import { exists } from './fs-operations.mjs';
+import { f as findCommandPath, g as getPlatform, a as getHomebrewCommandPaths, b as isTermux, c as getTermuxPrefix, d as isWSL, e as getWSLInfo, w as wrapCommandWithSudo, h as commandExists, j as getRecommendedInstallMethods } from './platform.mjs';
+import 'node:url';
+import 'i18next';
+import 'i18next-fs-backend';
+import '../shared/ccjk.DHbrGcgg.mjs';
+import 'inquirer-toggle';
+import './version-checker.mjs';
+import 'node:child_process';
+import 'node:path';
+import 'node:util';
+import 'semver';
+import 'node:crypto';
+import 'node:fs/promises';
 
-const { cyan, yellow, gray, green, red, blue: _blue, bold, dim: _dim } = ansis;
-const INSTALL_DIR = join(homedir(), ".agent-browser");
-const BIN_PATH = join(INSTALL_DIR, "bin", "agent-browser");
-function getInstallPath() {
-  return INSTALL_DIR;
+async function isClaudeCodeInstalled() {
+  return await commandExists("claude");
 }
-async function checkAgentBrowserInstalled() {
+async function installClaudeCode(skipMethodSelection = false) {
+  ensureI18nInitialized();
+  const codeType = "claude-code";
+  const installed = await isClaudeCodeInstalled();
+  if (installed) {
+    console.log(ansis.green(`\u2714 ${i18n.t("installation:alreadyInstalled")}`));
+    const version = await detectInstalledVersion(codeType);
+    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;
+  }
+  if (isTermux()) {
+    console.log(ansis.yellow(`\u2139 ${i18n.t("installation:termuxDetected")}`));
+    const termuxPrefix = getTermuxPrefix();
+    console.log(ansis.gray(i18n.t("installation:termuxPathInfo", { path: termuxPrefix })));
+    console.log(ansis.gray(`Node.js: ${termuxPrefix}/bin/node`));
+    console.log(ansis.gray(`npm: ${termuxPrefix}/bin/npm`));
+  }
+  if (isWSL()) {
+    const wslInfo = getWSLInfo();
+    if (wslInfo?.distro) {
+      console.log(ansis.yellow(`\u2139 ${i18n.t("installation:wslDetected", { distro: wslInfo.distro })}`));
+    } else {
+      console.log(ansis.yellow(`\u2139 ${i18n.t("installation:wslDetectedGeneric")}`));
+    }
+    console.log(ansis.gray(i18n.t("installation:wslPathInfo", { path: `${homedir()}/.claude/` })));
+  }
+  if (skipMethodSelection) {
+    console.log(i18n.t("installation:installing"));
+    try {
+      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`));
+      }
+      if (isWSL()) {
+        console.log(ansis.gray(`
+${i18n.t("installation:wslInstallSuccess")}`));
+      }
+    } catch (error) {
+      console.error(`\u2716 ${i18n.t("installation:installFailed")}`);
+      if (isTermux()) {
+        console.error(ansis.yellow(`
+${i18n.t("installation:termuxInstallHint")}
+`));
+      }
+      throw error;
+    }
+    return;
+  }
+  const method = await selectInstallMethod(codeType);
+  if (!method) {
+    console.log(ansis.yellow(i18n.t("common:cancelled")));
+    return;
+  }
+  const success = await executeInstallMethod(method, codeType);
+  if (!success) {
+    const retrySuccess = await handleInstallFailure(codeType, [method]);
+    if (!retrySuccess) {
+      console.error(ansis.red(`\u2716 ${i18n.t("installation:installFailed")}`));
+      throw new Error(i18n.t("installation:installFailed"));
+    }
+  }
+  if (isTermux()) {
+    console.log(ansis.gray(`
+Claude Code installed to: ${getTermuxPrefix()}/bin/claude`));
+  }
+  if (isWSL()) {
+    console.log(ansis.gray(`
+${i18n.t("installation:wslInstallSuccess")}`));
+  }
+}
+async function isCodexInstalled() {
+  return await commandExists("codex");
+}
+async function installCodex(skipMethodSelection = false) {
+  ensureI18nInitialized();
+  const codeType = "codex";
+  const codeTypeName = i18n.t("common:codex");
+  const installed = await isCodexInstalled();
+  if (installed) {
+    console.log(ansis.green(`\u2714 ${codeTypeName} ${i18n.t("installation:alreadyInstalled")}`));
+    const version = await detectInstalledVersion(codeType);
+    if (version) {
+      console.log(ansis.gray(`  ${i18n.t("installation:detectedVersion", { version })}`));
+    }
+    return;
+  }
+  if (skipMethodSelection) {
+    console.log(i18n.t("installation:installingWith", { method: "npm", codeType: codeTypeName }));
+    try {
+      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;
+    }
+    return;
+  }
+  const method = await selectInstallMethod(codeType);
+  if (!method) {
+    console.log(ansis.yellow(i18n.t("common:cancelled")));
+    return;
+  }
+  const success = await executeInstallMethod(method, codeType);
+  if (!success) {
+    const retrySuccess = await handleInstallFailure(codeType, [method]);
+    if (!retrySuccess) {
+      console.error(ansis.red(`\u2716 ${codeTypeName} ${i18n.t("installation:installFailed")}`));
+      throw new Error(i18n.t("installation:installFailed"));
+    }
+  }
+}
+async function getInstallationStatus() {
+  const hasGlobal = await isClaudeCodeInstalled();
+  return {
+    hasGlobal,
+    // Local installation was never implemented - these are kept for backward compatibility
+    hasLocal: false,
+    localPath: ""
+  };
+}
+async function getInstallMethodFromConfig(codeType) {
   try {
-    const { execSync } = await import('node:child_process');
-    execSync("which agent-browser 2>/dev/null || where agent-browser 2>nul", {
-      encoding: "utf-8",
-      stdio: "pipe"
-    });
-    return true;
+    if (codeType === "claude-code") {
+      const { readMcpConfig } = await import('./claude-config.mjs').then(function (n) { return n.h; });
+      const config = readMcpConfig();
+      return config?.installMethod || null;
+    }
   } catch {
   }
-  if (existsSync(BIN_PATH)) {
-    return true;
+  return null;
+}
+async function uninstallCodeTool(codeType) {
+  ensureI18nInitialized();
+  const codeTypeName = codeType === "claude-code" ? i18n.t("common:claudeCode") : i18n.t("common:codex");
+  let method = await getInstallMethodFromConfig(codeType);
+  if (!method) {
+    if (codeType === "claude-code") {
+      try {
+        const result = await exec("brew", ["list", "--cask", "claude-code"]);
+        if (result.exitCode === 0) {
+          method = "homebrew";
+        }
+      } catch {
+      }
+    } else if (codeType === "codex") {
+      try {
+        const result = await exec("brew", ["list", "--cask", "codex"]);
+        if (result.exitCode === 0) {
+          method = "homebrew";
+        }
+      } catch {
+      }
+    }
+    if (!method) {
+      method = "npm";
+    }
+  }
+  if (method === "native") {
+    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", "--cask", "codex"]);
+        if (testResult.exitCode === 0) {
+          method = "homebrew";
+        }
+      } catch {
+        method = "manual";
+      }
+    } else {
+      method = "manual";
+    }
   }
+  const spinner = ora(i18n.t("installation:uninstallingWith", { method, codeType: codeTypeName })).start();
   try {
-    const { execSync } = await import('node:child_process');
-    execSync("npx --yes @anthropic-ai/agent-browser --version 2>/dev/null", {
-      encoding: "utf-8",
-      stdio: "pipe",
-      timeout: 1e4
-    });
+    switch (method) {
+      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) {
+          spinner.info(i18n.t("installation:usingSudo"));
+          spinner.start();
+        }
+        await exec(command, args);
+        break;
+      }
+      case "homebrew": {
+        if (codeType === "claude-code") {
+          await exec("brew", ["uninstall", "--cask", "claude-code"]);
+        } else {
+          await exec("brew", ["uninstall", "--cask", "codex"]);
+        }
+        break;
+      }
+      case "manual":
+      default: {
+        spinner.warn(i18n.t("installation:manualUninstallRequired", { codeType: codeTypeName }));
+        const command = codeType === "claude-code" ? "claude" : "codex";
+        try {
+          const whichCmd = getPlatform() === "windows" ? "where" : "which";
+          const result = await exec(whichCmd, [command]);
+          if (result.stdout) {
+            const binaryPath = result.stdout.trim().split("\n")[0];
+            spinner.info(i18n.t("installation:binaryLocation", { path: binaryPath }));
+            const platform = getPlatform();
+            if (platform === "windows") {
+              const quotedBinaryPath = `"${binaryPath}"`;
+              await exec("cmd", ["/c", "del", "/f", "/q", quotedBinaryPath]);
+            } else {
+              const { command: rmCmd, args: rmArgs } = wrapCommandWithSudo("rm", ["-f", binaryPath]);
+              if (rmCmd === "sudo") {
+                spinner.info(i18n.t("installation:usingSudo"));
+                spinner.start();
+              }
+              await exec(rmCmd, rmArgs);
+            }
+          }
+        } catch {
+          spinner.fail(i18n.t("installation:failedToLocateBinary", { command }));
+          return false;
+        }
+        break;
+      }
+    }
+    spinner.succeed(i18n.t("installation:uninstallSuccess", { method, codeType: codeTypeName }));
     return true;
-  } catch {
+  } catch (error) {
+    spinner.fail(i18n.t("installation:uninstallFailed", { method, codeType: codeTypeName }));
+    if (error instanceof Error) {
+      console.error(ansis.gray(error.message));
+    }
+    return false;
   }
-  return false;
 }
-async function installAgentBrowser(options = {}) {
-  console.log(`
-${bold(cyan("Installing Agent Browser..."))}
-`);
-  if (!options.force) {
-    const installed = await checkAgentBrowserInstalled();
-    if (installed) {
-      console.log(`${green("\u2713")} Agent Browser is already installed`);
-      console.log(`  ${gray("Use --force to reinstall")}
-`);
-      return true;
+async function setInstallMethod(method, codeType = "claude-code") {
+  try {
+    if (codeType === "claude-code") {
+      const { readMcpConfig, writeMcpConfig } = await import('./claude-config.mjs').then(function (n) { return n.h; });
+      let config = readMcpConfig();
+      if (!config) {
+        config = { mcpServers: {} };
+      }
+      config.installMethod = method === "npm" ? "npm-global" : method;
+      writeMcpConfig(config);
     }
+  } catch (error) {
+    console.error("Failed to set installMethod:", error);
   }
-  const { execSync } = await import('node:child_process');
-  const { mkdirSync } = await import('node:fs');
+}
+async function detectInstalledVersion(codeType) {
   try {
-    mkdirSync(INSTALL_DIR, { recursive: true });
-    console.log(`${cyan("Step 1/3:")} Installing via npm...`);
-    try {
-      execSync("npm install -g @anthropic-ai/agent-browser 2>&1", {
-        encoding: "utf-8",
-        stdio: options.verbose ? "inherit" : "pipe"
-      });
-      console.log(`  ${green("\u2713")} npm package installed globally`);
-    } catch {
-      console.log(`  ${yellow("!")} Global install failed, trying local install...`);
-      execSync(`npm install @anthropic-ai/agent-browser --prefix "${INSTALL_DIR}" 2>&1`, {
-        encoding: "utf-8",
-        stdio: options.verbose ? "inherit" : "pipe"
-      });
-      console.log(`  ${green("\u2713")} npm package installed locally`);
-    }
-    console.log(`
-${cyan("Step 2/3:")} Installing Playwright browsers...`);
-    try {
-      execSync("npx playwright install chromium 2>&1", {
-        encoding: "utf-8",
-        stdio: options.verbose ? "inherit" : "pipe",
-        timeout: 3e5
-        // 5 minutes
-      });
-      console.log(`  ${green("\u2713")} Chromium browser installed`);
-    } catch (error) {
-      console.log(`  ${yellow("!")} Playwright browser installation may have issues`);
-      if (options.verbose && error instanceof Error) {
-        console.log(`    ${gray(error.message)}`);
-      }
-    }
-    console.log(`
-${cyan("Step 3/3:")} Verifying installation...`);
-    const verified = await checkAgentBrowserInstalled();
-    if (verified) {
-      console.log(`  ${green("\u2713")} Installation verified`);
-      console.log(`
-${green("\u2713")} ${bold("Agent Browser installed successfully!")}
-`);
-      showQuickStart();
-      return true;
-    } else {
-      console.log(`  ${red("\u2717")} Verification failed`);
-      console.log(`
-${yellow("Try manual installation:")}`);
-      console.log(`  npm install -g @anthropic-ai/agent-browser`);
-      console.log(`  npx playwright install chromium
-`);
+    const command = codeType === "claude-code" ? "claude" : "codex";
+    const result = await exec(command, ["--version"]);
+    if (result.exitCode === 0 && result.stdout) {
+      const versionMatch = result.stdout.match(/(\d+\.\d+\.\d+)/);
+      return versionMatch ? versionMatch[1] : result.stdout.trim();
+    }
+  } catch {
+  }
+  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();
+  const availableMethods = allMethods.filter((method) => {
+    if (codeType === "codex" && !["npm", "homebrew"].includes(method)) {
       return false;
     }
+    if (method === "homebrew")
+      return platform === "macos" || platform === "linux";
+    if (method === "curl")
+      return platform !== "windows" || isWSL();
+    if (method === "powershell" || method === "cmd")
+      return platform === "windows";
+    return true;
+  });
+  const topRecommended = recommendedMethods.length > 0 ? recommendedMethods[0] : null;
+  return availableMethods.map((method) => {
+    const isTopRecommended = method === topRecommended;
+    const methodLabel = getInstallMethodLabel(method);
+    const title = isTopRecommended ? `${methodLabel} ${ansis.green(`[${i18n.t("installation:recommendedMethod")}]`)}` : methodLabel;
+    return {
+      title,
+      value: method
+    };
+  });
+}
+async function selectInstallMethod(codeType, excludeMethods = []) {
+  ensureI18nInitialized();
+  const codeTypeName = codeType === "claude-code" ? i18n.t("common:claudeCode") : i18n.t("common:codex");
+  const recommendedMethods = getRecommendedInstallMethods(codeType);
+  const methodOptions = getInstallMethodOptions(codeType, recommendedMethods).filter((option) => !excludeMethods.includes(option.value));
+  if (methodOptions.length === 0) {
+    console.log(ansis.yellow(i18n.t("installation:noMoreMethods")));
+    return null;
+  }
+  const response = await inquirer.prompt({
+    type: "list",
+    name: "method",
+    message: i18n.t("installation:selectInstallMethod", { codeType: codeTypeName }),
+    choices: methodOptions.map((opt) => ({
+      name: opt.title,
+      value: opt.value
+    }))
+  });
+  return response.method || null;
+}
+async function executeInstallMethod(method, codeType) {
+  ensureI18nInitialized();
+  const codeTypeName = codeType === "claude-code" ? i18n.t("common:claudeCode") : i18n.t("common:codex");
+  const spinner = ora(i18n.t("installation:installingWith", { method, codeType: codeTypeName })).start();
+  try {
+    switch (method) {
+      case "npm": {
+        const packageName = codeType === "claude-code" ? "@anthropic-ai/claude-code" : "@openai/codex";
+        const { command, args, usedSudo } = wrapCommandWithSudo("npm", ["install", "-g", packageName, "--force"]);
+        if (usedSudo) {
+          spinner.info(i18n.t("installation:usingSudo"));
+          spinner.start();
+        }
+        await exec(command, args);
+        await setInstallMethod("npm", codeType);
+        break;
+      }
+      case "homebrew": {
+        if (codeType === "claude-code") {
+          await exec("brew", ["install", "--cask", "claude-code"]);
+        } else {
+          await exec("brew", ["install", "--cask", "codex"]);
+        }
+        await setInstallMethod("homebrew", codeType);
+        break;
+      }
+      case "curl": {
+        if (codeType === "claude-code") {
+          await exec("bash", ["-c", "curl -fsSL https://claude.ai/install.sh | bash"]);
+        } else {
+          spinner.stop();
+          return await executeInstallMethod("npm", codeType);
+        }
+        await setInstallMethod("curl", codeType);
+        break;
+      }
+      case "powershell": {
+        if (codeType === "claude-code") {
+          await exec("powershell", ["-Command", "irm https://claude.ai/install.ps1 | iex"]);
+        } else {
+          spinner.stop();
+          return await executeInstallMethod("npm", codeType);
+        }
+        await setInstallMethod("powershell", codeType);
+        break;
+      }
+      case "cmd": {
+        if (codeType === "claude-code") {
+          await exec("cmd", ["/c", "curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd"]);
+        } else {
+          spinner.stop();
+          return await executeInstallMethod("npm", codeType);
+        }
+        await setInstallMethod("cmd", codeType);
+        break;
+      }
+      default:
+        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) {
-    console.error(`
-${red("\u2717")} Installation failed`);
+    spinner.fail(i18n.t("installation:installMethodFailed", { method }));
     if (error instanceof Error) {
-      console.error(`  ${gray("Error:")} ${error.message}`);
-    }
-    console.log(`
-${yellow("Manual installation:")}`);
-    console.log(`  ${cyan("1.")} npm install -g @anthropic-ai/agent-browser`);
-    console.log(`  ${cyan("2.")} npx playwright install chromium`);
-    console.log(`  ${cyan("3.")} agent-browser --version
-`);
+      console.error(ansis.gray(error.message));
+    }
+    return false;
+  }
+}
+async function handleInstallFailure(codeType, failedMethods) {
+  ensureI18nInitialized();
+  const response = await inquirer.prompt({
+    type: "confirm",
+    name: "retry",
+    message: i18n.t("installation:tryAnotherMethod"),
+    default: true
+  });
+  if (!response.retry) {
+    return false;
+  }
+  const newMethod = await selectInstallMethod(codeType, failedMethods);
+  if (!newMethod) {
     return false;
   }
+  const success = await executeInstallMethod(newMethod, codeType);
+  if (success) {
+    return true;
+  }
+  return await handleInstallFailure(codeType, [...failedMethods, newMethod]);
 }
-async function uninstallAgentBrowser(options = {}) {
-  console.log(`
-${bold(cyan("Uninstalling Agent Browser..."))}
-`);
-  const { execSync } = await import('node:child_process');
-  const { rmSync } = await import('node:fs');
+async function isCommandInPath(command) {
   try {
-    console.log(`${cyan("Step 1/2:")} Removing npm package...`);
-    try {
-      execSync("npm uninstall -g @anthropic-ai/agent-browser 2>&1", {
-        encoding: "utf-8",
-        stdio: options.verbose ? "inherit" : "pipe"
-      });
-      console.log(`  ${green("\u2713")} Global package removed`);
-    } catch {
-      console.log(`  ${gray("-")} No global package found`);
-    }
-    console.log(`
-${cyan("Step 2/2:")} Cleaning up local files...`);
-    if (existsSync(INSTALL_DIR)) {
-      rmSync(INSTALL_DIR, { recursive: true, force: true });
-      console.log(`  ${green("\u2713")} Local files removed`);
+    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
+        };
+      }
+    }
+  }
+  if (getPlatform() === "linux") {
+    const home = homedir();
+    const linuxPaths = [
+      `${home}/.local/bin/${command}`,
+      // Standard XDG user bin (curl install default)
+      `${home}/.claude/bin/${command}`,
+      // Claude-specific bin directory
+      `/usr/local/bin/${command}`,
+      // System-wide installation
+      `/usr/bin/${command}`
+      // System package manager
+    ];
+    for (const path of linuxPaths) {
+      if (exists(path)) {
+        const version = await detectInstalledVersion(codeType);
+        const needsPathUpdate = path.includes(".local/bin") && !process__default.env.PATH?.includes(".local/bin");
+        return {
+          success: true,
+          commandPath: path,
+          version,
+          needsSymlink: false,
+          symlinkCreated: false,
+          error: needsPathUpdate ? "PATH_UPDATE_NEEDED" : void 0
+        };
+      }
+    }
+  }
+  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 {
-      console.log(`  ${gray("-")} No local files found`);
+      return {
+        success: false,
+        symlinkPath: null,
+        error: `File already exists at ${symlinkPath} and is not a symlink`
+      };
     }
-    console.log(`
-${green("\u2713")} ${bold("Agent Browser uninstalled successfully!")}
-`);
-    return true;
   } catch (error) {
-    console.error(`
-${red("\u2717")} Uninstallation failed`);
-    if (error instanceof Error) {
-      console.error(`  ${gray("Error:")} ${error.message}`);
+    if (error.code !== "ENOENT") {
+      return {
+        success: false,
+        symlinkPath: null,
+        error: `Failed to check existing file: ${error}`
+      };
     }
-    return false;
+  }
+  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 showQuickStart() {
-  console.log(`${yellow("Quick Start:")}`);
-  console.log(`  ${gray("# Open a webpage")}`);
-  console.log(`  ${cyan("agent-browser open https://example.com")}`);
-  console.log();
-  console.log(`  ${gray("# Get interactive elements")}`);
-  console.log(`  ${cyan("agent-browser snapshot -i")}`);
-  console.log();
-  console.log(`  ${gray("# Click an element by ref")}`);
-  console.log(`  ${cyan("agent-browser click @e1")}`);
-  console.log();
-  console.log(`  ${gray("# Take a screenshot")}`);
-  console.log(`  ${cyan("agent-browser screenshot page.png")}`);
-  console.log();
-  console.log(`  ${gray("# Close the browser")}`);
-  console.log(`  ${cyan("agent-browser close")}`);
-  console.log();
-  console.log(`${gray("For full documentation, run")} ${cyan("/browser")} ${gray("in Claude Code")}`);
-  console.log();
+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 })}`));
+    } else if (result.commandPath) {
+      console.log(ansis.green(`\u2714 ${codeTypeName} ${i18n.t("installation:verificationSuccess")}`));
+      console.log(ansis.gray(`  ${i18n.t("installation:foundAtPath", { path: result.commandPath })}`));
+    }
+    if (result.version) {
+      console.log(ansis.gray(`  ${i18n.t("installation:detectedVersion", { version: result.version })}`));
+    }
+    if (result.error === "PATH_UPDATE_NEEDED") {
+      console.log(ansis.yellow(`
+\u26A0 ${i18n.t("installation:pathUpdateNeeded")}`));
+      console.log(ansis.gray(`  ${i18n.t("installation:pathUpdateHint")}`));
+      console.log(ansis.green(`  export PATH="$HOME/.local/bin:$PATH"`));
+      console.log(ansis.gray(`  ${i18n.t("installation:pathUpdatePermanent")}`));
+      console.log(ansis.green(`  echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc`));
+    }
+  } 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 && result.error !== "PATH_UPDATE_NEEDED") {
+      console.log(ansis.gray(`  ${result.error}`));
+    }
+    if (result.needsSymlink && !result.symlinkCreated) {
+      console.log(ansis.yellow(`  ${i18n.t("installation:manualSymlinkHint")}`));
+    }
+  }
 }
 
-export { checkAgentBrowserInstalled, getInstallPath, installAgentBrowser, uninstallAgentBrowser };
+export { createHomebrewSymlink, detectInstalledVersion, displayVerificationResult, executeInstallMethod, getInstallationStatus, handleInstallFailure, installClaudeCode, installCodex, isClaudeCodeInstalled, isCodexInstalled, selectInstallMethod, setInstallMethod, uninstallCodeTool, verifyInstallation };