ccjk 13.3.18 → 13.3.19

package/dist/chunks/config2.mjs

@@ -1,478 +1,412 @@
-import { exec } from 'node:child_process';
-import { existsSync, copyFileSync, mkdirSync } from 'node:fs';
-import { homedir } from 'node:os';
-import process__default from 'node:process';
-import { promisify } from 'node:util';
+import { fileURLToPath } from 'node:url';
 import a from './index2.mjs';
 import { d as dayjs } from '../shared/ccjk.RyizuzOI.mjs';
 import { i as inquirer } from './index3.mjs';
-import { SETTINGS_FILE } from './constants.mjs';
+import { CLAUDE_DIR, SETTINGS_FILE, CLAUDE_VSC_CONFIG_FILE, AI_OUTPUT_LANGUAGES } from './constants.mjs';
 import { ensureI18nInitialized, i18n } from './index5.mjs';
-import { s as setPrimaryApiKey, a as addCompletedOnboarding } from './claude-config.mjs';
-import { b as backupExistingConfig } from './config.mjs';
+import { s as setPrimaryApiKey, c as addCompletedOnboarding, d as deepMerge } from './claude-config.mjs';
+import { exists, ensureDir, copyDir, writeFileAtomic, copyFile } from './fs-operations.mjs';
 import { readJsonConfig, writeJsonConfig } from './json-config.mjs';
-import { p as promptBoolean } from '../shared/ccjk.BWFpnOr3.mjs';
-import { j as join } from '../shared/ccjk.bQ7Dh1g4.mjs';
-import '../shared/ccjk.BAGoDD49.mjs';
-import 'node:readline';
-import 'stream';
-import 'node:tty';
-import 'node:async_hooks';
-import '../shared/ccjk.Cjgrln_h.mjs';
-import 'tty';
-import 'fs';
-import 'child_process';
-import 'node:path';
-import 'node:crypto';
-import 'buffer';
-import 'string_decoder';
-import 'node:url';
-import './platform.mjs';
-import './main.mjs';
-import 'module';
-import 'node:stream';
-import './fs-operations.mjs';
-import 'node:fs/promises';
-import '../shared/ccjk.DScm_NnL.mjs';
-import '../shared/ccjk.DeWpAShp.mjs';
+import { m as mergeAndCleanPermissions } from '../shared/ccjk.DScm_NnL.mjs';
+import { j as join, d as dirname } from '../shared/ccjk.bQ7Dh1g4.mjs';
 
