coding-tool-x 3.8.4 → 3.8.6

package/src/platforms/drivers/codex/native-logs.js

@@ -0,0 +1,166 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { NATIVE_PATHS } = require('../../../config/paths');
+const {
+  normalizeCost,
+  normalizeUsage,
+  subtractUsage,
+  usageFieldPaths,
+  createSelectiveJsonLineParser,
+  visitJsonLinesForward,
+  visitJsonLinesReverse,
+  walkFiles,
+  createIncrementalJsonlCursor
+} = require('../native-log-utils');
+const { calculateUsageCost } = require('../../../server/services/usage-log-utils');
+
+const CODEX_SELECTED_FIELDS = [
+  'type',
+  'timestamp',
+  'payload.type',
+  'payload.id',
+  'payload.model_provider',
+  'payload.model',
+  'payload.info.cost.total',
+  'payload.info.cost.usd',
+  'payload.info.cost.amount',
+  ...usageFieldPaths('payload.info.total_token_usage')
+];
+
+function applyCodexRecord(state, record) {
+  if (record?.type === 'session_meta') {
+    state.sessionId = record.payload?.id || state.sessionId;
+    state.provider = record.payload?.model_provider || state.provider;
+    return;
+  }
+  if (record?.type === 'turn_context') {
+    state.model = record.payload?.model || state.model;
+    return;
+  }
+  if (record?.type !== 'event_msg' || record.payload?.type !== 'token_count') return;
+  const usage = record.payload?.info?.total_token_usage;
+  if (!usage || typeof usage !== 'object') return;
+  state.pendingUsage = normalizeUsage(usage);
+  state.pendingTimestamp = record.timestamp || state.pendingTimestamp;
+  state.pendingCost = normalizeCost(record.payload?.info?.cost ?? usage.cost);
+}
+
+function bootstrapCodexFile(filePath, state, stat, fsImpl, stats) {
+  const endOffset = stat.size;
+  state.sessionId = path.basename(filePath, '.jsonl');
+  state.provider = '';
+  state.model = '';
+  state.lastUsage = null;
+  state.pendingUsage = null;
+  state.pendingTimestamp = null;
+  state.pendingCost = 0;
+  visitJsonLinesForward(filePath, (record) => {
+    if (record?.type === 'session_meta') {
+      state.sessionId = record.payload?.id || state.sessionId;
+      state.provider = record.payload?.model_provider || state.provider;
+      return false;
+    }
+    return true;
+  }, {
+    fsImpl,
+    endOffset,
+    createLongLineParser: () => createSelectiveJsonLineParser(CODEX_SELECTED_FIELDS),
+    stats
+  });
+
+  let latestUsage = null;
+  let foundLatestModel = false;
+  visitJsonLinesReverse(filePath, (record) => {
+    if (record?.type === 'event_msg' && record.payload?.type === 'token_count' && !latestUsage) {
+      const usage = record.payload?.info?.total_token_usage;
+      if (usage && typeof usage === 'object') {
+        latestUsage = normalizeUsage(usage);
+        state.pendingTimestamp = record.timestamp || state.pendingTimestamp;
+        state.pendingCost = normalizeCost(record.payload?.info?.cost ?? usage.cost);
+      }
+    }
+    if (record?.type === 'turn_context' && !foundLatestModel) {
+      const model = record.payload?.model;
+      if (model) {
+        state.model = model;
+        foundLatestModel = true;
+      }
+    }
+    return !(latestUsage && foundLatestModel);
+  }, {
+    fsImpl,
+    endOffset,
+    includeTrailingLine: false,
+    createLongLineParser: () => createSelectiveJsonLineParser(CODEX_SELECTED_FIELDS),
+    stats
+  });
+  if (latestUsage) state.lastUsage = latestUsage;
+  state.pendingUsage = null;
+  return { ok: true };
+}
+
+function createDriver({ nativeRoot, pathContext, fsImpl = fs } = {}) {
+  const resolvedNativeRoot = pathContext?.customized
+    ? (pathContext.native?.sessions || nativeRoot || NATIVE_PATHS.codex.sessions)
+    : (nativeRoot || NATIVE_PATHS.codex.sessions);
+  return {
+    platform: 'codex',
+    capability: 'nativeLogs',
+    createNativeLogCursor({ fs: cursorFs = fsImpl, skipInitialParse = false, onDiagnostic } = {}) {
+      const scanFiles = () => walkFiles(resolvedNativeRoot, name => /^rollout-.*\.jsonl$/.test(name), cursorFs);
+      return createIncrementalJsonlCursor({
+        scanFiles,
+        fsImpl: cursorFs,
+        skipInitialParse,
+        createFileState: (filePath, _stat, previousState) => ({
+          sessionId: previousState?.sessionId || path.basename(filePath, '.jsonl'),
+          provider: previousState?.provider || '',
+          model: previousState?.model || '',
+          lastUsage: previousState?.lastUsage || null,
+          pendingUsage: null,
+          pendingTimestamp: null,
+          pendingCost: 0
+        }),
+        bootstrapFile: (filePath, state, stat, stats) => bootstrapCodexFile(filePath, state, stat, cursorFs, stats),
+        parseLine: (_filePath, record, state) => {
+          applyCodexRecord(state, record);
+          return null;
+        },
+        afterRead: (_filePath, state) => {
+          if (!state.pendingUsage) return null;
+          const current = state.pendingUsage;
+          const previous = state.lastUsage;
+          const restarted = previous && current.total < previous.total;
+          const tokens = previous && !restarted ? subtractUsage(current, previous) : current;
+          state.lastUsage = current;
+          state.pendingUsage = null;
+          if (tokens.total <= 0) return null;
+          const sessionId = state.sessionId || '';
+          const event = {
+            id: `${sessionId}:token-count:${current.total}`,
+            source: 'codex',
+            sessionId,
+            timestamp: state.pendingTimestamp,
+            provider: state.provider,
+            model: state.model,
+            tokens,
+            cost: state.pendingCost || calculateUsageCost('codex', state.model, tokens)
+          };
+          state.pendingTimestamp = null;
+          state.pendingCost = 0;
+          return event;
+        },
+        createLongLineParser: () => createSelectiveJsonLineParser(CODEX_SELECTED_FIELDS),
+        onDiagnostic,
+        onError: (error, filePath) => {
+          console.warn('[Codex Native Logs] Failed to read changed usage events:', filePath, error.message);
+        }
+      });
+    },
+    createCursor(options) { return this.createNativeLogCursor(options); }
+  };
+}
+
+module.exports = { createDriver };

