coding-tool-x 3.5.13 → 3.5.14

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);
   }