coding-tool-x 3.3.7 → 3.3.9

package/src/server/proxy-server.js

@@ -18,6 +18,7 @@ const { createDecodedStream } = require('./services/response-decoder');
 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');
 
 let proxyServer = null;
 let proxyApp = null;
@@ -313,20 +314,20 @@ async function startProxyServer(options = {}) {
         const effectiveKey = getEffectiveApiKey(channel);
         if (!effectiveKey) {
           release();
+          publishFailureLog({
+            source: 'claude',
+            channel: channel.name,
+            message: 'API key not configured or expired. Please update your channel key.',
+            statusCode: 401,
+            stage: 'preflight',
+            broadcastLog
+          });
           return res.status(401).json({
             error: 'API key not configured or expired. Please update your channel key.',
             type: 'authentication_error'
           });
         }
         req.effectiveApiKey = effectiveKey;
-
-        const now = new Date();
-        const time = now.toLocaleTimeString('zh-CN', {
-          hour12: false,
-          hour: '2-digit',
-          minute: '2-digit',
-          second: '2-digit'
-        });
         const requestSnapshot = serializeFullClaudeRequest(req);
         persistClaudeRequestSnapshot({
           timestamp: Date.now(),
@@ -373,6 +374,21 @@ async function startProxyServer(options = {}) {
           if (err) {
             // 记录请求失败
             recordFailure(channel.id, 'claude', err);
+            const metadata = requestMetadata.get(req) || {
+              id: null,
+              channel: channel.name,
+              channelId: channel.id,
+              startTime: Date.now()
+            };
+            publishFailureLog({
+              source: 'claude',
+              metadata,
+              message: err.message,
+              error: err,
+              statusCode: 502,
+              stage: 'proxy_web',
+              broadcastLog
+            });
             console.error('Proxy error:', err);
             if (res && !res.headersSent) {
               res.status(502).json({
@@ -384,6 +400,13 @@ async function startProxyServer(options = {}) {
         });
       } catch (error) {
         console.error('Channel allocation error:', error);
+        publishFailureLog({
+          source: 'claude',
+          message: error.message || '所有渠道暂时不可用',
+          statusCode: 503,
+          stage: 'allocate_channel',
+          broadcastLog
+        });
         if (!res.headersSent) {
           res.status(503).json({
             error: error.message || '所有渠道暂时不可用',
@@ -425,8 +448,34 @@ async function startProxyServer(options = {}) {
         cacheRead: 0,
         model: ''
       };
+      let usageRecorded = false;
       const parsedStream = createDecodedStream(proxyRes);
 
+      function recordUsageIfReady() {
+        if (usageRecorded) return false;
+
+        const result = publishUsageLog({
+          source: 'claude',
+          metadata,
+          model: tokenData.model,
+          tokens: {
+            input: tokenData.inputTokens,
+            output: tokenData.outputTokens,
+            cacheCreation: tokenData.cacheCreation,
+            cacheRead: tokenData.cacheRead
+          },
+          calculateCost,
+          broadcastLog,
+          recordRequest,
+          recordSuccess,
+          allowBroadcast: !isResponseClosed
+        });
+
+        if (!result) return false;
+        usageRecorded = true;
+        return true;
+      }
+
       parsedStream.on('data', (chunk) => {
         if (isResponseClosed) return;
 
@@ -474,57 +523,8 @@ async function startProxyServer(options = {}) {
               }
             }
 
-            if (eventType === 'message_delta' && parsed.usage) {
-              const now = new Date();
-              const time = now.toLocaleTimeString('zh-CN', {
-                hour12: false,
-                hour: '2-digit',
-                minute: '2-digit',
-                second: '2-digit'
-              });
-
-              const tokens = {
-                input: tokenData.inputTokens,
-                output: tokenData.outputTokens,
-                cacheCreation: tokenData.cacheCreation,
-                cacheRead: tokenData.cacheRead,
-                total: tokenData.inputTokens + tokenData.outputTokens + tokenData.cacheCreation + tokenData.cacheRead
-              };
-              const cost = calculateCost(tokenData.model, tokens);
-
-              if (!isResponseClosed) {
-                broadcastLog({
-                  type: 'log',
-                  id: metadata.id,
-                  time: time,
-                  channel: metadata.channel,
-                  model: tokenData.model,
-                  inputTokens: tokenData.inputTokens,
-                  outputTokens: tokenData.outputTokens,
-                  cacheCreation: tokenData.cacheCreation,
-                  cacheRead: tokenData.cacheRead,
-                  cost: cost,
-                  source: 'claude'
-                });
-              }
-
-              const duration = Date.now() - metadata.startTime;
-
-              recordRequest({
-                id: metadata.id,
-                timestamp: new Date(metadata.startTime).toISOString(),
-                toolType: 'claude-code',
-                channel: metadata.channel,
-                channelId: metadata.channelId,
-                model: tokenData.model,
-                tokens: tokens,
-                duration: duration,
-                success: true,
-                cost: cost
-              });
-
-              // 记录请求成功（用于健康检查）
-              recordSuccess(metadata.channelId, 'claude');
+            if (eventType === 'message_stop') {
+              recordUsageIfReady();
             }
           } catch (err) {
           }
@@ -540,7 +540,10 @@ async function startProxyServer(options = {}) {
         }
       };
 
-      parsedStream.on('end', finalize);
+      parsedStream.on('end', () => {
+        recordUsageIfReady();
+        finalize();
+      });
 
       parsedStream.on('error', (err) => {
         if (err.code !== 'EPIPE' && err.code !== 'ECONNRESET') {
@@ -550,6 +553,15 @@ async function startProxyServer(options = {}) {
         if (metadata && metadata.channelId) {
           recordFailure(metadata.channelId, 'claude', err);
         }
+        publishFailureLog({
+          source: 'claude',
+          metadata,
+          message: err.message,
+          error: err,
+          statusCode: proxyRes.statusCode,
+          stage: 'response_stream',
+          broadcastLog
+        });
         isResponseClosed = true;
         finalize();
       });
@@ -561,6 +573,20 @@ async function startProxyServer(options = {}) {
       if (req && req.selectedChannel && req.selectedChannel.id) {
         recordFailure(req.selectedChannel.id, 'claude', err);
       }
+      const metadata = req ? requestMetadata.get(req) : null;
+      publishFailureLog({
+        source: 'claude',
+        metadata: metadata || {
+          channel: req?.selectedChannel?.name,
+          channelId: req?.selectedChannel?.id,
+          model: req?.body?.model
+        },
+        message: err.message,
+        error: err,
+        statusCode: 502,
+        stage: 'proxy',
+        broadcastLog
+      });
       if (res && !res.headersSent) {
         res.status(502).json({
           error: 'Proxy error: ' + err.message,

package/src/server/services/alias.js

@@ -2,13 +2,13 @@ const fs = require('fs');
 const path = require('path');
 const { PATHS } = require('../../config/paths');
 
-const ALIAS_DIR = PATHS.base;
 const ALIAS_FILE = PATHS.aliases;
 
 // Ensure alias directory exists
 function ensureAliasDir() {
-  if (!fs.existsSync(ALIAS_DIR)) {
-    fs.mkdirSync(ALIAS_DIR, { recursive: true });
+  const dir = path.dirname(ALIAS_FILE);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
   }
 }
 

package/src/server/services/channels.js

@@ -1,9 +1,11 @@
 const fs = require('fs');
+const path = require('path');
 const { isProxyConfig } = require('./settings-manager');
 const { PATHS, NATIVE_PATHS } = require('../../config/paths');
+const { clearNativeOAuth } = require('./native-oauth-adapters');
 
 function getChannelsFilePath() {
-  const dir = PATHS.base;
+  const dir = path.dirname(PATHS.channels.claude);
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
   }
@@ -11,7 +13,7 @@ function getChannelsFilePath() {
 }
 
 function getActiveChannelIdPath() {
-  const dir = PATHS.base;
+  const dir = path.dirname(PATHS.activeChannel.claude);
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
   }
@@ -165,11 +167,13 @@ function getCurrentSettings() {
       return null;
     }
     const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+    const nativeOAuth = require('./native-oauth-adapters').readNativeOAuth('claude');
 
     let baseUrl = settings.env?.ANTHROPIC_BASE_URL || '';
-    let apiKey = settings.env?.ANTHROPIC_API_KEY ||
-                 settings.env?.ANTHROPIC_AUTH_TOKEN ||
-                 '';
+    let apiKey = settings.env?.ANTHROPIC_API_KEY || '';
+    if (!apiKey && !nativeOAuth) {
+      apiKey = settings.env?.ANTHROPIC_AUTH_TOKEN || '';
+    }
 
     if (!apiKey && settings.apiKeyHelper) {
       apiKey = extractApiKeyFromHelper(settings.apiKeyHelper);
@@ -288,14 +292,6 @@ function updateChannel(id, updates) {
     console.log(`[Single-channel mode] Enabled "${nextChannel.name}", disabled all others`);
   }
 
-  // Prevent disabling last enabled channel when proxy is OFF
-  if (!isProxyRunning && !nextChannel.enabled && oldChannel.enabled) {
-    const enabledCount = data.channels.filter(ch => ch.enabled).length;
-    if (enabledCount === 0) {
-      throw new Error('无法禁用最后一个启用的渠道。请先启用其他渠道或启动动态切换。');
-    }
-  }
-
   saveChannels(data);
 
   // Sync settings.json only when proxy is OFF.
@@ -341,6 +337,7 @@ function applyChannelToSettings(id) {
 }
 
 function updateClaudeSettingsWithModelConfig(channel) {
+  clearNativeOAuth('claude');
   const settingsPath = getClaudeSettingsPath();
 
   let settings = {};
@@ -354,17 +351,10 @@ function updateClaudeSettingsWithModelConfig(channel) {
 
   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;
-  }
+  settings.env.ANTHROPIC_API_KEY = apiKey;
+  delete settings.env.ANTHROPIC_AUTH_TOKEN;
+  delete settings.env.CLAUDE_CODE_OAUTH_TOKEN;
 
   if (presetId && presetId !== 'official' && modelConfig) {
     if (modelConfig.model) {
@@ -433,6 +423,12 @@ function getEffectiveApiKey(channel) {
   return channel.apiKey || null;
 }
 
+function disableAllChannels() {
+  const data = loadChannels();
+  data.channels.forEach(ch => { ch.enabled = false; });
+  saveChannels(data);
+}
+
 module.exports = {
   getAllChannels,
   getCurrentChannel,
@@ -444,5 +440,6 @@ module.exports = {
   getBestChannelForRestore,
   updateClaudeSettings,
   updateClaudeSettingsWithModelConfig,
-  getEffectiveApiKey
+  getEffectiveApiKey,
+  disableAllChannels
 };