package/src/platforms/drivers/codex/project-config.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const mcpFormat = require('../../../shared/mcp-format');
+const {
+  createProjectAdapter,
+  createTomlMcpHandlers
+} = require('../../../shared/project-config');
+
+function createAdapter({ manifest, fsImpl } = {}) {
+  const relativePath = manifest?.projectResources?.mcp?.path;
+  const mcpHandlers = createTomlMcpHandlers({
+    relativePath,
+    format: manifest?.projectResources?.mcp?.format || 'codex-toml',
+    toNative: mcpFormat.convertToCodexFormat,
+    fromNative: mcpFormat.convertFromCodexFormat,
+    fsImpl
+  });
+  return createProjectAdapter({ manifest, fsImpl, mcpHandlers });
+}
+
+module.exports = { createAdapter };

package/src/platforms/drivers/codex/projects.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const { createProjectsDriver } = require('../../../shared/driver-factories/projects');
+
+function createDriver(context = {}) {
+  return createProjectsDriver({
+    ...context,
+    platform: 'codex',
+    servicePath: './codex/sessions-implementation',
+    localServicePath: '../../platforms/drivers/codex/sessions-implementation',
+    availabilityCheck: () => {
+      const config = context.requireImpl
+        ? context.requireImpl('./codex/config')
+        : require('./config');
+      config.configure?.({ pathContext: context.pathContext });
+      return config.isCodexInstalled();
+    },
+    onSuccess: operation => {
+      if (['saveProjectOrder', 'createProject', 'deleteProject'].includes(operation)) {
+        context.sessionHistoryIndex?.invalidateSource('codex');
+      }
+    }
+  });
+}
+
+module.exports = { createDriver };

package/src/platforms/drivers/codex/prompts.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const { createPromptDriver } = require('../../../shared/driver-factories/prompts');
+
+function createDriver(context = {}) {
+  return createPromptDriver({ ...context, platform: 'codex' });
+}
+
+module.exports = { createDriver };

package/src/{server/codex-proxy-server.js → platforms/drivers/codex/proxy-implementation.js}

@@ -2,26 +2,20 @@ const express = require('express');
 const httpProxy = require('http-proxy');
 const http = require('http');
 const chalk = require('chalk');
