coding-tool-x 3.8.3 → 3.8.5

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

package/src/{server/services/session-history-adapters/codex.js → platforms/drivers/codex/session-history-adapter.js}

@@ -2,47 +2,59 @@
 
 const fs = require('fs');
 const path = require('path');
-const { getCodexDir } = require('../codex-config');
-const { extractSessionMeta, extractMessages, extractTokenUsage, readJSONL } = require('../codex-parser');
+const { getCodexDir } = require('./config');
+const { parseSession } = require('./parser');
+
+function configure({ pathContext } = {}) {
+  require('./config').configure?.({ pathContext });
+}
+
+function extractSessionIdFromRolloutFilename(filePath) {
+  const basename = path.basename(filePath, '.jsonl');
+  const match = basename.match(/([0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})$/i);
+  return match ? match[1] : basename;
+}
 
 /**
  * Scan all Codex session files recursively.
  * @returns {Array<{filePath: string, size: number, mtimeMs: number, sessionId: string}>}
  */
-function scanSessionFiles() {
+async function scanSessionFiles(projectsDir = null) {
   const results = [];
-  const sessionsDir = path.join(getCodexDir(), 'sessions');
+  const sessionsDir = projectsDir || path.join(getCodexDir(), 'sessions');
 
-  if (!fs.existsSync(sessionsDir)) {
+  try {
+    await fs.promises.stat(sessionsDir);
+  } catch (_) {
     return results;
   }
 
-  function scanDir(dir) {
+  async function scanDir(dir) {
     let entries;
     try {
-      entries = fs.readdirSync(dir, { withFileTypes: true });
+      entries = await fs.promises.readdir(dir, { withFileTypes: true });
     } catch (_) {
       return;
     }
     for (const entry of entries) {
       const fullPath = path.join(dir, entry.name);
       if (entry.isDirectory()) {
-        scanDir(fullPath);
+        await scanDir(fullPath);
       } else if (entry.isFile() && entry.name.match(/^rollout-.*\.jsonl$/)) {
         try {
-          const stat = fs.statSync(fullPath);
+          const stat = await fs.promises.stat(fullPath);
           results.push({
             filePath: fullPath,
             size: stat.size,
             mtimeMs: stat.mtimeMs,
-            sessionId: entry.name.replace(/\.jsonl$/, '')
+            sessionId: extractSessionIdFromRolloutFilename(fullPath)
           });
         } catch (_) {}
       }
     }
   }
 
-  scanDir(sessionsDir);
+  await scanDir(sessionsDir);
   return results;
 }
 
@@ -67,8 +79,8 @@ function extractCodexProjectName(meta) {
  * Inventory all Codex session files.
  * @returns {Promise<Array>}
  */
-async function inventory() {
-  const files = scanSessionFiles();
+async function inventory({ projectsDir } = {}) {
+  const files = await scanSessionFiles(projectsDir);
   return files.map(f => ({
     filePath: f.filePath,
     size: f.size,
@@ -83,13 +95,15 @@ async function inventory() {
  */
 async function parse(descriptor) {
   const { filePath, size, mtimeMs, sessionId } = descriptor;
-  const lines = readJSONL(filePath);
-
-  const meta = extractSessionMeta(lines);
-  const messages = extractMessages(lines);
-  const tokenUsage = extractTokenUsage(lines);
-
+  const parsed = parseSession(filePath);
+  const meta = parsed?.meta;
+  const messages = parsed?.messages || [];
+  const tokenUsage = parsed?.tokens;
   const projectName = extractCodexProjectName(meta);
+  const descriptorIdIsNative = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(sessionId);
+  const nativeSessionId = descriptorIdIsNative
+    ? sessionId
+    : (typeof meta?.sessionId === 'string' && meta.sessionId.trim() ? meta.sessionId.trim() : sessionId);
   const usageJson = tokenUsage ? JSON.stringify(tokenUsage) : null;
 
   // Build normalized messages
@@ -119,7 +133,7 @@ async function parse(descriptor) {
 
     const isUser = msg.role === 'user' || msg.role === 'human';
     return {
-      messageId: msg.id || `codex-${sessionId}-${idx}`,
+      messageId: msg.id || `codex-${nativeSessionId}-${idx}`,
       role: msg.role || 'unknown',
       type: msg.type || msg.role || 'unknown',
       subtype: msg.subtype || null,
@@ -136,10 +150,10 @@ async function parse(descriptor) {
   const lastMsg = normalizedMessages[normalizedMessages.length - 1];
 
   const session = {
-    sessionId,
+    sessionId: nativeSessionId,
     projectName,
     projectDisplayName: projectName,
-    projectFullPath: null,
+    projectFullPath: typeof meta?.cwd === 'string' && meta.cwd.trim() ? meta.cwd.trim() : null,
     firstMessage: firstUserMsg ? firstUserMsg.content : null,
     gitBranch: meta ? (meta.gitBranch || null) : null,
     provider: null,
@@ -155,4 +169,4 @@ async function parse(descriptor) {
   return { session, messages: normalizedMessages };
 }
 
-module.exports = { inventory, parse, extractCodexProjectName };
+module.exports = { configure, inventory, parse, extractCodexProjectName };