coding-tool-x 3.2.0

package/src/server/services/alias.js

@@ -0,0 +1,71 @@
+const fs = require('fs');
+const path = require('path');
+const { PATHS } = require('../../config/paths');
+
+const ALIAS_DIR = PATHS.base;
+const ALIAS_FILE = PATHS.aliases;
+
+// Ensure alias directory exists
+function ensureAliasDir() {
+  if (!fs.existsSync(ALIAS_DIR)) {
+    fs.mkdirSync(ALIAS_DIR, { recursive: true });
+  }
+}
+
+// Load all aliases
+function loadAliases() {
+  ensureAliasDir();
+
+  if (!fs.existsSync(ALIAS_FILE)) {
+    return {};
+  }
+
+  try {
+    const content = fs.readFileSync(ALIAS_FILE, 'utf8');
+    return JSON.parse(content);
+  } catch (error) {
+    console.error('Error loading aliases:', error);
+    return {};
+  }
+}
+
+// Save aliases
+function saveAliases(aliases) {
+  ensureAliasDir();
+
+  try {
+    fs.writeFileSync(ALIAS_FILE, JSON.stringify(aliases, null, 2), 'utf8');
+  } catch (error) {
+    console.error('Error saving aliases:', error);
+    throw error;
+  }
+}
+
+// Set alias for a session
+function setAlias(sessionId, alias) {
+  const aliases = loadAliases();
+  aliases[sessionId] = alias;
+  saveAliases(aliases);
+  return aliases;
+}
+
+// Delete alias
+function deleteAlias(sessionId) {
+  const aliases = loadAliases();
+  delete aliases[sessionId];
+  saveAliases(aliases);
+  return aliases;
+}
+
+// Get alias for a session
+function getAlias(sessionId) {
+  const aliases = loadAliases();
+  return aliases[sessionId] || null;
+}
+
+module.exports = {
+  loadAliases,
+  setAlias,
+  deleteAlias,
+  getAlias
+};

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

