coding-tool-x 3.5.12 → 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/opencode-proxy-server.js

@@ -1924,6 +1924,12 @@ function reportOpenCodeGatewayFailure({
 }
 
 function publishOpenCodeUsageLog({ requestId, channel, model, usage, startTime }) {
+  const parsedUsage = parseNonStreamingUsage({
+    model: model || '',
+    usage: usage && typeof usage === 'object' ? usage : {}
+  });
+  const parsedTokens = parsedUsage.tokens || {};
+
   return publishUsageLog({
     source: 'opencode',
     metadata: {
@@ -1932,15 +1938,15 @@ function publishOpenCodeUsageLog({ requestId, channel, model, usage, startTime }
       channelId: channel?.id,
       startTime
     },
-    model: model || '',
+    model: parsedUsage.model || model || '',
     tokens: {
-      input: Number(usage?.input_tokens || usage?.prompt_tokens || 0),
-      output: Number(usage?.output_tokens || usage?.completion_tokens || 0),
-      cacheCreation: Number(usage?.cache_creation_input_tokens || 0),
-      cacheRead: Number(usage?.cache_read_input_tokens || 0),
-      cached: Number(usage?.input_tokens_details?.cached_tokens || 0),
-      reasoning: Number(usage?.output_tokens_details?.reasoning_tokens || 0),
-      total: Number(usage?.total_tokens || 0)
+      input: Number(parsedTokens.input || 0),
+      output: Number(parsedTokens.output || 0),
+      cacheCreation: Number(parsedTokens.cacheCreation || 0),
+      cacheRead: Number(parsedTokens.cacheRead || 0),
+      cached: Number(parsedTokens.cached || 0),
+      reasoning: Number(parsedTokens.reasoning || 0),
+      total: Number(parsedTokens.total || 0)
     },
     calculateCost,
     broadcastLog,

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/base/response-usage-parser.js

@@ -64,6 +64,15 @@ function parseUsageObject(rawUsage) {
     rawUsage.inputTokensDetails !== undefined ||
     rawUsage.output_tokens_details !== undefined ||
     rawUsage.outputTokensDetails !== undefined;
+  const hasOpenAiCompatibilityFields =
+    hasOpenAiPromptFields ||
+    hasOpenAiResponseFields ||
+    rawUsage.cached_tokens !== undefined ||
+    rawUsage.cachedTokens !== undefined ||
+    rawUsage.reasoning_tokens !== undefined ||
+    rawUsage.reasoningTokens !== undefined ||
+    rawUsage.completion_tokens_details !== undefined ||
+    rawUsage.completionTokensDetails !== undefined;
 
   const input = readNumericField(rawUsage, ['input_tokens', 'prompt_tokens', 'inputTokens', 'promptTokens']);
   if (input !== undefined) tokens.input = input;
@@ -74,31 +83,43 @@ function parseUsageObject(rawUsage) {
   const total = readNumericField(rawUsage, ['total_tokens', 'totalTokens']);
   if (total !== undefined) tokens.total = total;
 
-  const cacheCreation = readNumericField(rawUsage, ['cache_creation_input_tokens', 'cacheCreationInputTokens']);
+  const cacheCreation = readNumericField(rawUsage, ['cache_creation_input_tokens', 'cacheCreationInputTokens'])
+    ?? readNestedNumericField(rawUsage, [
+      ['prompt_tokens_details', 'cache_creation_input_tokens'],
+      ['promptTokensDetails', 'cacheCreationInputTokens']
+    ]);
   if (cacheCreation !== undefined) tokens.cacheCreation = cacheCreation;
 
   const cacheRead = readNumericField(rawUsage, ['cache_read_input_tokens', 'cacheReadInputTokens']);
   if (cacheRead !== undefined) tokens.cacheRead = cacheRead;
 
-  const cached = readNestedNumericField(rawUsage, [
-    ['input_tokens_details', 'cached_tokens'],
-    ['prompt_tokens_details', 'cached_tokens'],
-    ['inputTokensDetails', 'cachedTokens'],
-    ['promptTokensDetails', 'cachedTokens']
-  ]);
+  const cached = readNumericField(rawUsage, ['cached_tokens', 'cachedTokens'])
+    ?? readNestedNumericField(rawUsage, [
+      ['input_tokens_details', 'cached_tokens'],
+      ['prompt_tokens_details', 'cached_tokens'],
+      ['inputTokensDetails', 'cachedTokens'],
+      ['promptTokensDetails', 'cachedTokens']
+    ]);
   if (cached !== undefined) tokens.cached = cached;
 
-  const reasoning = readNestedNumericField(rawUsage, [
-    ['output_tokens_details', 'reasoning_tokens'],
-    ['outputTokensDetails', 'reasoningTokens']
-  ]);
+  const reasoning = readNumericField(rawUsage, ['reasoning_tokens', 'reasoningTokens'])
+    ?? readNestedNumericField(rawUsage, [
+      ['completion_tokens_details', 'reasoning_tokens'],
+      ['output_tokens_details', 'reasoning_tokens'],
+      ['completionTokensDetails', 'reasoningTokens'],
+      ['outputTokensDetails', 'reasoningTokens']
+    ]);
   if (reasoning !== undefined) tokens.reasoning = reasoning;
 
+  if (tokens.total === undefined && tokens.input !== undefined && tokens.output !== undefined && !hasAnthropicCacheFields) {
+    tokens.total = tokens.input + tokens.output;
+  }
+
   // OpenAI/OpenAI-compatible usage commonly reports prompt/input totals that
   // already include cache hits. Align with OpenCode's provider contract by
   // moving cached prompt tokens into a dedicated field and keeping input as the
   // net uncached prompt tokens.
-  if (!hasAnthropicCacheFields && (hasOpenAiPromptFields || hasOpenAiResponseFields) && tokens.cached !== undefined && tokens.input !== undefined) {
+  if (!hasAnthropicCacheFields && hasOpenAiCompatibilityFields && tokens.cached !== undefined && tokens.input !== undefined) {
     tokens.input = Math.max(tokens.input - tokens.cached, 0);
   }
 
@@ -132,13 +153,16 @@ function parseSSEUsage(parsed, eventType) {
   if (eventType === 'message_start' && parsed.message && parsed.message.model) {
     model = parsed.message.model;
   }
+  if (!tokens && parsed.message && parsed.message.usage) {
+    tokens = parseUsageObject(parsed.message.usage);
+  }
   if (eventType === 'message_stop') {
     isDone = true;
   }
 
   // === OpenAI Responses API 格式 ===
   // data: {"type": "response.completed", "response": {"model", "usage": {...}}}
-  if (parsed.type === 'response.completed' && parsed.response) {
+  if ((parsed.type === 'response.completed' || parsed.type === 'response.incomplete') && parsed.response) {
     if (parsed.response.model) {
       model = parsed.response.model;
     }
@@ -171,6 +195,9 @@ function parseSSEUsage(parsed, eventType) {
     if (parsed.usageMetadata.cachedContentTokenCount) {
       tokens.cached = parsed.usageMetadata.cachedContentTokenCount;
     }
+    if (parsed.usageMetadata.thoughtsTokenCount) {
+      tokens.reasoning = parsed.usageMetadata.thoughtsTokenCount;
+    }
   }
 
   // === 通用 model fallback ===

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