coding-tool-x 3.5.10 → 3.5.12

package/src/server/services/opencode-gateway-converter.js

@@ -11,6 +11,8 @@
  * - OpenAI Chat Completions API (/v1/chat/completions)
  */
 
+const { ensureOpenAiStreamUsage } = require('./base/proxy-utils');
+
 const SUPPORTED_SOURCE_TYPES = ['claude', 'codex', 'gemini'];
 const SUPPORTED_TARGET_APIS = ['responses', 'chat.completions'];
 
@@ -554,6 +556,7 @@ function buildChatCompletionsRequest(normalized, options, warnings) {
     if (chatTools.length > 0) request.tools = chatTools;
   }
 
+  ensureOpenAiStreamUsage(request);
   return request;
 }
 

package/src/server/services/opencode-statistics-service.js

@@ -110,6 +110,7 @@ function recordRequest(requestData = {}) {
       input: normalizedTokens.input,
       output: normalizedTokens.output,
       reasoning: normalizedTokens.reasoning,
+      cached: normalizedTokens.cached,
       cacheCreation: normalizedTokens.cacheCreation,
       cacheRead: normalizedTokens.cacheRead,
       total: normalizedTokens.total

package/src/server/services/proxy-log-helper.js

@@ -12,6 +12,30 @@ function normalizeToolSource(source = '') {
   return 'claude';
 }
 
+function normalizeModelName(value = '') {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function resolveActualModel(model = '', metadata = {}) {
+  const candidates = [
+    model,
+    metadata.redirectedModel,
+    metadata.modelFromUrl,
+    metadata.requestModel,
+    metadata.model,
+    metadata.originalModel
+  ];
+
+  for (const candidate of candidates) {
+    const normalized = normalizeModelName(candidate);
+    if (normalized) {
+      return normalized;
+    }
+  }
+
+  return '';
+}
+
 function normalizeUsageTokens(source, tokens = {}) {
   const normalizedSource = normalizeToolSource(source);
   const input = toNumber(tokens.input);
@@ -68,7 +92,8 @@ function buildSuccessLogPayload({
   redirectedModel,
   tokens,
   cost = 0,
-  timestamp = Date.now()
+  timestamp = Date.now(),
+  usageMissing = false
 }) {
   const normalized = normalizeUsageTokens(source, tokens);
   const payload = {
@@ -87,7 +112,8 @@ function buildSuccessLogPayload({
     totalTokens: normalized.total,
     cost,
     source: normalizeToolSource(source),
-    timestamp
+    timestamp,
+    usageMissing: Boolean(usageMissing)
   };
   if (originalModel) {
     payload.originalModel = originalModel;
@@ -151,40 +177,43 @@ function publishUsageLog({
   recordSuccess,
   allowBroadcast = true
 }) {
-  if (!hasMeaningfulUsage(source, tokens)) {
-    return null;
-  }
-
   const normalizedSource = normalizeToolSource(source);
+  const actualModel = resolveActualModel(model, metadata);
   const normalizedTokens = normalizeUsageTokens(normalizedSource, tokens);
+  const usageAvailable = hasMeaningfulUsage(normalizedSource, normalizedTokens);
   const requestId = metadata.id || `${normalizedSource}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   const timestamp = Date.now();
   const cost = typeof calculateCost === 'function'
-    ? calculateCost(model || '', normalizedTokens)
+    ? calculateCost(actualModel || '', normalizedTokens)
     : 0;
 
+  if (!usageAvailable && !actualModel) {
+    return null;
+  }
+
   if (allowBroadcast && typeof broadcastLog === 'function') {
     broadcastLog(buildSuccessLogPayload({
       source: normalizedSource,
       requestId,
       channel: metadata.channel,
-      model,
+      model: actualModel,
       originalModel: metadata.originalModel,
       redirectedModel: metadata.redirectedModel,
       tokens: normalizedTokens,
       cost,
-      timestamp
+      timestamp,
+      usageMissing: !usageAvailable
     }));
   }
 
-  if (typeof recordRequest === 'function') {
+  if (usageAvailable && typeof recordRequest === 'function') {
     const entry = {
       id: requestId,
       timestamp: new Date(metadata.startTime || timestamp).toISOString(),
       toolType: normalizedSource === 'claude' ? 'claude-code' : normalizedSource,
       channel: metadata.channel,
       channelId: metadata.channelId,
-      model: model || '',
+      model: actualModel || '',
       tokens: {
         input: normalizedTokens.input,
         output: normalizedTokens.output,
@@ -213,8 +242,10 @@ function publishUsageLog({
 
   return {
     cost,
+    model: actualModel,
     tokens: normalizedTokens,
-    timestamp
+    timestamp,
+    usageMissing: !usageAvailable
   };
 }
 
@@ -250,6 +281,7 @@ function publishFailureLog({
 module.exports = {
   toNumber,
   normalizeToolSource,
+  resolveActualModel,
   normalizeUsageTokens,
   hasMeaningfulUsage,
   formatRealtimeTime,

package/src/server/services/sessions.js

@@ -135,6 +135,7 @@ function sliceClaudeSessionContentByUserMessage(content, afterUserMessageNumber)
   const { lines, eol, hasTrailingEol } = splitTextPreserveEol(content);
   const keptLines = [];
   let matchedUserMessages = 0;
+  let targetUserReached = false;
 
   for (const line of lines) {
     if (!line.trim()) {
@@ -150,23 +151,32 @@ function sliceClaudeSessionContentByUserMessage(content, afterUserMessageNumber)
       continue;
     }
 
-    keptLines.push(line);
-
     if (json.type !== 'user') {
+      keptLines.push(line);
       continue;
     }
 
     const userText = getClaudeForkMessageText(json.message?.content);
     if (!userText) {
+      keptLines.push(line);
       continue;
     }
 
+    if (targetUserReached) {
+      return joinTextPreserveEol(keptLines, eol, hasTrailingEol);
+    }
+
     matchedUserMessages += 1;
+    keptLines.push(line);
     if (matchedUserMessages >= afterUserMessageNumber) {
-      return joinTextPreserveEol(keptLines, eol, hasTrailingEol);
+      targetUserReached = true;
     }
   }
 
+  if (targetUserReached) {
+    return joinTextPreserveEol(keptLines, eol, hasTrailingEol);
+  }
+
   throw new Error(`afterUserMessageNumber ${afterUserMessageNumber} exceeds available user messages (${matchedUserMessages})`);
 }
 

package/src/server/services/statistics-service.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const { PATHS } = require('../../config/paths');
+const { normalizeUsageTokens, resolveActualModel } = require('./proxy-log-helper');
 
 // 北京时间辅助（UTC+8），统一所有时间计算
 const CST_OFFSET_MS = 8 * 60 * 60 * 1000;
@@ -189,6 +190,8 @@ function initStatsObject() {
       output: 0,
       cacheCreation: 0,
       cacheRead: 0,
+      cached: 0,
+      reasoning: 0,
       total: 0
     },
     cost: 0
@@ -202,7 +205,9 @@ function updateStats(stats, tokens, cost) {
   stats.tokens.output += tokens.output || 0;
   stats.tokens.cacheCreation += tokens.cacheCreation || 0;
   stats.tokens.cacheRead += tokens.cacheRead || 0;
-  stats.tokens.total += tokens.total || 0;
+  stats.tokens.cached += tokens.cached || 0;
+  stats.tokens.reasoning += tokens.reasoning || 0;
+  stats.tokens.total += getTokenTotal(tokens);
   stats.cost += cost || 0;
 }
 
@@ -226,6 +231,9 @@ function recordRequest(requestData) {
       session,
       project
     } = requestData;
+    const resolvedModel = resolveActualModel(model, requestData);
+    const modelKey = resolvedModel || 'unknown';
+    const totalTokens = getTokenTotal(tokens);
 
     // 1. 写入详细日志
     const logEntry = {
@@ -234,7 +242,7 @@ function recordRequest(requestData) {
       toolType,
       channel,
       channelId,
-      model,
+      model: resolvedModel,
       tokens,
       duration,
       success,
@@ -256,7 +264,7 @@ function recordRequest(requestData) {
 
     // 更新全局统计
     globalStats.global.totalRequests += 1;
-    globalStats.global.totalTokens += tokens.total || 0;
+    globalStats.global.totalTokens += totalTokens;
     globalStats.global.totalCost += cost || 0;
 
     // 按工具类型统计
@@ -283,10 +291,10 @@ function recordRequest(requestData) {
     updateStats(globalStats.byToolType[toolType].channels[channelId], tokens, cost);
 
     // 按工具类型 -> 模型统计
-    if (!globalStats.byToolType[toolType].models[model]) {
-      globalStats.byToolType[toolType].models[model] = initStatsObject();
+    if (!globalStats.byToolType[toolType].models[modelKey]) {
+      globalStats.byToolType[toolType].models[modelKey] = initStatsObject();
     }
-    updateStats(globalStats.byToolType[toolType].models[model], tokens, cost);
+    updateStats(globalStats.byToolType[toolType].models[modelKey], tokens, cost);
 
     // 按渠道统计（跨工具）
     if (!globalStats.byChannel[channelId]) {
@@ -303,13 +311,13 @@ function recordRequest(requestData) {
     updateStats(globalStats.byChannel[channelId], tokens, cost);
 
     // 按模型统计（跨工具）
-    if (!globalStats.byModel[model]) {
-      globalStats.byModel[model] = {
+    if (!globalStats.byModel[modelKey]) {
+      globalStats.byModel[modelKey] = {
         toolType,
         ...initStatsObject()
       };
     }
-    updateStats(globalStats.byModel[model], tokens, cost);
+    updateStats(globalStats.byModel[modelKey], tokens, cost);
 
     saveStatistics(globalStats);
 
@@ -321,7 +329,7 @@ function recordRequest(requestData) {
 
     // 更新每日汇总
     dailyStats.summary.requests += 1;
-    dailyStats.summary.tokens += tokens.total || 0;
+    dailyStats.summary.tokens += totalTokens;
     dailyStats.summary.cost += cost || 0;
 
     // 按小时统计
@@ -361,6 +369,15 @@ function recordRequest(requestData) {
     }
     updateStats(dailyStats.byToolType[toolType].channels[channelId], tokens, cost);
 
+    // 按工具类型 -> 模型
+    if (!dailyStats.byToolType[toolType].models) {
+      dailyStats.byToolType[toolType].models = {};
+    }
+    if (!dailyStats.byToolType[toolType].models[modelKey]) {
+      dailyStats.byToolType[toolType].models[modelKey] = initStatsObject();
+    }
+    updateStats(dailyStats.byToolType[toolType].models[modelKey], tokens, cost);
+
     // 按渠道统计
     if (!dailyStats.byChannel[channelId]) {
       dailyStats.byChannel[channelId] = {
@@ -372,13 +389,13 @@ function recordRequest(requestData) {
     updateStats(dailyStats.byChannel[channelId], tokens, cost);
 
     // 按模型统计
-    if (!dailyStats.byModel[model]) {
-      dailyStats.byModel[model] = {
+    if (!dailyStats.byModel[modelKey]) {
+      dailyStats.byModel[modelKey] = {
         toolType,
         ...initStatsObject()
       };
     }
-    updateStats(dailyStats.byModel[model], tokens, cost);
+    updateStats(dailyStats.byModel[modelKey], tokens, cost);
 
     saveDailyStats(date, dailyStats);
 
@@ -447,21 +464,23 @@ function readJsonlForHour(year, month, day, hour, groupBy, filters) {
       const ts = new Date(entry.timestamp);
       if (getCSTHour(ts) !== hour) continue;
 
+      const actualModel = resolveActualModel(entry.model, entry);
+
       // Apply filters
       if (filters) {
         if (filters.toolType && entry.toolType !== filters.toolType) continue;
         if (filters.channel && entry.channel !== filters.channel) continue;
-        if (filters.model && entry.model !== filters.model) continue;
+        if (filters.model && actualModel !== filters.model) continue;
       }
 
       let key;
-      if (groupBy === 'model') key = entry.model || 'unknown';
+      if (groupBy === 'model') key = actualModel || 'unknown';
       else if (groupBy === 'channel') key = entry.channel || entry.channelId || 'unknown';
       else if (groupBy === 'toolType') key = entry.toolType || 'claude-code';
       else continue;
 
       if (!result[key]) result[key] = { tokens: { total: 0 }, cost: 0, requests: 0 };
-      result[key].tokens.total += entry.tokens?.total || 0;
+      result[key].tokens.total += getTokenTotal(entry.tokens);
       result[key].cost += entry.cost || 0;
       result[key].requests += 1;
     }
@@ -493,21 +512,23 @@ function readJsonlForDay(year, month, day, groupBy, filters) {
       let entry;
       try { entry = JSON.parse(line); } catch { continue; }
 
+      const actualModel = resolveActualModel(entry.model, entry);
+
       // Apply filters
       if (filters) {
         if (filters.toolType && entry.toolType !== filters.toolType) continue;
         if (filters.channel && entry.channel !== filters.channel) continue;
-        if (filters.model && entry.model !== filters.model) continue;
+        if (filters.model && actualModel !== filters.model) continue;
       }
 
       let key;
-      if (groupBy === 'model') key = entry.model || 'unknown';
+      if (groupBy === 'model') key = actualModel || 'unknown';
       else if (groupBy === 'channel') key = entry.channel || entry.channelId || 'unknown';
       else if (groupBy === 'toolType') key = entry.toolType || 'claude-code';
       else continue;
 
       if (!result[key]) result[key] = { tokens: { total: 0 }, cost: 0, requests: 0 };
-      result[key].tokens.total += entry.tokens?.total || 0;
+      result[key].tokens.total += getTokenTotal(entry.tokens);
       result[key].cost += entry.cost || 0;
       result[key].requests += 1;
     }
@@ -541,7 +562,7 @@ function filterProxyLogsForHour(logs, dateStr, hour, groupBy) {
   const result = {};
 
   for (const entry of logs) {
-    if (!entry || entry.type === 'action') continue;
+    if (!entry || entry.type === 'action' || entry.status === 'error') continue;
 
     const ts = new Date(entry.timestamp || Date.now());
     if (Number.isNaN(ts.getTime())) continue;
@@ -549,11 +570,22 @@ function filterProxyLogsForHour(logs, dateStr, hour, groupBy) {
     const entryDate = getCSTDateStr(ts);
     if (entryDate !== dateStr || getCSTHour(ts) !== hour) continue;
 
+    const actualModel = resolveActualModel(entry.model, entry);
+    const normalizedTokens = normalizeUsageTokens(entry.source || mapSourceToToolType(entry.source), {
+      input: entry.inputTokens ?? entry.tokens?.input,
+      output: entry.outputTokens ?? entry.tokens?.output,
+      cacheCreation: entry.cacheCreation ?? entry.tokens?.cacheCreation,
+      cacheRead: entry.cacheRead ?? entry.tokens?.cacheRead,
+      cached: entry.cachedTokens ?? entry.tokens?.cached,
+      reasoning: entry.reasoningTokens ?? entry.tokens?.reasoning,
+      total: entry.totalTokens ?? entry.tokens?.total
+    });
+
     let key;
     if (groupBy === 'toolType') {
       key = mapSourceToToolType(entry.source);
     } else if (groupBy === 'model') {
-      key = entry.model || 'unknown';
+      key = actualModel || 'unknown';
     } else if (groupBy === 'channel') {
       key = entry.channel || 'unknown';
     } else {
@@ -564,11 +596,7 @@ function filterProxyLogsForHour(logs, dateStr, hour, groupBy) {
       result[key] = { tokens: { total: 0 }, cost: 0, requests: 0 };
     }
 
-    const totalTokens = entry.totalTokens ||
-      entry.tokens?.total ||
-      (entry.inputTokens || 0) + (entry.outputTokens || 0) + (entry.reasoningTokens || 0);
-
-    result[key].tokens.total += totalTokens || 0;
+    result[key].tokens.total += normalizedTokens.total || 0;
     result[key].cost += entry.cost || 0;
     result[key].requests += 1;
   }
@@ -741,7 +769,7 @@ function aggregateDailyStatistics(dateStr) {
     }
 
     for (const [modelName, modelStats] of Object.entries(toolStats.models || {})) {
-      const key = getScopedKey(aggregated.byModel, modelName, toolType);
+      const key = modelName || 'unknown';
       if (!aggregated.byModel[key]) {
         aggregated.byModel[key] = createEmptyEntry(toolType);
       }
@@ -835,6 +863,7 @@ function getAvailableFilters(startDate, endDate) {
   const toolTypes = new Set();
   const channels = new Set();
   const models = new Set();
+  const includeProxyLogs = startDate <= getCSTDateStr(Date.now()) && getCSTDateStr(Date.now()) <= endDate;
 
   const start = new Date(startDate + 'T00:00:00');
   const end = new Date(endDate + 'T00:00:00');
@@ -852,15 +881,31 @@ function getAvailableFilters(startDate, endDate) {
         if (!line.trim()) continue;
         let entry;
         try { entry = JSON.parse(line); } catch { continue; }
+        const actualModel = resolveActualModel(entry.model, entry);
         if (entry.toolType) toolTypes.add(entry.toolType);
         if (entry.channel) channels.add(entry.channel);
-        if (entry.model) models.add(entry.model);
+        if (actualModel) models.add(actualModel);
       }
     } catch (err) {
       console.error('Failed to scan JSONL for filters:', err);
     }
   }
 
+  if (includeProxyLogs) {
+    for (const entry of loadProxyLogs()) {
+      if (!entry || entry.type === 'action' || entry.status === 'error') continue;
+      const ts = new Date(entry.timestamp || Date.now());
+      if (Number.isNaN(ts.getTime())) continue;
+      const entryDate = getCSTDateStr(ts);
+      if (entryDate < startDate || entryDate > endDate) continue;
+
+      toolTypes.add(mapSourceToToolType(entry.source));
+      if (entry.channel) channels.add(entry.channel);
+      const actualModel = resolveActualModel(entry.model, entry);
+      if (actualModel) models.add(actualModel);
+    }
+  }
+
   return {
     toolTypes: Array.from(toolTypes).sort(),
     channels: Array.from(channels).sort(),

package/src/server/services/web-build.js

@@ -0,0 +1,172 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const DEFAULT_PROJECT_ROOT = path.resolve(__dirname, '../../..');
+const IGNORED_DIR_NAMES = new Set(['node_modules', '.git', 'dist']);
+const WATCHED_WEB_FILES = ['index.html', 'package.json', 'package-lock.json', 'pnpm-lock.yaml', 'vite.config.js'];
+const WATCHED_WEB_DIRS = ['src', 'public'];
+
+function pathExists(targetPath) {
+  return fs.existsSync(targetPath);
+}
+
+function getLatestMtimeMs(targetPath) {
+  if (!pathExists(targetPath)) {
+    return 0;
+  }
+
+  const stat = fs.statSync(targetPath);
+  if (!stat.isDirectory()) {
+    return stat.mtimeMs;
+  }
+
+  let latest = stat.mtimeMs;
+  for (const entry of fs.readdirSync(targetPath, { withFileTypes: true })) {
+    if (entry.isDirectory() && IGNORED_DIR_NAMES.has(entry.name)) {
+      continue;
+    }
+    const childPath = path.join(targetPath, entry.name);
+    latest = Math.max(latest, getLatestMtimeMs(childPath));
+  }
+  return latest;
+}
+
+function getWatchedWebSourceMtimeMs(sourceRoot) {
+  let latest = 0;
+  for (const fileName of WATCHED_WEB_FILES) {
+    latest = Math.max(latest, getLatestMtimeMs(path.join(sourceRoot, fileName)));
+  }
+  for (const dirName of WATCHED_WEB_DIRS) {
+    latest = Math.max(latest, getLatestMtimeMs(path.join(sourceRoot, dirName)));
+  }
+  return latest;
+}
+
+function inspectWebBuildState(options = {}) {
+  const projectRoot = options.projectRoot || DEFAULT_PROJECT_ROOT;
+  const sourceRoot = options.sourceRoot || path.join(projectRoot, 'src/web');
+  const distRoot = options.distRoot || path.join(projectRoot, 'dist/web');
+  const distIndexPath = path.join(distRoot, 'index.html');
+  const sourceAvailable = pathExists(sourceRoot) && pathExists(path.join(sourceRoot, 'package.json'));
+  const distExists = pathExists(distIndexPath);
+
+  if (!sourceAvailable) {
+    return {
+      projectRoot,
+      sourceRoot,
+      distRoot,
+      distIndexPath,
+      sourceAvailable: false,
+      distExists,
+      sourceMtimeMs: 0,
+      distMtimeMs: getLatestMtimeMs(distRoot),
+      needsBuild: false,
+      reason: 'source-unavailable'
+    };
+  }
+
+  const sourceMtimeMs = getWatchedWebSourceMtimeMs(sourceRoot);
+  const distMtimeMs = getLatestMtimeMs(distRoot);
+  const hasDistAssets = distExists && distMtimeMs > 0;
+  const isStale = hasDistAssets && sourceMtimeMs > distMtimeMs + 1;
+
+  return {
+    projectRoot,
+    sourceRoot,
+    distRoot,
+    distIndexPath,
+    sourceAvailable: true,
+    distExists,
+    sourceMtimeMs,
+    distMtimeMs,
+    needsBuild: !hasDistAssets || isStale,
+    reason: !hasDistAssets ? 'dist-missing' : (isStale ? 'dist-stale' : 'up-to-date')
+  };
+}
+
+function getNpmCommand() {
+  return process.platform === 'win32' ? 'npm.cmd' : 'npm';
+}
+
+function runWebBuild(options = {}) {
+  const sourceRoot = options.sourceRoot || path.join(DEFAULT_PROJECT_ROOT, 'src/web');
+  const npmCommand = options.npmCommand || getNpmCommand();
+  const env = options.env || process.env;
+  const stdio = options.stdio || 'inherit';
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(npmCommand, ['run', 'build'], {
+      cwd: sourceRoot,
+      env,
+      stdio
+    });
+
+    child.once('error', (error) => {
+      reject(error);
+    });
+
+    child.once('close', (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`Web UI build exited with code ${code}`));
+    });
+  });
+}
+
+async function ensureWebDistReady(options = {}) {
+  const initialState = options.state || inspectWebBuildState(options);
+  if (!initialState.needsBuild) {
+    return {
+      ...initialState,
+      built: false,
+      skipped: true,
+      previousReason: initialState.reason
+    };
+  }
+
+  const runBuild = options.runBuild || runWebBuild;
+
+  try {
+    await runBuild({
+      sourceRoot: initialState.sourceRoot,
+      distRoot: initialState.distRoot,
+      npmCommand: options.npmCommand || getNpmCommand(),
+      env: options.env,
+      stdio: options.stdio
+    });
+  } catch (error) {
+    const dependencyHint = pathExists(path.join(initialState.sourceRoot, 'node_modules'))
+      ? ''
+      : '（未检测到 src/web/node_modules，前端依赖可能尚未安装）';
+    throw new Error(`Web UI 静态资源构建失败: ${error.message}${dependencyHint}`);
+  }
+
+  const finalState = inspectWebBuildState({
+    projectRoot: initialState.projectRoot,
+    sourceRoot: initialState.sourceRoot,
+    distRoot: initialState.distRoot
+  });
+
+  return {
+    ...finalState,
+    built: true,
+    skipped: false,
+    previousReason: initialState.reason
+  };
+}
+
+module.exports = {
+  inspectWebBuildState,
+  ensureWebDistReady,
+  _test: {
+    getLatestMtimeMs,
+    getWatchedWebSourceMtimeMs,
+    getNpmCommand,
+    runWebBuild
+  }
+};

package/src/server/websocket-server.js

@@ -504,11 +504,28 @@ function broadcastSchedulerState(source, schedulerState) {
   }
 }
 
+function broadcastBrowserNotification(notification = {}) {
+  if (wss && wsClients.size > 0) {
+    const message = JSON.stringify({
+      type: 'browser-notification',
+      ...notification,
+      timestamp: notification.timestamp || Date.now()
+    });
+
+    wsClients.forEach(client => {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(message);
+      }
+    });
+  }
+}
+
 module.exports = {
   startWebSocketServer,
   stopWebSocketServer,
   broadcastLog,
   clearAllLogs,
   broadcastProxyState,
-  broadcastSchedulerState
+  broadcastSchedulerState,
+  broadcastBrowserNotification
 };