@xwm111/ccs 0.1.0

package/dist/chunks/auto-updater.mjs

@@ -0,0 +1,1708 @@
+import { fileURLToPath } from 'node:url';
+import ansis from 'ansis';
+import dayjs from 'dayjs';
+import inquirer from 'inquirer';
+import { dirname, join } from 'pathe';
+import { homedir, platform as platform$1 } from 'node:os';
+import * as nodeFs from 'node:fs';
+import { existsSync, mkdirSync, copyFileSync, readFileSync, writeFileSync, lstatSync, statSync, rmSync, rmdirSync, readdirSync, unlinkSync } from 'node:fs';
+import process from 'node:process';
+import { exec } from 'tinyexec';
+import ora from 'ora';
+import semver from 'semver';
+import i18next from 'i18next';
+import Backend from 'i18next-fs-backend';
+import toggleModule from 'inquirer-toggle';
+import { exec as exec$1 } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const i18n = i18next.createInstance();
+const NAMESPACES = [
+  "common",
+  "api",
+  "cli",
+  "configuration",
+  "errors",
+  "installation",
+  "language",
+  "menu",
+  "multi-config",
+  "uninstall",
+  "updater"
+];
+function ensureI18nInitialized() {
+  if (!i18n.isInitialized) {
+    throw new Error(
+      "i18n is not initialized. Please call initI18n() in CLI command before using utility functions."
+    );
+  }
+}
+async function initI18n(language = "zh-CN") {
+  if (i18n.isInitialized) {
+    if (i18n.language !== language) {
+      await i18n.changeLanguage(language);
+    }
+    return;
+  }
+  await i18n.use(Backend).init({
+    lng: language,
+    fallbackLng: "en",
+    // Load all translations as a single flat structure
+    ns: NAMESPACES,
+    defaultNS: "common",
+    preload: [language],
+    // Preload the selected language
+    // Backend configuration for loading JSON files
+    backend: {
+      loadPath: (() => {
+        const currentDir = dirname(fileURLToPath(import.meta.url));
+        const packageRoot = (() => {
+          let dir = currentDir;
+          while (dir !== dirname(dir)) {
+            if (existsSync(join(dir, "package.json"))) {
+              return dir;
+            }
+            dir = dirname(dir);
+          }
+          return currentDir;
+        })();
+        const possibleBasePaths = [
+          join(currentDir, "locales"),
+          // Development: src/i18n/locales
+          join(packageRoot, "dist/i18n/locales"),
+          // NPM package: /node_modules/zcf/dist/i18n/locales
+          join(process.cwd(), "dist/i18n/locales"),
+          // Production build: ./dist/i18n/locales
+          join(currentDir, "../../../dist/i18n/locales"),
+          // Fallback for deep chunk paths
+          join(currentDir, "../../i18n/locales")
+          // Alternative chunk structure
+        ];
+        for (const basePath of possibleBasePaths) {
+          const testFile = join(basePath, "zh-CN/common.json");
+          if (existsSync(testFile)) {
+            return join(basePath, "{{lng}}/{{ns}}.json");
+          }
+        }
+        return join(process.cwd(), "dist/i18n/locales/{{lng}}/{{ns}}.json");
+      })()
+    },
+    // Interpolation settings
+    interpolation: {
+      escapeValue: false
+      // Not needed for server-side usage
+    },
+    // Disable key separator for flat keys, enable namespace separator
+    keySeparator: false,
+    nsSeparator: ":",
+    // Debugging (disable for clean output)
+    debug: false
+  });
+  for (const ns of NAMESPACES) {
+    if (ns !== "common") {
+      await i18n.loadNamespaces(ns);
+    }
+  }
+}
+function format(template, values) {
+  if (!values)
+    return template;
+  return Object.keys(values).reduce((result, key) => {
+    return result.replace(new RegExp(`{${key}}`, "g"), values[key]);
+  }, template);
+}
+async function changeLanguage(lng) {
+  await i18n.changeLanguage(lng);
+}
+
+const index = {
+  __proto__: null,
+  changeLanguage: changeLanguage,
+  ensureI18nInitialized: ensureI18nInitialized,
+  format: format,
+  i18n: i18n,
+  initI18n: initI18n
+};
+
+const CLAUDE_DIR = join(homedir(), ".claude");
+const SETTINGS_FILE = join(CLAUDE_DIR, "settings.json");
+const CLAUDE_MD_FILE = join(CLAUDE_DIR, "CLAUDE.md");
+const ClAUDE_CONFIG_FILE = join(homedir(), ".claude.json");
+const CLAUDE_VSC_CONFIG_FILE = join(CLAUDE_DIR, "config.json");
+const ZCF_CONFIG_DIR = join(homedir(), ".ccs");
+const ZCF_CONFIG_FILE = join(ZCF_CONFIG_DIR, "config.toml");
+const LEGACY_ZCF_CONFIG_FILES = [
+  join(CLAUDE_DIR, ".zcf-config.json"),
+  join(homedir(), ".zcf.json")
+];
+const CODE_TOOL_TYPES = ["claude-code"];
+const DEFAULT_CODE_TOOL_TYPE = "claude-code";
+const CODE_TOOL_BANNERS = {
+  "claude-code": "for Claude Code"
+};
+const CODE_TOOL_ALIASES = {
+  cc: "claude-code"
+};
+function isCodeToolType(value) {
+  return CODE_TOOL_TYPES.includes(value);
+}
+const API_DEFAULT_URL = "https://api.anthropic.com";
+const API_ENV_KEY = "ANTHROPIC_API_KEY";
+function resolveCodeToolType(value) {
+  if (isCodeToolType(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value in CODE_TOOL_ALIASES) {
+    return CODE_TOOL_ALIASES[value];
+  }
+  return DEFAULT_CODE_TOOL_TYPE;
+}
+const SUPPORTED_LANGS = ["zh-CN", "en"];
+const LANG_LABELS = {
+  "zh-CN": "\u7B80\u4F53\u4E2D\u6587",
+  "en": "English"
+};
+const AI_OUTPUT_LANGUAGES = {
+  "zh-CN": { directive: "Always respond in Chinese-simplified" },
+  "en": { directive: "Always respond in English" },
+  "custom": { directive: "" }
+};
+function getAiOutputLanguageLabel(lang) {
+  if (lang in LANG_LABELS) {
+    return LANG_LABELS[lang];
+  }
+  if (lang === "custom" && i18n?.isInitialized) {
+    try {
+      return i18n.t("language:labels.custom");
+    } catch {
+    }
+  }
+  return lang;
+}
+
+function getPlatform() {
+  const p = platform$1();
+  if (p === "win32")
+    return "windows";
+  if (p === "darwin")
+    return "macos";
+  return "linux";
+}
+function isTermux() {
+  return !!(process.env.PREFIX && process.env.PREFIX.includes("com.termux")) || !!process.env.TERMUX_VERSION || nodeFs.existsSync("/data/data/com.termux/files/usr");
+}
+function getTermuxPrefix() {
+  return process.env.PREFIX || "/data/data/com.termux/files/usr";
+}
+function isWindows() {
+  return getPlatform() === "windows";
+}
+function isWSL() {
+  if (process.env.WSL_DISTRO_NAME) {
+    return true;
+  }
+  if (nodeFs.existsSync("/proc/version")) {
+    try {
+      const version = nodeFs.readFileSync("/proc/version", "utf8");
+      if (version.includes("Microsoft") || version.includes("WSL")) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  if (nodeFs.existsSync("/mnt/c")) {
+    return true;
+  }
+  return false;
+}
+function getWSLDistro() {
+  if (process.env.WSL_DISTRO_NAME) {
+    return process.env.WSL_DISTRO_NAME;
+  }
+  if (nodeFs.existsSync("/etc/os-release")) {
+    try {
+      const osRelease = nodeFs.readFileSync("/etc/os-release", "utf8");
+      const nameMatch = osRelease.match(/^PRETTY_NAME="(.+)"$/m);
+      if (nameMatch) {
+        return nameMatch[1];
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function getWSLInfo() {
+  if (!isWSL()) {
+    return null;
+  }
+  let version = null;
+  if (nodeFs.existsSync("/proc/version")) {
+    try {
+      version = nodeFs.readFileSync("/proc/version", "utf8").trim();
+    } catch {
+    }
+  }
+  return {
+    isWSL: true,
+    distro: getWSLDistro(),
+    version
+  };
+}
+function normalizeTomlPath(str) {
+  return str.replace(/\\+/g, "/").replace(/\/+/g, "/");
+}
+function shouldUseSudoForGlobalInstall() {
+  if (isTermux())
+    return false;
+  if (getPlatform() !== "linux")
+    return false;
+  const npmPrefix = getGlobalNpmPrefix();
+  if (npmPrefix) {
+    if (isPathInsideHome(npmPrefix) || canWriteToPath(npmPrefix))
+      return false;
+  }
+  const getuid = process.getuid;
+  if (typeof getuid !== "function")
+    return false;
+  try {
+    return getuid() !== 0;
+  } catch {
+    return false;
+  }
+}
+function wrapCommandWithSudo(command, args) {
+  if (shouldUseSudoForGlobalInstall()) {
+    return {
+      command: "sudo",
+      args: [command, ...args],
+      usedSudo: true
+    };
+  }
+  return {
+    command,
+    args,
+    usedSudo: false
+  };
+}
+const WRITE_CHECK_FLAG = 2;
+function normalizePath(path) {
+  return normalizeTomlPath(path).replace(/\/+$/, "");
+}
+function isPathInsideHome(path) {
+  const home = process.env.HOME;
+  if (!home)
+    return false;
+  const normalizedHome = normalizePath(home);
+  const normalizedPath = normalizePath(path);
+  return normalizedPath === normalizedHome || normalizedPath.startsWith(`${normalizedHome}/`);
+}
+function canWriteToPath(path) {
+  try {
+    nodeFs.accessSync(path, WRITE_CHECK_FLAG);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getGlobalNpmPrefix() {
+  const env = process.env;
+  const envPrefix = env.npm_config_prefix || env.NPM_CONFIG_PREFIX || env.PREFIX;
+  if (envPrefix)
+    return envPrefix;
+  const execPath = process.execPath;
+  if (execPath) {
+    const binDir = dirname(execPath);
+    return dirname(binDir);
+  }
+  return null;
+}
+async function commandExists(command) {
+  try {
+    const cmd = getPlatform() === "windows" ? "where" : "which";
+    const res = await exec(cmd, [command]);
+    if (res.exitCode === 0) {
+      return true;
+    }
+  } catch {
+  }
+  if (isTermux()) {
+    const termuxPrefix = getTermuxPrefix();
+    const possiblePaths = [
+      `${termuxPrefix}/bin/${command}`,
+      `${termuxPrefix}/usr/bin/${command}`,
+      `/data/data/com.termux/files/usr/bin/${command}`
+    ];
+    for (const path of possiblePaths) {
+      if (nodeFs.existsSync(path)) {
+        return true;
+      }
+    }
+  }
+  if (getPlatform() !== "windows") {
+    const commonPaths = [
+      `/usr/local/bin/${command}`,
+      `/usr/bin/${command}`,
+      `/bin/${command}`,
+      `${process.env.HOME}/.local/bin/${command}`
+    ];
+    for (const path of commonPaths) {
+      if (nodeFs.existsSync(path)) {
+        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();
+  if (codeType === "claude-code") {
+    if (platform2 === "macos") {
+      return ["homebrew", "curl", "npm"];
+    }
+    if (platform2 === "linux" || wsl) {
+      return ["curl", "npm"];
+    }
+    if (platform2 === "windows") {
+      return ["powershell", "npm"];
+    }
+  }
+  if (codeType === "codex") {
+    if (platform2 === "macos") {
+      return ["homebrew", "npm"];
+    }
+    if (platform2 === "linux" || wsl || platform2 === "windows") {
+      return ["npm"];
+    }
+  }
+  return ["npm"];
+}
+
+const platform = {
+  __proto__: null,
+  commandExists: commandExists,
+  findCommandPath: findCommandPath,
+  getHomebrewCommandPaths: getHomebrewCommandPaths,
+  getPlatform: getPlatform,
+  getRecommendedInstallMethods: getRecommendedInstallMethods,
+  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);
+    this.path = path;
+    this.cause = cause;
+    this.name = "FileSystemError";
+  }
+}
+function exists(path) {
+  return existsSync(path);
+}
+function ensureDir(path) {
+  if (!existsSync(path)) {
+    mkdirSync(path, { recursive: true });
+  }
+}
+function ensureFileDir(filePath) {
+  const dir = dirname(filePath);
+  ensureDir(dir);
+}
+function readFile(path, encoding = "utf-8") {
+  try {
+    return readFileSync(path, encoding);
+  } catch (error) {
+    throw new FileSystemError(
+      `Failed to read file: ${path}`,
+      path,
+      error
+    );
+  }
+}
+function writeFile(path, content, encoding = "utf-8") {
+  try {
+    ensureFileDir(path);
+    writeFileSync(path, content, encoding);
+  } catch (error) {
+    throw new FileSystemError(
+      `Failed to write file: ${path}`,
+      path,
+      error
+    );
+  }
+}
+function copyFile(src, dest) {
+  try {
+    ensureFileDir(dest);
+    copyFileSync(src, dest);
+  } catch (error) {
+    throw new FileSystemError(
+      `Failed to copy file from ${src} to ${dest}`,
+      src,
+      error
+    );
+  }
+}
+function readDir(path) {
+  try {
+    return readdirSync(path);
+  } catch (error) {
+    throw new FileSystemError(
+      `Failed to read directory: ${path}`,
+      path,
+      error
+    );
+  }
+}
+function getStats(path) {
+  try {
+    return statSync(path);
+  } catch (error) {
+    throw new FileSystemError(
+      `Failed to get stats for: ${path}`,
+      path,
+      error
+    );
+  }
+}
+function removeFile(path) {
+  try {
+    if (exists(path)) {
+      unlinkSync(path);
+    }
+  } catch (error) {
+    throw new FileSystemError(
+      `Failed to remove file: ${path}`,
+      path,
+      error
+    );
+  }
+}
+function copyDir(src, dest, options = {}) {
+  const { filter, overwrite = true } = options;
+  if (!exists(src)) {
+    throw new FileSystemError(`Source directory does not exist: ${src}`, src);
+  }
+  ensureDir(dest);
+  const entries = readDir(src);
+  for (const entry of entries) {
+    const srcPath = `${src}/${entry}`;
+    const destPath = `${dest}/${entry}`;
+    let stats;
+    try {
+      stats = lstatSync(srcPath);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        continue;
+      }
+      throw error;
+    }
+    if (filter && !filter(srcPath, stats)) {
+      continue;
+    }
+    if (stats.isSymbolicLink()) {
+      try {
+        existsSync(srcPath);
+        const targetStats = statSync(srcPath);
+        if (targetStats.isDirectory()) {
+          copyDir(srcPath, destPath, options);
+        } else {
+          if (!overwrite && exists(destPath)) {
+            continue;
+          }
+          copyFile(srcPath, destPath);
+        }
+      } catch {
+        continue;
+      }
+      continue;
+    }
+    if (stats.isDirectory()) {
+      copyDir(srcPath, destPath, options);
+    } else {
+      if (!overwrite && exists(destPath)) {
+        continue;
+      }
+      copyFile(srcPath, destPath);
+    }
+  }
+}
+async function isExecutable(path) {
+  try {
+    if (!exists(path)) {
+      return false;
+    }
+    const stats = getStats(path);
+    if (!stats.isFile()) {
+      return false;
+    }
+    if (!isWindows()) {
+      const mode = stats.mode;
+      const executePermission = 73;
+      return (mode & executePermission) !== 0;
+    }
+    const isWinExecutable = path.endsWith(".exe") || path.endsWith(".cmd") || path.endsWith(".bat");
+    return isWinExecutable || !path.includes(".");
+  } catch {
+    return false;
+  }
+}
+async function remove(path) {
+  try {
+    if (!exists(path)) {
+      return;
+    }
+    const stats = getStats(path);
+    if (stats.isDirectory()) {
+      const entries = readDir(path);
+      for (const entry of entries) {
+        await remove(`${path}/${entry}`);
+      }
+      try {
+        if (rmSync) {
+          rmSync(path, { recursive: true, force: true });
+        } else if (rmdirSync) {
+          rmdirSync(path);
+        }
+      } catch (error) {
+        throw new FileSystemError(
+          `Failed to remove directory: ${path}`,
+          path,
+          error
+        );
+      }
+    } else {
+      removeFile(path);
+    }
+  } catch (error) {
+    throw new FileSystemError(
+      `Failed to remove: ${path}`,
+      path,
+      error
+    );
+  }
+}
+
+function readJsonConfig(path, options = {}) {
+  const { defaultValue = null, validate, sanitize } = options;
+  if (!exists(path)) {
+    return defaultValue;
+  }
+  try {
+    const content = readFile(path);
+    const data = JSON.parse(content);
+    if (validate && !validate(data)) {
+      console.log(`Invalid configuration: ${path}`);
+      return defaultValue;
+    }
+    if (sanitize) {
+      return sanitize(data);
+    }
+    return data;
+  } catch (error) {
+    console.error(`Failed to parse JSON: ${path}`, error);
+    return defaultValue;
+  }
+}
+function writeJsonConfig(path, data, options = {}) {
+  const { pretty = true, backup = false, backupDir } = options;
+  if (backup && exists(path)) {
+    backupJsonConfig(path, backupDir);
+  }
+  const content = pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+  writeFile(path, content);
+}
+function backupJsonConfig(path, backupDir) {
+  if (!exists(path)) {
+    return null;
+  }
+  const timestamp = dayjs().format("YYYY-MM-DD_HH-mm-ss");
+  const fileName = path.split("/").pop() || "config.json";
+  const baseDir = backupDir || join(path, "..", "backup");
+  const backupPath = join(baseDir, `${fileName}.backup_${timestamp}`);
+  try {
+    ensureDir(baseDir);
+    copyFile(path, backupPath);
+    return backupPath;
+  } catch (error) {
+    console.error("Failed to backup config", error);
+    return null;
+  }
+}
+
+const jsonConfig = {
+  __proto__: null,
+  backupJsonConfig: backupJsonConfig,
+  readJsonConfig: readJsonConfig,
+  writeJsonConfig: writeJsonConfig
+};
+
+function mergeArraysUnique(arr1, arr2) {
+  const combined = [...arr1 || [], ...arr2 || []];
+  return [...new Set(combined)];
+}
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && value.constructor === Object && Object.prototype.toString.call(value) === "[object Object]";
+}
+function deepMerge(target, source, options = {}) {
+  const { mergeArrays = false, arrayMergeStrategy = "replace" } = options;
+  const result = { ...target };
+  for (const key in source) {
+    const sourceValue = source[key];
+    const targetValue = result[key];
+    if (sourceValue === void 0) {
+      continue;
+    }
+    if (isPlainObject(sourceValue) && isPlainObject(targetValue)) {
+      result[key] = deepMerge(targetValue, sourceValue, options);
+    } else if (Array.isArray(sourceValue)) {
+      if (!mergeArrays || !Array.isArray(targetValue)) {
+        result[key] = sourceValue;
+      } else {
+        switch (arrayMergeStrategy) {
+          case "concat":
+            result[key] = [...targetValue, ...sourceValue];
+            break;
+          case "unique":
+            result[key] = mergeArraysUnique(targetValue, sourceValue);
+            break;
+          case "replace":
+          default:
+            result[key] = sourceValue;
+            break;
+        }
+      }
+    } else {
+      result[key] = sourceValue;
+    }
+  }
+  return result;
+}
+
+function readMcpConfig() {
+  return readJsonConfig(ClAUDE_CONFIG_FILE);
+}
+function writeMcpConfig(config) {
+  writeJsonConfig(ClAUDE_CONFIG_FILE, config);
+}
+function addCompletedOnboarding() {
+  try {
+    let config = readMcpConfig();
+    if (!config) {
+      config = { mcpServers: {} };
+    }
+    if (config.hasCompletedOnboarding === true) {
+      return;
+    }
+    config.hasCompletedOnboarding = true;
+    writeMcpConfig(config);
+  } catch (error) {
+    console.error("Failed to add onboarding flag", error);
+    throw error;
+  }
+}
+function setPrimaryApiKey() {
+  try {
+    let config = readJsonConfig(CLAUDE_VSC_CONFIG_FILE);
+    if (!config) {
+      config = {};
+    }
+    config.primaryApiKey = "zcf";
+    writeJsonConfig(CLAUDE_VSC_CONFIG_FILE, config);
+  } catch (error) {
+    ensureI18nInitialized();
+    console.error(i18n.t("api:primaryApiKeySetFailed"), error);
+  }
+}
+
+const claudeConfig = {
+  __proto__: null,
+  addCompletedOnboarding: addCompletedOnboarding,
+  readMcpConfig: readMcpConfig,
+  setPrimaryApiKey: setPrimaryApiKey,
+  writeMcpConfig: writeMcpConfig
+};
+
+const MODEL_ENV_KEYS = [
+  "ANTHROPIC_MODEL",
+  "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+  "ANTHROPIC_DEFAULT_SONNET_MODEL",
+  "ANTHROPIC_DEFAULT_OPUS_MODEL",
+  // Deprecated but still cleaned to avoid stale values
+  "ANTHROPIC_SMALL_FAST_MODEL"
+];
+function clearModelEnv(env) {
+  for (const key of MODEL_ENV_KEYS) {
+    delete env[key];
+  }
+}
+
+function ensureClaudeDir() {
+  ensureDir(CLAUDE_DIR);
+}
+function backupExistingConfig() {
+  if (!exists(CLAUDE_DIR)) {
+    return null;
+  }
+  const timestamp = dayjs().format("YYYY-MM-DD_HH-mm-ss");
+  const backupBaseDir = join(CLAUDE_DIR, "backup");
+  const backupDir = join(backupBaseDir, `backup_${timestamp}`);
+  ensureDir(backupDir);
+  const filter = (path) => {
+    return !path.includes("/backup");
+  };
+  copyDir(CLAUDE_DIR, backupDir, { filter });
+  return backupDir;
+}
+function copyConfigFiles(onlyMd = false) {
+  const currentFilePath = fileURLToPath(import.meta.url);
+  const distDir = dirname(dirname(currentFilePath));
+  const rootDir = dirname(distDir);
+  const baseTemplateDir = join(rootDir, "templates", "claude-code");
+  if (!onlyMd) {
+    const baseSettingsPath = join(baseTemplateDir, "common", "settings.json");
+    const destSettingsPath = join(CLAUDE_DIR, "settings.json");
+    if (exists(baseSettingsPath)) {
+      mergeSettingsFile(baseSettingsPath, destSettingsPath);
+    }
+  }
+}
+function getDefaultSettings() {
+  try {
+    const currentFilePath = fileURLToPath(import.meta.url);
+    const distDir = dirname(dirname(currentFilePath));
+    const rootDir = dirname(distDir);
+    const templateSettingsPath = join(rootDir, "templates", "claude-code", "common", "settings.json");
+    return readJsonConfig(templateSettingsPath) || {};
+  } catch (error) {
+    console.error("Failed to read template settings", error);
+    return {};
+  }
+}
+function configureApi(apiConfig) {
+  if (!apiConfig)
+    return null;
+  let settings = getDefaultSettings();
+  const existingSettings = readJsonConfig(SETTINGS_FILE);
+  if (existingSettings) {
+    settings = deepMerge(settings, existingSettings);
+  }
+  if (!settings.env) {
+    settings.env = {};
+  }
+  if (apiConfig.authType === "api_key") {
+    settings.env.ANTHROPIC_API_KEY = apiConfig.key;
+    delete settings.env.ANTHROPIC_AUTH_TOKEN;
+  } else if (apiConfig.authType === "auth_token") {
+    settings.env.ANTHROPIC_AUTH_TOKEN = apiConfig.key;
+    delete settings.env.ANTHROPIC_API_KEY;
+  }
+  if (apiConfig.url) {
+    settings.env.ANTHROPIC_BASE_URL = apiConfig.url;
+  }
+  writeJsonConfig(SETTINGS_FILE, settings);
+  if (apiConfig.authType) {
+    try {
+      setPrimaryApiKey();
+    } catch (error) {
+      ensureI18nInitialized();
+      console.error(i18n.t("api:primaryApiKeySetFailed"), error);
+    }
+  }
+  try {
+    addCompletedOnboarding();
+  } catch (error) {
+    console.error("Failed to set onboarding flag", error);
+  }
+  return apiConfig;
+}
+function mergeConfigs(sourceFile, targetFile) {
+  if (!exists(sourceFile))
+    return;
+  const target = readJsonConfig(targetFile) || {};
+  const source = readJsonConfig(sourceFile) || {};
+  const merged = deepMerge(target, source);
+  writeJsonConfig(targetFile, merged);
+}
+function updateCustomModel(primaryModel, haikuModel, sonnetModel, opusModel) {
+  if (!primaryModel?.trim() && !haikuModel?.trim() && !sonnetModel?.trim() && !opusModel?.trim()) {
+    return;
+  }
+  let settings = getDefaultSettings();
+  const existingSettings = readJsonConfig(SETTINGS_FILE);
+  if (existingSettings) {
+    settings = existingSettings;
+  }
+  delete settings.model;
+  settings.env = settings.env || {};
+  clearModelEnv(settings.env);
+  if (primaryModel?.trim()) {
+    settings.env.ANTHROPIC_MODEL = primaryModel.trim();
+  }
+  if (haikuModel?.trim())
+    settings.env.ANTHROPIC_DEFAULT_HAIKU_MODEL = haikuModel.trim();
+  if (sonnetModel?.trim())
+    settings.env.ANTHROPIC_DEFAULT_SONNET_MODEL = sonnetModel.trim();
+  if (opusModel?.trim())
+    settings.env.ANTHROPIC_DEFAULT_OPUS_MODEL = opusModel.trim();
+  writeJsonConfig(SETTINGS_FILE, settings);
+}
+function updateDefaultModel(model) {
+  let settings = getDefaultSettings();
+  const existingSettings = readJsonConfig(SETTINGS_FILE);
+  if (existingSettings) {
+    settings = existingSettings;
+  }
+  if (!settings.env) {
+    settings.env = {};
+  }
+  if (model !== "custom") {
+    clearModelEnv(settings.env);
+  }
+  if (model === "default" || model === "custom") {
+    delete settings.model;
+  } else {
+    settings.model = model;
+  }
+  writeJsonConfig(SETTINGS_FILE, settings);
+}
+function mergeSettingsFile(templatePath, targetPath) {
+  try {
+    const templateSettings = readJsonConfig(templatePath);
+    if (!templateSettings) {
+      console.error("Failed to read template settings");
+      return;
+    }
+    if (!exists(targetPath)) {
+      writeJsonConfig(targetPath, templateSettings);
+      return;
+    }
+    const existingSettings = readJsonConfig(targetPath) || {};
+    const mergedEnv = {
+      ...templateSettings.env || {},
+      // Template env vars first
+      ...existingSettings.env || {}
+      // User's env vars override (preserving API keys, etc.)
+    };
+    const mergedSettings = deepMerge(templateSettings, existingSettings, {
+      mergeArrays: true,
+      arrayMergeStrategy: "unique"
+    });
+    mergedSettings.env = mergedEnv;
+    if (mergedSettings.permissions && mergedSettings.permissions.allow) {
+      mergedSettings.permissions.allow = [
+        .../* @__PURE__ */ new Set([
+          ...templateSettings.permissions?.allow ?? [],
+          ...existingSettings.permissions?.allow ?? []
+        ])
+      ];
+    }
+    writeJsonConfig(targetPath, mergedSettings);
+  } catch (error) {
+    console.error("Failed to merge settings", error);
+    if (exists(targetPath)) {
+      console.log("Preserving existing settings");
+    } else {
+      copyFile(templatePath, targetPath);
+    }
+  }
+}
+function getExistingModelConfig() {
+  const settings = readJsonConfig(SETTINGS_FILE);
+  if (!settings) {
+    return null;
+  }
+  const hasModelEnv = MODEL_ENV_KEYS.some((key) => settings.env?.[key]);
+  if (hasModelEnv) {
+    return "custom";
+  }
+  if (!settings.model) {
+    return "default";
+  }
+  const validModels = ["opus", "sonnet", "sonnet[1m]"];
+  if (validModels.includes(settings.model)) {
+    return settings.model;
+  }
+  return "default";
+}
+function getExistingApiConfig() {
+  const settings = readJsonConfig(SETTINGS_FILE);
+  if (!settings || !settings.env) {
+    return null;
+  }
+  const { ANTHROPIC_API_KEY, ANTHROPIC_AUTH_TOKEN, ANTHROPIC_BASE_URL } = settings.env;
+  if (!ANTHROPIC_BASE_URL && !ANTHROPIC_API_KEY && !ANTHROPIC_AUTH_TOKEN) {
+    return null;
+  }
+  let authType;
+  let key;
+  if (ANTHROPIC_AUTH_TOKEN) {
+    authType = "auth_token";
+    key = ANTHROPIC_AUTH_TOKEN;
+  } else if (ANTHROPIC_API_KEY) {
+    authType = "api_key";
+    key = ANTHROPIC_API_KEY;
+  }
+  return {
+    url: ANTHROPIC_BASE_URL || "",
+    key: key || "",
+    authType
+  };
+}
+function applyAiLanguageDirective(aiOutputLang) {
+  const claudeFile = join(CLAUDE_DIR, "CLAUDE.md");
+  let directive = "";
+  if (aiOutputLang === "custom") {
+    return;
+  } else if (AI_OUTPUT_LANGUAGES[aiOutputLang]) {
+    directive = AI_OUTPUT_LANGUAGES[aiOutputLang].directive;
+  } else {
+    directive = `Always respond in ${aiOutputLang}`;
+  }
+  writeFile(claudeFile, directive);
+}
+function switchToOfficialLogin() {
+  try {
+    ensureI18nInitialized();
+    const settings = readJsonConfig(SETTINGS_FILE) || {};
+    if (settings.env) {
+      delete settings.env.ANTHROPIC_BASE_URL;
+      delete settings.env.ANTHROPIC_AUTH_TOKEN;
+      delete settings.env.ANTHROPIC_API_KEY;
+    }
+    writeJsonConfig(SETTINGS_FILE, settings);
+    const vscConfig = readJsonConfig(CLAUDE_VSC_CONFIG_FILE);
+    if (vscConfig) {
+      delete vscConfig.primaryApiKey;
+      writeJsonConfig(CLAUDE_VSC_CONFIG_FILE, vscConfig);
+    }
+    console.log(i18n.t("api:officialLoginConfigured"));
+    return true;
+  } catch (error) {
+    ensureI18nInitialized();
+    console.error(i18n.t("api:officialLoginFailed"), error);
+    return false;
+  }
+}
+async function promptApiConfigurationAction() {
+  ensureI18nInitialized();
+  const existingConfig = getExistingApiConfig();
+  if (!existingConfig) {
+    return null;
+  }
+  console.log(`
+${ansis.blue(`\u2139 ${i18n.t("api:existingApiConfig")}`)}`);
+  console.log(ansis.gray(`  ${i18n.t("api:apiConfigUrl")}: ${existingConfig.url || "N/A"}`));
+  console.log(ansis.gray(`  ${i18n.t("api:apiConfigKey")}: ${existingConfig.key ? `***${existingConfig.key.slice(-4)}` : "N/A"}`));
+  console.log(ansis.gray(`  ${i18n.t("api:apiConfigAuthType")}: ${existingConfig.authType || "N/A"}
+`));
+  const { choice } = await inquirer.prompt({
+    type: "list",
+    name: "choice",
+    message: i18n.t("api:selectCustomConfigAction"),
+    choices: [
+      {
+        name: i18n.t("api:modifyPartialConfig"),
+        value: "modify-partial"
+      },
+      {
+        name: i18n.t("api:modifyAllConfig"),
+        value: "modify-all"
+      },
+      {
+        name: i18n.t("api:keepExistingConfig"),
+        value: "keep-existing"
+      }
+    ]
+  });
+  return choice || null;
+}
+
+const config = {
+  __proto__: null,
+  applyAiLanguageDirective: applyAiLanguageDirective,
+  backupExistingConfig: backupExistingConfig,
+  configureApi: configureApi,
+  copyConfigFiles: copyConfigFiles,
+  ensureClaudeDir: ensureClaudeDir,
+  getExistingApiConfig: getExistingApiConfig,
+  getExistingModelConfig: getExistingModelConfig,
+  mergeConfigs: mergeConfigs,
+  mergeSettingsFile: mergeSettingsFile,
+  promptApiConfigurationAction: promptApiConfigurationAction,
+  switchToOfficialLogin: switchToOfficialLogin,
+  updateCustomModel: updateCustomModel,
+  updateDefaultModel: updateDefaultModel
+};
+
+const version = "0.1.0";
+const homepage = "https://github.com/xwm111/ccs";
+
+const togglePrompt = toggleModule?.default?.default || toggleModule?.default || toggleModule;
+async function promptBoolean(options) {
+  const { message, defaultValue = false, theme } = options;
+  return await togglePrompt({
+    message,
+    default: defaultValue,
+    ...theme ? { theme } : {}
+  });
+}
+
+const execAsync = promisify(exec$1);
+async function getInstalledVersion(command, maxRetries = 3) {
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      let stdout;
+      try {
+        const result = await execAsync(`${command} -v`);
+        stdout = result.stdout;
+      } catch {
+        const result = await execAsync(`${command} --version`);
+        stdout = result.stdout;
+      }
+      const versionMatch = stdout.match(/(\d+\.\d+\.\d+(?:-[\w.]+)?)/);
+      return versionMatch ? versionMatch[1] : null;
+    } catch {
+      if (attempt === maxRetries) {
+        return null;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 100 * attempt));
+    }
+  }
+  return null;
+}
+async function getLatestVersion(packageName, maxRetries = 3) {
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      const { stdout } = await execAsync(`npm view ${packageName} version`);
+      return stdout.trim();
+    } catch {
+      if (attempt === maxRetries) {
+        return null;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 200 * attempt));
+    }
+  }
+  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(`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(`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(`"${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(`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("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(`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 import('./installer.mjs');
+      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("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;
+  }
+  return semver.compare(current, latest);
+}
+function shouldUpdate(current, latest) {
+  return compareVersions(current, latest) < 0;
+}
+async function checkClaudeCodeVersion() {
+  const currentVersion = await getInstalledVersion("claude");
+  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,
+    isHomebrew,
+    commandPath,
+    installationSource
+  };
+}
+
+const CCS_PACKAGE_NAME = "@xwm111/ccs";
+async function execWithSudoIfNeeded(command, args) {
+  const needsSudo = shouldUseSudoForGlobalInstall();
+  if (needsSudo) {
+    console.log(ansis.yellow(`
+${i18n.t("updater:usingSudo")}`));
+    const result = await exec("sudo", [command, ...args]);
+    if (result.exitCode !== 0) {
+      throw new Error(result.stderr || `Command failed with exit code ${result.exitCode}`);
+    }
+    return { usedSudo: true };
+  } else {
+    const result = await exec(command, args);
+    if (result.exitCode !== 0) {
+      throw new Error(result.stderr || `Command failed with exit code ${result.exitCode}`);
+    }
+    return { usedSudo: false };
+  }
+}
+async function updateCcsSelf(force = false, skipPrompt = false) {
+  ensureI18nInitialized();
+  const spinner = ora(i18n.t("updater:checkingVersion")).start();
+  try {
+    const latestVersion = await getLatestVersion(CCS_PACKAGE_NAME);
+    spinner.stop();
+    if (!latestVersion) {
+      console.log(ansis.yellow(i18n.t("updater:cannotCheckVersion")));
+      return false;
+    }
+    const needsUpdate = semver.valid(latestVersion) && semver.valid(version) ? semver.gt(latestVersion, version) : latestVersion !== version;
+    if (!needsUpdate && !force) {
+      console.log(ansis.green(format(i18n.t("updater:ccsUpToDate"), { version })));
+      return true;
+    }
+    console.log(ansis.cyan(format(i18n.t("updater:currentVersion"), { version })));
+    console.log(ansis.cyan(format(i18n.t("updater:latestVersion"), { version: latestVersion })));
+    if (!skipPrompt) {
+      const confirm = await promptBoolean({
+        message: format(i18n.t("updater:confirmUpdate"), { tool: "ccs" }),
+        defaultValue: true
+      });
+      if (!confirm) {
+        console.log(ansis.gray(i18n.t("updater:updateSkipped")));
+        return true;
+      }
+    } else {
+      console.log(ansis.cyan(format(i18n.t("updater:autoUpdating"), { tool: "ccs" })));
+    }
+    const updateSpinner = ora(format(i18n.t("updater:updating"), { tool: "ccs" })).start();
+    try {
+      await execWithSudoIfNeeded("npm", ["install", "-g", `${CCS_PACKAGE_NAME}@latest`]);
+      updateSpinner.succeed(format(i18n.t("updater:updateSuccess"), { tool: "ccs" }));
+      return true;
+    } catch (error) {
+      updateSpinner.fail(format(i18n.t("updater:updateFailed"), { tool: "ccs" }));
+      console.error(ansis.red(error instanceof Error ? error.message : String(error)));
+      return false;
+    }
+  } catch (error) {
+    spinner.fail(i18n.t("updater:checkFailed"));
+    console.error(ansis.red(error instanceof Error ? error.message : String(error)));
+    return false;
+  }
+}
+async function updateClaudeCode(force = false, skipPrompt = false) {
+  ensureI18nInitialized();
+  const spinner = ora(i18n.t("updater:checkingVersion")).start();
+  try {
+    const { installed, currentVersion, latestVersion, needsUpdate, isHomebrew } = await checkClaudeCodeVersion();
+    spinner.stop();
+    if (!installed) {
+      console.log(ansis.yellow(i18n.t("updater:claudeCodeNotInstalled")));
+      return false;
+    }
+    if (!needsUpdate && !force) {
+      console.log(ansis.green(format(i18n.t("updater:claudeCodeUpToDate"), { version: currentVersion || "" })));
+      return true;
+    }
+    if (!latestVersion) {
+      console.log(ansis.yellow(i18n.t("updater:cannotCheckVersion")));
+      return false;
+    }
+    console.log(ansis.cyan(format(i18n.t("updater:currentVersion"), { version: currentVersion || "" })));
+    console.log(ansis.cyan(format(i18n.t("updater:latestVersion"), { version: latestVersion })));
+    if (!skipPrompt) {
+      const confirm = await promptBoolean({
+        message: format(i18n.t("updater:confirmUpdate"), { tool: "Claude Code" }),
+        defaultValue: true
+      });
+      if (!confirm) {
+        console.log(ansis.gray(i18n.t("updater:updateSkipped")));
+        return true;
+      }
+    } else {
+      console.log(ansis.cyan(format(i18n.t("updater:autoUpdating"), { tool: "Claude Code" })));
+    }
+    const toolName = isHomebrew ? "Claude Code (Homebrew)" : "Claude Code";
+    const updateSpinner = ora(format(i18n.t("updater:updating"), { tool: toolName })).start();
+    try {
+      if (isHomebrew) {
+        const result = await exec("brew", ["upgrade", "--cask", "claude-code"]);
+        if (result.exitCode !== 0) {
+          throw new Error(result.stderr || `Command failed with exit code ${result.exitCode}`);
+        }
+      } else {
+        await execWithSudoIfNeeded("claude", ["update"]);
+      }
+      updateSpinner.succeed(format(i18n.t("updater:updateSuccess"), { tool: "Claude Code" }));
+      return true;
+    } catch (error) {
+      updateSpinner.fail(format(i18n.t("updater:updateFailed"), { tool: "Claude Code" }));
+      console.error(ansis.red(error instanceof Error ? error.message : String(error)));
+      return false;
+    }
+  } catch (error) {
+    spinner.fail(i18n.t("updater:checkFailed"));
+    console.error(ansis.red(error instanceof Error ? error.message : String(error)));
+    return false;
+  }
+}
+async function checkAndUpdateTools(skipPrompt = false) {
+  ensureI18nInitialized();
+  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 updateCcsSelf(false, skipPrompt);
+    results.push({ tool: "ccs", success });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(ansis.red(`\u274C ${format(i18n.t("updater:updateFailed"), { tool: "ccs" })}: ${errorMessage}`));
+    results.push({ tool: "ccs", success: false, error: errorMessage });
+  }
+  console.log();
+  try {
+    const success = await updateClaudeCode(false, skipPrompt);
+    results.push({ tool: "Claude Code", success });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(ansis.red(`\u274C ${format(i18n.t("updater:updateFailed"), { tool: "Claude Code" })}: ${errorMessage}`));
+    results.push({ tool: "Claude Code", success: false, error: errorMessage });
+  }
+  if (skipPrompt) {
+    console.log(ansis.bold.cyan(`
+\u{1F4CB} ${i18n.t("updater:updateSummary")}`));
+    for (const result of results) {
+      if (result.success) {
+        console.log(ansis.green(`\u2714 ${result.tool}: ${i18n.t("updater:success")}`));
+      } else {
+        console.log(ansis.red(`\u274C ${result.tool}: ${i18n.t("updater:failed")} ${result.error ? `(${result.error})` : ""}`));
+      }
+    }
+  }
+}
+
+export { readJsonConfig as $, API_DEFAULT_URL as A, applyAiLanguageDirective as B, CLAUDE_DIR as C, DEFAULT_CODE_TOOL_TYPE as D, switchToOfficialLogin as E, promptApiConfigurationAction as F, ensureI18nInitialized as G, i18n as H, updateClaudeCode as I, isTermux as J, getTermuxPrefix as K, LEGACY_ZCF_CONFIG_FILES as L, isWSL as M, getWSLInfo as N, wrapCommandWithSudo as O, exists as P, isExecutable as Q, remove as R, SETTINGS_FILE as S, getRecommendedInstallMethods as T, findCommandPath as U, getHomebrewCommandPaths as V, promptBoolean as W, ensureDir as X, readFile as Y, ZCF_CONFIG_DIR as Z, writeFile as _, CLAUDE_MD_FILE as a, checkAndUpdateTools as a0, clearModelEnv as a1, copyFile as a2, version as a3, homepage as a4, changeLanguage as a5, writeJsonConfig as a6, initI18n as a7, index as a8, jsonConfig as a9, claudeConfig as aa, config as ab, ClAUDE_CONFIG_FILE as b, commandExists as c, CLAUDE_VSC_CONFIG_FILE as d, ZCF_CONFIG_FILE as e, CODE_TOOL_TYPES as f, getPlatform as g, CODE_TOOL_BANNERS as h, CODE_TOOL_ALIASES as i, isCodeToolType as j, API_ENV_KEY as k, SUPPORTED_LANGS as l, LANG_LABELS as m, AI_OUTPUT_LANGUAGES as n, getAiOutputLanguageLabel as o, ensureClaudeDir as p, backupExistingConfig as q, resolveCodeToolType as r, copyConfigFiles as s, configureApi as t, mergeConfigs as u, updateCustomModel as v, updateDefaultModel as w, mergeSettingsFile as x, getExistingModelConfig as y, getExistingApiConfig as z };