-const { broadcastLog, broadcastSchedulerState } = require('./websocket-server');
-const { allocateChannel, releaseChannel, getSchedulerState } = require('./services/channel-scheduler');
-const { recordSuccess, recordFailure } = require('./services/channel-health');
-const { loadConfig } = require('../config/loader');
-const DEFAULT_CONFIG = require('../config/default');
-const { resolveModelPricing, calculateTokenCost } = require('./utils/pricing');
-const { recordRequest: recordCodexRequest } = require('./services/codex-statistics-service');
-const { saveProxyStartTime, clearProxyStartTime, getProxyStartTime, getProxyRuntime } = require('./services/proxy-runtime');
-const { createDecodedStream } = require('./services/response-decoder');
-const { getEffectiveApiKey } = require('./services/codex-channels');
-const { persistProxyRequestSnapshot } = require('./services/request-logger');
-const { publishUsageLog, publishFailureLog } = require('./services/proxy-log-helper');
+const { broadcastSchedulerState } = require('../../../server/websocket-server');
+const { allocateChannel, releaseChannel, getSchedulerState } = require('../../../server/services/channel-scheduler');
+const { recordSuccess, recordFailure } = require('../../../server/services/channel-health');
+const { loadConfig } = require('../../../config/loader');
+const { saveProxyStartTime, clearProxyStartTime, getProxyStartTime, getProxyRuntime } = require('../../../server/services/proxy-runtime');
+const { getEffectiveApiKey, getCodexProxyExcludedChannelIds } = require('./channels-implementation');
+const { persistProxyRequestSnapshot } = require('../../../server/services/request-logger');
 const {
   redirectModel,
   resolveTargetUrl,
   isChatCompletionsPath,
   ensureOpenAiStreamUsage
-} = require('./services/base/proxy-utils');
-const { parseSSEUsage, parseNonStreamingUsage, mergeUsageIntoTokenData, createTokenData } = require('./services/base/response-usage-parser');
-const { attachServerShutdownHandling, expediteServerShutdown } = require('./services/server-shutdown');
+} = require('../../../shared/proxy-utils');
+const { attachServerShutdownHandling, expediteServerShutdown } = require('../../../server/services/server-shutdown');
 
 let proxyServer = null;
 let proxyApp = null;
@@ -34,64 +28,12 @@ const requestMetadata = new Map();
 // 格式: { channelId: { "originalModel": "redirectedModel", ... } }
 const printedRedirectCache = new Map();
 
-// OpenAI 模型定价（每百万 tokens 的价格，单位：美元）
-// 作为 model-metadata 未覆盖时的兜底值
-const PRICING = {
-  'gpt-4o': { input: 2.5, output: 10 },
-  'gpt-4o-2024-11-20': { input: 2.5, output: 10 },
-  'gpt-4o-mini': { input: 0.15, output: 0.6 },
-  'gpt-4-turbo': { input: 10, output: 30 },
-  'gpt-4': { input: 30, output: 60 },
-  'gpt-3.5-turbo': { input: 0.5, output: 1.5 },
-  'o1': { input: 15, output: 60 },
-  'o1-mini': { input: 3, output: 12 },
-  'o1-pro': { input: 150, output: 600 },
-  'o3': { input: 10, output: 40 },
-  'o3-mini': { input: 1.1, output: 4.4 },
-  'o4-mini': { input: 1.1, output: 4.4 }
-};
-
-const CODEX_BASE_PRICING = DEFAULT_CONFIG.pricing.codex;
 
-// detectModelTier, redirectModel, resolveTargetUrl imported from services/base/proxy-utils
+// detectModelTier, redirectModel, resolveTargetUrl imported from shared/proxy-utils
 
 // resolveCodexTarget replaced by resolveTargetUrl from proxy-utils
 const resolveCodexTarget = resolveTargetUrl;
 
