ccjk 14.1.2 → 14.1.5

package/dist/chunks/config.mjs

@@ -1,77 +1,16 @@
+import { fileURLToPath } from 'node:url';
 import a from './index5.mjs';
 import { d as dayjs } from '../shared/ccjk.RyizuzOI.mjs';
 import { i as inquirer } from './index6.mjs';
-import { fileURLToPath } from 'node:url';
-import { ZCF_CONFIG_FILE, ZCF_CONFIG_DIR, SETTINGS_FILE, CLAUDE_VSC_CONFIG_FILE, CLAUDE_DIR, ClAUDE_CONFIG_FILE, AI_OUTPUT_LANGUAGES } from './constants.mjs';
+import { ZCF_CONFIG_FILE, ZCF_CONFIG_DIR, CLAUDE_VSC_CONFIG_FILE, CLAVUE_CONFIG_FILE, CLAVUE_CREDENTIALS_FILE, CLAVUE_SETTINGS_FILE, AI_OUTPUT_LANGUAGES, SETTINGS_FILE } from './constants.mjs';
 import { ensureI18nInitialized, i18n } from './index2.mjs';
-import { existsSync, readFileSync } from 'node:fs';
-import { readJsonConfig, writeJsonConfig, backupJsonConfig } from './json-config.mjs';
-import { i as isWindows, m as getMcpCommand } from './platform.mjs';
+import { existsSync, readFileSync, chmodSync } from 'node:fs';
+import { readDefaultTomlConfig, createDefaultTomlConfig, writeTomlConfig } from './ccjk-config.mjs';
 import { ensureDir, exists, copyFile, copyDir, writeFileAtomic } from './fs-operations.mjs';
-import { m as mergeAndCleanPermissions } from '../shared/ccjk.DScm_NnL.mjs';
+import { readJsonConfig, writeJsonConfig, backupJsonConfig } from './json-config.mjs';
+import { r as resolveClaudeFamilySettingsTarget, m as mergeAndCleanPermissions } from '../shared/ccjk.Ccrqt7u2.mjs';
 import { j as join, d as dirname } from '../shared/ccjk.bQ7Dh1g4.mjs';
