coding-tool-x 3.7.1 → 3.7.3

package/src/server/services/channels.js

@@ -6,6 +6,12 @@ const { PATHS, NATIVE_PATHS } = require('../../config/paths');
 const { clearNativeOAuth } = require('./native-oauth-adapters');
 const { isWindowsLikePlatform } = require('../../utils/home-dir');
 const { normalizeGatewaySourceType } = require('./base/proxy-utils');
+const {
+  createSkippedResult,
+  isLocalProxyBaseUrl,
+  resolveExistingActiveChannel,
+  upsertSyncedChannels
+} = require('./channel-sync-utils');
 
 // ── Claude 特有工具函数 ──
 
@@ -338,6 +344,118 @@ function getCurrentSettings() {
   };
 }
 
+function readClaudeNativeSettings() {
+  const settingsPath = getClaudeSettingsPath();
+  if (!fs.existsSync(settingsPath)) {
+    return {};
+  }
+  try {
+    return JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+  } catch (error) {
+    throw new Error(`Failed to read Claude settings.json: ${error.message}`);
+  }
+}
+
+function readClaudeNativeOAuth() {
+  try {
+    const adapters = require('./native-oauth-adapters');
+    return typeof adapters.readNativeOAuth === 'function'
+      ? adapters.readNativeOAuth('claude')
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function buildClaudeSyncCandidate(settings, channels) {
+  const env = settings?.env && typeof settings.env === 'object' ? settings.env : {};
+  const baseUrl = String(env.ANTHROPIC_BASE_URL || '').trim();
+
+  if (isLocalProxyBaseUrl(baseUrl)) {
+    const existing = resolveExistingActiveChannel('claude', channels);
+    if (existing) {
+      return {
+        skip: true,
+        channel: existing,
+        warning: 'Claude 当前配置指向 ctx 代理；对应渠道已在列表中，未重复导入。'
+      };
+    }
+    return {
+      skip: true,
+      warning: 'Claude 当前配置指向 ctx 代理，但没有找到可匹配的现有渠道。请先确认 ctx 渠道列表。'
+    };
+  }
+
+  const helperKey = extractApiKeyFromHelper(settings?.apiKeyHelper);
+  const apiKey = String(env.ANTHROPIC_API_KEY || env.ANTHROPIC_AUTH_TOKEN || helperKey || '').trim();
+  const hasOAuth = Boolean(env.CLAUDE_CODE_OAUTH_TOKEN || readClaudeNativeOAuth());
+  const existingByBaseUrl = baseUrl
+    ? channels.find(ch => String(ch.baseUrl || '').trim() === baseUrl)
+    : null;
+
+  if (!apiKey) {
+    if (existingByBaseUrl) {
+      return {
+        skip: true,
+        channel: existingByBaseUrl,
+        warning: 'Claude 当前配置未暴露 API Key；已找到同 baseUrl 渠道，未重复导入。'
+      };
+    }
+    return {
+      skip: true,
+      warning: hasOAuth
+        ? 'Claude 当前配置是 OAuth/登录态，OAuth 渠道不支持同步导入。'
+        : 'Claude 当前配置缺少 API Key，无法同步导入。'
+    };
+  }
+
+  const modelConfig = {
+    model: env.ANTHROPIC_MODEL || '',
+    haikuModel: env.ANTHROPIC_DEFAULT_HAIKU_MODEL || '',
+    sonnetModel: env.ANTHROPIC_DEFAULT_SONNET_MODEL || '',
+    opusModel: env.ANTHROPIC_DEFAULT_OPUS_MODEL || ''
+  };
+  Object.keys(modelConfig).forEach((key) => {
+    if (!modelConfig[key]) delete modelConfig[key];
+  });
+
+  const finalBaseUrl = baseUrl || 'https://api.anthropic.com';
+  return {
+    name: existingByBaseUrl?.name || 'Claude 当前配置',
+    baseUrl: finalBaseUrl,
+    apiKey,
+    presetId: finalBaseUrl.includes('api.anthropic.com') ? 'official' : 'custom',
+    modelConfig,
+    proxyUrl: env.HTTPS_PROXY || env.HTTP_PROXY || '',
+    targetApi: 'responses',
+    gatewaySourceType: 'claude',
+    credentialSource: env.ANTHROPIC_API_KEY || env.ANTHROPIC_AUTH_TOKEN ? 'config' : 'apiKeyHelper'
+  };
+}
+
+function syncCurrentClaudeChannel() {
+  const data = service.loadChannels();
+  const channels = Array.isArray(data.channels) ? data.channels : [];
+  const settings = readClaudeNativeSettings();
+  const candidate = buildClaudeSyncCandidate(settings, channels);
+
+  if (candidate?.skip) {
+    return createSkippedResult('claude', candidate.warning, candidate.channel);
+  }
+
+  return upsertSyncedChannels({
+    toolType: 'claude',
+    loadChannels: () => service.loadChannels(),
+    saveChannels: payload => service.saveChannels(payload),
+    applyDefaults: channel => service._applyDefaults(channel),
+    candidates: [candidate],
+    matchers: [
+      (channel, current) => channel.baseUrl === current.baseUrl && channel.apiKey === current.apiKey,
+      (channel, current) => channel.baseUrl === current.baseUrl && channel.targetApi === current.targetApi
+    ]
+  });
+}
+
 function getBestChannelForRestore() {
   const channels = getAllChannels();
   const enabled = channels.filter(ch => ch.enabled !== false);
@@ -394,4 +512,5 @@ module.exports = {
   getEffectiveApiKey,
   disableAllChannels,
   extractApiKeyFromHelper,
+  syncCurrentClaudeChannel,
 };

package/src/server/services/codex-channels.js

@@ -8,6 +8,13 @@ const { getCodexDir } = require('./codex-config');
 const { isProxyConfig, readConfig } = require('./codex-settings-manager');
 const { syncCodexUserEnvironment } = require('./codex-env-manager');
 const BaseChannelService = require('./base/base-channel-service');
+const {
+  createSkippedResult,
+  isLocalProxyBaseUrl,
+  resolveApiKeyValue,
+  resolveExistingActiveChannel,
+  upsertSyncedChannels
+} = require('./channel-sync-utils');
 
 const CODEX_MANAGED_ENV_KEY = 'CC_PROXY_KEY';
 const CODEX_PROXY_ENV_VALUE = 'PROXY_KEY';
@@ -269,6 +276,123 @@ function applyChannelToSettings(id) { return service.applyChannelToSettings(id);
 function getEffectiveApiKey(channel) { return service.getEffectiveApiKey(channel); }
 function disableAllChannels() { return service.disableAllChannels(); }
 
+function findCodexExistingChannel(channels = [], providerKey = '', baseUrl = '') {
+  const key = String(providerKey || '').trim();
+  const url = String(baseUrl || '').trim();
+  return channels.find(channel => key && channel.providerKey === key)
+    || channels.find(channel => url && channel.baseUrl === url)
+    || null;
+}
+
+function buildDefaultCodexProvider(providerKey = '') {
+  if (providerKey !== 'openai') return null;
+  return {
+    name: 'OpenAI',
+    base_url: 'https://api.openai.com/v1',
+    env_key: 'OPENAI_API_KEY',
+    wire_api: 'responses'
+  };
+}
+
+function buildCodexSyncCandidate(config, channels) {
+  const configuredProvider = String(config?.model_provider || '').trim();
+  const currentProvider = configuredProvider || (process.env.OPENAI_API_KEY ? 'openai' : '');
+  if (!currentProvider) {
+    return {
+      skip: true,
+      warning: 'Codex config.toml 未配置 model_provider，且未找到 OPENAI_API_KEY，无法同步当前渠道。'
+    };
+  }
+
+  const provider = config?.model_providers?.[currentProvider]
+    || buildDefaultCodexProvider(currentProvider)
+    || null;
+  const baseUrl = String(provider?.base_url || provider?.baseUrl || '').trim();
+  if (currentProvider === 'cc-proxy' || isLocalProxyBaseUrl(baseUrl)) {
+    const existing = resolveExistingActiveChannel('codex', channels);
+    if (existing) {
+      return {
+        skip: true,
+        channel: existing,
+        warning: 'Codex 当前配置指向 ctx 代理；对应渠道已在列表中，未重复导入。'
+      };
+    }
+    return {
+      skip: true,
+      warning: 'Codex 当前配置指向 ctx 代理，但没有找到可匹配的现有渠道。'
+    };
+  }
+
+  if (!provider || typeof provider !== 'object') {
+    return {
+      skip: true,
+      warning: `Codex 当前 provider "${currentProvider}" 未在 model_providers 中定义。`
+    };
+  }
+
+  const existing = findCodexExistingChannel(channels, currentProvider, baseUrl);
+  const directKey = provider.api_key || provider.apiKey || provider.key || '';
+  let credential = resolveApiKeyValue(directKey);
+  if (!credential.value && provider.env_key) {
+    credential = resolveApiKeyValue(String(provider.env_key || ''));
+  }
+  const apiKey = credential.value || existing?.apiKey || '';
+  if (!apiKey) {
+    return {
+      skip: true,
+      channel: existing || null,
+      warning: provider.requires_openai_auth
+        ? 'Codex 当前 provider 使用 OAuth/OpenAI 登录态，OAuth 渠道不支持同步导入。'
+        : `Codex 当前 provider "${currentProvider}" 缺少可解析 API Key，无法同步导入。`
+    };
+  }
+
+  return {
+    name: existing?.name || provider.name || currentProvider,
+    providerKey: currentProvider,
+    baseUrl,
+    apiKey,
+    wireApi: provider.wire_api || provider.wireApi || 'responses',
+    envKey: CODEX_MANAGED_ENV_KEY,
+    requiresOpenaiAuth: false,
+    queryParams: provider.query_params || provider.queryParams || {},
+    gatewaySourceType: existing?.gatewaySourceType || 'codex',
+    credentialSource: credential.value ? credential.source : 'existing-channel'
+  };
+}
+
+function syncCurrentCodexChannel() {
+  const data = service.loadChannels();
+  const channels = Array.isArray(data.channels) ? data.channels : [];
+  let config = {};
+  try {
+    config = readConfig();
+  } catch (error) {
+    if (/ENOENT|no such file|config\.toml not found/i.test(String(error?.message || ''))) {
+      config = {};
+    } else {
+      return createSkippedResult('codex', `Codex config.toml 读取失败：${error.message}`);
+    }
+  }
+
+  const candidate = buildCodexSyncCandidate(config, channels);
+  if (candidate?.skip) {
+    return createSkippedResult('codex', candidate.warning, candidate.channel);
+  }
+
+  return upsertSyncedChannels({
+    toolType: 'codex',
+    loadChannels: () => service.loadChannels(),
+    saveChannels: payload => service.saveChannels(payload),
+    applyDefaults: channel => service._applyDefaults(channel),
+    candidates: [candidate],
+    matchers: [
+      (channel, current) => channel.providerKey && channel.providerKey === current.providerKey,
+      (channel, current) => channel.baseUrl === current.baseUrl && channel.apiKey === current.apiKey
+    ]
+  });
+}
+
 // 服务启动时自动同步环境变量
 try {
   const data = service.loadChannels();
@@ -292,6 +416,7 @@ module.exports = {
   applyChannelToSettings,
   getEffectiveApiKey,
   disableAllChannels,
+  syncCurrentCodexChannel,
   _test: {
     buildManagedCodexEnvMap,
     CODEX_MANAGED_ENV_KEY,

package/src/server/services/gemini-channels.js

@@ -5,6 +5,13 @@ const { PATHS, NATIVE_PATHS } = require('../../config/paths');
 const { resolveChannelWebsiteUrl } = require('../../config/channel-preset-websites');
 const { clearNativeOAuth } = require('./native-oauth-adapters');
 const { normalizeGatewaySourceType } = require('./base/proxy-utils');
+const {
+  createSkippedResult,
+  isLocalProxyBaseUrl,
+  resolveApiKeyValue,
+  resolveExistingActiveChannel,
+  upsertSyncedChannels
+} = require('./channel-sync-utils');
 
 const GEMINI_API_FORMATS = new Set(['gemini_api', 'vertex_ai_v1']);
 
@@ -516,6 +523,121 @@ function disableAllChannels() {
   saveChannels(data);
 }
 
+function readGeminiSettings() {
+  const settingsPath = NATIVE_PATHS.gemini.settings;
+  if (!settingsPath || !fs.existsSync(settingsPath)) {
+    return {};
+  }
+  try {
+    return JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function normalizeGeminiChannel(channel = {}) {
+  const normalized = {
+    ...channel,
+    enabled: channel.enabled !== false,
+    weight: channel.weight || 1,
+    maxConcurrency: channel.maxConcurrency || null,
+    balanceToken: channel.balanceToken || '',
+    balanceUserId: channel.balanceUserId || null,
+    modelRedirects: channel.modelRedirects || [],
+    speedTestModel: channel.speedTestModel || null,
+    apiFormat: normalizeGeminiApiFormat(channel.apiFormat),
+    gatewaySourceType: normalizeGatewaySourceType(channel.gatewaySourceType, 'gemini')
+  };
+  normalized.websiteUrl = resolveChannelWebsiteUrl('gemini', normalized);
+  return normalized;
+}
+
+function loadStoredGeminiChannels() {
+  const filePath = getChannelsFilePath();
+  if (!fs.existsSync(filePath)) {
+    return { channels: [] };
+  }
+  try {
+    const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    return {
+      ...data,
+      channels: Array.isArray(data?.channels)
+        ? data.channels.map(normalizeGeminiChannel)
+        : []
+    };
+  } catch (error) {
+    console.error('[Gemini Channels] Failed to parse channels file for sync:', error.message);
+    return { channels: [] };
+  }
+}
+
+function buildGeminiSyncCandidate(env, channels) {
+  const baseUrl = String(env.GOOGLE_GEMINI_BASE_URL || '').trim();
+  if (isLocalProxyBaseUrl(baseUrl)) {
+    const existing = resolveExistingActiveChannel('gemini', channels);
+    if (existing) {
+      return {
+        skip: true,
+        channel: existing,
+        warning: 'Gemini 当前配置指向 ctx 代理；对应渠道已在列表中，未重复导入。'
+      };
+    }
+    return {
+      skip: true,
+      warning: 'Gemini 当前配置指向 ctx 代理，但没有找到可匹配的现有渠道。'
+    };
+  }
+
+  const settings = readGeminiSettings();
+  const selectedAuthType = String(settings?.security?.auth?.selectedType || '').trim();
+  const existing = baseUrl
+    ? channels.find(channel => String(channel.baseUrl || '').trim() === baseUrl)
+    : null;
+  const credential = resolveApiKeyValue(env.GEMINI_API_KEY || '');
+  const apiKey = credential.value || existing?.apiKey || '';
+  if (!apiKey) {
+    return {
+      skip: true,
+      channel: existing || null,
+      warning: selectedAuthType.includes('oauth')
+        ? 'Gemini 当前配置是 OAuth/登录态，OAuth 渠道不支持同步导入。'
+        : 'Gemini 当前 .env 缺少 GEMINI_API_KEY，无法同步导入。'
+    };
+  }
+
+  return {
+    name: existing?.name || 'Gemini 当前配置',
+    baseUrl: baseUrl || 'https://generativelanguage.googleapis.com/v1beta',
+    apiKey,
+    model: env.GEMINI_MODEL || existing?.model || 'gemini-2.5-pro',
+    apiFormat: existing?.apiFormat || 'gemini_api',
+    gatewaySourceType: existing?.gatewaySourceType || 'gemini',
+    credentialSource: credential.value ? credential.source : 'existing-channel'
+  };
+}
+
+function syncCurrentGeminiChannel() {
+  const data = loadStoredGeminiChannels();
+  const channels = Array.isArray(data.channels) ? data.channels : [];
+  const env = readExistingGeminiEnv();
+  const candidate = buildGeminiSyncCandidate(env, channels);
+  if (candidate?.skip) {
+    return createSkippedResult('gemini', candidate.warning, candidate.channel);
+  }
+
+  return upsertSyncedChannels({
+    toolType: 'gemini',
+    loadChannels: loadStoredGeminiChannels,
+    saveChannels,
+    applyDefaults: normalizeGeminiChannel,
+    candidates: [candidate],
+    matchers: [
+      (channel, current) => channel.baseUrl === current.baseUrl && channel.apiKey === current.apiKey,
+      (channel, current) => channel.baseUrl === current.baseUrl && channel.model === current.model
+    ]
+  });
+}
+
 module.exports = {
   getChannels,
   createChannel,
@@ -529,6 +651,7 @@ module.exports = {
   getGeminiDir,
   applyChannelToSettings,
   disableAllChannels,
+  syncCurrentGeminiChannel,
   _test: {
     normalizeGeminiApiFormat
   }

package/src/server/services/model-detector.js

@@ -95,6 +95,13 @@ function getModelPriority(channelType, options = {}) {
     console.warn(`[ModelDetector] Failed to load default models config: ${error.message}`);
   }
 
+  for (const toolType of candidateTypes) {
+    const models = MODEL_PRIORITY[toolType];
+    if (Array.isArray(models) && models.length > 0) {
+      return normalizeModelCandidates(models);
+    }
+  }
+
   return [];
 }
 
@@ -779,6 +786,12 @@ function buildChannelCacheSignature(channel, payload = {}) {
   return crypto.createHash('sha1').update(raw).digest('hex');
 }
 
+function getChannelCacheKey(channel, signature) {
+  const id = String(channel?.id || '').trim();
+  if (id) return id;
+  return `temporary:${signature}`;
+}
+
 function isSignatureCacheValid(cacheEntry, signatureKey, expectedSignature) {
   if (!cacheEntry || !signatureKey || !expectedSignature) return false;
   return cacheEntry[signatureKey] === expectedSignature;
@@ -846,7 +859,6 @@ async function probeModelAvailability(channel, channelType, options = {}) {
   const toolType = options.toolType;
   const stopOnFirstAvailable = !!options.stopOnFirstAvailable;
   const cache = loadModelCache();
-  const cacheKey = channel.id;
   const preferredModels = normalizeModelCandidates(options.preferredModels);
   const probeSignature = buildChannelCacheSignature(channel, {
     type: 'probe',
@@ -855,6 +867,7 @@ async function probeModelAvailability(channel, channelType, options = {}) {
     stopOnFirstAvailable,
     preferredModels
   });
+  const cacheKey = getChannelCacheKey(channel, probeSignature);
 
   // Return cached result if channel and probe options are unchanged
   if (!forceRefresh && isSignatureCacheValid(cache[cacheKey], 'probeSignature', probeSignature)) {
@@ -1007,11 +1020,11 @@ async function fetchModelsFromProvider(channel, channelType, options = {}) {
   }
 
   const cache = loadModelCache();
-  const cacheKey = channel.id;
   const listSignature = buildChannelCacheSignature(channel, {
     type: 'model-list',
     channelType: String(channelType || '').trim().toLowerCase()
   });
+  const cacheKey = getChannelCacheKey(channel, listSignature);
 
   // Check cache first, and only reuse when channel/list context is unchanged
   if (!forceRefresh