coding-tool-x 3.5.13 → 3.6.0

package/src/server/api/channels.js

@@ -13,12 +13,14 @@ const {
 } = require('../services/channels');
 const { getSchedulerState } = require('../services/channel-scheduler');
 const { getChannelHealthStatus, getAllChannelHealthStatus, resetChannelHealth } = require('../services/channel-health');
+const { fetchModelsFromProvider } = require('../services/model-detector');
 const {
   testChannelSpeed,
   getLatencyLevel,
   sanitizeBatchConcurrency,
   runWithConcurrencyLimit
 } = require('../services/speed-test');
+const { normalizeGatewaySourceType } = require('../services/base/proxy-utils');
 const { PATHS } = require('../../config/paths');
 const { deleteBackup } = require('../services/settings-manager');
 const { getDefaultSpeedTestModelByToolType } = require('../../config/model-metadata');
@@ -30,6 +32,19 @@ function getDefaultClaudeModel() {
   return getDefaultSpeedTestModelByToolType('claude');
 }
 
+function resolveClaudeGatewaySourceType(channel, requestedType) {
+  return normalizeGatewaySourceType(requestedType || channel?.gatewaySourceType, 'claude');
+}
+
+function getDefaultModelsForGatewaySourceType(gatewaySourceType) {
+  if (gatewaySourceType === 'openai_compatible' || gatewaySourceType === 'codex') {
+    const model = getDefaultSpeedTestModelByToolType('codex');
+    return model ? [model] : [];
+  }
+  const model = getDefaultClaudeModel();
+  return model ? [model] : [];
+}
+
 // GET /api/channels - Get all channels with health status
 router.get('/', (req, res) => {
   try {
@@ -92,7 +107,8 @@ router.post('/', (req, res) => {
       modelRedirects,
       proxyUrl,
       speedTestModel,
-      gatewaySourceType
+      gatewaySourceType,
+      targetApi
     } = req.body;
 
     if (!name || !baseUrl) {
@@ -112,7 +128,8 @@ router.post('/', (req, res) => {
       modelRedirects: modelRedirects || [],
       proxyUrl: proxyUrl || '',
       speedTestModel: speedTestModel || null,
-      gatewaySourceType
+      gatewaySourceType,
+      targetApi
     });
     res.json({ channel });
     broadcastSchedulerState('claude', getSchedulerState('claude'));
@@ -224,7 +241,7 @@ router.post('/:id/apply-to-settings', async (req, res) => {
     });
   } catch (error) {
     console.error('Error applying channel to settings:', error);
-    res.status(500).json({ error: error.message });
+    res.status(error.statusCode || 500).json({ error: error.message });
   }
 });
 
@@ -256,7 +273,7 @@ router.post('/:id/speed-test', async (req, res) => {
       return res.status(404).json({ error: '渠道不存在' });
     }
 
-    const speedTestType = CLAUDE_GATEWAY_SOURCE_TYPE;
+    const speedTestType = resolveClaudeGatewaySourceType(channel);
     const result = await testChannelSpeed(channel, timeout, speedTestType);
     result.level = getLatencyLevel(result.latency);
     result.gatewaySourceType = speedTestType;
@@ -280,18 +297,46 @@ router.get('/:id/models', async (req, res) => {
       return res.status(404).json({ error: '渠道不存在' });
     }
 
-    const gatewaySourceType = CLAUDE_GATEWAY_SOURCE_TYPE;
-    const models = [getDefaultClaudeModel()];
-    const now = new Date().toISOString();
-    const result = {
-      models,
-      supported: models.length > 0,
-      cached: false,
-      fallbackUsed: false,
-      lastChecked: now,
-      error: models.length > 0 ? null : '未配置默认模型列表',
-      errorHint: models.length > 0 ? null : '请在设置中配置 Claude 默认模型'
-    };
+    const gatewaySourceType = resolveClaudeGatewaySourceType(channel, req.query.type);
+    const fallbackModels = getDefaultModelsForGatewaySourceType(gatewaySourceType);
+    let result;
+
+    if (gatewaySourceType === 'openai_compatible' || gatewaySourceType === 'codex') {
+      try {
+        result = await fetchModelsFromProvider(channel, gatewaySourceType);
+      } catch (error) {
+        result = {
+          models: [],
+          supported: true,
+          cached: false,
+          fallbackUsed: true,
+          lastChecked: new Date().toISOString(),
+          error: error.message || '获取模型列表失败',
+          errorHint: '已回退到默认模型列表'
+        };
+      }
+
+      if (!Array.isArray(result.models) || result.models.length === 0) {
+        result = {
+          ...result,
+          models: fallbackModels,
+          fallbackUsed: true,
+          error: result.error || (fallbackModels.length > 0 ? null : '未配置默认模型列表'),
+          errorHint: result.errorHint || (fallbackModels.length > 0 ? '已回退到默认模型列表' : '请在设置中配置默认模型')
+        };
+      }
+    } else {
+      const now = new Date().toISOString();
+      result = {
+        models: fallbackModels,
+        supported: fallbackModels.length > 0,
+        cached: false,
+        fallbackUsed: false,
+        lastChecked: now,
+        error: fallbackModels.length > 0 ? null : '未配置默认模型列表',
+        errorHint: fallbackModels.length > 0 ? null : '请在设置中配置 Claude 默认模型'
+      };
+    }
 
     res.json({
       channelId: id,
@@ -328,7 +373,7 @@ router.post('/speed-test-all', async (req, res) => {
       channels,
       safeConcurrency,
       async channel => {
-        const speedTestType = CLAUDE_GATEWAY_SOURCE_TYPE;
+        const speedTestType = resolveClaudeGatewaySourceType(channel);
         const result = await testChannelSpeed(channel, timeout, speedTestType);
         result.level = getLatencyLevel(result.latency);
         result.gatewaySourceType = speedTestType;

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

@@ -166,7 +166,8 @@ module.exports = (config) => {
         modelRedirects: modelRedirects || [],
         speedTestModel: speedTestModel || null,
         presetId: presetId || null,
-        gatewaySourceType
+        gatewaySourceType,
+        requiresOpenaiAuth: false
       });
       res.json(channel);
       broadcastSchedulerState('codex', getSchedulerState('codex'));
@@ -188,12 +189,22 @@ module.exports = (config) => {
 
       const { channelId } = req.params;
       const updates = req.body;
+      const currentChannel = getChannels().channels.find(channel => channel.id === channelId) || null;
+      const finalApiKey = Object.prototype.hasOwnProperty.call(updates, 'apiKey')
+        ? updates.apiKey
+        : currentChannel?.apiKey;
       if (Object.prototype.hasOwnProperty.call(updates, 'providerKey')) {
         const providerKeyError = validateCodexProviderKey(updates.providerKey);
         if (providerKeyError) {
           return res.status(400).json({ error: providerKeyError });
         }
       }
+      if (currentChannel) {
+        if (!finalApiKey) {
+          return res.status(400).json({ error: 'Missing required fields: apiKey' });
+        }
+        updates.requiresOpenaiAuth = false;
+      }
 
       const channel = updateChannel(channelId, updates);
       // 清除该渠道的模型重定向日志缓存，使下次请求时重新打印

package/src/server/api/pm2-autostart.js

@@ -1,12 +1,10 @@
 const express = require('express');
 const { exec } = require('child_process');
-const { promisify } = require('util');
 const path = require('path');
 const fs = require('fs');
 const pm2 = require('pm2');
 const { HOME_DIR } = require('../../config/paths');
-
-const execAsync = promisify(exec);
+const PM2_BIN_PATH = require.resolve('pm2/bin/pm2');
 
 function getExecOptions(timeout = 30000, runtimePlatform = process.platform) {
   if (runtimePlatform === 'win32') {
@@ -15,6 +13,46 @@ function getExecOptions(timeout = 30000, runtimePlatform = process.platform) {
   return { shell: '/bin/bash', timeout, windowsHide: true };
 }
 
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
+function getPm2CliCommand() {
+  return `${shellQuote(process.execPath)} ${shellQuote(PM2_BIN_PATH)}`;
+}
+
+function listMatchingFiles(dirPath, matcher) {
+  if (!fs.existsSync(dirPath)) {
+    return [];
+  }
+
+  return fs.readdirSync(dirPath)
+    .filter(fileName => matcher.test(fileName))
+    .map(fileName => path.join(dirPath, fileName));
+}
+
+function getStartupCommand(runtimePlatform = process.platform) {
+  const pm2Cli = getPm2CliCommand();
+  if (runtimePlatform === 'darwin') {
+    return `${pm2Cli} startup launchd -u $(whoami) --hp $(eval echo ~$(whoami))`;
+  }
+  if (runtimePlatform === 'linux') {
+    return `${pm2Cli} startup systemd -u $(whoami) --hp $(eval echo ~$(whoami))`;
+  }
+  return `${pm2Cli} startup`;
+}
+
+function getUnstartupCommand(runtimePlatform = process.platform) {
+  const pm2Cli = getPm2CliCommand();
+  if (runtimePlatform === 'darwin') {
+    return `${pm2Cli} unstartup launchd -u $(whoami)`;
+  }
+  if (runtimePlatform === 'linux') {
+    return `${pm2Cli} unstartup systemd -u $(whoami)`;
+  }
+  return `${pm2Cli} unstartup`;
+}
+
 /**
  * Check if PM2 autostart is enabled
  * by looking for PM2 startup script in system
@@ -24,17 +62,21 @@ async function checkAutoStartStatus() {
     const platform = process.platform;
 
     if (platform === 'darwin') {
-      // macOS - check for LaunchDaemon
-      const launchDaemonsPath = path.join(HOME_DIR, 'Library/LaunchDaemons');
-      const pm2Files = fs.existsSync(launchDaemonsPath)
-        ? fs.readdirSync(launchDaemonsPath).filter(f => f.includes('pm2'))
-        : [];
-
-      return { enabled: pm2Files.length > 0, platform: 'darwin' };
+      const pm2Files = [
+        ...listMatchingFiles(path.join(HOME_DIR, 'Library/LaunchAgents'), /pm2/i),
+        ...listMatchingFiles(path.join(HOME_DIR, 'Library/LaunchDaemons'), /pm2/i),
+        ...listMatchingFiles('/Library/LaunchAgents', /pm2/i),
+        ...listMatchingFiles('/Library/LaunchDaemons', /pm2/i)
+      ];
+
+      return {
+        enabled: pm2Files.length > 0,
+        platform: 'darwin',
+        files: pm2Files
+      };
     } else if (platform === 'linux') {
       // Linux - check for systemd service
       const systemdPath = '/etc/systemd/system/pm2-root.service';
-      const userSystemdPath = path.join(HOME_DIR, '.config/systemd/user/pm2-*.service');
 
       const rootExists = fs.existsSync(systemdPath);
       const userExists = fs.existsSync(path.join(HOME_DIR, '.config/systemd/user')) &&
@@ -102,12 +144,7 @@ async function enableAutoStart() {
           }
 
           // Run startup command
-          const platform = process.platform;
-          const command = platform === 'darwin'
-            ? 'pm2 startup launchd -u $(whoami) --hp $(eval echo ~$(whoami))'
-            : platform === 'linux'
-            ? 'pm2 startup systemd -u $(whoami) --hp $(eval echo ~$(whoami))'
-            : 'pm2 startup';
+          const command = getStartupCommand();
 
           console.log(`Running startup command: ${command}`);
 
@@ -161,12 +198,7 @@ async function disableAutoStart() {
       }
 
       // Run unstartup command
-      const platform = process.platform;
-      const command = platform === 'darwin'
-        ? 'pm2 unstartup launchd -u $(whoami)'
-        : platform === 'linux'
-        ? 'pm2 unstartup systemd -u $(whoami)'
-        : 'pm2 unstartup';
+      const command = getUnstartupCommand();
 
       console.log(`Running unstartup command: ${command}`);
 
@@ -277,5 +309,8 @@ function createPm2AutostartRouter() {
 
 module.exports = createPm2AutostartRouter;
 module.exports._test = {
-  getExecOptions
+  getExecOptions,
+  getPm2CliCommand,
+  getStartupCommand,
+  getUnstartupCommand
 };

package/src/server/proxy-server.js

@@ -19,8 +19,15 @@ const eventBus = require('../plugins/event-bus');
 const { getEffectiveApiKey } = require('./services/channels');
 const { persistProxyRequestSnapshot, persistClaudeRequestTemplate } = require('./services/request-logger');
 const { publishUsageLog, publishFailureLog } = require('./services/proxy-log-helper');
-const { redirectModel } = require('./services/base/proxy-utils');
-const { parseSSEUsage, mergeUsageIntoTokenData, createTokenData } = require('./services/base/response-usage-parser');
+const { redirectModel, normalizeGatewaySourceType } = require('./services/base/proxy-utils');
+const { parseSSEUsage, parseNonStreamingUsage, mergeUsageIntoTokenData, createTokenData } = require('./services/base/response-usage-parser');
+const {
+  createClaudeStreamRecoveryState,
+  mergeClaudeStreamEvent,
+  buildAssistantMessageFromStreamState,
+  recoverClaudeUsageViaCountTokens
+} = require('./services/claude-token-recovery');
+const { handleClaudeOpenAiGatewayRequest } = require('./services/claude-openai-gateway');
 const { attachServerShutdownHandling, expediteServerShutdown } = require('./services/server-shutdown');
 
 let proxyServer = null;
@@ -172,6 +179,16 @@ function buildClaudeRequestSummary(req, sessionId = null) {
   };
 }
 
+function clearTokenDataUsage(tokenData) {
+  tokenData.inputTokens = 0;
+  tokenData.outputTokens = 0;
+  tokenData.cacheCreation = 0;
+  tokenData.cacheRead = 0;
+  tokenData.cachedTokens = 0;
+  tokenData.reasoningTokens = 0;
+  tokenData.totalTokens = 0;
+}
+
 async function startProxyServer(options = {}) {
   const preserveStartTime = options.preserveStartTime || false;
 
@@ -314,6 +331,21 @@ async function startProxyServer(options = {}) {
           }
         }
 
+        const gatewaySourceType = normalizeGatewaySourceType(channel.gatewaySourceType, 'claude');
+        if (gatewaySourceType === 'openai_compatible') {
+          const handled = await handleClaudeOpenAiGatewayRequest({
+            req,
+            res,
+            channel,
+            effectiveKey,
+            calculateCost,
+            onDone: release
+          });
+          if (handled) {
+            return;
+          }
+        }
+
         const proxyOptions = {
           target: channel.baseUrl,
           changeOrigin: true,
@@ -396,9 +428,16 @@ async function startProxyServer(options = {}) {
         requestMetadata.delete(req);
       });
 
+      const isSseResponse = proxyRes.headers['content-type']?.includes('text/event-stream');
       let buffer = '';
       let tokenData = createTokenData();
       let usageRecorded = false;
+      const streamRecoveryState = createClaudeStreamRecoveryState();
+      const usageObservation = {
+        sawAnyUsage: false,
+        sawMessageStartUsage: false,
+        sawNonInitialUsage: false
+      };
       const parsedStream = createDecodedStream(proxyRes);
 
       function recordUsageIfReady() {
@@ -434,6 +473,10 @@ async function startProxyServer(options = {}) {
 
         buffer += chunk.toString('utf8');
 
+        if (!isSseResponse) {
+          return;
+        }
+
         const events = buffer.split('\n\n');
         buffer = events.pop() || '';
 
@@ -456,10 +499,19 @@ async function startProxyServer(options = {}) {
             if (!data || data === '[DONE]') return;
 
             const parsed = JSON.parse(data);
+            mergeClaudeStreamEvent(streamRecoveryState, eventType, parsed);
             const usage = parseSSEUsage(parsed, eventType);
+            if (usage.tokens) {
+              usageObservation.sawAnyUsage = true;
+              if (eventType === 'message_start') {
+                usageObservation.sawMessageStartUsage = true;
+              } else {
+                usageObservation.sawNonInitialUsage = true;
+              }
+            }
             mergeUsageIntoTokenData(tokenData, usage);
 
-            if (usage.isDone) {
+            if (usage.isDone && (!isSseResponse || usageObservation.sawNonInitialUsage)) {
               recordUsageIfReady();
             }
           } catch (err) {
@@ -477,8 +529,48 @@ async function startProxyServer(options = {}) {
       };
 
       parsedStream.on('end', () => {
-        recordUsageIfReady();
-        finalize();
+        void (async () => {
+          if (!isSseResponse) {
+            try {
+              const parsed = JSON.parse(buffer);
+              const usage = parseNonStreamingUsage(parsed);
+              mergeUsageIntoTokenData(tokenData, usage);
+            } catch (err) {
+            }
+          } else {
+            const assistantMessage = buildAssistantMessageFromStreamState(streamRecoveryState);
+            const shouldRecoverUsage = Boolean(assistantMessage)
+              && (!usageObservation.sawAnyUsage || (usageObservation.sawMessageStartUsage && !usageObservation.sawNonInitialUsage));
+
+            if (shouldRecoverUsage) {
+              try {
+                const recoveredUsage = await recoverClaudeUsageViaCountTokens({
+                  baseUrl: req.selectedChannel?.baseUrl || '',
+                  apiKey: req.effectiveApiKey || '',
+                  requestBody: req.body,
+                  assistantMessage
+                });
+                if (recoveredUsage) {
+                  tokenData.model = tokenData.model || streamRecoveryState.model || '';
+                  tokenData.inputTokens = Number(recoveredUsage.inputTokens || 0);
+                  tokenData.outputTokens = Number(recoveredUsage.outputTokens || 0);
+                  // Let publishUsageLog recompute Claude totals from the recovered
+                  // prompt/output pair plus any cache fields already present.
+                  tokenData.totalTokens = 0;
+                } else {
+                  tokenData.model = tokenData.model || streamRecoveryState.model || '';
+                  clearTokenDataUsage(tokenData);
+                }
+              } catch (error) {
+                tokenData.model = tokenData.model || streamRecoveryState.model || '';
+                clearTokenDataUsage(tokenData);
+              }
+            }
+          }
+
+          recordUsageIfReady();
+          finalize();
+        })();
       });
 
       parsedStream.on('error', (err) => {

package/src/server/services/channels.js

@@ -5,6 +5,7 @@ const { isProxyConfig } = require('./settings-manager');
 const { PATHS, NATIVE_PATHS } = require('../../config/paths');
 const { clearNativeOAuth } = require('./native-oauth-adapters');
 const { isWindowsLikePlatform } = require('../../utils/home-dir');
+const { normalizeGatewaySourceType } = require('./base/proxy-utils');
 
 // ── Claude 特有工具函数 ──
 
@@ -160,6 +161,27 @@ function resolveCurrentManagedChannel(channels = []) {
   return allChannels.find(ch => ch.enabled !== false) || null;
 }
 
+function normalizeClaudeTargetApi(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  if (normalized === 'chat' || normalized === 'chat/completions' || normalized === 'chat.completions') {
+    return 'chat.completions';
+  }
+  return 'responses';
+}
+
+function isOfficialOpenAiBaseUrl(baseUrl = '') {
+  try {
+    const parsed = new URL(String(baseUrl || '').trim());
+    return String(parsed.hostname || '').trim().toLowerCase() === 'api.openai.com';
+  } catch {
+    return false;
+  }
+}
+
+function isOpenAiCompatibleGateway(channel) {
+  return normalizeGatewaySourceType(channel?.gatewaySourceType, 'claude') === 'openai_compatible';
+}
+
 // ── ClaudeChannelService ──
 
 class ClaudeChannelService extends BaseChannelService {
@@ -179,6 +201,20 @@ class ClaudeChannelService extends BaseChannelService {
     return `channel-${Date.now()}`;
   }
 
+  _applyDefaults(channel) {
+    const normalized = super._applyDefaults(channel);
+    normalized.presetId = normalized.presetId || 'official';
+    normalized.modelConfig = normalized.modelConfig || {};
+    normalized.modelRedirects = Array.isArray(normalized.modelRedirects) ? normalized.modelRedirects : [];
+    normalized.proxyUrl = normalized.proxyUrl || '';
+    normalized.speedTestModel = normalized.speedTestModel || null;
+    normalized.targetApi = normalizeClaudeTargetApi(normalized.targetApi);
+    if (isOpenAiCompatibleGateway(normalized) && !isOfficialOpenAiBaseUrl(normalized.baseUrl)) {
+      normalized.targetApi = 'chat.completions';
+    }
+    return normalized;
+  }
+
   // Claude 使用缓存 + fs.watchFile
   loadChannels() {
     if (this._cacheInitialized && this._cache) {
@@ -209,7 +245,7 @@ class ClaudeChannelService extends BaseChannelService {
   }
 
   _onAfterCreate(channel, _allChannels) {
-    if (!isProxyConfig() && channel.enabled !== false) {
+    if (!isProxyConfig() && channel.enabled !== false && !isOpenAiCompatibleGateway(channel)) {
       this._applyToNativeSettings(channel);
     }
   }
@@ -220,12 +256,18 @@ class ClaudeChannelService extends BaseChannelService {
     }
 
     if (oldChannel.enabled === false && nextChannel.enabled !== false) {
-      this._applyToNativeSettings(nextChannel);
+      if (!isOpenAiCompatibleGateway(nextChannel)) {
+        this._applyToNativeSettings(nextChannel);
+      }
       return;
     }
 
     const activeChannel = resolveCurrentManagedChannel(allChannels);
-    if (nextChannel.enabled !== false && activeChannel?.id === nextChannel.id) {
+    if (
+      nextChannel.enabled !== false
+      && activeChannel?.id === nextChannel.id
+      && !isOpenAiCompatibleGateway(nextChannel)
+    ) {
       this._applyToNativeSettings(nextChannel);
     }
   }
@@ -236,11 +278,27 @@ class ClaudeChannelService extends BaseChannelService {
     }
 
     const activeChannel = resolveCurrentManagedChannel(allChannels);
-    if (activeChannel) {
+    if (activeChannel && !isOpenAiCompatibleGateway(activeChannel)) {
       this._applyToNativeSettings(activeChannel);
     }
   }
 
+  applyChannelToSettings(channelId) {
+    const data = this.loadChannels();
+    const channel = data.channels.find(ch => ch.id === channelId);
+    if (!channel) {
+      throw new Error('Channel not found');
+    }
+
+    if (isOpenAiCompatibleGateway(channel)) {
+      const error = new Error('OpenAI 格式渠道需要通过 Claude 代理使用，请先启动代理。');
+      error.statusCode = 400;
+      throw error;
+    }
+
+    return super.applyChannelToSettings(channelId);
+  }
+
   _applyToNativeSettings(channel) {
     updateClaudeSettingsWithModelConfig(channel);
   }