@cc-monitoring/proxy-core 0.3.0 → 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/index.js

@@ -2,11 +2,13 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { getProjectVersion } from '../utils/version.js';
 import { MCP_TOOLS, registerMcpTools } from './tools.js';
-const MCP_INSTRUCTIONS = `This server provides a hybrid knowledge base plus cc-monitoring proxy observability tools.
+const MCP_INSTRUCTIONS = `This server provides a project knowledge base and cc-monitoring proxy observability tools.
 
-BEFORE answering domain/project-specific questions, proactively search the knowledge base: call \`list_topics\` to discover topics, then \`get_topic\` to inspect chunks, then \`read_chunk\` to read chunk bodies (one chunk per call). If the topic is unknown, use \`search_chunks\` first. Do not wait for the user to explicitly ask.
+KNOWLEDGE BASE: it is the authoritative source for this project, and your own knowledge may be outdated. Before answering any question that could relate to the project or its domain, call \`query_knowledge\` with the key terms — it searches and returns matching chunk bodies in one call. Do not rely on your own knowledge first, and do not wait for the user to explicitly ask. Skip this only for purely general questions (language syntax, standard algorithms, chitchat) with no plausible connection to a project topic.
 
-Observability tools (\`get_status\`, \`list_requests\`, \`get_token_stats\`, \`get_logs\`) are for inspecting the proxy itself: request history, token usage, log tail. Use them only when the user asks about the proxy/monitoring state.`;
+If query_knowledge returns nothing or the result is insufficient, browse with \`list_topics\` → \`get_topic\` → \`read_chunk\` (one chunk per call). Do not call \`list_topics\` again when its result is already present in this conversation.
+
+OBSERVABILITY tools (\`get_status\`, \`list_requests\`, \`get_token_stats\`, \`get_logs\`) inspect the proxy itself — request history, token usage, logs. Use them only when the user asks about the proxy or monitoring state.`;
 export function createMcpServer(config) {
     const server = new Server({ name: 'cc-monitoring', version: getProjectVersion() }, {
         capabilities: { tools: {} },

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 };
         }
@@ -135,9 +134,22 @@ export const MCP_TOOLS = [
             additionalProperties: false,
         },
     },
+    {
+        name: 'query_knowledge',
+        description: 'Search the knowledge base and return matching chunk bodies in one call. This is the primary tool for answering project/domain questions.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search keywords' },
+                limit: { type: 'number', description: 'Max chunks to return (default 3, max 5).' },
+            },
+            required: ['query'],
+            additionalProperties: false,
+        },
+    },
     {
         name: 'list_topics',
-        description: 'List all knowledge topics with one-line summary. Call this first to discover what topics exist.',
+        description: 'List all knowledge topics with one-line summary. Use this to browse topics when keyword search does not answer the question.',
         inputSchema: { type: 'object', properties: {}, additionalProperties: false },
     },
     {
@@ -152,7 +164,7 @@ export const MCP_TOOLS = [
     },
     {
         name: 'search_chunks',
-        description: 'Keyword search across all chunks. Returns matching chunk list (no body). Use when topic is unknown.',
+        description: 'Keyword search across all chunks, returning a matching chunk list without bodies. Prefer query_knowledge, which returns bodies directly; use this only when you need chunk lists without bodies.',
         inputSchema: {
             type: 'object',
             properties: { query: { type: 'string', description: 'Search keyword' } },
@@ -179,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);
@@ -192,10 +204,19 @@ const HANDLERS = {
             return err(e);
         }
     },
-    search_chunks: async (args) => ok(JSON.stringify(await knowledgeStore.searchChunks(args.query ?? ''), null, 2)),
+    query_knowledge: async (args) => {
+        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.');
+        }
+        return ok(JSON.stringify({
+            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 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,28 +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,
-            baseUrl: resolved.baseUrl
-        }, 'pending');
+        await rec.pending();
         // Mock interception (PoC)
         if (shouldMock(request.body)) {
             reply.hijack();
@@ -125,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');
@@ -143,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') {
@@ -162,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;
@@ -171,98 +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,
-                                    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,
-                        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,
-                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);
@@ -290,31 +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,
-                    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()) {
@@ -330,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 };
@@ -353,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,
@@ -365,26 +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,
-                                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) {