coding-tool-x 3.8.4 → 3.8.5

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

@@ -0,0 +1,72 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { NATIVE_PATHS } = require('../../../config/paths');
+const {
+  normalizeUsage,
+  normalizeCost,
+  usageFieldPaths,
+  createSelectiveJsonLineParser,
+  walkFiles,
+  createIncrementalJsonlCursor
+} = require('../native-log-utils');
+const { calculateUsageCost } = require('../../../server/services/usage-log-utils');
+
+const CLAUDE_SELECTED_FIELDS = [
+  'type', 'role', 'uuid', 'id', 'model', 'timestamp', 'provider', 'cost', 'channelId', 'channel',
+  'message.role', 'message.id', 'message.uuid', 'message.model', 'message.timestamp',
+  'message.provider', 'message.cost', 'message.channelId', 'message.channel',
+  ...usageFieldPaths('usage'),
+  ...usageFieldPaths('message.usage')
+];
+
+function createDriver({ nativeRoot, pathContext, fsImpl = fs } = {}) {
+  const resolvedNativeRoot = pathContext?.customized
+    ? (pathContext.native?.projects || nativeRoot || NATIVE_PATHS.claude.projects)
+    : (nativeRoot || NATIVE_PATHS.claude.projects);
+  return {
+    platform: 'claude',
+    capability: 'nativeLogs',
+    createNativeLogCursor({ fs: cursorFs = fsImpl, skipInitialParse = false, onDiagnostic } = {}) {
+      const scanFiles = () => walkFiles(resolvedNativeRoot, name => name.endsWith('.jsonl') && !name.startsWith('agent-'), cursorFs);
+      const parseLine = (filePath, record) => {
+        const message = record.message && typeof record.message === 'object' ? record.message : {};
+        const role = record.role || message.role || (record.type === 'assistant' ? 'assistant' : null);
+        if (role !== 'assistant') return null;
+        const usage = record.usage || message.usage;
+        const messageId = record.uuid || record.id || message.id;
+        if (!usage || typeof usage !== 'object' || !messageId) return null;
+        const tokens = normalizeUsage(usage);
+        const model = record.model || message.model || '';
+        return {
+          id: `${path.basename(filePath)}:${messageId}`,
+          source: 'claude',
+          sessionId: path.basename(filePath, '.jsonl'),
+          timestamp: record.timestamp || message.timestamp,
+          provider: record.provider || message.provider || '',
+          model,
+          tokens,
+          cost: normalizeCost(record.cost ?? message.cost ?? usage.cost)
+            || calculateUsageCost('claude', model, tokens),
+          channelId: record.channelId || message.channelId,
+          channel: record.channel || message.channel
+        };
+      };
+      return createIncrementalJsonlCursor({
+        scanFiles,
+        parseLine,
+        fsImpl: cursorFs,
+        skipInitialParse,
+        createLongLineParser: () => createSelectiveJsonLineParser(CLAUDE_SELECTED_FIELDS),
+        onDiagnostic,
+        onError: (error, filePath) => {
+          console.warn('[Claude Native Logs] Failed to read changed usage events:', filePath, error.message);
+        }
+      });
+    },
+    createCursor(options) { return this.createNativeLogCursor(options); }
+  };
+}
+
+module.exports = { createDriver };

package/src/{server/services/claude-openai-gateway.js → platforms/drivers/claude/openai-gateway.js}

@@ -2,13 +2,10 @@ const http = require('http');
 const https = require('https');
 const crypto = require('crypto');
 const { HttpsProxyAgent } = require('https-proxy-agent');
-const { broadcastLog } = require('../websocket-server');
-const { recordRequest } = require('./statistics-service');
-const { recordSuccess, recordFailure } = require('./channel-health');
-const { publishUsageLog, publishFailureLog } = require('./proxy-log-helper');
-const { createDecodedStream } = require('./response-decoder');
-const { parseNonStreamingUsage } = require('./base/response-usage-parser');
-const { convertClaudeToOpenCodePayload } = require('./opencode-gateway-converter');
+const { recordSuccess, recordFailure } = require('../../../server/services/channel-health');
+const { createDecodedStream } = require('../../../server/services/response-decoder');
+const { parseNonStreamingUsage } = require('../../../shared/response-usage-parser');
+const { convertClaudeToOpenCodePayload } = require('../opencode/gateway-converter');
 
 const REQUEST_TIMEOUT_MS = 120000;
 