-import { readDefaultTomlConfig, createDefaultTomlConfig, writeTomlConfig } from './ccjk-config.mjs';
-
-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 deepClone(obj) {
-  if (obj === null || typeof obj !== "object") {
-    return obj;
-  }
-  if (obj instanceof Date) {
-    return new Date(obj.getTime());
-  }
-  if (Array.isArray(obj)) {
-    return obj.map((item) => deepClone(item));
-  }
-  if (isPlainObject(obj)) {
-    const cloned = {};
-    for (const key in obj) {
-      cloned[key] = deepClone(obj[key]);
-    }
-    return cloned;
-  }
-  return obj;
-}
+import { i as isWindows, m as getMcpCommand } from './platform.mjs';
 
 class ClaudeCodeConfigManager {
   static CONFIG_FILE = ZCF_CONFIG_FILE;
@@ -263,14 +202,16 @@ class ClaudeCodeConfigManager {
   static async applyProfileSettings(profile) {
     const { ensureI18nInitialized, i18n } = await import('./index2.mjs');
     ensureI18nInitialized();
+    const target = resolveClaudeFamilySettingsTarget();
     try {
       if (!profile) {
         const { switchToOfficialLogin } = await Promise.resolve().then(function () { return config; });
-        switchToOfficialLogin();
+        switchToOfficialLogin(target.codeTool);
         return;
       }
       const { readJsonConfig: readJsonConfig2, writeJsonConfig } = await import('./json-config.mjs');
-      const settings = readJsonConfig2(SETTINGS_FILE) || {};
+      const settings = readJsonConfig2(target.settingsFile) || {};
+      clearLegacyTopLevelRuntimeSettings(settings);
       if (!settings.env)
         settings.env = {};
       let shouldRestartCcr = false;
@@ -310,13 +251,14 @@ class ClaudeCodeConfigManager {
         sonnetModel: profile.defaultSonnetModel,
         opusModel: profile.defaultOpusModel
       }, modelMode);
-      writeJsonConfig(SETTINGS_FILE, settings);
+      writeJsonConfig(target.settingsFile, settings);
       const { setPrimaryApiKey, addCompletedOnboarding } = await Promise.resolve().then(function () { return claudeConfig; });
-      setPrimaryApiKey();
-      addCompletedOnboarding();
-      let verifiedSettings = readJsonConfig2(SETTINGS_FILE) || {};
+      setPrimaryApiKey(target.codeTool);
+      addCompletedOnboarding(target.codeTool);
+      let verifiedSettings = readJsonConfig2(target.settingsFile) || {};
       if (!this.settingsMatchProfile(verifiedSettings, profile)) {
-        const repairedSettings = readJsonConfig2(SETTINGS_FILE) || {};
+        const repairedSettings = readJsonConfig2(target.settingsFile) || {};
+        clearLegacyTopLevelRuntimeSettings(repairedSettings);
         repairedSettings.env = repairedSettings.env || {};
         if (profile?.authType === "api_key") {
           repairedSettings.env.ANTHROPIC_API_KEY = profile.apiKey;
@@ -337,8 +279,8 @@ class ClaudeCodeConfigManager {
           sonnetModel: profile?.defaultSonnetModel,
           opusModel: profile?.defaultOpusModel
         }, profile ? modelMode : "reset");
-        writeJsonConfig(SETTINGS_FILE, repairedSettings);
-        verifiedSettings = readJsonConfig2(SETTINGS_FILE) || {};
+        writeJsonConfig(target.settingsFile, repairedSettings);
+        verifiedSettings = readJsonConfig2(target.settingsFile) || {};
       }
       if (!this.settingsMatchProfile(verifiedSettings, profile)) {
         throw new Error("settings.json verification failed after applying current profile");
@@ -849,15 +791,83 @@ const claudeCodeConfigManager = {
   ClaudeCodeConfigManager: ClaudeCodeConfigManager
 };
 
-function readMcpConfig() {
-  return readJsonConfig(ClAUDE_CONFIG_FILE);
+function mergeArraysUnique(arr1, arr2) {
+  const combined = [...arr1 || [], ...arr2 || []];
+  return [...new Set(combined)];
 }
-function writeMcpConfig(config) {
-  writeJsonConfig(ClAUDE_CONFIG_FILE, config);
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && value.constructor === Object && Object.prototype.toString.call(value) === "[object Object]";
 }
-function backupMcpConfig() {
-  const backupBaseDir = join(CLAUDE_DIR, "backup");
-  return backupJsonConfig(ClAUDE_CONFIG_FILE, backupBaseDir);
+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 deepClone(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepClone(item));
+  }
+  if (isPlainObject(obj)) {
+    const cloned = {};
+    for (const key in obj) {
+      cloned[key] = deepClone(obj[key]);
+    }
+    return cloned;
+  }
+  return obj;
+}
+
+function readMcpConfig(codeTool) {
+  return readJsonConfig(resolveClaudeFamilySettingsTarget(codeTool).runtimeConfigFile);
+}
+function writeMcpConfig(config, codeTool) {
+  writeJsonConfig(resolveClaudeFamilySettingsTarget(codeTool).runtimeConfigFile, config);
+}
+function backupMcpConfig(codeTool) {
+  const target = resolveClaudeFamilySettingsTarget(codeTool);
+  const backupBaseDir = join(target.configDir, target.runtimeBackupDirName);
+  return backupJsonConfig(target.runtimeConfigFile, backupBaseDir);
+}
+function readClavueConfig() {
+  return readJsonConfig(CLAVUE_CONFIG_FILE);
+}
+function writeClavueConfig(config) {
+  writeJsonConfig(CLAVUE_CONFIG_FILE, config);
 }
 function mergeMcpServers(existing, newServers) {
   const config = existing || { mcpServers: {} };
@@ -911,9 +921,9 @@ function fixWindowsMcpConfig(config) {
   }
   return fixed;
 }
-function addCompletedOnboarding() {
+function addCompletedOnboarding(codeTool) {
   try {
-    let config = readMcpConfig();
+    let config = readMcpConfig(codeTool);
     if (!config) {
       config = { mcpServers: {} };
     }
@@ -921,7 +931,7 @@ function addCompletedOnboarding() {
       return;
     }
     config.hasCompletedOnboarding = true;
-    writeMcpConfig(config);
+    writeMcpConfig(config, codeTool);
   } catch (error) {
     console.error("Failed to add onboarding flag", error);
     throw error;
@@ -954,21 +964,24 @@ function ensureApiKeyApproved(config, apiKey) {
   }
   return updatedConfig;
 }
-function manageApiKeyApproval(apiKey) {
+function manageApiKeyApproval(apiKey, codeTool) {
   try {
-    let config = readMcpConfig();
+    let config = readMcpConfig(codeTool);
     if (!config) {
       config = { mcpServers: {} };
     }
     const updatedConfig = ensureApiKeyApproved(config, apiKey);
-    writeMcpConfig(updatedConfig);
+    writeMcpConfig(updatedConfig, codeTool);
   } catch (error) {
     ensureI18nInitialized();
     console.error(i18n.t("mcp:apiKeyApprovalFailed"), error);
   }
 }
-function setPrimaryApiKey() {
+function setPrimaryApiKey(codeTool) {
   try {
+    if (resolveClaudeFamilySettingsTarget(codeTool).codeTool !== "claude-code") {
+      return;
+    }
     let config = readJsonConfig(CLAUDE_VSC_CONFIG_FILE);
     if (!config) {
       config = {};
@@ -980,16 +993,310 @@ function setPrimaryApiKey() {
     console.error(i18n.t("mcp:primaryApiKeySetFailed"), error);
   }
 }
+function normalizeMyclaudeProviderProfile(profile) {
+  return {
+    ...profile,
+    ...describeMyclaudeProviderProfile(profile)
+  };
+}
+function normalizeClavueBaseUrl(url) {
+  if (typeof url !== "string") {
+    return void 0;
+  }
+  const normalized = url.trim().replace(/\/v1(?:\/messages|\/responses)?\/?$/i, "").replace(/\/+$/, "");
+  return normalized || void 0;
+}
+function normalizeClavueAuthType(authType) {
+  return authType === "auth_token" ? "auth_token" : "api_key";
+}
+function inferClavueProviderId(provider, baseUrl) {
+  const providerId = typeof provider === "string" ? provider.trim() : "";
+  if (providerId && providerId !== "ccr_proxy") {
+    return providerId;
+  }
+  if (baseUrl === "https://api.anthropic.com") {
+    return "anthropic";
+  }
+  return "custom";
+}
+function isOpenAiFamilyModel(model) {
+  return /^(?:gpt-|o\d|codex|kimi|glm|moonshot|deepseek|qwen|doubao|yi-|minimax)/i.test(model.trim());
+}
+function inferClavueModelMode(profile) {
+  if (profile.authType === "ccr_proxy" || profile.mode === "ccr-proxy") {
+    return "hybrid_compatible";
+  }
+  const routedModels = [
+    profile.primaryModel,
+    profile.model,
+    profile.defaultHaikuModel,
+    profile.fastModel,
+    profile.defaultSonnetModel,
+    profile.defaultOpusModel
+  ].filter((model) => typeof model === "string" && model.trim().length > 0);
+  if (routedModels.length > 0 && routedModels.every(isOpenAiFamilyModel)) {
+    return "openai_native";
+  }
+  if (routedModels.length > 0 && !routedModels.some(isOpenAiFamilyModel)) {
+    return "anthropic_native";
+  }
+  if (profile.mode === "openai-native") {
+    return "openai_native";
+  }
+  if (!profile.baseUrl || profile.provider === "anthropic" || profile.mode === "official") {
+    return "anthropic_native";
+  }
+  return routedModels.some(isOpenAiFamilyModel) ? "hybrid_compatible" : "anthropic_native";
+}
+function isCcjkClavueProfile(profile) {
+  return profile.provenance?.kind === "imported" && profile.provenance.sourceId === "ccjk";
+}
+const CCJK_CLAVUE_PROFILE_ID_PREFIX = "ccjk-";
+function getSourceProfileId(profile) {
+  const id = typeof profile.id === "string" ? profile.id.trim() : "";
+  if (id) {
+    return id;
+  }
+  const name = typeof profile.name === "string" ? profile.name.trim() : "";
+  return name || "profile";
+}
+function getCcjkExternalProfileId(profile) {
+  const externalProfileId = profile.provenance?.externalProfileId;
+  if (typeof externalProfileId === "string" && externalProfileId.trim()) {
+    return externalProfileId.trim();
+  }
+  const profileId = typeof profile.id === "string" ? profile.id.trim() : "";
+  if (profileId.startsWith(CCJK_CLAVUE_PROFILE_ID_PREFIX) && profileId.length > CCJK_CLAVUE_PROFILE_ID_PREFIX.length) {
+    return profileId.slice(CCJK_CLAVUE_PROFILE_ID_PREFIX.length);
+  }
+  return profileId || "profile";
+}
+function getCcjkClavueProfileId(externalProfileId) {
+  const cleanExternalId = externalProfileId.trim() || "profile";
+  return cleanExternalId.startsWith(CCJK_CLAVUE_PROFILE_ID_PREFIX) ? cleanExternalId : `${CCJK_CLAVUE_PROFILE_ID_PREFIX}${cleanExternalId}`;
+}
+function getUniqueClavueProfileId(baseProfileId, reservedProfileIds) {
+  if (!reservedProfileIds.has(baseProfileId)) {
+    return baseProfileId;
+  }
+  let index = 2;
+  let candidate = `${baseProfileId}-${index}`;
+  while (reservedProfileIds.has(candidate)) {
+    index += 1;
+    candidate = `${baseProfileId}-${index}`;
+  }
+  return candidate;
+}
+function buildExistingCcjkProfileByExternalId(existingProfiles) {
+  const existingByExternalId = /* @__PURE__ */ new Map();
+  for (const profile of existingProfiles) {
+    if (!isCcjkClavueProfile(profile)) {
+      continue;
+    }
+    const externalProfileId = getCcjkExternalProfileId(profile);
+    const current = existingByExternalId.get(externalProfileId);
+    if (!current || profile.id.startsWith(CCJK_CLAVUE_PROFILE_ID_PREFIX)) {
+      existingByExternalId.set(externalProfileId, profile);
+    }
+  }
+  return existingByExternalId;
+}
+function resolveClavueProviderProfiles(profiles, existingProfiles) {
+  const existingCcjkByExternalId = buildExistingCcjkProfileByExternalId(existingProfiles);
+  const reservedProfileIds = new Set(existingProfiles.filter((profile) => !isCcjkClavueProfile(profile)).map((profile) => profile.id));
+  return profiles.map((profile) => {
+    const externalProfileId = getSourceProfileId(profile);
+    const existing = existingCcjkByExternalId.get(externalProfileId);
+    const canReuseExistingManagedId = Boolean(
+      existing && existing.id.startsWith(CCJK_CLAVUE_PROFILE_ID_PREFIX) && !reservedProfileIds.has(existing.id)
+    );
+    const clavueProfileId = canReuseExistingManagedId ? existing.id : getUniqueClavueProfileId(getCcjkClavueProfileId(externalProfileId), reservedProfileIds);
+    reservedProfileIds.add(clavueProfileId);
+    return {
+      source: profile,
+      clavueProfileId,
+      existing
+    };
+  });
+}
+function findResolvedClavueProfile(profiles, profileId) {
+  const requestedProfileId = typeof profileId === "string" ? profileId.trim() : "";
+  if (!requestedProfileId) {
+    return void 0;
+  }
+  return profiles.find((profile) => {
+    return profile.clavueProfileId === requestedProfileId || getSourceProfileId(profile.source) === requestedProfileId;
+  });
+}
+function resolveClavueActiveProviderProfileId(config, activeProfileId) {
+  const requestedProfileId = typeof activeProfileId === "string" ? activeProfileId.trim() : "";
+  if (!requestedProfileId) {
+    return void 0;
+  }
+  const existingProfiles = getClavueProviderProfiles(config);
+  if (existingProfiles.some((profile) => profile.id === requestedProfileId)) {
+    return requestedProfileId;
+  }
+  return existingProfiles.find((profile) => {
+    return isCcjkClavueProfile(profile) && getCcjkExternalProfileId(profile) === requestedProfileId;
+  })?.id || requestedProfileId;
+}
+function createClavueModelRouting(profile) {
+  const primaryModel = (profile.primaryModel || profile.model || "").trim();
+  const haikuModel = (profile.defaultHaikuModel || profile.fastModel || "").trim();
+  const sonnetModel = (profile.defaultSonnetModel || primaryModel).trim();
+  const opusModel = (profile.defaultOpusModel || primaryModel).trim();
+  const executionModel = sonnetModel || primaryModel;
+  return {
+    presetId: "custom",
+    primaryModel,
+    subagentModel: executionModel && executionModel !== primaryModel ? executionModel : "",
+    smallFastModel: haikuModel,
+    planModel: opusModel || primaryModel,
+    exploreModel: executionModel,
+    generalModel: executionModel,
+    teamModel: executionModel,
+    guideModel: opusModel || primaryModel
+  };
+}
+function toClavueProviderProfile(profile, clavueProfileId, existing) {
+  const now = Date.now();
+  const normalizedBaseUrl = normalizeClavueBaseUrl(profile.baseUrl);
+  const createdAt = typeof existing?.createdAt === "number" ? existing.createdAt : now;
+  return {
+    id: clavueProfileId,
+    name: profile.name,
+    providerId: inferClavueProviderId(profile.provider, normalizedBaseUrl),
+    modelMode: inferClavueModelMode(profile),
+    ...normalizedBaseUrl ? { baseUrl: normalizedBaseUrl } : {},
+    authType: normalizeClavueAuthType(profile.authType),
+    modelRouting: createClavueModelRouting(profile),
+    provenance: {
+      kind: "imported",
+      sourceId: "ccjk",
+      importedAt: typeof existing?.provenance?.importedAt === "number" ? existing.provenance.importedAt : createdAt,
+      externalProfileId: getSourceProfileId(profile)
+    },
+    createdAt,
+    updatedAt: now
+  };
+}
+function readClavueCredentialsConfig() {
+  return readJsonConfig(CLAVUE_CREDENTIALS_FILE) || {};
+}
+function writeClavueCredentialsConfig(config) {
+  writeJsonConfig(CLAVUE_CREDENTIALS_FILE, config);
+  try {
+    chmodSync(CLAVUE_CREDENTIALS_FILE, 384);
+  } catch {
+  }
+}
+function syncClavueProviderCredentials(profiles, replaceProfileIds = /* @__PURE__ */ new Set()) {
+  const existingCredentials = readClavueCredentialsConfig();
+  const providerProfiles = { ...existingCredentials.providerProfiles || {} };
+  for (const profileId of replaceProfileIds) {
+    delete providerProfiles[profileId];
+  }
+  for (const profile of profiles) {
+    const credential = typeof profile.source.apiKey === "string" ? profile.source.apiKey.trim() : "";
+    if (!profile.clavueProfileId || !credential) {
+      continue;
+    }
+    providerProfiles[profile.clavueProfileId] = {
+      credential,
+      authType: normalizeClavueAuthType(profile.source.authType)
+    };
+  }
+  writeClavueCredentialsConfig({
+    ...existingCredentials,
+    providerProfiles: Object.keys(providerProfiles).length > 0 ? providerProfiles : void 0
+  });
+}
+function getClavueProviderProfiles(config) {
+  return Array.isArray(config?.clavueProviderProfiles) ? config.clavueProviderProfiles : [];
+}
+function getLegacyMyclaudeProviderProfiles(config) {
+  return Array.isArray(config?.myclaudeProviderProfiles) ? config.myclaudeProviderProfiles : [];
+}
+function toLegacyProviderProfile(profile) {
+  const routing = profile.modelRouting || createClavueModelRouting({ id: profile.id, name: profile.name, provider: profile.providerId });
+  return {
+    id: isCcjkClavueProfile(profile) ? getCcjkExternalProfileId(profile) : profile.id,
+    name: profile.name,
+    provider: profile.providerId || "custom",
+    baseUrl: profile.baseUrl,
+    model: routing.primaryModel,
+    fastModel: routing.smallFastModel,
+    authType: profile.authType,
+    primaryModel: routing.primaryModel,
+    defaultHaikuModel: routing.smallFastModel,
+    defaultSonnetModel: routing.generalModel || routing.subagentModel,
+    defaultOpusModel: routing.planModel,
+    ...describeMyclaudeProviderProfile({
+      authType: profile.authType,
+      baseUrl: profile.baseUrl,
+      mode: profile.modelMode === "openai_native" ? "openai-native" : profile.modelMode === "hybrid_compatible" ? "ccr-proxy" : "official"
+    })
+  };
+}
+function getClavueActiveProfile(config) {
+  const activeId = config?.clavueActiveProviderProfileId || config?.myclaudeActiveProviderProfileId || "";
+  const legacyProfiles = getLegacyMyclaudeProviderProfiles(config);
+  const activeLegacyProfile = legacyProfiles.find((profile) => profile.id === activeId);
+  if (activeLegacyProfile) {
+    return activeLegacyProfile;
+  }
+  const nativeProfiles = getClavueProviderProfiles(config);
+  const activeNativeProfile = nativeProfiles.find((profile) => profile.id === activeId);
+  if (activeNativeProfile) {
+    return toLegacyProviderProfile(activeNativeProfile);
+  }
+  return nativeProfiles.map(toLegacyProviderProfile).find((profile) => profile.id === activeId) || null;
+}
 function setMyclaudeProviderProfiles(profiles, activeProfileId) {
-  const config = readMcpConfig() || { mcpServers: {} };
-  config.myclaudeProviderProfiles = profiles;
-  config.myclaudeActiveProviderProfileId = activeProfileId ?? profiles[0]?.id;
-  writeMcpConfig(config);
+  const config = readClavueConfig() || { mcpServers: {} };
+  const normalizedProfiles = profiles.map(normalizeMyclaudeProviderProfile);
+  const existingProfiles = getClavueProviderProfiles(config);
+  const resolvedProfiles = resolveClavueProviderProfiles(normalizedProfiles, existingProfiles);
+  const selectedProfile = findResolvedClavueProfile(
+    resolvedProfiles,
+    activeProfileId ?? (normalizedProfiles[0] ? getSourceProfileId(normalizedProfiles[0]) : void 0)
+  );
+  const nextActiveProfileId = selectedProfile?.clavueProfileId;
+  const existingCcjkProfileIds = new Set(existingProfiles.filter(isCcjkClavueProfile).map((profile) => profile.id));
+  const preservedProfiles = existingProfiles.filter((profile) => !isCcjkClavueProfile(profile));
+  const preservedProfileIds = new Set(preservedProfiles.map((profile) => profile.id));
+  const replacedCredentialIds = new Set([...existingCcjkProfileIds].filter((profileId) => !preservedProfileIds.has(profileId)));
+  const clavueProfiles = resolvedProfiles.map((profile) => toClavueProviderProfile(
+    profile.source,
+    profile.clavueProfileId,
+    profile.existing
+  ));
+  config.clavueProviderProfiles = [...preservedProfiles, ...clavueProfiles];
+  if (nextActiveProfileId) {
+    config.clavueActiveProviderProfileId = nextActiveProfileId;
+  } else {
+    delete config.clavueActiveProviderProfileId;
+  }
+  delete config.myclaudeProviderProfiles;
+  delete config.myclaudeActiveProviderProfileId;
+  writeClavueConfig(config);
+  syncClavueProviderCredentials(resolvedProfiles, replacedCredentialIds);
+  const activeProfile = selectedProfile?.source || null;
+  syncMyclaudeActiveProfileToSettings(activeProfile);
+  return nextActiveProfileId;
 }
 function setMyclaudeActiveProviderProfile(activeProfileId) {
-  const config = readMcpConfig() || { mcpServers: {} };
-  config.myclaudeActiveProviderProfileId = activeProfileId ?? "";
-  writeMcpConfig(config);
+  const config = readClavueConfig() || { mcpServers: {} };
+  const nextActiveProfileId = resolveClavueActiveProviderProfileId(config, activeProfileId);
+  if (nextActiveProfileId) {
+    config.clavueActiveProviderProfileId = nextActiveProfileId;
+  } else {
+    delete config.clavueActiveProviderProfileId;
+  }
+  delete config.myclaudeActiveProviderProfileId;
+  writeClavueConfig(config);
+  syncMyclaudeActiveProfileToSettings(getClavueActiveProfile(config));
 }
 function detectMyclaudeProviderMode(profile) {
   if (profile.authType === "ccr_proxy") {
@@ -1046,20 +1353,13 @@ function toMyclaudeProviderProfile(profile, existing) {
   };
 }
 function syncMyclaudeActiveProfileToSettings(profile) {
-  const settings = readJsonConfig(SETTINGS_FILE) || {};
+  const settings = readJsonConfig(CLAVUE_SETTINGS_FILE) || {};
   settings.env = settings.env || {};
-  if (profile?.authType === "auth_token") {
-    settings.env.ANTHROPIC_AUTH_TOKEN = profile.apiKey;
-    delete settings.env.ANTHROPIC_API_KEY;
-  } else if (profile?.apiKey) {
-    settings.env.ANTHROPIC_API_KEY = profile.apiKey;
-    delete settings.env.ANTHROPIC_AUTH_TOKEN;
-  } else {
-    delete settings.env.ANTHROPIC_API_KEY;
-    delete settings.env.ANTHROPIC_AUTH_TOKEN;
-  }
+  clearLegacyTopLevelRuntimeSettings(settings);
+  delete settings.env.ANTHROPIC_API_KEY;
+  delete settings.env.ANTHROPIC_AUTH_TOKEN;
   if (profile?.baseUrl) {
-    settings.env.ANTHROPIC_BASE_URL = profile.baseUrl;
+    settings.env.ANTHROPIC_BASE_URL = normalizeClavueBaseUrl(profile.baseUrl);
   } else {
     delete settings.env.ANTHROPIC_BASE_URL;
   }
@@ -1069,7 +1369,26 @@ function syncMyclaudeActiveProfileToSettings(profile) {
     sonnetModel: typeof profile?.defaultSonnetModel === "string" ? profile.defaultSonnetModel : void 0,
     opusModel: typeof profile?.defaultOpusModel === "string" ? profile.defaultOpusModel : void 0
   }, profile ? "override" : "reset");
-  writeJsonConfig(SETTINGS_FILE, settings);
+  const primaryModel = typeof profile?.primaryModel === "string" ? profile.primaryModel.trim() : typeof profile?.model === "string" ? profile.model.trim() : "";
+  const subagentModel = typeof profile?.defaultSonnetModel === "string" ? profile.defaultSonnetModel.trim() : "";
+  if (primaryModel) {
+    settings.env.ANTHROPIC_MODEL = primaryModel;
+    settings.env.ANTHROPIC_CUSTOM_MODEL_OPTION = primaryModel;
+    settings.model = primaryModel;
+  } else if (profile) {
+    delete settings.env.ANTHROPIC_MODEL;
+    delete settings.env.ANTHROPIC_CUSTOM_MODEL_OPTION;
+    delete settings.model;
+  } else {
+    delete settings.env.ANTHROPIC_CUSTOM_MODEL_OPTION;
+    delete settings.model;
+  }
+  if (subagentModel) {
+    settings.env.CLAUDE_CODE_SUBAGENT_MODEL = subagentModel;
+  } else {
+    delete settings.env.CLAUDE_CODE_SUBAGENT_MODEL;
+  }
+  writeJsonConfig(CLAVUE_SETTINGS_FILE, settings);
 }
 function syncMyclaudeProviderProfilesFromClaudeConfig(configData) {
   if (!configData) {
@@ -1080,15 +1399,15 @@ function syncMyclaudeProviderProfilesFromClaudeConfig(configData) {
       profiles: []
     };
   }
-  const existingProfiles = readMcpConfig()?.myclaudeProviderProfiles || [];
+  const existingConfig = readClavueConfig();
+  const existingProfiles = getLegacyMyclaudeProviderProfiles(existingConfig).length > 0 ? getLegacyMyclaudeProviderProfiles(existingConfig) : getClavueProviderProfiles(existingConfig).map(toLegacyProviderProfile);
   const existingById = new Map(existingProfiles.map((profile) => [String(profile.id), profile]));
   const profiles = Object.entries(configData.profiles).map(([id, profile]) => toMyclaudeProviderProfile({ ...profile, id }, existingById.get(id)));
   const activeProfileId = configData.currentProfileId ?? "";
   const activeProfile = profiles.find((profile) => profile.id === activeProfileId) || null;
-  setMyclaudeProviderProfiles(profiles, activeProfileId);
-  syncMyclaudeActiveProfileToSettings(activeProfile);
+  const activeClavueProfileId = setMyclaudeProviderProfiles(profiles, activeProfileId);
   return {
-    activeProfileId,
+    activeProfileId: activeClavueProfileId || "",
     activeProfile,
     profiles
   };
@@ -1098,18 +1417,49 @@ function syncMyclaudeProviderProfilesFromCurrentClaudeConfig() {
   return syncMyclaudeProviderProfilesFromClaudeConfig(configData);
 }
 function clearMyclaudeProviderProfiles() {
-  const config = readMcpConfig();
+  const config = readClavueConfig();
+  let preservedActiveProfile = null;
   if (config) {
+    const existingProfiles = getClavueProviderProfiles(config);
+    const removedIds = /* @__PURE__ */ new Set([
+      ...existingProfiles.filter(isCcjkClavueProfile).map((profile) => profile.id),
+      ...getLegacyMyclaudeProviderProfiles(config).map((profile) => profile.id)
+    ]);
+    const preservedProfiles = existingProfiles.filter((profile) => !removedIds.has(profile.id));
+    const currentActiveId = config.clavueActiveProviderProfileId || config.myclaudeActiveProviderProfileId;
+    const nextActiveId = preservedProfiles.some((profile) => profile.id === currentActiveId) ? currentActiveId : preservedProfiles[0]?.id;
+    if (preservedProfiles.length > 0) {
+      config.clavueProviderProfiles = preservedProfiles;
+      config.clavueActiveProviderProfileId = nextActiveId;
+      preservedActiveProfile = preservedProfiles.find((profile) => profile.id === nextActiveId) ? toLegacyProviderProfile(preservedProfiles.find((profile) => profile.id === nextActiveId)) : null;
+    } else {
+      delete config.clavueProviderProfiles;
+      delete config.clavueActiveProviderProfileId;
+    }
     delete config.myclaudeProviderProfiles;
     delete config.myclaudeActiveProviderProfileId;
-    writeMcpConfig(config);
+    writeClavueConfig(config);
+    if (removedIds.size > 0) {
+      const credentials = readClavueCredentialsConfig();
+      if (credentials.providerProfiles) {
+        const nextProviderProfiles = { ...credentials.providerProfiles };
+        for (const profileId of removedIds) {
+          delete nextProviderProfiles[profileId];
+        }
+        writeClavueCredentialsConfig({
+          ...credentials,
+          providerProfiles: Object.keys(nextProviderProfiles).length > 0 ? nextProviderProfiles : void 0
+        });
+      }
+    }
   }
-  syncMyclaudeActiveProfileToSettings(null);
+  syncMyclaudeActiveProfileToSettings(preservedActiveProfile);
 }
-function syncMcpPermissions() {
-  const mcpConfig = readMcpConfig();
+function syncMcpPermissions(codeTool) {
+  const target = resolveClaudeFamilySettingsTarget(codeTool);
+  const mcpConfig = readMcpConfig(codeTool);
   const mcpServerIds = Object.keys(mcpConfig?.mcpServers || {});
-  const settingsPath = join(CLAUDE_DIR, "settings.json");
+  const settingsPath = target.settingsFile;
   if (!existsSync(settingsPath))
     return;
   try {
@@ -1138,6 +1488,7 @@ const claudeConfig = {
   fixWindowsMcpConfig: fixWindowsMcpConfig,
   manageApiKeyApproval: manageApiKeyApproval,
   mergeMcpServers: mergeMcpServers,
+  readClavueConfig: readClavueConfig,
   readMcpConfig: readMcpConfig,
   replaceMcpServers: replaceMcpServers,
   setMyclaudeActiveProviderProfile: setMyclaudeActiveProviderProfile,
@@ -1146,6 +1497,7 @@ const claudeConfig = {
   syncMcpPermissions: syncMcpPermissions,
   syncMyclaudeProviderProfilesFromClaudeConfig: syncMyclaudeProviderProfilesFromClaudeConfig,
   syncMyclaudeProviderProfilesFromCurrentClaudeConfig: syncMyclaudeProviderProfilesFromCurrentClaudeConfig,
+  writeClavueConfig: writeClavueConfig,
   writeMcpConfig: writeMcpConfig
 };
 
@@ -1168,36 +1520,47 @@ function clearModelEnv(env, mode = "reset") {
 }
 
 const BUILTIN_MODEL_VALUES = ["opus", "sonnet", "sonnet[1m]"];
+function clearLegacyTopLevelRuntimeSettings(settings) {
+  delete settings.baseUrl;
+  delete settings.apiProvider;
+  delete settings.apiUrl;
+  delete settings.apiKey;
+  delete settings.authToken;
+  delete settings.defaultModel;
+  delete settings.preferredModel;
+}
 function hasAdaptiveRoutingEnv(settings) {
   return Boolean(
     settings.env?.ANTHROPIC_DEFAULT_HAIKU_MODEL || settings.env?.ANTHROPIC_DEFAULT_SONNET_MODEL || settings.env?.ANTHROPIC_DEFAULT_OPUS_MODEL
   );
 }
-function ensureClaudeDir() {
-  ensureDir(CLAUDE_DIR);
+function ensureClaudeDir(codeTool) {
+  ensureDir(resolveClaudeFamilySettingsTarget(codeTool).configDir);
 }
-function backupExistingConfig() {
-  if (!exists(CLAUDE_DIR)) {
+function backupExistingConfig(codeTool) {
+  const target = resolveClaudeFamilySettingsTarget(codeTool);
+  if (!exists(target.configDir)) {
     return null;
   }
   const timestamp = dayjs().format("YYYY-MM-DD_HH-mm-ss");
-  const backupBaseDir = join(CLAUDE_DIR, "backup");
+  const backupBaseDir = join(target.configDir, target.runtimeBackupDirName);
   const backupDir = join(backupBaseDir, `backup_${timestamp}`);
   ensureDir(backupDir);
   const filter = (path) => {
-    return !path.includes("/backup");
+    return !path.includes("/backup") && !path.includes("/backups");
   };
-  copyDir(CLAUDE_DIR, backupDir, { filter });
+  copyDir(target.configDir, backupDir, { filter });
   return backupDir;
 }
-function copyConfigFiles(onlyMd = false) {
+function copyConfigFiles(onlyMd = false, codeTool) {
+  const target = resolveClaudeFamilySettingsTarget(codeTool);
   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");
+    const destSettingsPath = target.settingsFile;
     if (exists(baseSettingsPath)) {
       mergeSettingsFile(baseSettingsPath, destSettingsPath);
     }
@@ -1215,10 +1578,11 @@ function getDefaultSettings() {
     return {};
   }
 }
-function configureApi(apiConfig) {
+function configureApi(apiConfig, codeTool) {
   if (!apiConfig)
     return null;
-  const existingSettings = readJsonConfig(SETTINGS_FILE);
+  const target = resolveClaudeFamilySettingsTarget(codeTool);
+  const existingSettings = readJsonConfig(target.settingsFile);
   let settings;
   if (existingSettings) {
     settings = existingSettings;
@@ -1228,6 +1592,7 @@ function configureApi(apiConfig) {
   if (!settings.env) {
     settings.env = {};
   }
+  clearLegacyTopLevelRuntimeSettings(settings);
   if (apiConfig.authType === "api_key") {
     settings.env.ANTHROPIC_API_KEY = apiConfig.key;
     delete settings.env.ANTHROPIC_AUTH_TOKEN;
@@ -1238,26 +1603,27 @@ function configureApi(apiConfig) {
   if (apiConfig.url) {
     settings.env.ANTHROPIC_BASE_URL = apiConfig.url;
   }
-  writeJsonConfig(SETTINGS_FILE, settings);
-  if (apiConfig.authType) {
+  writeJsonConfig(target.settingsFile, settings);
+  if (apiConfig.authType && target.codeTool === "claude-code") {
     try {
-      setPrimaryApiKey();
+      setPrimaryApiKey(target.codeTool);
     } catch (error) {
       ensureI18nInitialized();
       console.error(i18n.t("mcp:primaryApiKeySetFailed"), error);
     }
   }
   try {
-    addCompletedOnboarding();
+    addCompletedOnboarding(target.codeTool);
   } catch (error) {
     console.error("Failed to set onboarding flag", error);
   }
-  const verification = readJsonConfig(SETTINGS_FILE);
+  const verification = readJsonConfig(target.settingsFile);
   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;
+      const freshSettings = readJsonConfig(target.settingsFile) || settings;
+      clearLegacyTopLevelRuntimeSettings(freshSettings);
       if (!freshSettings.env)
         freshSettings.env = {};
       if (apiConfig.authType === "api_key") {
@@ -1270,7 +1636,7 @@ function configureApi(apiConfig) {
       if (apiConfig.url) {
         freshSettings.env.ANTHROPIC_BASE_URL = apiConfig.url;
       }
-      writeJsonConfig(SETTINGS_FILE, freshSettings);
+      writeJsonConfig(target.settingsFile, freshSettings);
     }
   }
   return apiConfig;
@@ -1320,22 +1686,24 @@ function overwriteModelSettings(settings, {
   }
   return settings;
 }
-function updateCustomModel(primaryModel, haikuModel, sonnetModel, opusModel) {
+function updateCustomModel(primaryModel, haikuModel, sonnetModel, opusModel, codeTool) {
   if (!primaryModel?.trim() && !haikuModel?.trim() && !sonnetModel?.trim() && !opusModel?.trim()) {
     return;
   }
+  const target = resolveClaudeFamilySettingsTarget(codeTool);
   let settings = getDefaultSettings();
-  const existingSettings = readJsonConfig(SETTINGS_FILE);
+  const existingSettings = readJsonConfig(target.settingsFile);
   if (existingSettings) {
     settings = existingSettings;
   }
+  clearLegacyTopLevelRuntimeSettings(settings);
   overwriteModelSettings(settings, {
     primaryModel,
     haikuModel,
     sonnetModel,
     opusModel
   }, "override");
-  writeJsonConfig(SETTINGS_FILE, settings);
+  writeJsonConfig(target.settingsFile, settings);
 }
 function updateDefaultModel(model) {
   let settings = getDefaultSettings();
@@ -1343,6 +1711,7 @@ function updateDefaultModel(model) {
   if (existingSettings) {
     settings = existingSettings;
   }
+  clearLegacyTopLevelRuntimeSettings(settings);
   if (!settings.env) {
     settings.env = {};
   }
@@ -1461,8 +1830,9 @@ function getExistingCustomModelConfig() {
     opusModel: ANTHROPIC_DEFAULT_OPUS_MODEL
   };
 }
-function getExistingApiConfig() {
-  const settings = readJsonConfig(SETTINGS_FILE);
+function getExistingApiConfig(codeTool) {
+  const target = resolveClaudeFamilySettingsTarget(codeTool);
+  const settings = readJsonConfig(target.settingsFile);
   if (!settings || !settings.env) {
     return null;
   }
@@ -1485,8 +1855,9 @@ function getExistingApiConfig() {
     authType
   };
 }
-function applyAiLanguageDirective(aiOutputLang) {
-  const claudeFile = join(CLAUDE_DIR, "CLAUDE.md");
+function applyAiLanguageDirective(aiOutputLang, codeTool) {
+  const target = resolveClaudeFamilySettingsTarget(codeTool);
+  const instructionsFile = target.instructionsFile;
   let directive = "";
   if (aiOutputLang === "custom") {
     return;
@@ -1495,25 +1866,26 @@ function applyAiLanguageDirective(aiOutputLang) {
   } else {
     directive = `Always respond in ${aiOutputLang}`;
   }
-  const frontmatter = "---\nscope: user\n---";
-  writeFileAtomic(claudeFile, `${frontmatter}
-
-${directive}`);
+  const frontmatter = target.codeTool === "clavue" ? "" : "---\nscope: user\n---\n\n";
+  writeFileAtomic(instructionsFile, `${frontmatter}${directive}`);
 }
-function switchToOfficialLogin() {
+function switchToOfficialLogin(codeTool) {
   try {
     ensureI18nInitialized();
-    const settings = readJsonConfig(SETTINGS_FILE) || {};
+    const target = resolveClaudeFamilySettingsTarget(codeTool);
+    const settings = readJsonConfig(target.settingsFile) || {};
     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);
+    writeJsonConfig(target.settingsFile, settings);
+    if (target.codeTool === "claude-code") {
+      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;
@@ -1561,6 +1933,7 @@ const config = {
   __proto__: null,
   applyAiLanguageDirective: applyAiLanguageDirective,
   backupExistingConfig: backupExistingConfig,
+  clearLegacyTopLevelRuntimeSettings: clearLegacyTopLevelRuntimeSettings,
   configureApi: configureApi,
   configureHooks: configureHooks,
   copyConfigFiles: copyConfigFiles,
@@ -1577,4 +1950,4 @@ const config = {
   updateDefaultModel: updateDefaultModel
 };
 
-export { syncMcpPermissions as A, buildMyclaudeProviderPresentation as B, ClaudeCodeConfigManager as C, config as D, claudeCodeConfigManager as E, claudeConfig as F, getExistingCustomModelConfig as a, backupExistingConfig as b, updateDefaultModel as c, backupMcpConfig as d, buildMcpServerConfig as e, fixWindowsMcpConfig as f, getExistingModelConfig as g, getExistingApiConfig as h, configureApi as i, syncMyclaudeProviderProfilesFromClaudeConfig as j, copyConfigFiles as k, setPrimaryApiKey as l, mergeMcpServers as m, addCompletedOnboarding as n, deepMerge as o, promptApiConfigurationAction as p, switchToOfficialLogin as q, readMcpConfig as r, setMyclaudeActiveProviderProfile as s, applyAiLanguageDirective as t, updateCustomModel as u, setMyclaudeProviderProfiles as v, writeMcpConfig as w, ensureClaudeDir as x, clearMyclaudeProviderProfiles as y, replaceMcpServers as z };
+export { clearMyclaudeProviderProfiles as A, replaceMcpServers as B, ClaudeCodeConfigManager as C, syncMcpPermissions as D, buildMyclaudeProviderPresentation as E, config as F, claudeCodeConfigManager as G, claudeConfig as H, getExistingCustomModelConfig as a, backupExistingConfig as b, updateDefaultModel as c, backupMcpConfig as d, buildMcpServerConfig as e, fixWindowsMcpConfig as f, getExistingModelConfig as g, getExistingApiConfig as h, configureApi as i, syncMyclaudeProviderProfilesFromClaudeConfig as j, copyConfigFiles as k, deepMerge as l, mergeMcpServers as m, clearLegacyTopLevelRuntimeSettings as n, setPrimaryApiKey as o, promptApiConfigurationAction as p, addCompletedOnboarding as q, readMcpConfig as r, setMyclaudeActiveProviderProfile as s, switchToOfficialLogin as t, updateCustomModel as u, applyAiLanguageDirective as v, writeMcpConfig as w, overwriteModelSettings as x, setMyclaudeProviderProfiles as y, ensureClaudeDir as z };