@adversity/coding-tool-x 2.2.0

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

@@ -0,0 +1,234 @@
+const { getAllChannels } = require('./channels');
+const { getChannels: getCodexChannels } = require('./codex-channels');
+const { getChannels: getGeminiChannels } = require('./gemini-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 : [];
+  }
+};
+
+function createState() {
+  return {
+    channels: [],
+    inflight: new Map(),
+    sessionBindings: new Map(),
+    queue: []
+  };
+}
+
+const schedulerStates = {
+  claude: createState(),
+  codex: createState(),
+  gemini: 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 => ({
+      id: ch.id,
+      name: ch.name,
+      baseUrl: ch.baseUrl,
+      apiKey: ch.apiKey,
+      weight: Math.max(1, Number(ch.weight) || 1),
+      maxConcurrency: ch.maxConcurrency ?? null
+    }));
+
+  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
+};

package/src/server/services/channels.js

@@ -0,0 +1,347 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { isProxyConfig } = require('./settings-manager');
+
+function getChannelsFilePath() {
+  const dir = path.join(os.homedir(), '.claude', 'cc-tool');
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  return path.join(dir, 'channels.json');
+}
+
+function getActiveChannelIdPath() {
+  const dir = path.join(os.homedir(), '.claude', 'cc-tool');
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  return path.join(dir, 'active-channel.json');
+}
+
+function getClaudeSettingsPath() {
+  return path.join(os.homedir(), '.claude', 'settings.json');
+}
+
+function saveActiveChannelId(channelId) {
+  const filePath = getActiveChannelIdPath();
+  fs.writeFileSync(filePath, JSON.stringify({ activeChannelId: channelId }, null, 2), 'utf8');
+}
+
+function loadActiveChannelId() {
+  const filePath = getActiveChannelIdPath();
+  try {
+    if (fs.existsSync(filePath)) {
+      const content = fs.readFileSync(filePath, 'utf8');
+      const data = JSON.parse(content);
+      return data.activeChannelId || null;
+    }
+  } catch (error) {
+    console.error('Error loading active channel ID:', error);
+  }
+  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 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);
+  }
+
+  return normalized;
+}
+
+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'));
+
+    let baseUrl = settings.env?.ANTHROPIC_BASE_URL || '';
+    let apiKey = settings.env?.ANTHROPIC_API_KEY ||
+                 settings.env?.ANTHROPIC_AUTH_TOKEN ||
+                 '';
+
+    if (!apiKey && settings.apiKeyHelper) {
+      const match = settings.apiKeyHelper.match(/['"]([^'"]+)['"]/);
+      if (match && match[1]) {
+        apiKey = match[1];
+      }
+    }
+
+    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 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,
+    proxyUrl: extraConfig.proxyUrl || ''
+  });
+
+  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');
+  }
+
+  const merged = { ...data.channels[index], ...updates };
+  data.channels[index] = applyChannelDefaults({
+    ...merged,
+    weight: merged.weight,
+    maxConcurrency: merged.maxConcurrency,
+    enabled: merged.enabled,
+    presetId: merged.presetId,
+    modelConfig: merged.modelConfig,
+    proxyUrl: merged.proxyUrl
+  });
+
+  saveChannels(data);
+  return data.channels[index];
+}
+
+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');
+  }
+
+  channel.enabled = true;
+  saveChannels(data);
+  updateClaudeSettingsWithModelConfig(channel);
+
+  return channel;
+}
+
+function updateClaudeSettingsWithModelConfig(channel) {
+  const settingsPath = getClaudeSettingsPath();
+
+  let settings = {};
+  if (fs.existsSync(settingsPath)) {
+    settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+  }
+
+  if (!settings.env) {
+    settings.env = {};
+  }
+
+  const { baseUrl, apiKey, modelConfig, presetId, proxyUrl } = channel;
+
+  const useAuthToken = settings.env.ANTHROPIC_AUTH_TOKEN !== undefined;
+  const useApiKey = settings.env.ANTHROPIC_API_KEY !== undefined;
+
+  settings.env.ANTHROPIC_BASE_URL = baseUrl;
+
+  if (useAuthToken || (!useAuthToken && !useApiKey)) {
+    settings.env.ANTHROPIC_AUTH_TOKEN = apiKey;
+    delete settings.env.ANTHROPIC_API_KEY;
+  } else {
+    settings.env.ANTHROPIC_API_KEY = apiKey;
+  }
+
+  if (presetId && presetId !== 'official' && modelConfig) {
+    if (modelConfig.model) {
+      settings.env.ANTHROPIC_MODEL = modelConfig.model;
+    }
+    if (modelConfig.haikuModel) {
+      settings.env.ANTHROPIC_DEFAULT_HAIKU_MODEL = modelConfig.haikuModel;
+    }
+    if (modelConfig.sonnetModel) {
+      settings.env.ANTHROPIC_DEFAULT_SONNET_MODEL = modelConfig.sonnetModel;
+    }
+    if (modelConfig.opusModel) {
+      settings.env.ANTHROPIC_DEFAULT_OPUS_MODEL = modelConfig.opusModel;
+    }
+  } else {
+    delete settings.env.ANTHROPIC_MODEL;
+    delete settings.env.ANTHROPIC_DEFAULT_HAIKU_MODEL;
+    delete settings.env.ANTHROPIC_DEFAULT_SONNET_MODEL;
+    delete settings.env.ANTHROPIC_DEFAULT_OPUS_MODEL;
+  }
+
+  if (proxyUrl) {
+    settings.env.HTTPS_PROXY = proxyUrl;
+    settings.env.HTTP_PROXY = proxyUrl;
+  } else {
+    delete settings.env.HTTPS_PROXY;
+    delete settings.env.HTTP_PROXY;
+    delete settings.env.NO_PROXY;
+  }
+
+  settings.apiKeyHelper = `echo '${apiKey}'`;
+
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
+}
+
+function updateClaudeSettings(baseUrl, apiKey) {
+  const settingsPath = getClaudeSettingsPath();
+
+  let settings = {};
+  if (fs.existsSync(settingsPath)) {
+    settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+  }
+
+  if (!settings.env) {
+    settings.env = {};
+  }
+
+  const useAuthToken = settings.env.ANTHROPIC_AUTH_TOKEN !== undefined;
+  const useApiKey = settings.env.ANTHROPIC_API_KEY !== undefined;
+
+  settings.env.ANTHROPIC_BASE_URL = baseUrl;
+
+  if (useAuthToken || (!useAuthToken && !useApiKey)) {
+    settings.env.ANTHROPIC_AUTH_TOKEN = apiKey;
+    delete settings.env.ANTHROPIC_API_KEY;
+  } else {
+    settings.env.ANTHROPIC_API_KEY = apiKey;
+  }
+
+  settings.apiKeyHelper = `echo '${apiKey}'`;
+
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
+}
+
+module.exports = {
+  getAllChannels,
+  getCurrentSettings,
+  createChannel,
+  updateChannel,
+  deleteChannel,
+  applyChannelToSettings,
+  getBestChannelForRestore,
+  updateClaudeSettings
+};