@@ -299,18 +296,6 @@ function buildClaudeUsageFromTokens(tokens = {}) {
   };
 }
 
-function buildPublishTokensFromClaudeUsage(usage = {}) {
-  return {
-    input: Number(usage.input_tokens || 0),
-    output: Number(usage.output_tokens || 0),
-    cacheCreation: Number(usage.cache_creation_input_tokens || 0),
-    cacheRead: Number(usage.cache_read_input_tokens || 0),
-    cached: Number(usage.cache_read_input_tokens || 0),
-    reasoning: 0,
-    total: 0
-  };
-}
-
 function mapResponsesStopReason(response, hasToolUse) {
   if (hasToolUse) return 'tool_use';
 
@@ -1086,31 +1071,8 @@ async function relayChatStreamAsClaude(upstreamResponse, res, fallbackModel = ''
   });
 }
 
-function publishClaudeGatewayUsage(metadata, message, calculateCost) {
-  return publishUsageLog({
-    source: 'claude',
-    metadata,
-    model: message?.model || '',
-    tokens: buildPublishTokensFromClaudeUsage(message?.usage || {}),
-    calculateCost,
-    broadcastLog,
-    recordRequest,
-    recordSuccess,
-    allowBroadcast: true
-  });
-}
-
-function reportGatewayFailure({ channel, metadata, res, statusCode, message, error, stage, onDone }) {
+function reportGatewayFailure({ channel, res, statusCode, message, error, onDone }) {
   recordFailure(channel.id, 'claude', error || new Error(message));
-  publishFailureLog({
-    source: 'claude',
-    metadata,
-    message,
-    error,
-    statusCode,
-    stage,
-    broadcastLog
-  });
   sendAnthropicError(res, statusCode, message);
   if (typeof onDone === 'function') {
     onDone();
@@ -1118,7 +1080,7 @@ function reportGatewayFailure({ channel, metadata, res, statusCode, message, err
   return true;
 }
 
-async function handleClaudeOpenAiGatewayRequest({ req, res, channel, effectiveKey, calculateCost, onDone }) {
+async function handleClaudeOpenAiGatewayRequest({ req, res, channel, effectiveKey, onDone }) {
   const pathname = getRequestPathname(req?.url || '');
   if (!isClaudeMessagesPath(pathname)) {
     return false;
@@ -1132,21 +1094,12 @@ async function handleClaudeOpenAiGatewayRequest({ req, res, channel, effectiveKe
     return true;
   }
 
-  const requestId = `claude-openai-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
-  const startTime = Date.now();
   const targetApi = resolveClaudeGatewayTargetApi(channel);
   const converted = convertClaudeToOpenCodePayload({
     payload: req.body,
     options: { targetApi }
   });
   const upstreamModel = converted?.requestBody?.model || req.body.model || '';
-  const metadata = {
-    id: requestId,
-    channel: channel?.name,
-    channelId: channel?.id,
-    startTime,
-    requestModel: upstreamModel
-  };
   const wantsStream = req.body.stream === true;
   const targetUrl = buildOpenAiTargetUrl(channel?.baseUrl || '', converted.endpoint || '/v1/responses');
   const headers = buildOpenAiHeaders(effectiveKey, {
@@ -1171,12 +1124,10 @@ async function handleClaudeOpenAiGatewayRequest({ req, res, channel, effectiveKe
         const upstreamMessage = parsedError?.error?.message || parsedError?.message || rawBody || `HTTP ${upstream.statusCode}`;
         return reportGatewayFailure({
           channel,
-          metadata,
           res,
           statusCode: upstream.statusCode,
           message: String(upstreamMessage).slice(0, 1000),
           error: new Error(String(upstreamMessage).slice(0, 200)),
-          stage: 'openai_gateway_upstream',
           onDone
         });
       }
@@ -1185,9 +1136,7 @@ async function handleClaudeOpenAiGatewayRequest({ req, res, channel, effectiveKe
         ? await relayChatStreamAsClaude(upstream.response, res, upstreamModel)
         : await relayResponsesStreamAsClaude(upstream.response, res, upstreamModel);
 
-      if (message) {
-        publishClaudeGatewayUsage(metadata, message, calculateCost);
-      }
+      recordSuccess(channel.id, 'claude');
       if (typeof onDone === 'function') {
         onDone();
       }
@@ -1207,12 +1156,10 @@ async function handleClaudeOpenAiGatewayRequest({ req, res, channel, effectiveKe
       const upstreamMessage = parsedBody?.error?.message || parsedBody?.message || upstream.rawBody || `HTTP ${upstream.statusCode}`;
       return reportGatewayFailure({
         channel,
-        metadata,
         res,
         statusCode: upstream.statusCode,
         message: String(upstreamMessage).slice(0, 1000),
         error: new Error(String(upstreamMessage).slice(0, 200)),
-        stage: 'openai_gateway_upstream',
         onDone
       });
     }
@@ -1220,12 +1167,10 @@ async function handleClaudeOpenAiGatewayRequest({ req, res, channel, effectiveKe
     if (!parsedBody || typeof parsedBody !== 'object') {
       return reportGatewayFailure({
         channel,
-        metadata,
         res,
         statusCode: 502,
         message: 'Invalid OpenAI gateway response',
         error: new Error('Invalid OpenAI gateway response'),
-        stage: 'openai_gateway_parse',
         onDone
       });
     }
@@ -1235,7 +1180,7 @@ async function handleClaudeOpenAiGatewayRequest({ req, res, channel, effectiveKe
       : buildClaudeMessageFromResponses(parsedBody, upstreamModel);
 
     res.json(message);
-    publishClaudeGatewayUsage(metadata, message, calculateCost);
+    recordSuccess(channel.id, 'claude');
     if (typeof onDone === 'function') {
       onDone();
     }
@@ -1243,12 +1188,10 @@ async function handleClaudeOpenAiGatewayRequest({ req, res, channel, effectiveKe
   } catch (error) {
     return reportGatewayFailure({
       channel,
-      metadata,
       res,
       statusCode: 502,
       message: `OpenAI gateway network error: ${error.message}`,
       error,
-      stage: 'openai_gateway_network',
       onDone
     });
   }

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

@@ -0,0 +1,21 @@
+'use strict';
+
+const mcpFormat = require('../../../shared/mcp-format');
+const {
+  createProjectAdapter,
+  createJsonMcpHandlers
+} = require('../../../shared/project-config');
+
+function createAdapter({ manifest, fsImpl } = {}) {
+  const relativePath = manifest?.projectResources?.mcp?.path;
+  const mcpHandlers = createJsonMcpHandlers({
+    relativePath,
+    format: manifest?.projectResources?.mcp?.format || 'claude-json',
+    toNative: mcpFormat.extractServerSpec,
+    fromNative: value => ({ ...value }),
+    fsImpl
+  });
+  return createProjectAdapter({ manifest, fsImpl, mcpHandlers });
+}
+
+module.exports = { createAdapter };

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

@@ -0,0 +1,62 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { createProjectsDriver } = require('../../../shared/driver-factories/projects');
+
+function createProject({ projectName, projectPath } = {}) {
+  if (!projectName || !projectPath) {
+    const error = new Error('projectName and projectPath are required');
+    error.statusCode = 400;
+    throw error;
+  }
+  if (!fs.existsSync(projectPath)) {
+    const error = new Error('项目路径不存在');
+    error.statusCode = 400;
+    throw error;
+  }
+  if (!fs.statSync(projectPath).isDirectory()) {
+    const error = new Error('项目路径必须是一个目录');
+    error.statusCode = 400;
+    throw error;
+  }
+
+  const claudeDir = path.join(projectPath, '.claude');
+  const sessionsDir = path.join(claudeDir, 'sessions');
+  if (fs.existsSync(claudeDir)) {
+    const error = new Error('该项目已经初始化过 Claude Code');
+    error.statusCode = 400;
+    throw error;
+  }
+
+  fs.mkdirSync(sessionsDir, { recursive: true });
+  const projectConfig = {
+    name: projectName,
+    createdAt: new Date().toISOString(),
+    version: '1.0'
+  };
+  fs.writeFileSync(
+    path.join(claudeDir, 'project.json'),
+    JSON.stringify(projectConfig, null, 2),
+    'utf8'
+  );
+
+  return { success: true, projectName, projectPath, claudeDir };
+}
+
+function createDriver(context = {}) {
+  return createProjectsDriver({
+    ...context,
+    platform: 'claude',
+    servicePath: './claude/sessions-implementation',
+    localServicePath: '../../platforms/drivers/claude/sessions-implementation',
+    createProject,
+    onSuccess: operation => {
+      if (['saveProjectOrder', 'createProject', 'deleteProject'].includes(operation)) {
+        context.sessionHistoryIndex?.invalidateSource('claude');
+      }
+    }
+  });
+}
+
+module.exports = { createDriver };

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

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