@@ -0,0 +1,234 @@
+// 渠道健康检查和智能切换模块
+
+const healthConfig = {
+  // 故障检测
+  failureThreshold: 3,           // 连续失败3次触发冻结
+
+  // 冻结时间配置
+  initialFreezeTime: 60 * 1000,  // 初始冻结1分钟
+  maxFreezeTime: 30 * 60 * 1000, // 最大冻结30分钟
+  freezeMultiplier: 2,           // 冻结时间倍增
+
+  // 健康检测
+  healthCheckWindow: 5,          // 健康检测需要连续5次成功
+};
+
+// 渠道健康状态
+const channelHealth = new Map(); // `${source}:${channelId}` → health info
+
+// 冻结回调（用于通知调度器解绑会话）
+let onChannelFrozenCallback = null;
+
+/**
+ * 设置渠道冻结时的回调
+ */
+function setOnChannelFrozen(callback) {
+  onChannelFrozenCallback = callback;
+}
+
+/**
+ * 初始化渠道健康信息
+ */
+function makeKey(source, channelId) {
+  return `${source || 'claude'}:${channelId}`;
+}
+
+function initChannelHealth(channelId, source = 'claude') {
+  const key = makeKey(source, channelId);
+  if (!channelHealth.has(key)) {
+    channelHealth.set(key, {
+      status: 'healthy',           // healthy, frozen, checking
+      consecutiveFailures: 0,      // 连续失败次数
+      consecutiveSuccesses: 0,     // 连续成功次数
+      totalFailures: 0,           // 总失败次数
+      totalSuccesses: 0,          // 总成功次数
+      freezeUntil: 0,             // 冻结到期时间
+      nextFreezeTime: healthConfig.initialFreezeTime,
+      lastCheckTime: null,        // 最后检查时间
+      source
+    });
+  }
+  return channelHealth.get(key);
+}
+
+/**
+ * 记录成功请求
+ */
+function recordSuccess(channelId, source = 'claude') {
+  const health = initChannelHealth(channelId, source);
+  const now = Date.now();
+
+  health.totalSuccesses++;
+  health.consecutiveSuccesses++;
+  health.consecutiveFailures = 0;
+  health.lastCheckTime = now;
+
+  // 如果在检测中状态，检查是否可以恢复
+  if (health.status === 'checking') {
+    if (health.consecutiveSuccesses >= healthConfig.healthCheckWindow) {
+      // 恢复健康状态
+      health.status = 'healthy';
+      health.nextFreezeTime = healthConfig.initialFreezeTime; // 重置冻结时间
+      console.log(`[ChannelHealth] Channel ${channelId} recovered and marked as healthy`);
+    }
+  }
+}
+
+/**
+ * 记录失败请求
+ */
+function recordFailure(channelId, source = 'claude', error) {
+  const health = initChannelHealth(channelId, source);
+  const now = Date.now();
+
+  health.totalFailures++;
+  health.consecutiveFailures++;
+  health.consecutiveSuccesses = 0;
+  health.lastCheckTime = now;
+
+  // 如果当前是健康状态或检测中状态，检查是否需要冻结
+  if (health.status === 'healthy' || health.status === 'checking') {
+    if (health.consecutiveFailures >= healthConfig.failureThreshold) {
+      // 触发冻结
+      const previousStatus = health.status;
+      health.status = 'frozen';
+      health.freezeUntil = now + health.nextFreezeTime;
+
+      const freezeMinutes = Math.round(health.nextFreezeTime / 60000);
+      console.warn(`[ChannelHealth] Channel ${channelId} frozen due to ${health.consecutiveFailures} consecutive failures (was ${previousStatus}). Frozen for ${freezeMinutes} minutes`);
+
+      // 更新下次冻结时间（翻倍，不超过最大值）
+      health.nextFreezeTime = Math.min(
+        health.nextFreezeTime * healthConfig.freezeMultiplier,
+        healthConfig.maxFreezeTime
+      );
+
+      // 触发冻结回调（通知调度器解绑会话）
+      if (onChannelFrozenCallback) {
+        onChannelFrozenCallback(source || 'claude', channelId);
+      }
+    }
+  }
+}
+
+/**
+ * 检查渠道是否可用
+ */
+function isChannelAvailable(channelId, source = 'claude') {
+  const key = makeKey(source, channelId);
+  const health = channelHealth.get(key);
+  if (!health) return true;
+
+  const now = Date.now();
+
+  switch (health.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':
+      // 在检测中的渠道可用，等待成功记录
+      return true;
+
+    default:
+      return true;
+  }
+}
+
+/**
+ * 从渠道列表中过滤出可用的渠道
+ */
+function getAvailableChannels(channels, source = 'claude') {
+  return channels.filter(channel => isChannelAvailable(channel.id, source));
+}
+
+/**
+ * 获取渠道健康状态（用于前端显示）
+ */
+function getChannelHealthStatus(channelId, source = 'claude') {
+  const key = makeKey(source, channelId);
+  const health = channelHealth.get(key);
+  if (!health) {
+    return {
+      status: 'healthy',
+      statusText: '健康',
+      statusColor: '#18a058',
+      consecutiveFailures: 0,
+      consecutiveSuccesses: 0,
+      totalFailures: 0,
+      totalSuccesses: 0,
+      freezeUntil: null,
+      freezeRemaining: 0,
+    };
+  }
+
+  const now = Date.now();
+  const freezeRemaining = Math.max(0, health.freezeUntil - now);
+
+  const statusMap = {
+    'healthy': { text: '健康', color: '#18a058' },
+    'frozen': { text: '冻结', color: '#d03050' },
+    'checking': { text: '检测中', color: '#f0a020' }
+  };
+
+  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,
+    freezeRemaining: Math.ceil(freezeRemaining / 1000), // 剩余秒数
+  };
+}
+
+/**
+ * 获取所有渠道的健康状态
+ */
+function getAllChannelHealthStatus(source = 'claude') {
+  const result = {};
+  for (const [key] of channelHealth) {
+    const [keySource, channelId] = key.split(':');
+    if (keySource === (source || 'claude')) {
+      result[channelId] = getChannelHealthStatus(channelId, keySource);
+    }
+  }
+  return result;
+}
+
+/**
+ * 手动重置渠道健康状态（用于测试或管理员操作）
+ */
+function resetChannelHealth(channelId, source = 'claude') {
+  const health = initChannelHealth(channelId, source);
+  health.status = 'healthy';
+  health.consecutiveFailures = 0;
+  health.consecutiveSuccesses = 0;
+  health.freezeUntil = 0;
+  health.nextFreezeTime = healthConfig.initialFreezeTime;
+  console.log(`[ChannelHealth] Channel ${channelId} health status reset`);
+}
+
+module.exports = {
+  recordSuccess,
+  recordFailure,
+  isChannelAvailable,
+  getAvailableChannels,
+  getChannelHealthStatus,
+  getAllChannelHealthStatus,
+  resetChannelHealth,
+  setOnChannelFrozen,
+  healthConfig,
+};

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