-/**
- * 计算请求成本
- */
-function calculateCost(model, tokens) {
-  let fallbackPricing = PRICING[model];
-  if (!fallbackPricing) {
-    const modelLower = String(model || '').toLowerCase();
-    if (modelLower.includes('gpt-4o-mini')) {
-      fallbackPricing = PRICING['gpt-4o-mini'];
-    } else if (modelLower.includes('gpt-4o')) {
-      fallbackPricing = PRICING['gpt-4o'];
-    } else if (modelLower.includes('gpt-4')) {
-      fallbackPricing = PRICING['gpt-4'];
-    } else if (modelLower.includes('gpt-3.5')) {
-      fallbackPricing = PRICING['gpt-3.5-turbo'];
-    } else if (modelLower.includes('o1-mini')) {
-      fallbackPricing = PRICING['o1-mini'];
-    } else if (modelLower.includes('o1-pro')) {
-      fallbackPricing = PRICING['o1-pro'];
-    } else if (modelLower.includes('o1')) {
-      fallbackPricing = PRICING['o1'];
-    } else if (modelLower.includes('o3-mini')) {
-      fallbackPricing = PRICING['o3-mini'];
-    } else if (modelLower.includes('o3')) {
-      fallbackPricing = PRICING['o3'];
-    } else if (modelLower.includes('o4-mini')) {
-      fallbackPricing = PRICING['o4-mini'];
-    }
-  }
-
-  const pricing = resolveModelPricing('codex', model, fallbackPricing, CODEX_BASE_PRICING);
-  return calculateTokenCost(pricing, tokens, CODEX_BASE_PRICING);
-}
-
 const jsonBodyParser = express.json({
   limit: '100mb',
   verify: (req, res, buf) => {
@@ -114,6 +56,11 @@ async function startCodexProxyServer(options = {}) {
     return { success: true, port: currentPort };
   }
 
+  const excludedChannelIds = getCodexProxyExcludedChannelIds();
+  if (excludedChannelIds.length > 0) {
+    throw new Error('Codex dynamic proxy supports API-key channels only; disable OAuth channels first');
+  }
+
   try {
     const config = loadConfig();
     const port = config.ports?.codexProxy || 20089;
@@ -163,7 +110,11 @@ async function startCodexProxyServer(options = {}) {
 
     proxyApp.use(async (req, res) => {
       try {
-        const channel = await allocateChannel({ source: 'codex', enableSessionBinding: false });
+        const channel = await allocateChannel({
+          source: 'codex',
+          enableSessionBinding: false,
+          excludeChannelIds: getCodexProxyExcludedChannelIds()
+        });
         req.selectedChannel = channel;
 
         const release = (() => {
@@ -184,14 +135,6 @@ async function startCodexProxyServer(options = {}) {
         const effectiveKey = getEffectiveApiKey(channel);
         if (!effectiveKey) {
           release();
-          publishFailureLog({
-            source: 'codex',
-            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: {
               message: 'API key not configured or expired. Please update your channel key.',
@@ -263,20 +206,6 @@ async function startCodexProxyServer(options = {}) {
           release();
           if (err) {
             recordFailure(channel.id, 'codex', err);
-            const metadata = requestMetadata.get(req) || {
-              channel: channel.name,
-              channelId: channel.id,
-              startTime: Date.now()
-            };
-            publishFailureLog({
-              source: 'codex',
-              metadata,
-              message: err.message,
-              error: err,
-              statusCode: 502,
-              stage: 'proxy_web',
-              broadcastLog
-            });
             console.error('Codex proxy error:', err);
             if (res && !res.headersSent) {
               res.status(502).json({
@@ -290,13 +219,6 @@ async function startCodexProxyServer(options = {}) {
         });
       } catch (error) {
         console.error('Codex channel allocation error:', error);
-        publishFailureLog({
-          source: 'codex',
-          message: error.message || 'No Codex channel available',
-          statusCode: 503,
-          stage: 'allocate_channel',
-          broadcastLog
-        });
         if (!res.headersSent) {
           res.status(503).json({
             error: {
@@ -308,155 +230,44 @@ async function startCodexProxyServer(options = {}) {
       }
     });
 
-    // 监听代理响应 (OpenAI 格式)
+    // 代理响应只负责维护传输健康状态；实时日志和 usage 来自 CLI 原生日志。
     proxy.on('proxyRes', (proxyRes, req, res) => {
       const metadata = requestMetadata.get(req);
-      if (!metadata) {
-        return;
-      }
+      if (!metadata) return;
 
-      // 检查响应是否已关闭
       if (res.writableEnded || res.destroyed) {
         requestMetadata.delete(req);
         return;
       }
 
-      // 标记响应是否已关闭
-      let isResponseClosed = false;
-
       // 监听响应关闭事件
       res.on('close', () => {
-        isResponseClosed = true;
         requestMetadata.delete(req);
       });
 
       // 监听响应错误事件
       res.on('error', (err) => {
-        isResponseClosed = true;
-        // 忽略客户端断开连接的常见错误
         if (err.code !== 'EPIPE' && err.code !== 'ECONNRESET') {
           console.error('Response error:', err);
         }
+        recordFailure(metadata.channelId, 'codex', err);
         requestMetadata.delete(req);
       });
 
-      let buffer = '';
-      let tokenData = createTokenData();
-      let usageRecorded = false;
-      const parsedStream = createDecodedStream(proxyRes);
-
-      function recordUsageIfReady() {
-        if (usageRecorded) {
-          return false;
-        }
-
-        const result = publishUsageLog({
-          source: 'codex',
-          metadata,
-          model: tokenData.model,
-          tokens: {
-            input: tokenData.inputTokens,
-            output: tokenData.outputTokens,
-            cacheCreation: tokenData.cacheCreation,
-            cacheRead: tokenData.cacheRead,
-            cached: tokenData.cachedTokens,
-            reasoning: tokenData.reasoningTokens,
-            total: tokenData.totalTokens
-          },
-          calculateCost,
-          broadcastLog,
-          recordRequest: recordCodexRequest,
-          recordSuccess,
-          allowBroadcast: true
-        });
-
-        if (!result) {
-          return false;
-        }
-
-        usageRecorded = true;
-        return true;
-      }
-
-      parsedStream.on('data', (chunk) => {
-        if (isResponseClosed) {
-          return;
-        }
-
-        buffer += chunk.toString('utf8');
-
-        // 检查是否是 SSE 流
-        if (proxyRes.headers['content-type']?.includes('text/event-stream')) {
-          const events = buffer.split('\n\n');
-          buffer = events.pop() || '';
-
-          events.forEach((eventText) => {
-            if (!eventText.trim()) return;
-
-            try {
-              const lines = eventText.split('\n');
-              let eventType = '';
-              let data = '';
-
-              lines.forEach(line => {
-                if (line.startsWith('event:')) {
-                  eventType = line.substring(6).trim();
-                } else if (line.startsWith('data:')) {
-                  data = line.substring(5).trim();
-                }
-              });
-
-              if (!data || data === '[DONE]') return;
-
-              const parsed = JSON.parse(data);
-              const usage = parseSSEUsage(parsed, eventType);
-              mergeUsageIntoTokenData(tokenData, usage);
-
-              if (usage.isDone) {
-                recordUsageIfReady();
-              }
-            } catch (err) {
-              // 忽略解析错误
-            }
-          });
-        }
-      });
-
-      parsedStream.on('end', () => {
-        // 如果不是流式响应，尝试从完整响应中解析
-        if (!proxyRes.headers['content-type']?.includes('text/event-stream')) {
-          try {
-            const parsed = JSON.parse(buffer);
-            const usage = parseNonStreamingUsage(parsed);
-            mergeUsageIntoTokenData(tokenData, usage);
-          } catch (err) {
-            // 忽略解析错误
-          }
-        }
-
-        recordUsageIfReady();
-
-        if (!isResponseClosed) {
-          requestMetadata.delete(req);
+      proxyRes.on('end', () => {
+        if (Number(proxyRes.statusCode) >= 400) {
+          recordFailure(metadata.channelId, 'codex', new Error(`Codex upstream HTTP ${proxyRes.statusCode}`));
+        } else {
+          recordSuccess(metadata.channelId, 'codex');
         }
+        requestMetadata.delete(req);
       });
 
-      parsedStream.on('error', (err) => {
-        // 忽略代理响应错误（可能是网络问题）
+      proxyRes.on('error', (err) => {
         if (err.code !== 'EPIPE' && err.code !== 'ECONNRESET') {
           console.error('Proxy response error:', err);
         }
-        isResponseClosed = true;
         recordFailure(metadata.channelId, 'codex', err);
-        publishFailureLog({
-          source: 'codex',
-          metadata,
-          message: err.message,
-          error: err,
-          statusCode: proxyRes.statusCode,
-          stage: 'response_stream',
-          broadcastLog
-        });
         requestMetadata.delete(req);
       });
     });
@@ -469,19 +280,6 @@ async function startCodexProxyServer(options = {}) {
         releaseChannel(req.selectedChannel.id, 'codex');
         broadcastSchedulerState('codex', getSchedulerState('codex'));
       }
-      publishFailureLog({
-        source: 'codex',
-        metadata: (req && requestMetadata.get(req)) || {
-          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: {
@@ -592,5 +390,4 @@ module.exports = {
   stopCodexProxyServer,
   getCodexProxyStatus,
   clearCodexRedirectCache,
-  calculateCost
 };

package/src/platforms/drivers/codex/proxy.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const { createProxyDriver } = require('../../../shared/proxy-driver');
+
+function createDriver(context = {}) {
+  return createProxyDriver({
+    ...context,
+    platform: 'codex',
+    servicePath: './codex/proxy-implementation',
+    localServicePath: '../platforms/drivers/codex/proxy-implementation',
+    exports: { status: 'getCodexProxyStatus', start: 'startCodexProxyServer', stop: 'stopCodexProxyServer' },
+    cliMetadata: { defaultPort: 20089 }
+  });
+}
+
+module.exports = { createDriver };

package/src/platforms/drivers/codex/resource-sync.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const { createResourceSyncDriver } = require('../../../shared/driver-factories/resource-sync');
+
+function createDriver(context = {}) {
+  return createResourceSyncDriver({ ...context, platform: 'codex' });
+}
+
+module.exports = { createDriver };