-const PROVIDER_PRESETS_URL = "https://pub-0dc3e1677e894f07bbea11b17a29e032.r2.dev/providers.json";
-async function fetchProviderPresets() {
-  try {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 5e3);
-    const response = await fetch(PROVIDER_PRESETS_URL, {
-      signal: controller.signal
-    });
-    clearTimeout(timeoutId);
-    if (!response.ok) {
-      throw new Error(`HTTP error! status: ${response.status}`);
-    }
-    const data = await response.json();
-    const presets = [];
-    if (Array.isArray(data)) {
-      for (const provider of data) {
-        if (provider && typeof provider === "object") {
-          presets.push({
-            name: provider.name || "",
-            provider: provider.name || "",
-            baseURL: provider.api_base_url || provider.baseURL || provider.url,
-            requiresApiKey: provider.api_key === "" || provider.requiresApiKey !== false,
-            models: provider.models || [],
-            description: provider.description || provider.name || "",
-            transformer: provider.transformer
-          });
-        }
-      }
-    } else if (data && typeof data === "object") {
-      for (const [key, value] of Object.entries(data)) {
-        if (typeof value === "object" && value !== null) {
-          const provider = value;
-          presets.push({
-            name: provider.name || key,
-            provider: key,
-            baseURL: provider.api_base_url || provider.baseURL || provider.url,
-            requiresApiKey: provider.api_key === "" || provider.requiresApiKey !== false,
-            models: provider.models || [],
-            description: provider.description || "",
-            transformer: provider.transformer
-          });
-        }
-      }
+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, mode = "reset") {
+  for (const key of MODEL_ENV_KEYS) {
+    if (mode === "reset" && key === "ANTHROPIC_MODEL") {
+      env[key] = "";
+    } else {
+      delete env[key];
     }
-    return presets;
-  } catch {
-    return getFallbackPresets();
   }
 }
-function getFallbackPresets() {
-  return [
-    {
-      name: "dashscope",
-      provider: "dashscope",
-      baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions",
-      requiresApiKey: true,
-      models: ["qwen3-coder-plus"],
-      description: "Alibaba DashScope",
-      transformer: {
-        "use": [["maxtoken", { max_tokens: 65536 }]],
-        "qwen3-coder-plus": {
-          use: ["enhancetool"]
-        }
-      }
-    },
-    {
-      name: "deepseek",
-      provider: "deepseek",
-      baseURL: "https://api.deepseek.com/chat/completions",
-      requiresApiKey: true,
-      models: ["deepseek-chat", "deepseek-reasoner"],
-      description: "DeepSeek AI models",
-      transformer: {
-        "use": ["deepseek"],
-        "deepseek-chat": {
-          use: ["tooluse"]
-        }
-      }
-    },
-    {
-      name: "gemini",
-      provider: "gemini",
-      baseURL: "https://generativelanguage.googleapis.com/v1beta/models/",
-      requiresApiKey: true,
-      models: ["gemini-2.5-flash", "gemini-2.5-pro"],
-      description: "Google Gemini models",
-      transformer: {
-        use: ["gemini"]
-      }
-    },
-    {
-      name: "modelscope",
-      provider: "modelscope",
-      baseURL: "https://api-inference.modelscope.cn/v1/chat/completions",
-      requiresApiKey: true,
-      models: ["Qwen/Qwen3-Coder-480B-A35B-Instruct", "Qwen/Qwen3-235B-A22B-Thinking-2507", "ZhipuAI/GLM-4.5"],
-      description: "ModelScope AI models",
-      transformer: {
-        "use": [["maxtoken", { max_tokens: 65536 }]],
-        "Qwen/Qwen3-Coder-480B-A35B-Instruct": {
-          use: ["enhancetool"]
-        },
-        "Qwen/Qwen3-235B-A22B-Thinking-2507": {
-          use: ["reasoning"]
-        }
-      }
-    },
-    {
-      name: "openrouter",
-      provider: "openrouter",
-      baseURL: "https://openrouter.ai/api/v1/chat/completions",
-      requiresApiKey: true,
-      models: [
-        "google/gemini-2.5-pro-preview",
-        "anthropic/claude-sonnet-4",
-        "anthropic/claude-3.5-sonnet",
-        "anthropic/claude-3.7-sonnet:thinking"
-      ],
-      description: "OpenRouter API",
-      transformer: {
-        use: ["openrouter"]
-      }
-    },
-    {
-      name: "siliconflow",
-      provider: "siliconflow",
-      baseURL: "https://api.siliconflow.cn/v1/chat/completions",
-      requiresApiKey: true,
-      models: ["moonshotai/Kimi-K2-Instruct"],
-      description: "SiliconFlow AI",
-      transformer: {
-        use: [["maxtoken", { max_tokens: 16384 }]]
-      }
-    },
-    {
-      name: "volcengine",
-      provider: "volcengine",
-      baseURL: "https://ark.cn-beijing.volces.com/api/v3/chat/completions",
-      requiresApiKey: true,
-      models: ["deepseek-v3-250324", "deepseek-r1-250528"],
-      description: "Volcengine AI",
-      transformer: {
-        use: ["deepseek"]
-      }
-    }
-  ];
-}
 
-const execAsync = promisify(exec);
-const CCR_CONFIG_DIR = join(homedir(), ".claude-code-router");
-const CCR_CONFIG_FILE = join(CCR_CONFIG_DIR, "config.json");
-const CCR_BACKUP_DIR = CCR_CONFIG_DIR;
-function ensureCcrConfigDir() {
-  if (!existsSync(CCR_CONFIG_DIR)) {
-    mkdirSync(CCR_CONFIG_DIR, { recursive: true });
-  }
+function ensureClaudeDir() {
+  ensureDir(CLAUDE_DIR);
 }
-async function backupCcrConfig() {
-  ensureI18nInitialized();
-  try {
-    if (!existsSync(CCR_CONFIG_FILE)) {
-      return null;
-    }
-    const timestamp = `${dayjs().format("YYYY-MM-DDTHH-mm-ss-SSS")}Z`;
-    const backupFileName = `config.json.${timestamp}.bak`;
-    const backupPath = join(CCR_BACKUP_DIR, backupFileName);
-    console.log(a.green(`${i18n.t("ccr:backupCcrConfig")}`));
-    copyFileSync(CCR_CONFIG_FILE, backupPath);
-    console.log(a.green(`\u2714 ${i18n.t("ccr:ccrBackupSuccess").replace("{path}", backupPath)}`));
-    return backupPath;
-  } catch (error) {
-    console.error(a.red(`${i18n.t("ccr:ccrBackupFailed")}:`), error.message);
+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 readCcrConfig() {
-  if (!existsSync(CCR_CONFIG_FILE)) {
-    return null;
+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);
+    }
   }
-  return readJsonConfig(CCR_CONFIG_FILE);
-}
-function writeCcrConfig(config) {
-  ensureCcrConfigDir();
-  writeJsonConfig(CCR_CONFIG_FILE, config);
 }
-async function configureCcrProxy(ccrConfig) {
-  const settings = readJsonConfig(SETTINGS_FILE) || {};
-  const host = ccrConfig.HOST || "127.0.0.1";
-  const port = ccrConfig.PORT || 3456;
-  const apiKey = ccrConfig.APIKEY || "sk-ccjk-x-ccr";
-  if (!settings.env) {
-    settings.env = {};
-  }
-  delete settings.env.ANTHROPIC_AUTH_TOKEN;
-  settings.env.ANTHROPIC_BASE_URL = `http://${host}:${port}`;
-  settings.env.ANTHROPIC_API_KEY = apiKey;
-  writeJsonConfig(SETTINGS_FILE, settings);
+function getDefaultSettings() {
   try {
-    setPrimaryApiKey();
+    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) {
-    ensureI18nInitialized();
-    console.error(i18n.t("mcp:primaryApiKeySetFailed"), error);
+    console.error("Failed to read template settings", error);
+    return {};
   }
 }
-async function selectCcrPreset() {
-  ensureI18nInitialized();
-  console.log(a.green(`${i18n.t("ccr:fetchingPresets")}`));
-  const presets = await fetchProviderPresets();
-  if (!presets || presets.length === 0) {
-    console.log(a.yellow(`${i18n.t("ccr:noPresetsAvailable")}`));
+function configureApi(apiConfig) {
+  if (!apiConfig)
     return null;
+  const existingSettings = readJsonConfig(SETTINGS_FILE);
+  let settings;
+  if (existingSettings) {
+    settings = existingSettings;
+  } else {
+    settings = getDefaultSettings();
   }
-  try {
-    const choices = [
-      {
-        name: `1. ${i18n.t("ccr:skipOption")}`,
-        value: "skip"
-      },
-      ...presets.map((p, index) => ({
-        name: `${index + 2}. ${p.name}`,
-        value: p
-      }))
-    ];
-    const { preset } = await inquirer.prompt({
-      type: "list",
-      name: "preset",
-      message: i18n.t("ccr:selectCcrPreset"),
-      choices
-    });
-    return preset;
-  } catch (error) {
-    if (error.name === "ExitPromptError") {
-      console.log(a.yellow(i18n.t("common:cancelled")));
-      return null;
-    }
-    throw error;
+  if (!settings.env) {
+    settings.env = {};
   }
-}
-async function configureCcrWithPreset(preset) {
-  ensureI18nInitialized();
-  const provider = {
-    name: preset.name,
-    // Use the original name from JSON
-    api_base_url: preset.baseURL || "",
-    api_key: "",
-    models: preset.models
-  };
-  if (preset.transformer) {
-    provider.transformer = preset.transformer;
+  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 (preset.requiresApiKey) {
-    try {
-      const { apiKey } = await inquirer.prompt({
-        type: "input",
-        name: "apiKey",
-        message: i18n.t("ccr:enterApiKeyForProvider").replace("{provider}", preset.name),
-        validate: async (value) => !!value || i18n.t("api:keyRequired")
-      });
-      provider.api_key = apiKey;
-    } catch (error) {
-      if (error.name === "ExitPromptError") {
-        throw error;
-      }
-      throw error;
-    }
-  } else {
-    provider.api_key = "sk-free";
+  if (apiConfig.url) {
+    settings.env.ANTHROPIC_BASE_URL = apiConfig.url;
   }
-  let defaultModel = preset.models[0];
-  if (preset.models.length > 1) {
+  writeJsonConfig(SETTINGS_FILE, settings);
+  if (apiConfig.authType) {
     try {
-      const { model } = await inquirer.prompt({
-        type: "list",
-        name: "model",
-        message: i18n.t("ccr:selectDefaultModelForProvider").replace("{provider}", preset.name),
-        choices: preset.models.map((m, index) => ({
-          name: `${index + 1}. ${m}`,
-          value: m
-        }))
-      });
-      defaultModel = model;
+      setPrimaryApiKey();
     } catch (error) {
-      if (error.name === "ExitPromptError") {
-        throw error;
-      }
-      throw error;
+      ensureI18nInitialized();
+      console.error(i18n.t("mcp:primaryApiKeySetFailed"), error);
     }
   }
-  const router = {
-    default: `${preset.name},${defaultModel}`,
-    // Use the original name
-    background: `${preset.name},${defaultModel}`,
-    think: `${preset.name},${defaultModel}`,
-    longContext: `${preset.name},${defaultModel}`,
-    longContextThreshold: 6e4,
-    webSearch: `${preset.name},${defaultModel}`
-  };
-  const config = {
-    LOG: true,
-    CLAUDE_PATH: "",
-    HOST: "127.0.0.1",
-    PORT: 3456,
-    APIKEY: "sk-ccjk-x-ccr",
-    API_TIMEOUT_MS: "600000",
-    PROXY_URL: "",
-    transformers: [],
-    Providers: [provider],
-    Router: router
-  };
-  return config;
-}
-async function restartAndCheckCcrStatus() {
-  ensureI18nInitialized();
   try {
-    console.log(a.green(`${i18n.t("ccr:restartingCcr")}`));
-    await execAsync("ccr restart");
-    console.log(a.green(`\u2714 ${i18n.t("ccr:ccrRestartSuccess")}`));
-    console.log(a.green(`${i18n.t("ccr:checkingCcrStatus")}`));
-    const { stdout } = await execAsync("ccr status");
-    console.log(a.gray(stdout));
+    addCompletedOnboarding();
   } catch (error) {
-    console.error(a.red(`${i18n.t("ccr:ccrRestartFailed")}:`), error.message || error);
-    if (process__default.env.DEBUG) {
-      console.error("Full error:", error);
+    console.error("Failed to set onboarding flag", error);
+  }
+  const verification = readJsonConfig(SETTINGS_FILE);
+  if (verification?.env) {
+    const envKey = apiConfig.authType === "api_key" ? "ANTHROPIC_API_KEY" : "ANTHROPIC_AUTH_TOKEN";
+    if (verification.env[envKey] !== apiConfig.key) {
+      console.error(a.red("\u26A0 API config write verification failed \u2014 retrying..."));
+      const freshSettings = readJsonConfig(SETTINGS_FILE) || settings;
+      if (!freshSettings.env)
+        freshSettings.env = {};
+      if (apiConfig.authType === "api_key") {
+        freshSettings.env.ANTHROPIC_API_KEY = apiConfig.key;
+        delete freshSettings.env.ANTHROPIC_AUTH_TOKEN;
+      } else if (apiConfig.authType === "auth_token") {
+        freshSettings.env.ANTHROPIC_AUTH_TOKEN = apiConfig.key;
+        delete freshSettings.env.ANTHROPIC_API_KEY;
+      }
+      if (apiConfig.url) {
+        freshSettings.env.ANTHROPIC_BASE_URL = apiConfig.url;
+      }
+      writeJsonConfig(SETTINGS_FILE, freshSettings);
     }
   }
+  return apiConfig;
 }
-async function showConfigurationTips(apiKey) {
-  ensureI18nInitialized();
-  console.log(a.bold.cyan(`
-\u{1F4CC} ${i18n.t("ccr:configTips")}:`));
-  console.log(a.green(`  \u2022 ${i18n.t("ccr:advancedConfigTip")}`));
-  console.log(a.green(`  \u2022 ${i18n.t("ccr:manualConfigTip")}`));
-  console.log(a.bold.yellow(`  \u2022 ${i18n.t("ccr:useClaudeCommand")}`));
-  if (apiKey) {
-    console.log(a.bold.green(`  \u2022 ${i18n.t("ccr:ccrUiApiKey") || "CCR UI API Key"}: ${apiKey}`));
-    console.log(a.gray(`    ${i18n.t("ccr:ccrUiApiKeyHint") || "Use this API key to login to CCR UI"}`));
-  }
-  console.log("");
-}
-function createDefaultCcrConfig() {
-  return {
-    LOG: false,
-    CLAUDE_PATH: "",
-    HOST: "127.0.0.1",
-    PORT: 3456,
-    APIKEY: "sk-ccjk-x-ccr",
-    API_TIMEOUT_MS: "600000",
-    PROXY_URL: "",
-    transformers: [],
-    Providers: [],
-    // Empty providers array - user configures in UI
-    Router: {}
-    // Empty router configuration - user configures in UI
+function configureHooks(hooks) {
+  let settings = getDefaultSettings();
+  const existingSettings = readJsonConfig(SETTINGS_FILE);
+  if (existingSettings) {
+    settings = existingSettings;
+  }
+  settings.hooks = {
+    ...settings.hooks || {},
+    ...hooks
   };
+  writeJsonConfig(SETTINGS_FILE, settings);
 }
-async function setupCcrConfiguration() {
-  ensureI18nInitialized();
+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, "override");
+  if (primaryModel?.trim()) {
+    settings.env.ANTHROPIC_MODEL = primaryModel.trim();
+  }
+  if (haikuModel?.trim()) {
+    settings.env.ANTHROPIC_SMALL_FAST_MODEL = 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 existingConfig = readCcrConfig();
-    if (existingConfig) {
-      console.log(a.green(`\u2139 ${i18n.t("ccr:existingCcrConfig")}`));
-      let shouldBackupAndReconfigure = false;
-      try {
-        shouldBackupAndReconfigure = await promptBoolean({
-          message: i18n.t("ccr:overwriteCcrConfig"),
-          defaultValue: false
-        });
-      } catch (error) {
-        if (error.name === "ExitPromptError") {
-          console.log(a.yellow(i18n.t("common:cancelled")));
-          return false;
-        }
-        throw error;
-      }
-      if (!shouldBackupAndReconfigure) {
-        console.log(a.yellow(`${i18n.t("ccr:keepingExistingConfig")}`));
-        await configureCcrProxy(existingConfig);
-        try {
-          const { manageApiKeyApproval } = await import('./claude-config.mjs').then(function (n) { return n.h; });
-          const apiKey = existingConfig.APIKEY || "sk-ccjk-x-ccr";
-          manageApiKeyApproval(apiKey);
-          console.log(a.green(`\u2714 ${i18n.t("ccr:apiKeyApprovalSuccess")}`));
-        } catch (error) {
-          console.error(a.red(`${i18n.t("ccr:apiKeyApprovalFailed")}:`), error);
+    const templateSettings = readJsonConfig(templatePath);
+    if (!templateSettings) {
+      console.error("Failed to read template settings");
+      return;
+    }
+    if (!exists(targetPath)) {
+      copyFile(templatePath, targetPath);
+      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 = { ...templateSettings };
+    const schemaCriticalFields = [
+      "$schema",
+      "attribution",
+      "fileSuggestion",
+      "permissions"
+    ];
+    const removeNullFields = [
+      "plansDirectory",
+      "contextFiles"
+    ];
+    for (const [key, value] of Object.entries(existingSettings)) {
+      if (!schemaCriticalFields.includes(key)) {
+        if (removeNullFields.includes(key) && value === null) {
+          continue;
         }
-        return true;
+        mergedSettings[key] = value;
       }
-      backupCcrConfig();
     }
-    const preset = await selectCcrPreset();
-    if (!preset) {
-      return false;
+    mergedSettings.env = mergedEnv;
+    if (mergedSettings.permissions && mergedSettings.permissions.allow) {
+      mergedSettings.permissions.allow = mergeAndCleanPermissions(
+        templateSettings.permissions?.allow,
+        existingSettings.permissions?.allow
+      );
     }
-    let config;
-    if (preset === "skip") {
-      console.log(a.yellow(`${i18n.t("ccr:skipConfiguring")}`));
-      config = createDefaultCcrConfig();
+    if (mergedSettings.plansDirectory === null) {
+      delete mergedSettings.plansDirectory;
+    }
+    writeJsonConfig(targetPath, mergedSettings);
+  } catch (error) {
+    console.error("Failed to merge settings", error);
+    if (exists(targetPath)) {
+      console.log("Preserving existing settings");
     } else {
-      config = await configureCcrWithPreset(preset);
+      copyFile(templatePath, targetPath);
     }
-    writeCcrConfig(config);
-    console.log(a.green(`\u2714 ${i18n.t("ccr:ccrConfigSuccess")}`));
-    await configureCcrProxy(config);
-    console.log(a.green(`\u2714 ${i18n.t("ccr:proxyConfigSuccess")}`));
-    await restartAndCheckCcrStatus();
-    await showConfigurationTips(config.APIKEY);
-    try {
-      addCompletedOnboarding();
-    } catch (error) {
-      console.error(a.red(i18n.t("errors:failedToSetOnboarding")), error);
+  }
+}
+function getExistingModelConfig() {
+  const settings = readJsonConfig(SETTINGS_FILE);
+  if (!settings) {
+    return null;
+  }
+  const hasModelEnv = MODEL_ENV_KEYS.some((key) => {
+    const value = settings.env?.[key];
+    return value !== void 0 && value !== null && value !== "";
+  });
+  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 getExistingCustomModelConfig() {
+  const settings = readJsonConfig(SETTINGS_FILE);
+  if (!settings || !settings.env) {
+    return null;
+  }
+  const {
+    ANTHROPIC_MODEL,
+    ANTHROPIC_SMALL_FAST_MODEL,
+    ANTHROPIC_DEFAULT_HAIKU_MODEL,
+    ANTHROPIC_DEFAULT_SONNET_MODEL,
+    ANTHROPIC_DEFAULT_OPUS_MODEL
+  } = settings.env;
+  if (!ANTHROPIC_MODEL && !ANTHROPIC_DEFAULT_HAIKU_MODEL && !ANTHROPIC_DEFAULT_SONNET_MODEL && !ANTHROPIC_DEFAULT_OPUS_MODEL) {
+    return null;
+  }
+  return {
+    primaryModel: ANTHROPIC_MODEL,
+    haikuModel: ANTHROPIC_DEFAULT_HAIKU_MODEL || ANTHROPIC_SMALL_FAST_MODEL,
+    sonnetModel: ANTHROPIC_DEFAULT_SONNET_MODEL,
+    opusModel: ANTHROPIC_DEFAULT_OPUS_MODEL
+  };
+}
+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}`;
+  }
+  const frontmatter = "---\nscope: user\n---";
+  writeFileAtomic(claudeFile, `${frontmatter}
+
+${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;
     }
-    try {
-      const { manageApiKeyApproval } = await import('./claude-config.mjs').then(function (n) { return n.h; });
-      const apiKey = config.APIKEY || "sk-ccjk-x-ccr";
-      manageApiKeyApproval(apiKey);
-      console.log(a.green(`\u2714 ${i18n.t("ccr:apiKeyApprovalSuccess")}`));
-    } catch (error) {
-      console.error(a.red(`${i18n.t("ccr:apiKeyApprovalFailed")}:`), error);
+    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) {
-    if (error.name === "ExitPromptError") {
-      console.log(a.yellow(i18n.t("common:cancelled")));
-      return false;
-    }
-    console.error(a.red(`${i18n.t("ccr:ccrConfigFailed")}:`), error);
+    ensureI18nInitialized();
+    console.error(i18n.t("api:officialLoginFailed"), error);
     return false;
   }
 }
-async function configureCcrFeature() {
+async function promptApiConfigurationAction() {
   ensureI18nInitialized();
-  const backupDir = backupExistingConfig();
-  if (backupDir) {
-    console.log(a.gray(`\u2714 ${i18n.t("configuration:backupSuccess")}: ${backupDir}`));
+  const existingConfig = getExistingApiConfig();
+  if (!existingConfig) {
+    return null;
   }
-  await setupCcrConfiguration();
+  console.log(`
+${a.green(`\u2139 ${i18n.t("api:existingApiConfig")}`)}`);
+  console.log(a.gray(`  ${i18n.t("api:apiConfigUrl")}: ${existingConfig.url || "N/A"}`));
+  console.log(a.gray(`  ${i18n.t("api:apiConfigKey")}: ${existingConfig.key ? `***${existingConfig.key.slice(-4)}` : "N/A"}`));
+  console.log(a.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;
 }
 
-export { backupCcrConfig, configureCcrFeature, configureCcrProxy, configureCcrWithPreset, createDefaultCcrConfig, ensureCcrConfigDir, readCcrConfig, restartAndCheckCcrStatus, selectCcrPreset, setupCcrConfiguration, showConfigurationTips, writeCcrConfig };
+const config = {
+  __proto__: null,
+  applyAiLanguageDirective: applyAiLanguageDirective,
+  backupExistingConfig: backupExistingConfig,
+  configureApi: configureApi,
+  configureHooks: configureHooks,
+  copyConfigFiles: copyConfigFiles,
+  ensureClaudeDir: ensureClaudeDir,
+  getExistingApiConfig: getExistingApiConfig,
+  getExistingCustomModelConfig: getExistingCustomModelConfig,
+  getExistingModelConfig: getExistingModelConfig,
+  mergeConfigs: mergeConfigs,
+  mergeSettingsFile: mergeSettingsFile,
+  promptApiConfigurationAction: promptApiConfigurationAction,
+  switchToOfficialLogin: switchToOfficialLogin,
+  updateCustomModel: updateCustomModel,
+  updateDefaultModel: updateDefaultModel
+};
+
+export { getExistingCustomModelConfig as a, backupExistingConfig as b, copyConfigFiles as c, updateDefaultModel as d, applyAiLanguageDirective as e, getExistingApiConfig as f, getExistingModelConfig as g, configureApi as h, clearModelEnv as i, ensureClaudeDir as j, config as k, promptApiConfigurationAction as p, switchToOfficialLogin as s, updateCustomModel as u };