@@ -0,0 +1,240 @@
+const { getAllChannels } = require('./channels');
+const { getChannels: getCodexChannels } = require('./codex-channels');
+const { getChannels: getGeminiChannels } = require('./gemini-channels');
+const { getChannels: getOpenCodeChannels } = require('./opencode-channels');
+const { isChannelAvailable, getChannelHealthStatus, setOnChannelFrozen } = require('./channel-health');
+
+const channelProviders = {
+  claude: () => getAllChannels(),
+  codex: () => {
+    const data = getCodexChannels();
+    return Array.isArray(data?.channels) ? data.channels : [];
+  },
+  gemini: () => {
+    const data = getGeminiChannels();
+    return Array.isArray(data?.channels) ? data.channels : [];
+  },
+  opencode: () => {
+    const data = getOpenCodeChannels();
+    return Array.isArray(data?.channels) ? data.channels : [];
+  }
+};
+
+function createState() {
+  return {
+    channels: [],
+    inflight: new Map(),
+    sessionBindings: new Map(),
+    queue: []
+  };
+}
+
+const schedulerStates = {
+  claude: createState(),
+  codex: createState(),
+  gemini: createState(),
+  opencode: createState()
+};
+
+function getState(source = 'claude') {
+  if (!schedulerStates[source]) {
+    schedulerStates[source] = createState();
+  }
+  return schedulerStates[source];
+}
+
+const WAIT_TIMEOUT_MS = 15000;
+
+/**
+ * 解绑指定渠道的所有会话
+ */
+function unbindChannelSessions(source, channelId) {
+  const state = getState(source);
+  let unbindCount = 0;
+  for (const [sessionId, boundChannelId] of state.sessionBindings) {
+    if (boundChannelId === channelId) {
+      state.sessionBindings.delete(sessionId);
+      unbindCount++;
+    }
+  }
+  if (unbindCount > 0) {
+    console.log(`[ChannelScheduler] Unbound ${unbindCount} sessions from ${source} channel ${channelId}`);
+  }
+}
+
+// 注册冻结回调，当渠道被冻结时解绑其会话
+setOnChannelFrozen(unbindChannelSessions);
+
+function refreshChannels(source = 'claude') {
+  const state = getState(source);
+  const provider = channelProviders[source];
+  if (!provider) return;
+
+  // 每次直接读取最新配置，不做缓存
+  const raw = provider();
+  state.channels = raw
+    .filter(ch => ch.enabled !== false)
+    .map(ch => ({
+      // 保留渠道完整字段，避免 proxy 等运行时配置在调度层丢失
+      ...ch,
+      weight: Math.max(1, Number(ch.weight) || 1),
+      maxConcurrency: ch.maxConcurrency ?? null,
+      modelConfig: ch.modelConfig || null,
+      modelRedirects: ch.modelRedirects || []
+    }));
+
+  state.channels.forEach(ch => {
+    if (!state.inflight.has(ch.id)) {
+      state.inflight.set(ch.id, 0);
+    }
+  });
+}
+
+function getAvailableChannels(source = 'claude') {
+  refreshChannels(source);
+  const state = getState(source);
+  return state.channels.filter(ch => {
+    if (!isChannelAvailable(ch.id, source)) {
+      return false;
+    }
+    if (ch.maxConcurrency === null) {
+      return true;
+    }
+    return (state.inflight.get(ch.id) || 0) < ch.maxConcurrency;
+  });
+}
+
+function pickWeightedChannel(channels) {
+  if (!channels.length) return null;
+  const totalWeight = channels.reduce((sum, ch) => sum + ch.weight, 0);
+  let threshold = Math.random() * totalWeight;
+  for (const channel of channels) {
+    threshold -= channel.weight;
+    if (threshold <= 0) {
+      return channel;
+    }
+  }
+  return channels[channels.length - 1];
+}
+
+function tryAllocate(source = 'claude', options = {}) {
+  const state = getState(source);
+  const sessionId = options.sessionId;
+  const enableSessionBinding = options.enableSessionBinding !== false; // 默认开启
+  const available = getAvailableChannels(source);
+  if (!available.length) {
+    return null;
+  }
+
+  // 如果启用会话绑定且已有绑定，优先使用绑定渠道
+  if (enableSessionBinding && sessionId && state.sessionBindings.has(sessionId)) {
+    const boundId = state.sessionBindings.get(sessionId);
+    const boundChannel = available.find(ch => ch.id === boundId);
+    if (boundChannel) {
+      state.inflight.set(boundChannel.id, (state.inflight.get(boundChannel.id) || 0) + 1);
+      return boundChannel;
+    }
+  }
+
+  // 选择新的渠道（加权随机）
+  const chosen = pickWeightedChannel(available);
+  if (!chosen) return null;
+
+  // 只有在启用会话绑定时才记录绑定
+  if (enableSessionBinding && sessionId) {
+    state.sessionBindings.set(sessionId, chosen.id);
+  }
+  state.inflight.set(chosen.id, (state.inflight.get(chosen.id) || 0) + 1);
+  return chosen;
+}
+
+function drainQueue(source = 'claude') {
+  const state = getState(source);
+  if (!state.queue.length) return;
+
+  for (let i = 0; i < state.queue.length; i++) {
+    const entry = state.queue[i];
+    const channel = tryAllocate(source, entry.options);
+    if (channel) {
+      clearTimeout(entry.timer);
+      state.queue.splice(i, 1);
+      entry.resolve(channel);
+      return drainQueue(source);
+    }
+  }
+}
+
+function allocateChannel(options = {}) {
+  const source = options.source || 'claude';
+  const state = getState(source);
+  const channel = tryAllocate(source, options);
+  if (channel) {
+    return Promise.resolve(channel);
+  }
+
+  if (!state.channels.length) {
+    return Promise.reject(new Error('暂无可用渠道，请先添加并启用至少一个渠道'));
+  }
+
+  // 检查是否所有渠道都被冻结
+  const allFrozen = state.channels.every(ch => !isChannelAvailable(ch.id, source));
+
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      const index = state.queue.findIndex(item => item.timer === timer);
+      if (index !== -1) {
+        state.queue.splice(index, 1);
+      }
+      // 根据实际情况返回更准确的错误信息
+      if (allFrozen) {
+        reject(new Error('所有渠道均已被冻结，请等待健康检查恢复或手动重置'));
+      } else {
+        reject(new Error('所有渠道均已达到并发上限，请稍后重试'));
+      }
+    }, WAIT_TIMEOUT_MS);
+
+    state.queue.push({
+      source,
+      options,
+      resolve,
+      reject,
+      timer
+    });
+  });
+}
+
+function releaseChannel(channelId, source = 'claude') {
+  const state = getState(source);
+  if (!channelId) return;
+  if (!state.inflight.has(channelId)) {
+    state.inflight.set(channelId, 0);
+  }
+  const current = state.inflight.get(channelId) || 0;
+  state.inflight.set(channelId, current > 0 ? current - 1 : 0);
+  drainQueue(source);
+}
+
+function getSchedulerState(source = 'claude') {
+  refreshChannels(source);
+  const state = getState(source);
+  return {
+    channels: state.channels.map(ch => {
+      const healthStatus = getChannelHealthStatus(ch.id, source);
+      return {
+        id: ch.id,
+        name: ch.name,
+        weight: ch.weight,
+        maxConcurrency: ch.maxConcurrency,
+        inflight: state.inflight.get(ch.id) || 0,
+        health: healthStatus
+      };
+    }),
+    pending: state.queue.length
+  };
+}
+
+module.exports = {
+  allocateChannel,
+  releaseChannel,
+  getSchedulerState
+};