coding-tool-x 3.3.9 → 3.4.1

package/src/server/services/base/proxy-utils.js

@@ -0,0 +1,152 @@
+/**
+ * proxy-utils.js - 代理服务器共享工具函数
+ *
+ * 从四个 proxy-server 中提取的公共逻辑，消除重复代码。
+ */
+
+/**
+ * 检测模型层级（Claude 系列）
+ * @param {string} modelName
+ * @returns {'opus'|'sonnet'|'haiku'|null}
+ */
+function detectModelTier(modelName) {
+  if (!modelName) return null;
+  const lower = modelName.toLowerCase();
+  if (lower.includes('opus')) return 'opus';
+  if (lower.includes('sonnet')) return 'sonnet';
+  if (lower.includes('haiku')) return 'haiku';
+  return null;
+}
+
+/**
+ * 应用模型重定向
+ *
+ * 支持两种格式：
+ * 1. modelRedirects 数组（新格式，精确匹配）
+ * 2. modelConfig 对象（旧格式，层级匹配 + 通用覆盖）
+ *
+ * @param {string} originalModel
+ * @param {object} channel - 渠道对象
+ * @param {object} [options]
+ * @param {boolean} [options.useTierFallback=true] - 是否启用层级回退（Gemini 不用）
+ * @returns {string}
+ */
+function redirectModel(originalModel, channel, options = {}) {
+  if (!originalModel) return originalModel;
+
+  // 优先使用 modelRedirects 数组格式（精确匹配）
+  const modelRedirects = channel?.modelRedirects;
+  if (Array.isArray(modelRedirects) && modelRedirects.length > 0) {
+    for (const rule of modelRedirects) {
+      if (rule.from && rule.to && rule.from === originalModel) {
+        return rule.to;
+      }
+    }
+  }
+
+  // 如果不启用层级回退，到此为止
+  const useTierFallback = options.useTierFallback !== false;
+  if (!useTierFallback) {
+    return originalModel;
+  }
+
+  // 向后兼容：使用旧的 modelConfig 格式
+  const modelConfig = channel?.modelConfig;
+  if (!modelConfig) return originalModel;
+
+  const tier = detectModelTier(originalModel);
+
+  if (tier === 'opus' && modelConfig.opusModel) return modelConfig.opusModel;
+  if (tier === 'sonnet' && modelConfig.sonnetModel) return modelConfig.sonnetModel;
+  if (tier === 'haiku' && modelConfig.haikuModel) return modelConfig.haikuModel;
+
+  // 回退到通用模型覆盖
+  if (modelConfig.model) return modelConfig.model;
+
+  return originalModel;
+}
+
+/**
+ * 解析代理目标 URL，避免 /v1/v1 重复
+ *
+ * 当 baseUrl 以 /v1 结尾且请求路径也以 /v1 开头时，
+ * 去掉 baseUrl 的 /v1 后缀，因为 http-proxy 会自动拼接 req.url。
+ *
+ * @param {string} baseUrl - 渠道配置的 base_url
+ * @param {string} requestPath - 请求路径
+ * @returns {string} 传给 http-proxy 的 target
+ */
+function resolveTargetUrl(baseUrl, requestPath) {
+  let target = baseUrl || '';
+  if (target.endsWith('/')) {
+    target = target.slice(0, -1);
+  }
+  if (target.endsWith('/v1') && requestPath.startsWith('/v1')) {
+    target = target.slice(0, -3);
+  }
+  return target;
+}
+
+/**
+ * 规范化网关来源类型
+ * @param {string} value
+ * @param {string} [fallback='claude']
+ * @returns {string}
+ */
+function normalizeGatewaySourceType(value, fallback = 'claude') {
+  const normalized = String(value || '').trim().toLowerCase();
+  if (normalized === 'claude') return 'claude';
+  if (normalized === 'codex') return 'codex';
+  if (normalized === 'gemini') return 'gemini';
+  if (normalized === 'openai_compatible') return 'openai_compatible';
+  return fallback;
+}
+
+/**
+ * 规范化数值字段
+ * @param {*} value
+ * @param {number} defaultValue
+ * @param {number|null} [max=null]
+ * @returns {number}
+ */
+function normalizeNumber(value, defaultValue, max = null) {
+  const num = Number(value);
+  if (!Number.isFinite(num) || num <= 0) {
+    return defaultValue;
+  }
+  if (max !== null && num > max) {
+    return max;
+  }
+  return num;
+}
+
+/**
+ * 记录模型重定向日志（避免重复打印）
+ * @param {Map} cache - 重定向缓存 Map
+ * @param {string} channelId
+ * @param {string} originalModel
+ * @param {string} redirectedModel
+ * @param {string} channelName
+ * @param {string} source - 平台标识
+ */
+function logModelRedirect(cache, channelId, originalModel, redirectedModel, channelName, source) {
+  if (originalModel === redirectedModel) return;
+
+  if (!cache.has(channelId)) {
+    cache.set(channelId, {});
+  }
+  const channelCache = cache.get(channelId);
+  if (channelCache[originalModel] === redirectedModel) return;
+
+  channelCache[originalModel] = redirectedModel;
+  console.log(`[${source}-proxy] Model redirect: ${originalModel} → ${redirectedModel} (channel: ${channelName})`);
+}
+
+module.exports = {
+  detectModelTier,
+  redirectModel,
+  resolveTargetUrl,
+  normalizeGatewaySourceType,
+  normalizeNumber,
+  logModelRedirect,
+};

