@adversity/coding-tool-x 3.1.0 → 3.1.2

package/src/server/api/channels.js

@@ -12,10 +12,19 @@ const {
 } = require('../services/channels');
 const { getSchedulerState } = require('../services/channel-scheduler');
 const { getChannelHealthStatus, getAllChannelHealthStatus, resetChannelHealth } = require('../services/channel-health');
-const { testChannelSpeed, testMultipleChannels, getLatencyLevel } = require('../services/speed-test');
-const { fetchModelsFromProvider } = require('../services/model-detector');
+const {
+  testChannelSpeed,
+  getLatencyLevel,
+  sanitizeBatchConcurrency,
+  runWithConcurrencyLimit
+} = require('../services/speed-test');
+const {
+  probeModelAvailability,
+  fetchModelsFromProvider
+} = require('../services/model-detector');
 const { broadcastLog, broadcastProxyState, broadcastSchedulerState } = require('../websocket-server');
 const { clearRedirectCache } = require('../proxy-server');
+const CLAUDE_GATEWAY_SOURCE_TYPE = 'claude';
 
 // GET /api/channels - Get all channels with health status
 router.get('/', (req, res) => {
@@ -66,16 +75,40 @@ router.get('/current', (req, res) => {
 // POST /api/channels - Create new channel
 router.post('/', (req, res) => {
   try {
-    const { name, baseUrl, apiKey, websiteUrl, enabled, weight, maxConcurrency } = req.body;
+    const {
+      name,
+      baseUrl,
+      apiKey,
+      websiteUrl,
+      enabled,
+      weight,
+      maxConcurrency,
+      presetId,
+      modelConfig,
+      modelRedirects,
+      proxyUrl,
+      speedTestModel,
+      gatewaySourceType
+    } = req.body;
+
+    if (!name || !baseUrl) {
+      return res.status(400).json({ error: 'Missing required fields: name, baseUrl' });
+    }
 
-    if (!name || !baseUrl || !apiKey) {
-      return res.status(400).json({ error: 'Missing required fields' });
+    if (!apiKey) {
+      return res.status(400).json({ error: 'Missing required fields: apiKey' });
     }
 
     const channel = createChannel(name, baseUrl, apiKey, websiteUrl, {
       enabled,
       weight,
-      maxConcurrency
+      maxConcurrency,
+      presetId,
+      modelConfig,
+      modelRedirects: modelRedirects || [],
+      proxyUrl: proxyUrl || '',
+      speedTestModel: speedTestModel || null,
+      gatewaySourceType
     });
     res.json({ channel });
     broadcastSchedulerState('claude', getSchedulerState('claude'));
@@ -114,10 +147,10 @@ router.put('/:id', (req, res) => {
 });
 
 // DELETE /api/channels/:id - Delete channel
-router.delete('/:id', (req, res) => {
+router.delete('/:id', async (req, res) => {
   try {
     const { id } = req.params;
-    const result = deleteChannel(id);
+    const result = await deleteChannel(id);
     res.json(result);
     broadcastSchedulerState('claude', getSchedulerState('claude'));
   } catch (error) {
@@ -213,9 +246,10 @@ router.post('/:id/speed-test', async (req, res) => {
       return res.status(404).json({ error: '渠道不存在' });
     }
 
-    // Claude 渠道使用 'claude' 类型
-    const result = await testChannelSpeed(channel, timeout, 'claude');
+    const speedTestType = CLAUDE_GATEWAY_SOURCE_TYPE;
+    const result = await testChannelSpeed(channel, timeout, speedTestType);
     result.level = getLatencyLevel(result.latency);
+    result.gatewaySourceType = speedTestType;
 
     res.json(result);
   } catch (error) {
@@ -228,12 +262,6 @@ router.post('/:id/speed-test', async (req, res) => {
 router.get('/:id/models', async (req, res) => {
   try {
     const { id } = req.params;
-    const VALID_CHANNEL_TYPES = ['claude', 'codex', 'gemini', 'openai_compatible'];
-    const { type = 'claude' } = req.query;
-
-    if (!VALID_CHANNEL_TYPES.includes(type)) {
-      return res.status(400).json({ error: 'Invalid channel type', channelId: id });
-    }
 
     const channels = getAllChannels();
     const channel = channels.find(ch => ch.id === id);
@@ -242,23 +270,53 @@ router.get('/:id/models', async (req, res) => {
       return res.status(404).json({ error: '渠道不存在' });
     }
 
-    // If no type specified or type is 'claude', auto-detect
-    let channelType = type;
-    if (!type || type === 'claude') {
-      const { detectChannelType } = require('../services/model-detector');
-      channelType = detectChannelType(channel);
-      console.log(`[API] Auto-detected channel type: ${channelType} for ${channel.name}`);
+    const gatewaySourceType = CLAUDE_GATEWAY_SOURCE_TYPE;
+    const listResult = await fetchModelsFromProvider(channel, 'openai_compatible');
+    const listedModels = Array.isArray(listResult.models) ? listResult.models : [];
+    let result;
+
+    if (listedModels.length > 0) {
+      result = {
+        models: listedModels,
+        supported: true,
+        cached: !!listResult.cached,
+        fallbackUsed: false,
+        lastChecked: listResult.lastChecked || new Date().toISOString(),
+        error: null,
+        errorHint: null
+      };
+    } else {
+      const usingConfiguredProbe = !!listResult.disabledByConfig;
+      const probe = await probeModelAvailability(channel, gatewaySourceType, {
+        stopOnFirstAvailable: false
+      });
+      const probedModels = Array.isArray(probe.availableModels) ? probe.availableModels : [];
+
+      result = {
+        models: probedModels,
+        supported: probedModels.length > 0,
+        cached: !!probe.cached || !!listResult.cached,
+        fallbackUsed: probedModels.length > 0,
+        lastChecked: probe.lastChecked || listResult.lastChecked || new Date().toISOString(),
+        error: probedModels.length > 0 ? null : (listResult.error || '无法获取可用模型'),
+        errorHint: probedModels.length > 0
+          ? (usingConfiguredProbe ? '已按设置跳过 /v1/models，使用默认模型探测结果' : '模型列表接口不可用，已使用模型探测结果')
+          : (listResult.errorHint || (usingConfiguredProbe
+            ? '已按设置跳过 /v1/models，且默认模型探测无可用结果'
+            : '模型列表接口不可用且模型探测无可用结果'))
+      };
     }
 
-    const result = await fetchModelsFromProvider(channel, channelType);
-
     res.json({
       channelId: id,
+      gatewaySourceType,
       models: result.models,
       supported: result.supported,
+      fallbackUsed: result.fallbackUsed,
       cached: result.cached,
       fetchedAt: result.lastChecked || new Date().toISOString(),
-      error: result.error
+      error: result.error,
+      errorHint: result.errorHint
     });
   } catch (error) {
     console.error('Error fetching channel models:', error);
@@ -272,18 +330,36 @@ router.get('/:id/models', async (req, res) => {
 // POST /api/channels/speed-test-all - Test all channels speed
 router.post('/speed-test-all', async (req, res) => {
   try {
-    const { timeout = 10000 } = req.body;
+    const { timeout = 10000, concurrency } = req.body || {};
     const channels = getAllChannels();
+    const safeConcurrency = sanitizeBatchConcurrency(concurrency);
 
     if (channels.length === 0) {
       return res.json({ results: [], message: '没有可测试的渠道' });
     }
 
-    // Claude 渠道使用 'claude' 类型
-    const results = await testMultipleChannels(channels, timeout, 'claude');
-    // 添加延迟等级
-    results.forEach(r => {
-      r.level = getLatencyLevel(r.latency);
+    const results = await runWithConcurrencyLimit(
+      channels,
+      safeConcurrency,
+      async channel => {
+        const speedTestType = CLAUDE_GATEWAY_SOURCE_TYPE;
+        const result = await testChannelSpeed(channel, timeout, speedTestType);
+        result.level = getLatencyLevel(result.latency);
+        result.gatewaySourceType = speedTestType;
+        return result;
+      }
+    );
+
+    // 与其他渠道保持一致：成功在前，成功结果按延迟升序
+    results.sort((a, b) => {
+      if (a.success && !b.success) return -1;
+      if (!a.success && b.success) return 1;
+      if (a.success && b.success) {
+        const aLatency = (a.latency === null || a.latency === undefined) ? Infinity : a.latency;
+        const bLatency = (b.latency === null || b.latency === undefined) ? Infinity : b.latency;
+        return aLatency - bLatency;
+      }
+      return 0;
     });
 
     res.json({
@@ -292,7 +368,8 @@ router.post('/speed-test-all', async (req, res) => {
         total: results.length,
         success: results.filter(r => r.success).length,
         failed: results.filter(r => !r.success).length,
-        avgLatency: calculateAvgLatency(results)
+        avgLatency: calculateAvgLatency(results),
+        concurrency: safeConcurrency
       }
     });
   } catch (error) {
@@ -303,7 +380,9 @@ router.post('/speed-test-all', async (req, res) => {
 
 // 计算平均延迟
 function calculateAvgLatency(results) {
-  const successResults = results.filter(r => r.success && r.latency);
+  const successResults = results.filter(
+    r => r.success && r.latency !== null && r.latency !== undefined
+  );
   if (successResults.length === 0) return null;
   const sum = successResults.reduce((acc, r) => acc + r.latency, 0);
   return Math.round(sum / successResults.length);

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

@@ -13,9 +13,18 @@ const { getSchedulerState } = require('../services/channel-scheduler');
 const { getChannelHealthStatus, resetChannelHealth } = require('../services/channel-health');
 const { broadcastSchedulerState, broadcastLog } = require('../websocket-server');
 const { isCodexInstalled } = require('../services/codex-config');
-const { testChannelSpeed, testMultipleChannels, getLatencyLevel } = require('../services/speed-test');
+const {
+  testChannelSpeed,
+  getLatencyLevel,
+  sanitizeBatchConcurrency,
+  runWithConcurrencyLimit
+} = require('../services/speed-test');
 const { clearCodexRedirectCache } = require('../codex-proxy-server');
-const { fetchModelsFromProvider } = require('../services/model-detector');
+const {
+  fetchModelsFromProvider,
+  probeModelAvailability,
+} = require('../services/model-detector');
+const CODEX_GATEWAY_SOURCE_TYPE = 'codex';
 
 module.exports = (config) => {
   /**
@@ -58,11 +67,50 @@ module.exports = (config) => {
         return res.status(404).json({ error: '渠道不存在' });
       }
 
-      // Codex 渠道大多数是 OpenAI 兼容的
-      const result = await fetchModelsFromProvider(channel, 'openai_compatible');
+      const gatewaySourceType = CODEX_GATEWAY_SOURCE_TYPE;
+      const listResult = await fetchModelsFromProvider(channel, 'openai_compatible');
+      const listedModels = Array.isArray(listResult.models) ? listResult.models : [];
+      let result;
+
+      if (listedModels.length > 0) {
+        result = listResult;
+      } else {
+        const usingConfiguredProbe = !!listResult.disabledByConfig;
+        const probe = await probeModelAvailability(channel, 'codex');
+        const probedModels = Array.isArray(probe.availableModels) ? probe.availableModels : [];
+
+        if (probedModels.length > 0) {
+          result = {
+            models: probedModels,
+            supported: true,
+            cached: !!probe.cached,
+            fallbackUsed: false,
+            lastChecked: probe.lastChecked || listResult.lastChecked || new Date().toISOString(),
+            error: null,
+            errorHint: listResult.error
+              ? (usingConfiguredProbe
+                ? '已按设置跳过 /v1/models，使用默认模型探测结果'
+                : '模型列表接口不可用，已自动切换为模型探测结果')
+              : null
+          };
+        } else {
+          result = {
+            models: [],
+            supported: false,
+            cached: !!probe.cached || !!listResult.cached,
+            fallbackUsed: false,
+            lastChecked: probe.lastChecked || listResult.lastChecked || new Date().toISOString(),
+            error: listResult.error || '无法探测可用模型',
+            errorHint: listResult.errorHint || (usingConfiguredProbe
+              ? '已按设置跳过 /v1/models，且默认模型探测无可用结果'
+              : '模型列表接口不可用且模型探测无可用结果')
+          };
+        }
+      }
 
       res.json({
         channelId: id,
+        gatewaySourceType,
         models: result.models,
         supported: result.supported,
         cached: result.cached,
@@ -91,10 +139,27 @@ module.exports = (config) => {
         return res.status(404).json({ error: 'Codex CLI not installed' });
       }
 
-      const { name, providerKey, baseUrl, apiKey, websiteUrl, enabled, weight, maxConcurrency } = req.body;
+      const {
+        name,
+        providerKey,
+        baseUrl,
+        apiKey,
+        websiteUrl,
+        enabled,
+        weight,
+        maxConcurrency,
+        modelRedirects,
+        speedTestModel,
+        presetId,
+        gatewaySourceType
+      } = req.body;
+
+      if (!name || !providerKey || !baseUrl) {
+        return res.status(400).json({ error: 'Missing required fields: name, providerKey, baseUrl' });
+      }
 
-      if (!name || !providerKey || !baseUrl || !apiKey) {
-        return res.status(400).json({ error: 'Missing required fields' });
+      if (!apiKey) {
+        return res.status(400).json({ error: 'Missing required fields: apiKey' });
       }
 
       // wireApi 固定为 'responses' (OpenAI Responses API 格式)
@@ -102,7 +167,11 @@ module.exports = (config) => {
         websiteUrl,
         enabled,
         weight,
-        maxConcurrency
+        maxConcurrency,
+        modelRedirects: modelRedirects || [],
+        speedTestModel: speedTestModel || null,
+        presetId: presetId || null,
+        gatewaySourceType
       });
       res.json(channel);
       broadcastSchedulerState('codex', getSchedulerState('codex'));
@@ -140,14 +209,14 @@ module.exports = (config) => {
    * DELETE /api/codex/channels/:channelId
    * 删除渠道
    */
-  router.delete('/:channelId', (req, res) => {
+  router.delete('/:channelId', async (req, res) => {
     try {
       if (!isCodexInstalled()) {
         return res.status(404).json({ error: 'Codex CLI not installed' });
       }
 
       const { channelId } = req.params;
-      const result = deleteChannel(channelId);
+      const result = await deleteChannel(channelId);
       res.json(result);
       broadcastSchedulerState('codex', getSchedulerState('codex'));
     } catch (err) {
@@ -217,8 +286,10 @@ module.exports = (config) => {
         return res.status(404).json({ error: '渠道不存在' });
       }
 
-      const result = await testChannelSpeed(channel, timeout, 'codex');
+      const speedTestType = CODEX_GATEWAY_SOURCE_TYPE;
+      const result = await testChannelSpeed(channel, timeout, speedTestType);
       result.level = getLatencyLevel(result.latency);
+      result.gatewaySourceType = speedTestType;
 
       res.json(result);
     } catch (error) {
@@ -237,18 +308,37 @@ module.exports = (config) => {
         return res.json({ results: [], message: 'Codex CLI not installed' });
       }
 
-      const { timeout = 10000 } = req.body;
+      const { timeout = 10000, concurrency } = req.body || {};
       const data = getChannels();
       const channels = data.channels || [];
+      const safeConcurrency = sanitizeBatchConcurrency(concurrency);
 
       if (channels.length === 0) {
         return res.json({ results: [], message: '没有可测试的渠道' });
       }
 
-      // Codex 渠道使用 'codex' 类型
-      const results = await testMultipleChannels(channels, timeout, 'codex');
-      results.forEach(r => {
-        r.level = getLatencyLevel(r.latency);
+      const results = await runWithConcurrencyLimit(
+        channels,
+        safeConcurrency,
+        async channel => {
+          const speedTestType = CODEX_GATEWAY_SOURCE_TYPE;
+          const result = await testChannelSpeed(channel, timeout, speedTestType);
+          result.level = getLatencyLevel(result.latency);
+          result.gatewaySourceType = speedTestType;
+          return result;
+        }
+      );
+
+      // 成功在前，成功结果按延迟升序
+      results.sort((a, b) => {
+        if (a.success && !b.success) return -1;
+        if (!a.success && b.success) return 1;
+        if (a.success && b.success) {
+          const aLatency = (a.latency === null || a.latency === undefined) ? Infinity : a.latency;
+          const bLatency = (b.latency === null || b.latency === undefined) ? Infinity : b.latency;
+          return aLatency - bLatency;
+        }
+        return 0;
       });
 
       res.json({
@@ -257,7 +347,8 @@ module.exports = (config) => {
           total: results.length,
           success: results.filter(r => r.success).length,
           failed: results.filter(r => !r.success).length,
-          avgLatency: calculateAvgLatency(results)
+          avgLatency: calculateAvgLatency(results),
+          concurrency: safeConcurrency
         }
       });
     } catch (error) {
@@ -345,7 +436,9 @@ module.exports = (config) => {
 
 // 计算平均延迟
 function calculateAvgLatency(results) {
-  const successResults = results.filter(r => r.success && r.latency);
+  const successResults = results.filter(
+    r => r.success && r.latency !== null && r.latency !== undefined
+  );
   if (successResults.length === 0) return null;
   const sum = successResults.reduce((acc, r) => acc + r.latency, 0);
   return Math.round(sum / successResults.length);

package/src/server/api/codex-proxy.js

@@ -15,9 +15,9 @@ const {
 } = require('../services/codex-settings-manager');
 const { getChannels, getEnabledChannels } = require('../services/codex-channels');
 const { clearAllLogs } = require('../websocket-server');
+const { PATHS, ensureStorageDirMigrated } = require('../../config/paths');
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
 
 function sanitizeChannel(channel) {
   if (!channel) return null;
@@ -32,14 +32,24 @@ function sanitizeChannel(channel) {
 
 // 保存激活渠道ID
 function saveActiveChannelId(channelId) {
-  const dir = path.join(os.homedir(), '.claude', 'cc-tool');
+  ensureStorageDirMigrated();
+  const filePath = PATHS.activeChannel.codex;
+  const dir = path.dirname(filePath);
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
   }
-  const filePath = path.join(dir, 'codex-active-channel.json');
   fs.writeFileSync(filePath, JSON.stringify({ activeChannelId: channelId }, null, 2), 'utf8');
 }
 
+function removeActiveChannelFile() {
+  ensureStorageDirMigrated();
+  const filePath = PATHS.activeChannel.codex;
+  if (fs.existsSync(filePath)) {
+    fs.unlinkSync(filePath);
+    console.log('[Codex Proxy] Removed codex-active-channel.json');
+  }
+}
+
 // 获取代理状态
 router.get('/status', (req, res) => {
   try {
@@ -147,11 +157,7 @@ router.post('/stop', async (req, res) => {
       console.log('[Codex Proxy] Restored settings from backup');
 
       // 删除 active-channel.json
-      const activeChannelPath = path.join(os.homedir(), '.claude', 'cc-tool', 'codex-active-channel.json');
-      if (fs.existsSync(activeChannelPath)) {
-        fs.unlinkSync(activeChannelPath);
-        console.log('[Codex Proxy] Removed codex-active-channel.json');
-      }
+      removeActiveChannelFile();
 
       const response = {
         success: true,