@cc-monitoring/proxy-core 0.3.1 → 0.4.0

package/dist/logger/index.d.ts

@@ -1,11 +1,8 @@
 import pino from 'pino';
 import type { LogConfig } from '../types/config.js';
-declare const LEVEL_MAP: Record<string, number>;
-declare const NUM_TO_LEVEL: Record<number, string>;
 export declare function createLogger(config: LogConfig): pino.Logger;
 export declare function readLogs(filePath: string, options: {
     limit?: number;
     level?: string;
     grep?: string;
 }): Promise<string[]>;
-export { LEVEL_MAP, NUM_TO_LEVEL };

package/dist/logger/index.js

@@ -116,4 +116,3 @@ export async function readLogs(filePath, options) {
     }
     return filtered;
 }
-export { LEVEL_MAP, NUM_TO_LEVEL };

package/dist/mcp-server/tools.js

@@ -2,8 +2,8 @@ import fs from 'fs';
 import { CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { getDatabase } from '../utils/db.js';
 import { listRequestDB } from '../utils/request-writer.js';
-import { listProviders } from '../utils/providers-db.js';
-import { knowledgeStore } from '../utils/knowledge-store.js';
+import { getActiveProvider } from '../utils/providers-db.js';
+import { vault } from '../utils/vault.js';
 function ok(text) {
     return { content: [{ type: 'text', text }] };
 }
@@ -18,8 +18,7 @@ async function handleGetStatus(_args, ctx) {
     const countRow = db.prepare('SELECT COUNT(*) AS n FROM requests').get();
     let defaultProvider = null;
     try {
-        const providers = listProviders(db);
-        const def = providers.find(p => p.default);
+        const def = getActiveProvider(db);
         if (def) {
             defaultProvider = { name: def.name, model: def.model, base_url: def.base_url };
         }
@@ -192,10 +191,10 @@ const HANDLERS = {
     list_requests: handleListRequests,
     get_token_stats: handleGetTokenStats,
     get_logs: handleGetLogs,
-    list_topics: async () => ok(JSON.stringify(await knowledgeStore.listTopics(), null, 2)),
+    list_topics: async () => ok(JSON.stringify(await vault.listTopics(), null, 2)),
     get_topic: async (args) => {
         try {
-            return ok(JSON.stringify(await knowledgeStore.getTopic(args.topic), null, 2));
+            return ok(JSON.stringify(await vault.getTopic(args.topic), null, 2));
         }
         catch (e) {
             const msg = e instanceof Error ? e.message : String(e);
@@ -206,7 +205,7 @@ const HANDLERS = {
         }
     },
     query_knowledge: async (args) => {
-        const hits = await knowledgeStore.queryKnowledge(args.query ?? '', args.limit);
+        const hits = await vault.queryKnowledge(args.query ?? '', args.limit);
         if (hits.length === 0) {
             return ok('No knowledge chunks matched. Call list_topics to browse available topics, or refine your query.');
         }
@@ -214,10 +213,10 @@ const HANDLERS = {
             hits: hits.map(h => ({ topic: h.topic, chunkId: h.chunkId, title: h.title, body: h.body })),
         }, null, 2));
     },
-    search_chunks: async (args) => ok(JSON.stringify(await knowledgeStore.searchChunks(args.query ?? ''), null, 2)),
+    search_chunks: async (args) => ok(JSON.stringify(await vault.searchChunks(args.query ?? ''), null, 2)),
     read_chunk: async (args) => {
         try {
-            const body = await knowledgeStore.readChunk(args.topic, args.chunk_id);
+            const body = await vault.readChunk(args.topic, args.chunk_id);
             return ok(body);
         }
         catch (e) {

package/dist/server/__tests__/providers-route.test.js

@@ -49,6 +49,7 @@ jest.mock('@utils/db', () => {
       provider TEXT NOT NULL,
       is_default INTEGER NOT NULL DEFAULT 0,
       is_openai_compatible INTEGER NOT NULL DEFAULT 0,
+      auth_style TEXT NOT NULL DEFAULT 'bearer',
       created_at TEXT DEFAULT CURRENT_TIMESTAMP,
       updated_at TEXT DEFAULT CURRENT_TIMESTAMP
     )

package/dist/server/auth.d.ts

@@ -1,2 +1 @@
-export declare const AUTH_TOKEN_ENV = "UI_AUTH_TOKEN";
 export declare function checkAuth(request: any, config: any): boolean;

package/dist/server/auth.js

@@ -1,4 +1,4 @@
-export const AUTH_TOKEN_ENV = 'UI_AUTH_TOKEN';
+const AUTH_TOKEN_ENV = 'UI_AUTH_TOKEN';
 export function checkAuth(request, config) {
     // If no auth token configured, allow all (dev mode)
     const token = config?.auth?.token || process.env[AUTH_TOKEN_ENV];

package/dist/server/chat-route.js

@@ -1,10 +1,9 @@
 import { Readable } from 'stream';
 import { randomUUID } from 'node:crypto';
 import { loadConfig } from '../config/index.js';
-import { saveRequestDB, extractTokenUsage, loadSessionHistory } from '../utils/request-writer.js';
+import { createRequestRecorder, recordIteration, loadSessionHistory } from '../utils/request-writer.js';
 import { cleanOldRequestsDB } from '../utils/request-writer.js';
-import { pushNewRequest } from './data-push.js';
-import { initDatabase, getDatabase } from '../utils/db.js';
+import { initDatabase } from '../utils/db.js';
 import { resolveProxyTarget, getProxyModel, filterForwardHeaders, extractSafeHeaders } from './proxy.js';
 import { injectMcpTools } from '../utils/tool-injector.js';
 import { findInjectedCall, runJsonInjectLoop, runStreamingInjectLoop } from '../utils/inject-loop.js';
@@ -12,6 +11,7 @@ import { findEnabledTool } from '../tools/index.js';
 import { writeSSEEvent, writeTextAsSSE, shouldMock } from '../utils/sse-writer.js';
 import { SSEStreamProcessor } from '../utils/sse-stream-processor.js';
 import { getMachineIdSync, preloadMachineId } from '../utils/machine-id.js';
+import { createClientAbortSignal, createTimeoutSignal } from '../utils/abort-signals.js';
 export async function setupChatRoute(fastify, proxyConfig) {
     const fullConfig = await loadConfig();
     const maxDays = fullConfig.storage?.maxDays ?? 7;
@@ -20,6 +20,8 @@ export async function setupChatRoute(fastify, proxyConfig) {
     fastify.post('/api/chat', async (request, reply) => {
         const startTime = Date.now();
         const resolved = resolveProxyTarget(proxyConfig);
+        // 下游客户端中止：建一次，主 fetch 与 inject 循环内 fetch 全部复用同一 signal
+        const clientSignal = createClientAbortSignal(request.raw);
         // Generate or reuse session ID
         const providedSessionId = request.headers['x-chat-session-id'];
         const sessionId = providedSessionId || randomUUID();
@@ -57,7 +59,7 @@ export async function setupChatRoute(fastify, proxyConfig) {
             request.log.info(`[chat] MCP tools injected: ${injectedNames.join(',')} (${request.id})`);
         }
         // Filter and forward headers
-        const forwardHeaders = filterForwardHeaders(extractSafeHeaders(request.headers), resolved.apiKey);
+        const forwardHeaders = filterForwardHeaders(extractSafeHeaders(request.headers), resolved.apiKey, resolved.auth_style);
         forwardHeaders['x-chat-session-id'] = sessionId;
         // Extract API keys for recording
         const authHeader = request.headers['authorization'];
@@ -69,9 +71,9 @@ export async function setupChatRoute(fastify, proxyConfig) {
             (forwardedAuthHeader?.startsWith('Bearer ') ? forwardedAuthHeader.slice(7) : undefined);
         // Build request data
         const machineId = getMachineIdSync() ?? undefined;
-        const requestData = {
-            requestId: request.id,
+        const meta = {
             sessionId,
+            localRequestId: request.id,
             timestamp: new Date().toISOString(),
             apiKey,
             proxyApiKey,
@@ -83,29 +85,12 @@ export async function setupChatRoute(fastify, proxyConfig) {
                 path: request.url,
                 headers: forwardHeaders,
                 body: request.body
-            },
-            response: {
-                statusCode: 0,
-                events: []
             }
         };
+        const rec = createRequestRecorder(meta);
         await cleanOldRequestsDB(maxDays);
         // Save initial record + push pending status to frontend
-        await saveRequestDB(sessionId, request.id, requestData);
-        pushNewRequest({
-            requestId: request.id,
-            sessionId,
-            compositeId: `${sessionId}:${request.id}`,
-            method: request.method,
-            path: request.url,
-            timestamp: requestData.timestamp,
-            statusCode: 0,
-            responseTime: 0,
-            model: forwardedModel,
-            machineId,
-            userAgent: request.headers['user-agent'],
-            baseUrl: resolved.baseUrl
-        }, 'pending');
+        await rec.pending();
         // Mock interception (PoC)
         if (shouldMock(request.body)) {
             reply.hijack();
@@ -126,14 +111,11 @@ export async function setupChatRoute(fastify, proxyConfig) {
             method: 'POST',
             headers: forwardHeaders,
             body: JSON.stringify(request.body),
-            signal: AbortSignal.timeout(300000)
+            signal: createTimeoutSignal(300000, clientSignal)
         });
         request.log.info(`[chat] response status: ${response.status}`);
         // Extract cloud request ID
         const cloudRequestId = response.headers.get('x-request-id') || request.id;
-        requestData.requestId = cloudRequestId;
-        requestData.response.statusCode = response.status;
-        requestData.response.headers = Object.fromEntries(response.headers);
         // Check response type
         const contentType = response.headers.get('content-type') || '';
         const isSSE = contentType.includes('text/event-stream');
@@ -144,10 +126,10 @@ export async function setupChatRoute(fastify, proxyConfig) {
             let jsonBody;
             try {
                 jsonBody = JSON.parse(responseBody);
-                requestData.response.events.push(jsonBody);
+                rec.appendEvent(jsonBody);
             }
             catch {
-                requestData.response.events.push({ raw: responseBody });
+                rec.appendEvent({ raw: responseBody });
             }
             // JSON inject loop: if MCP tools injected and response has tool_use
             if (injected && jsonBody && jsonBody.stop_reason === 'tool_use') {
@@ -163,7 +145,7 @@ export async function setupChatRoute(fastify, proxyConfig) {
                                 method: 'POST',
                                 headers: forwardHeaders,
                                 body: JSON.stringify(b),
-                                signal: AbortSignal.timeout(300000)
+                                signal: createTimeoutSignal(300000, clientSignal)
                             });
                             const loopResponseBody = await r.text();
                             let loopJson;
@@ -172,101 +154,42 @@ export async function setupChatRoute(fastify, proxyConfig) {
                             }
                             catch { /* ignore */ }
                             // Record each loop iteration as a separate request
-                            if (loopJson) {
-                                const loopRequestId = r.headers.get('x-request-id') || `loop_${request.id}_${Date.now()}`;
-                                const loopData = {
-                                    requestId: loopRequestId,
-                                    sessionId,
-                                    timestamp: new Date().toISOString(),
-                                    apiKey,
-                                    proxyApiKey,
-                                    baseUrl: resolved.baseUrl,
-                                    model: forwardedModel,
-                                    machineId,
-                                    request: { method: 'POST', path: '/api/chat', headers: forwardHeaders, body: b },
-                                    response: {
-                                        statusCode: r.status,
-                                        headers: Object.fromEntries(r.headers),
-                                        events: [loopJson],
-                                        completedAt: new Date().toISOString()
-                                    }
-                                };
-                                await saveRequestDB(sessionId, loopRequestId, loopData);
-                                const loopUsage = extractTokenUsage(loopData.response.events);
-                                pushNewRequest({
-                                    requestId: loopRequestId,
-                                    sessionId,
-                                    compositeId: `${sessionId}:${loopRequestId}`,
-                                    method: 'POST',
-                                    path: '/api/chat',
-                                    timestamp: loopData.timestamp,
+                            await recordIteration({
+                                sessionId,
+                                localRequestId: r.headers.get('x-request-id') || `loop_${request.id}_${Date.now()}`,
+                                timestamp: new Date().toISOString(),
+                                apiKey,
+                                proxyApiKey,
+                                baseUrl: resolved.baseUrl,
+                                model: forwardedModel,
+                                machineId,
+                                request: { method: 'POST', path: '/api/chat', headers: forwardHeaders, body: b },
+                                response: {
                                     statusCode: r.status,
-                                    responseTime: 0,
-                                    model: forwardedModel,
-                                    machineId,
-                                    userAgent: request.headers['user-agent'],
-                                    baseUrl: resolved.baseUrl,
-                                    usage: loopUsage
-                                }, 'completed');
-                            }
+                                    headers: Object.fromEntries(r.headers),
+                                    events: loopJson ? [loopJson] : []
+                                }
+                            });
                             return loopJson || JSON.parse(loopResponseBody);
                         }
                     });
                     request.log.info(`[chat] json loop done: ${loopResult.iterations} iter (${cloudRequestId})`);
-                    requestData.response.completedAt = new Date().toISOString();
-                    // Remove pending row if cloudRequestId differs from request.id
-                    if (cloudRequestId !== request.id) {
-                        const db = getDatabase();
-                        db.prepare('DELETE FROM requests WHERE request_id = ? AND session_id = ?').run(request.id, sessionId);
-                    }
-                    await saveRequestDB(sessionId, cloudRequestId, requestData);
-                    const usage = extractTokenUsage(requestData.response.events);
-                    pushNewRequest({
-                        requestId: cloudRequestId,
-                        sessionId,
-                        compositeId: `${sessionId}:${cloudRequestId}`,
-                        method: request.method,
-                        path: request.url,
-                        timestamp: requestData.timestamp,
+                    await rec.complete({
+                        cloudRequestId: cloudRequestId !== request.id ? cloudRequestId : undefined,
                         statusCode: response.status,
-                        responseTime: Date.now() - startTime,
-                        model: forwardedModel,
-                        machineId,
-                        userAgent: request.headers['user-agent'],
-                        baseUrl: resolved.baseUrl,
-                        usage,
-                        pendingId: cloudRequestId !== request.id ? `${sessionId}:${request.id}` : undefined
-                    }, 'completed');
+                        headers: Object.fromEntries(response.headers)
+                    });
                     const finalBody = { ...loopResult.finalBody, _sessionId: sessionId };
                     reply.code(200).header('x-chat-session-id', sessionId).send(JSON.stringify(finalBody));
                     return;
                 }
             }
             // Normal JSON passthrough
-            requestData.response.completedAt = new Date().toISOString();
-            // Remove pending row if cloudRequestId differs from request.id
-            if (cloudRequestId !== request.id) {
-                const db = getDatabase();
-                db.prepare('DELETE FROM requests WHERE request_id = ? AND session_id = ?').run(request.id, sessionId);
-            }
-            await saveRequestDB(sessionId, cloudRequestId, requestData);
-            const usage = extractTokenUsage(requestData.response.events);
-            pushNewRequest({
-                requestId: cloudRequestId,
-                sessionId,
-                compositeId: `${sessionId}:${cloudRequestId}`,
-                method: request.method,
-                path: request.url,
-                timestamp: requestData.timestamp,
+            await rec.complete({
+                cloudRequestId: cloudRequestId !== request.id ? cloudRequestId : undefined,
                 statusCode: response.status,
-                responseTime: Date.now() - startTime,
-                model: forwardedModel,
-                machineId,
-                userAgent: request.headers['user-agent'],
-                baseUrl: resolved.baseUrl,
-                usage,
-                pendingId: cloudRequestId !== request.id ? `${sessionId}:${request.id}` : undefined
-            }, 'completed');
+                headers: Object.fromEntries(response.headers)
+            });
             // Inject session ID into response for passthrough
             try {
                 const passthroughBody = JSON.parse(responseBody);
@@ -294,32 +217,13 @@ export async function setupChatRoute(fastify, proxyConfig) {
             });
             nodeStream.on('end', async () => {
                 processor.flushLeftover();
-                // 保存原始请求到 DB
-                requestData.response.events = processor.events;
-                requestData.response.completedAt = new Date().toISOString();
-                // Remove pending row if cloudRequestId differs from request.id
-                if (cloudRequestId !== request.id) {
-                    const db = getDatabase();
-                    db.prepare('DELETE FROM requests WHERE request_id = ? AND session_id = ?').run(request.id, sessionId);
-                }
-                await saveRequestDB(sessionId, cloudRequestId, requestData);
-                const usage = extractTokenUsage(requestData.response.events);
-                pushNewRequest({
-                    requestId: cloudRequestId,
-                    sessionId,
-                    compositeId: `${sessionId}:${cloudRequestId}`,
-                    method: request.method,
-                    path: request.url,
-                    timestamp: requestData.timestamp,
+                for (const ev of processor.events)
+                    rec.appendEvent(ev);
+                await rec.complete({
+                    cloudRequestId: cloudRequestId !== request.id ? cloudRequestId : undefined,
                     statusCode: response.status,
-                    responseTime: Date.now() - startTime,
-                    model: forwardedModel,
-                    machineId,
-                    userAgent: request.headers['user-agent'],
-                    baseUrl: resolved.baseUrl,
-                    usage,
-                    pendingId: cloudRequestId !== request.id ? `${sessionId}:${request.id}` : undefined
-                }, 'completed');
+                    headers: Object.fromEntries(response.headers)
+                });
                 request.log.info(`[chat] stream completed: ${cloudRequestId} ${response.status} (${Date.now() - startTime}ms, ${processor.events.length} events)`);
                 // 检测注入的 MCP tool_use → 发 proxy_status 信号 + 跑 streaming inject loop
                 if (processor.hasInjectedToolUse()) {
@@ -335,7 +239,7 @@ export async function setupChatRoute(fastify, proxyConfig) {
                                 method: 'POST',
                                 headers: forwardHeaders,
                                 body: JSON.stringify(b),
-                                signal: AbortSignal.timeout(300000)
+                                signal: createTimeoutSignal(300000, clientSignal)
                             });
                             const loopRequestId = r.headers.get('x-request-id') || `loop_${request.id}_${Date.now()}`;
                             return { response: r, requestId: loopRequestId };
@@ -358,9 +262,9 @@ export async function setupChatRoute(fastify, proxyConfig) {
                         },
                         sessionId,
                         saveIterationDB: async (loopRequestId, loopProcessor, loopStatusCode, loopBody) => {
-                            const loopData = {
-                                requestId: loopRequestId,
+                            await recordIteration({
                                 sessionId,
+                                localRequestId: loopRequestId,
                                 timestamp: new Date().toISOString(),
                                 apiKey,
                                 proxyApiKey,
@@ -370,27 +274,9 @@ export async function setupChatRoute(fastify, proxyConfig) {
                                 request: { method: 'POST', path: '/api/chat', headers: forwardHeaders, body: loopBody },
                                 response: {
                                     statusCode: loopStatusCode,
-                                    events: loopProcessor.events,
-                                    completedAt: new Date().toISOString()
+                                    events: loopProcessor.events
                                 }
-                            };
-                            await saveRequestDB(sessionId, loopRequestId, loopData);
-                            const loopUsage = extractTokenUsage(loopProcessor.events);
-                            pushNewRequest({
-                                requestId: loopRequestId,
-                                sessionId,
-                                compositeId: `${sessionId}:${loopRequestId}`,
-                                method: 'POST',
-                                path: '/api/chat',
-                                timestamp: loopData.timestamp,
-                                statusCode: loopStatusCode,
-                                responseTime: 0,
-                                model: forwardedModel,
-                                machineId,
-                                userAgent: request.headers['user-agent'],
-                                baseUrl: resolved.baseUrl,
-                                usage: loopUsage
-                            }, 'completed');
+                            });
                         },
                         raw: reply.raw
                     });

package/dist/server/data-push.d.ts

@@ -3,5 +3,4 @@ export declare function addDataClient(ws: WebSocket): void;
 export declare function removeDataClient(ws: WebSocket): void;
 export declare function getDataClientCount(): number;
 export declare function pushNewRequest(summary: any, status?: 'pending' | 'completed'): void;
-export declare function pushStatsNotify(): void;
 export declare function broadcastToDataClients(msg: any): void;

package/dist/server/data-push.js

@@ -18,13 +18,6 @@ export function pushNewRequest(summary, status = 'completed') {
         data: { ...summary, status }
     });
 }
-export function pushStatsNotify() {
-    broadcast({
-        type: 'stats',
-        action: 'notify',
-        data: { reason: 'file_updated' }
-    });
-}
 function broadcast(msg) {
     const payload = JSON.stringify(msg);
     for (const ws of dataClients) {