package/src/server/services/channel-health.js

@@ -51,6 +51,24 @@ function initChannelHealth(channelId, source = 'claude') {
   return channelHealth.get(key);
 }
 
+function transitionFrozenChannelIfExpired(channelId, source = 'claude') {
+  const health = initChannelHealth(channelId, source);
+  if (health.status !== 'frozen') {
+    return health;
+  }
+
+  const now = Date.now();
+  if (now < health.freezeUntil) {
+    return health;
+  }
+
+  health.status = 'checking';
+  health.consecutiveSuccesses = 0;
+  health.freezeUntil = 0;
+  console.log(`[ChannelHealth] Channel ${channelId} freeze expired, entering checking mode`);
+  return health;
+}
+
 /**
  * 记录成功请求
  */
@@ -119,21 +137,13 @@ function isChannelAvailable(channelId, source = 'claude') {
   const health = channelHealth.get(key);
   if (!health) return true;
 
-  const now = Date.now();
+  const currentHealth = transitionFrozenChannelIfExpired(channelId, source);
 
-  switch (health.status) {
+  switch (currentHealth.status) {
     case 'healthy':
       return true;
 
     case 'frozen':
-      // 检查冻结时间是否到期
-      if (now >= health.freezeUntil) {
-        // 进入检测状态
-        health.status = 'checking';
-        health.consecutiveSuccesses = 0;
-        console.log(`[ChannelHealth] Channel ${channelId} freeze expired, entering checking mode`);
-        return true; // 允许一个请求用于健康检测
-      }
       return false;
 
     case 'checking':
@@ -172,8 +182,9 @@ function getChannelHealthStatus(channelId, source = 'claude') {
     };
   }
 
+  const currentHealth = transitionFrozenChannelIfExpired(channelId, source);
   const now = Date.now();
-  const freezeRemaining = Math.max(0, health.freezeUntil - now);
+  const freezeRemaining = Math.max(0, currentHealth.freezeUntil - now);
 
   const statusMap = {
     'healthy': { text: '健康', color: '#18a058' },
@@ -182,14 +193,14 @@ function getChannelHealthStatus(channelId, source = 'claude') {
   };
 
   return {
-    status: health.status,
-    statusText: statusMap[health.status]?.text || '未知',
-    statusColor: statusMap[health.status]?.color || '#909399',
-    consecutiveFailures: health.consecutiveFailures,
-    consecutiveSuccesses: health.consecutiveSuccesses,
-    totalFailures: health.totalFailures,
-    totalSuccesses: health.totalSuccesses,
-    freezeUntil: health.freezeUntil,
+    status: currentHealth.status,
+    statusText: statusMap[currentHealth.status]?.text || '未知',
+    statusColor: statusMap[currentHealth.status]?.color || '#909399',
+    consecutiveFailures: currentHealth.consecutiveFailures,
+    consecutiveSuccesses: currentHealth.consecutiveSuccesses,
+    totalFailures: currentHealth.totalFailures,
+    totalSuccesses: currentHealth.totalSuccesses,
+    freezeUntil: currentHealth.freezeUntil,
     freezeRemaining: Math.ceil(freezeRemaining / 1000), // 剩余秒数
   };
 }

package/src/server/services/channels.js

@@ -1,16 +1,11 @@
 const fs = require('fs');
 const path = require('path');
+const BaseChannelService = require('./base/base-channel-service');
 const { isProxyConfig } = require('./settings-manager');
 const { PATHS, NATIVE_PATHS } = require('../../config/paths');
 const { clearNativeOAuth } = require('./native-oauth-adapters');
 
-function getChannelsFilePath() {
-  const dir = path.dirname(PATHS.channels.claude);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-  return PATHS.channels.claude;
-}
+// ── Claude 特有工具函数 ──
 
 function getActiveChannelIdPath() {
   const dir = path.dirname(PATHS.activeChannel.claude);
@@ -43,298 +38,23 @@ function loadActiveChannelId() {
   return null;
 }
 
-let channelsCache = null;
-let channelsCacheInitialized = false;
-const DEFAULT_CHANNELS = { channels: [] };
-
-function normalizeNumber(value, defaultValue, max = null) {
-  const num = Number(value);
-  if (!Number.isFinite(num) || num <= 0) {
-    return defaultValue;
-  }
-  if (max !== null && num > max) {
-    return max;
-  }
-  return num;
-}
-
-function normalizeGatewaySourceType(value, fallback = 'claude') {
-  const normalized = String(value || '').trim().toLowerCase();
-  if (normalized === 'claude') return 'claude';
-  if (normalized === 'codex') return 'codex';
-  if (normalized === 'gemini') return 'gemini';
-  return fallback;
-}
-
 function extractApiKeyFromHelper(apiKeyHelper) {
   if (typeof apiKeyHelper !== 'string' || !apiKeyHelper.trim()) {
     return '';
   }
-
   const helper = apiKeyHelper.trim();
   let match = helper.match(/^echo\s+["']([^"']+)["']$/);
-  if (match && match[1]) {
-    return match[1];
-  }
-
+  if (match && match[1]) return match[1];
   match = helper.match(/^printf\s+["'][^"']*["']\s+["']([^"']+)["']$/);
-  if (match && match[1]) {
-    return match[1];
-  }
-
+  if (match && match[1]) return match[1];
   return '';
 }
 
 function buildApiKeyHelperCommand() {
-  // 避免把明文 API Key 写入可执行命令，降低注入风险
-  return 'printf "%s" "${ANTHROPIC_AUTH_TOKEN:-${ANTHROPIC_API_KEY:-}}"';
-}
-
-function applyChannelDefaults(channel) {
-  const normalized = { ...channel };
-  if (normalized.enabled === undefined) {
-    normalized.enabled = true;
-  } else {
-    normalized.enabled = !!normalized.enabled;
-  }
-
-  normalized.weight = normalizeNumber(normalized.weight, 1, 100);
-
-  if (normalized.maxConcurrency === undefined ||
-      normalized.maxConcurrency === null ||
-      normalized.maxConcurrency === 0) {
-    normalized.maxConcurrency = null;
-  } else {
-    normalized.maxConcurrency = normalizeNumber(normalized.maxConcurrency, 1, 100);
-  }
-
-  normalized.gatewaySourceType = normalizeGatewaySourceType(normalized.gatewaySourceType, 'claude');
-
-  return normalized;
+  return 'echo \'ctx-managed\'';
 }
 
-function readChannelsFromFile() {
-  const filePath = getChannelsFilePath();
-  try {
-    if (fs.existsSync(filePath)) {
-      const content = fs.readFileSync(filePath, 'utf8');
-      const data = JSON.parse(content);
-      data.channels = (data.channels || []).map(applyChannelDefaults);
-      return data;
-    }
-  } catch (error) {
-    console.error('Error loading channels:', error);
-  }
-  return { ...DEFAULT_CHANNELS };
-}
-
-function initializeChannelsCache() {
-  if (channelsCacheInitialized) return;
-  channelsCache = readChannelsFromFile();
-  channelsCacheInitialized = true;
-
-  try {
-    const filePath = getChannelsFilePath();
-    fs.watchFile(filePath, { persistent: false }, () => {
-      channelsCache = readChannelsFromFile();
-    });
-  } catch (err) {
-    console.error('Failed to watch channels file:', err);
-  }
-}
-
-function loadChannels() {
-  if (!channelsCacheInitialized) {
-    initializeChannelsCache();
-  }
-  return JSON.parse(JSON.stringify(channelsCache));
-}
-
-function saveChannels(data) {
-  const filePath = getChannelsFilePath();
-  const payload = {
-    ...data,
-    channels: (data.channels || []).map(applyChannelDefaults)
-  };
-  fs.writeFileSync(filePath, JSON.stringify(payload, null, 2), 'utf8');
-  channelsCache = JSON.parse(JSON.stringify(payload));
-}
-
-function getCurrentSettings() {
-  try {
-    const settingsPath = getClaudeSettingsPath();
-    if (!fs.existsSync(settingsPath)) {
-      return null;
-    }
-    const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-    const nativeOAuth = require('./native-oauth-adapters').readNativeOAuth('claude');
-
-    let baseUrl = settings.env?.ANTHROPIC_BASE_URL || '';
-    let apiKey = settings.env?.ANTHROPIC_API_KEY || '';
-    if (!apiKey && !nativeOAuth) {
-      apiKey = settings.env?.ANTHROPIC_AUTH_TOKEN || '';
-    }
-
-    if (!apiKey && settings.apiKeyHelper) {
-      apiKey = extractApiKeyFromHelper(settings.apiKeyHelper);
-    }
-
-    if (!baseUrl && !apiKey) {
-      return null;
-    }
-
-    return { baseUrl, apiKey };
-  } catch (error) {
-    console.error('Error reading current settings:', error);
-    return null;
-  }
-}
-
-function getBestChannelForRestore() {
-  const data = loadChannels();
-  const enabledChannels = data.channels.filter(ch => ch.enabled !== false);
-
-  if (enabledChannels.length === 0) {
-    return data.channels[0];
-  }
-
-  enabledChannels.sort((a, b) => (b.weight || 1) - (a.weight || 1));
-  return enabledChannels[0];
-}
-
-function getAllChannels() {
-  const data = loadChannels();
-  return data.channels;
-}
-
-function getCurrentChannel() {
-  const channels = getAllChannels();
-  if (!Array.isArray(channels) || channels.length === 0) {
-    return null;
-  }
-
-  const activeChannelId = loadActiveChannelId();
-  if (activeChannelId) {
-    const matched = channels.find(ch => ch.id === activeChannelId);
-    if (matched) {
-      return matched;
-    }
-  }
-
-  return channels.find(ch => ch.enabled !== false) || channels[0];
-}
-
-function createChannel(name, baseUrl, apiKey, websiteUrl, extraConfig = {}) {
-  const data = loadChannels();
-  const newChannel = applyChannelDefaults({
-    id: `channel-${Date.now()}`,
-    name,
-    baseUrl,
-    apiKey,
-    createdAt: Date.now(),
-    websiteUrl: websiteUrl || undefined,
-    enabled: extraConfig.enabled !== undefined ? !!extraConfig.enabled : true,
-    weight: extraConfig.weight,
-    maxConcurrency: extraConfig.maxConcurrency,
-    presetId: extraConfig.presetId || 'official',
-    modelConfig: extraConfig.modelConfig || null,
-    modelRedirects: extraConfig.modelRedirects || [],
-    proxyUrl: extraConfig.proxyUrl || '',
-    speedTestModel: extraConfig.speedTestModel || null,
-    gatewaySourceType: normalizeGatewaySourceType(extraConfig.gatewaySourceType, 'claude')
-  });
-
-  data.channels.push(newChannel);
-  saveChannels(data);
-  return newChannel;
-}
-
-function updateChannel(id, updates) {
-  const data = loadChannels();
-  const index = data.channels.findIndex(ch => ch.id === id);
-
-  if (index === -1) {
-    throw new Error('Channel not found');
-  }
-
-  // Store old channel data before updates
-  const oldChannel = { ...data.channels[index] };
-
-  const merged = { ...data.channels[index], ...updates };
-  const nextChannel = applyChannelDefaults({
-    ...merged,
-    weight: merged.weight,
-    maxConcurrency: merged.maxConcurrency,
-    enabled: merged.enabled,
-    presetId: merged.presetId,
-    modelConfig: merged.modelConfig,
-    modelRedirects: merged.modelRedirects || [],
-    proxyUrl: merged.proxyUrl,
-    speedTestModel: merged.speedTestModel,
-    gatewaySourceType: normalizeGatewaySourceType(merged.gatewaySourceType, 'claude'),
-    updatedAt: Date.now()
-  });
-  data.channels[index] = nextChannel;
-
-  // Get proxy status
-  const { getProxyStatus } = require('../proxy-server');
-  const proxyStatus = getProxyStatus();
-  const isProxyRunning = proxyStatus.running;
-
-  // Single-channel enforcement: enabling a channel disables all others ONLY when proxy is OFF
-  // When proxy is ON (dynamic switching), multiple channels can be enabled simultaneously
-  if (!isProxyRunning && nextChannel.enabled && !oldChannel.enabled) {
-    data.channels.forEach((ch, i) => {
-      if (i !== index && ch.enabled) {
-        ch.enabled = false;
-      }
-    });
-    console.log(`[Single-channel mode] Enabled "${nextChannel.name}", disabled all others`);
-  }
-
-  saveChannels(data);
-
-  // Sync settings.json only when proxy is OFF.
-  // In dynamic switching mode, defer local config writes until proxy stop.
-  if (!isProxyRunning && nextChannel.enabled) {
-    console.log(`[Settings-sync] Channel "${nextChannel.name}" enabled, syncing settings.json...`);
-    updateClaudeSettingsWithModelConfig(nextChannel);
-  }
-
-  return data.channels[index];
-}
-
-async function deleteChannel(id) {
-  const data = loadChannels();
-  const index = data.channels.findIndex(ch => ch.id === id);
-
-  if (index === -1) {
-    throw new Error('Channel not found');
-  }
-
-  data.channels.splice(index, 1);
-  saveChannels(data);
-
-  return { success: true };
-}
-
-function applyChannelToSettings(id) {
-  const data = loadChannels();
-  const channel = data.channels.find(ch => ch.id === id);
-
-  if (!channel) {
-    throw new Error('Channel not found');
-  }
-
-  // In single-channel mode, only this channel should be enabled
-  data.channels.forEach(ch => {
-    ch.enabled = ch.id === id;
-  });
-  saveChannels(data);
-  updateClaudeSettingsWithModelConfig(channel);
-
-  return channel;
-}
+// ── Claude 原生设置写入 ──
 
 function updateClaudeSettingsWithModelConfig(channel) {
   clearNativeOAuth('claude');
@@ -386,7 +106,6 @@ function updateClaudeSettingsWithModelConfig(channel) {
   }
 
   settings.apiKeyHelper = buildApiKeyHelperCommand();
-
   fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
 }
 
@@ -415,18 +134,131 @@ function updateClaudeSettings(baseUrl, apiKey) {
   }
 
   settings.apiKeyHelper = buildApiKeyHelperCommand();
-
   fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
 }
 
+// ── ClaudeChannelService ──
+
+class ClaudeChannelService extends BaseChannelService {
+  constructor() {
+    super({
+      platform: 'claude',
+      channelsFilePath: PATHS.channels.claude,
+      defaultGatewaySource: 'claude',
+      isProxyRunning: () => isProxyConfig(),
+    });
+    // Claude 特有：文件监听缓存
+    this._cache = null;
+    this._cacheInitialized = false;
+  }
+
+  _generateId() {
+    return `channel-${Date.now()}`;
+  }
+
+  // Claude 使用缓存 + fs.watchFile
+  loadChannels() {
+    if (this._cacheInitialized && this._cache) {
+      return { channels: this._cache.channels.map(ch => this._applyDefaults(ch)) };
+    }
+
+    const data = super.loadChannels();
+    this._cache = data;
+    this._cacheInitialized = true;
+
+    // 设置文件监听
+    try {
+      fs.watchFile(this.channelsFilePath, { interval: 2000 }, () => {
+        try {
+          this._cache = null;
+          this._cacheInitialized = false;
+        } catch (_) {}
+      });
+    } catch (_) {}
+
+    return data;
+  }
+
+  saveChannels(data) {
+    super.saveChannels(data);
+    this._cache = data;
+    this._cacheInitialized = true;
+  }
+
+  _applyToNativeSettings(channel) {
+    updateClaudeSettingsWithModelConfig(channel);
+  }
+
+  getEffectiveApiKey(channel) {
+    return channel?.apiKey || null;
+  }
+}
+
+// ── 单例 + 兼容导出 ──
+
+const service = new ClaudeChannelService();
+
+function getAllChannels() {
+  const data = service.loadChannels();
+  return data.channels;
+}
+
+function getCurrentChannel() {
+  const channels = getAllChannels();
+  const activeId = loadActiveChannelId();
+  if (activeId) {
+    const active = channels.find(ch => ch.id === activeId);
+    if (active) return active;
+  }
+  return channels.find(ch => ch.enabled !== false) || channels[0] || null;
+}
+
+function getCurrentSettings() {
+  const channel = getCurrentChannel();
+  if (!channel) return null;
+  return {
+    baseUrl: channel.baseUrl,
+    apiKey: channel.apiKey,
+    channelName: channel.name,
+    channelId: channel.id,
+  };
+}
+
+function getBestChannelForRestore() {
+  const channels = getAllChannels();
+  const enabled = channels.filter(ch => ch.enabled !== false);
+  if (enabled.length > 0) return enabled[0];
+  return channels[0] || null;
+}
+
+function createChannel(name, baseUrl, apiKey, websiteUrl, extraConfig) {
+  return service.createChannel({
+    name,
+    baseUrl,
+    apiKey,
+    websiteUrl,
+    ...extraConfig,
+  });
+}
+
+function updateChannel(id, updates) {
+  return service.updateChannel(id, updates);
+}
+
+function deleteChannel(id) {
+  return service.deleteChannel(id);
+}
+
+function applyChannelToSettings(id) {
+  return service.applyChannelToSettings(id);
+}
+
 function getEffectiveApiKey(channel) {
-  return channel.apiKey || null;
+  return service.getEffectiveApiKey(channel);
 }
 
 function disableAllChannels() {
-  const data = loadChannels();
-  data.channels.forEach(ch => { ch.enabled = false; });
-  saveChannels(data);
+  return service.disableAllChannels();
 }
 
 module.exports = {
@@ -441,5 +273,5 @@ module.exports = {
   updateClaudeSettings,
   updateClaudeSettingsWithModelConfig,
   getEffectiveApiKey,
-  disableAllChannels
+  disableAllChannels,
 };