coding-tool-x 3.4.0 → 3.4.2

package/src/server/services/base/base-channel-service.js

@@ -0,0 +1,247 @@
+/**
+ * BaseChannelService - 四平台渠道管理的公共基类
+ *
+ * 提取 channels.js / codex-channels.js / gemini-channels.js / opencode-channels.js
+ * 中的共享 CRUD、启用/禁用、单渠道强制等逻辑。
+ *
+ * 子类通过覆写钩子方法实现平台差异化行为。
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { normalizeGatewaySourceType, normalizeNumber } = require('./proxy-utils');
+
+class BaseChannelService {
+  /**
+   * @param {object} config
+   * @param {string} config.platform - 'claude'|'codex'|'gemini'|'opencode'
+   * @param {string} config.channelsFilePath - 渠道数据文件路径
+   * @param {string} [config.defaultGatewaySource] - 默认网关来源类型
+   * @param {Function} [config.isProxyRunning] - 返回代理是否运行中
+   */
+  constructor(config) {
+    this.platform = config.platform;
+    this.channelsFilePath = config.channelsFilePath;
+    this.defaultGatewaySource = config.defaultGatewaySource || config.platform;
+    this._isProxyRunning = config.isProxyRunning || (() => false);
+  }
+
+  // ── 文件 I/O ──
+
+  _ensureDir() {
+    const dir = path.dirname(this.channelsFilePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  }
+
+  loadChannels() {
+    this._ensureDir();
+    try {
+      if (fs.existsSync(this.channelsFilePath)) {
+        const raw = JSON.parse(fs.readFileSync(this.channelsFilePath, 'utf8'));
+        const channels = Array.isArray(raw?.channels) ? raw.channels : [];
+        return { channels: channels.map(ch => this._applyDefaults(ch)) };
+      }
+    } catch (err) {
+      console.error(`[${this.platform}-channels] Error loading channels:`, err.message);
+    }
+    return { channels: [] };
+  }
+
+  saveChannels(data) {
+    this._ensureDir();
+    fs.writeFileSync(this.channelsFilePath, JSON.stringify(data, null, 2), 'utf8');
+  }
+
+  // ── 查询 ──
+
+  getChannels() {
+    return this.loadChannels();
+  }
+
+  getEnabledChannels() {
+    const data = this.loadChannels();
+    return data.channels.filter(ch => ch.enabled !== false);
+  }
+
+  // ── CRUD ──
+
+  createChannel(fields) {
+    const data = this.loadChannels();
+
+    // 子类可覆写的唯一性校验
+    this._validateUniqueness(data.channels, fields);
+
+    const channel = this._applyDefaults({
+      id: this._generateId(),
+      ...fields,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    });
+
+    data.channels.push(channel);
+
+    // 单渠道强制：代理未运行时只允许一个渠道启用
+    if (channel.enabled && !this._isProxyRunning()) {
+      this._enforceSingleChannel(data.channels, data.channels.length - 1);
+    }
+
+    this.saveChannels(data);
+    this._onAfterCreate(channel, data.channels);
+    return channel;
+  }
+
+  updateChannel(channelId, updates) {
+    const data = this.loadChannels();
+    const index = data.channels.findIndex(ch => ch.id === channelId);
+    if (index === -1) {
+      throw new Error('Channel not found');
+    }
+
+    const oldChannel = data.channels[index];
+
+    // 子类可覆写的唯一性校验（排除自身）
+    this._validateUniqueness(data.channels, updates, channelId);
+
+    const nextChannel = this._applyDefaults({
+      ...oldChannel,
+      ...updates,
+      id: channelId,
+      updatedAt: Date.now(),
+    });
+    data.channels[index] = nextChannel;
+
+    // 单渠道强制
+    const isProxyRunning = this._isProxyRunning();
+    if (!isProxyRunning && nextChannel.enabled && !oldChannel.enabled) {
+      this._enforceSingleChannel(data.channels, index);
+    }
+
+    this.saveChannels(data);
+    this._onAfterUpdate(oldChannel, nextChannel, data.channels);
+    return nextChannel;
+  }
+
+  deleteChannel(channelId) {
+    const data = this.loadChannels();
+    const index = data.channels.findIndex(ch => ch.id === channelId);
+    if (index === -1) {
+      throw new Error('Channel not found');
+    }
+
+    const removed = data.channels.splice(index, 1)[0];
+    this.saveChannels(data);
+    this._onAfterDelete(removed, data.channels);
+    return { success: true };
+  }
+
+  // ── 启用/禁用 ──
+
+  disableAllChannels() {
+    const data = this.loadChannels();
+    data.channels.forEach(ch => { ch.enabled = false; });
+    this.saveChannels(data);
+  }
+
+  applyChannelToSettings(channelId) {
+    const data = this.loadChannels();
+    const channel = data.channels.find(ch => ch.id === channelId);
+    if (!channel) {
+      throw new Error('Channel not found');
+    }
+
+    // 单渠道模式：只启用目标渠道
+    data.channels.forEach(ch => {
+      ch.enabled = ch.id === channelId;
+    });
+    this.saveChannels(data);
+    this._applyToNativeSettings(channel);
+    return channel;
+  }
+
+  // ── 排序 ──
+
+  saveChannelOrder(order) {
+    if (!Array.isArray(order)) return;
+    const data = this.loadChannels();
+    const channelMap = new Map(data.channels.map(ch => [ch.id, ch]));
+    const ordered = [];
+    for (const id of order) {
+      const ch = channelMap.get(id);
+      if (ch) {
+        ordered.push(ch);
+        channelMap.delete(id);
+      }
+    }
+    // 未在 order 中的渠道追加到末尾
+    for (const ch of channelMap.values()) {
+      ordered.push(ch);
+    }
+    data.channels = ordered;
+    this.saveChannels(data);
+  }
+
+  // ── API Key ──
+
+  getEffectiveApiKey(channel) {
+    return channel?.apiKey || null;
+  }
+
+  // ── 内部方法 ──
+
+  _generateId() {
+    return crypto.randomUUID();
+  }
+
+  _enforceSingleChannel(channels, enabledIndex) {
+    channels.forEach((ch, i) => {
+      if (i !== enabledIndex && ch.enabled) {
+        ch.enabled = false;
+      }
+    });
+    const name = channels[enabledIndex]?.name || channels[enabledIndex]?.id;
+    console.log(`[${this.platform}] Single-channel mode: enabled "${name}", disabled all others`);
+  }
+
+  // ── 子类钩子（默认空实现）──
+
+  /** 应用渠道默认值，子类覆写以添加平台特有字段 */
+  _applyDefaults(channel) {
+    const normalized = { ...channel };
+    if (normalized.enabled === undefined) {
+      normalized.enabled = true;
+    } else {
+      normalized.enabled = !!normalized.enabled;
+    }
+    normalized.weight = normalizeNumber(normalized.weight, 1, 100);
+    normalized.maxConcurrency = normalizeNumber(normalized.maxConcurrency, 0);
+    normalized.gatewaySourceType = normalizeGatewaySourceType(
+      normalized.gatewaySourceType,
+      this.defaultGatewaySource
+    );
+    return normalized;
+  }
+
+  /** 唯一性校验，子类覆写（如 Codex 的 providerKey、Gemini 的 name） */
+  _validateUniqueness(_channels, _fields, _excludeId) {
+    // 默认无校验
+  }
+
+  /** 创建后钩子 */
+  _onAfterCreate(_channel, _allChannels) {}
+
+  /** 更新后钩子 */
+  _onAfterUpdate(_oldChannel, _newChannel, _allChannels) {}
+
+  /** 删除后钩子 */
+  _onAfterDelete(_channel, _allChannels) {}
+
+  /** 将渠道配置写入平台原生设置文件，子类必须覆写 */
+  _applyToNativeSettings(_channel) {
+    throw new Error(`${this.platform}: _applyToNativeSettings not implemented`);
+  }
+}
+
+module.exports = BaseChannelService;

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), // 剩余秒数
   };
 }