@cc-monitoring/proxy-core 0.3.1 → 0.4.1

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__/data-push.test.js

@@ -0,0 +1,44 @@
+import { WebSocket } from 'ws';
+import { addDataClient, removeDataClient, pushNewRequest } from '../data-push';
+// 统计 fake client 收到的各类广播
+function messagesOf(send) {
+    return send.mock.calls.map((call) => JSON.parse(call[0]));
+}
+describe('data-push stats notify debounce', () => {
+    let send;
+    const fakeWs = {
+        readyState: WebSocket.OPEN,
+        send: jest.fn()
+    };
+    beforeEach(() => {
+        jest.useFakeTimers();
+        send = fakeWs.send;
+        send.mockClear();
+        addDataClient(fakeWs);
+    });
+    afterEach(() => {
+        removeDataClient(fakeWs);
+        jest.clearAllTimers();
+        jest.useRealTimers();
+    });
+    it('trailing：重复 completed push 会重置延迟窗口，只在最后一次后 1.5s 广播一次', () => {
+        // t=0 第一次 completed push
+        pushNewRequest({ id: 1 }, 'completed');
+        jest.advanceTimersByTime(1000);
+        // t=1000 第二次 completed push，trailing 重置：窗口从第二次重新起算
+        pushNewRequest({ id: 2 }, 'completed');
+        // 距第二次 1499ms（总 2499ms）仍无 stats 广播；若没有重置，第一次的 timer 在 t=1500 就会触发
+        jest.advanceTimersByTime(1499);
+        expect(messagesOf(send).filter((m) => m.type === 'stats')).toHaveLength(0);
+        // 总 2500ms（距第二次 1500ms）恰好广播一次
+        jest.advanceTimersByTime(1);
+        const statsMessages = messagesOf(send).filter((m) => m.type === 'stats');
+        expect(statsMessages).toHaveLength(1);
+        expect(statsMessages[0]).toEqual({ type: 'stats', action: 'notify' });
+    });
+    it('pending push 不产生 stats 广播', () => {
+        pushNewRequest({ id: 1 }, 'pending');
+        jest.advanceTimersByTime(5000);
+        expect(messagesOf(send).filter((m) => m.type === 'stats')).toHaveLength(0);
+    });
+});

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/__tests__/proxy.test.js

@@ -1,4 +1,6 @@
-import { getErrorStatusCode, getErrorMessage, resolveProxyTarget, filterForwardHeaders } from '../proxy';
+import { getErrorStatusCode, getErrorMessage, resolveProxyTarget, filterForwardHeaders, setupProxy } from '../proxy';
+import Fastify from 'fastify';
+import http from 'node:http';
 import Database from 'better-sqlite3';
 jest.mock('@utils/db', () => ({
     __esModule: true,
@@ -6,7 +8,24 @@ jest.mock('@utils/db', () => ({
     initDatabase: jest.fn(),
     closeDatabase: jest.fn()
 }));
-const { getDatabase } = jest.requireMock('@utils/db');
+jest.mock('@config/index', () => ({
+    loadConfig: jest.fn().mockResolvedValue({ storage: { maxDays: 7 } })
+}));
+jest.mock('../../utils/mcp-manager', () => ({
+    mcpManager: {
+        init: jest.fn().mockResolvedValue(undefined),
+        close: jest.fn().mockResolvedValue(undefined)
+    }
+}));
+jest.mock('../../utils/machine-id', () => ({
+    getMachineId: jest.fn().mockResolvedValue('test-machine-id'),
+    getMachineIdSync: jest.fn().mockReturnValue('test-machine-id'),
+    preloadMachineId: jest.fn().mockResolvedValue(undefined)
+}));
+jest.mock('../../utils/stats-aggregator', () => ({
+    aggregateStats: jest.fn()
+}));
+const { getDatabase, initDatabase } = jest.requireMock('@utils/db');
 function makeError(code, message) {
     const error = new Error(message);
     error.code = code;
@@ -135,3 +154,263 @@ describe('filterForwardHeaders with authStyle', () => {
         expect(out['x-api-key']).toBe('inbound-key');
     });
 });
+// --- G2: 逻辑终止识别 + 收割接入（setupProxy 集成测试）---
+// 构造集成测试用内存库：仅建 proxy.ts 运行路径触及的表
+function createIntegrationDb() {
+    const db = new Database(':memory:');
+    db.exec(`
+    CREATE TABLE requests (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      request_id TEXT UNIQUE NOT NULL,
+      session_id TEXT NOT NULL,
+      timestamp TEXT NOT NULL,
+      method TEXT NOT NULL,
+      path TEXT NOT NULL,
+      status_code INTEGER NOT NULL,
+      response_time INTEGER NOT NULL,
+      api_key TEXT,
+      proxy_api_key TEXT,
+      base_url TEXT,
+      model TEXT,
+      machine_id TEXT,
+      user_agent TEXT,
+      input_tokens INTEGER,
+      output_tokens INTEGER,
+      cache_read_tokens INTEGER,
+      cache_creation_tokens INTEGER,
+      request_headers TEXT,
+      request_body TEXT,
+      response_headers TEXT,
+      response_events TEXT,
+      completed_at TEXT,
+      closed_at TEXT,
+      error TEXT,
+      created_at TEXT DEFAULT CURRENT_TIMESTAMP
+    );
+    CREATE TABLE response_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      request_id TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      event_index INTEGER NOT NULL,
+      event_type TEXT,
+      event_data TEXT NOT NULL
+    );
+    CREATE TABLE learn_tasks (
+      task_id TEXT PRIMARY KEY,
+      slug TEXT NOT NULL,
+      source_type TEXT NOT NULL,
+      label TEXT NOT NULL,
+      status TEXT NOT NULL,
+      error TEXT,
+      created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      ended_at TEXT
+    );
+    CREATE TABLE providers (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT UNIQUE NOT NULL,
+      base_url TEXT,
+      api_key TEXT,
+      model TEXT,
+      haiku_model TEXT,
+      sonnet_model TEXT,
+      opus_model TEXT,
+      subagent_model TEXT,
+      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
+    );
+  `);
+    return db;
+}
+function sseFrame(event, data) {
+    const body = typeof data === 'string' ? data : JSON.stringify(data);
+    return event !== null ? `event: ${event}\ndata: ${body}\n\n` : `data: ${body}\n\n`;
+}
+const completeClaudeFrames = [
+    sseFrame('message_start', { type: 'message_start', usage: { input_tokens: 10, cache_read_input_tokens: 2 } }),
+    sseFrame('ping', { type: 'ping' }),
+    sseFrame('message_delta', { type: 'message_delta', usage: { output_tokens: 4 } }),
+    sseFrame('message_stop', { type: 'message_stop' })
+];
+const incompleteClaudeFrames = [
+    sseFrame('message_start', { type: 'message_start', usage: { input_tokens: 3 } }),
+    sseFrame('content_block_start', { type: 'content_block_start', index: 0, content_block: { type: 'text', text: '' } }),
+    sseFrame('content_block_delta', { type: 'content_block_delta', index: 0, delta: { type: 'text_delta', text: 'hel' } })
+];
+// 上游 Web 流：逐帧异步入队；endAfter=false 时入队后保持悬挂（不 close）。
+// singleChunk=true 时所有帧合并为一次 enqueue（模拟真实 TCP 合包，如
+// finish_reason chunk 与紧随的 [DONE] 通常在同一缓冲到达）。
+function createUpstreamWebStream(frames, endAfter = false, singleChunk = false) {
+    let controller;
+    const webStream = new ReadableStream({
+        start(c) { controller = c; }
+    });
+    void (async () => {
+        try {
+            if (singleChunk) {
+                controller.enqueue(Buffer.from(frames.join(''), 'utf-8'));
+            }
+            else {
+                for (const frame of frames) {
+                    controller.enqueue(Buffer.from(frame, 'utf-8'));
+                    await new Promise(r => setTimeout(r, 3));
+                }
+            }
+            if (endAfter)
+                controller.close();
+        }
+        catch {
+            // nodeStream.destroy 取消 web 流后 controller 已关闭，忽略后续入队
+        }
+    })();
+    return webStream;
+}
+async function waitFor(predicate, { timeout = 3000, interval = 20 } = {}) {
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+        const value = predicate();
+        if (value !== undefined)
+            return value;
+        await new Promise(r => setTimeout(r, interval));
+    }
+    throw new Error('waitFor timed out');
+}
+function mockUpstreamFetch(webStream, requestId) {
+    return jest.spyOn(globalThis, 'fetch').mockImplementation(async () => new Response(webStream, {
+        status: 200,
+        headers: { 'content-type': 'text/event-stream', 'x-request-id': requestId }
+    }));
+}
+const proxyConfig = {
+    target: 'https://upstream.example.com/apps/anthropic',
+    changeOrigin: true
+};
+const requestPayload = JSON.stringify({
+    model: 'claude-sonnet-4-20250514',
+    max_tokens: 16,
+    messages: [{ role: 'user', content: 'hi' }]
+});
+describe('setupProxy SSE lifecycle (G2)', () => {
+    let db;
+    let fastify;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        db = createIntegrationDb();
+        getDatabase.mockReturnValue(db);
+        initDatabase.mockReturnValue(db);
+        fastify = Fastify();
+    });
+    afterEach(async () => {
+        delete process.env.CCM_STREAM_IDLE_TIMEOUT_MS;
+        await fastify.close();
+        db.close();
+    });
+    test('message_stop 已发出后上游悬挂：行落 completed_at，不标中断，客户端不悬挂', async () => {
+        await setupProxy(fastify, proxyConfig);
+        mockUpstreamFetch(createUpstreamWebStream(completeClaudeFrames), 'cloud-req-1');
+        const response = await fastify.inject({
+            method: 'POST',
+            url: '/v1/messages',
+            headers: { 'content-type': 'application/json' },
+            payload: requestPayload
+        });
+        expect(response.statusCode).toBe(200);
+        expect(response.payload).toContain('message_stop');
+        const row = db.prepare('SELECT * FROM requests WHERE request_id = ?').get('cloud-req-1');
+        expect(row).toBeDefined();
+        expect(row.completed_at).not.toBeNull();
+        expect(row.closed_at).toBeNull();
+        expect(row.error).toBeNull();
+    });
+    test('无 message_stop 的 idle 超时仍标中断（closed_at + error）', async () => {
+        // 测试专用时长覆盖：真实定时器，只缩短看门狗超时
+        process.env.CCM_STREAM_IDLE_TIMEOUT_MS = '80';
+        await setupProxy(fastify, proxyConfig);
+        mockUpstreamFetch(createUpstreamWebStream(incompleteClaudeFrames), 'cloud-req-2');
+        // 走真实 TCP：中断分支 pipe 不结束客户端（保持既有语义），客户端自行判超时
+        await fastify.listen({ port: 0, host: '127.0.0.1' });
+        const port = fastify.server.address().port;
+        const clientReq = http.request({
+            port,
+            host: '127.0.0.1',
+            method: 'POST',
+            path: '/v1/messages',
+            headers: { 'content-type': 'application/json', 'content-length': Buffer.byteLength(requestPayload) }
+        });
+        clientReq.on('error', () => { });
+        clientReq.end(requestPayload);
+        // 客户端收到数据后看门狗触发，不再有数据；保底 1s 后自毁连接
+        const clientTimer = setTimeout(() => clientReq.destroy(), 1000);
+        clientReq.on('close', () => clearTimeout(clientTimer));
+        const row = await waitFor(() => {
+            const r = db.prepare('SELECT * FROM requests LIMIT 1').get();
+            return r && r.closed_at ? r : undefined;
+        });
+        expect(row.completed_at).toBeNull();
+        expect(row.closed_at).not.toBeNull();
+        expect(row.error).toContain('idle timeout');
+        expect(row.status_code).toBe(200);
+    });
+    test('OpenAI 流 finish_reason + [DONE] 后上游悬挂：行落 completed_at', async () => {
+        db.prepare(`
+      INSERT INTO providers (name, base_url, api_key, model, provider, is_default, is_openai_compatible, auth_style)
+      VALUES ('openai-test', 'https://openai.example.com/v1', 'k', 'gpt-4o', 'openai', 1, 1, 'bearer')
+    `).run();
+        await setupProxy(fastify, proxyConfig);
+        const openaiFrames = [
+            sseFrame(null, { id: 'chat-1', choices: [{ delta: { role: 'assistant' }, finish_reason: null }] }),
+            sseFrame(null, { id: 'chat-1', choices: [{ delta: { content: 'hi' }, finish_reason: null }] }),
+            sseFrame(null, { id: 'chat-1', choices: [{ delta: {}, finish_reason: 'stop' }], usage: { prompt_tokens: 5, completion_tokens: 7 } }),
+            sseFrame(null, '[DONE]')
+        ];
+        const fetchSpy = mockUpstreamFetch(createUpstreamWebStream(openaiFrames, false, true), 'cloud-openai-1');
+        const response = await fastify.inject({
+            method: 'POST',
+            url: '/v1/messages',
+            headers: { 'content-type': 'application/json' },
+            payload: requestPayload
+        });
+        expect(response.statusCode).toBe(200);
+        expect(response.payload).toContain('message_stop');
+        expect(fetchSpy.mock.calls[0][0]).toBe('https://openai.example.com/v1/chat/completions');
+        const row = db.prepare('SELECT * FROM requests WHERE request_id = ?').get('cloud-openai-1');
+        expect(row).toBeDefined();
+        expect(row.completed_at).not.toBeNull();
+        expect(row.closed_at).toBeNull();
+        expect(row.error).toBeNull();
+    });
+    test('message_stop 到达后客户端断开：内容已完整交付，仍走 complete', async () => {
+        await setupProxy(fastify, proxyConfig);
+        mockUpstreamFetch(createUpstreamWebStream(completeClaudeFrames), 'cloud-req-3');
+        await fastify.listen({ port: 0, host: '127.0.0.1' });
+        const port = fastify.server.address().port;
+        await new Promise((resolve, reject) => {
+            const clientReq = http.request({
+                port,
+                host: '127.0.0.1',
+                method: 'POST',
+                path: '/v1/messages',
+                headers: { 'content-type': 'application/json', 'content-length': Buffer.byteLength(requestPayload) }
+            });
+            clientReq.on('error', () => { });
+            clientReq.on('response', (res) => {
+                res.on('data', (chunk) => {
+                    if (chunk.toString().includes('message_stop'))
+                        clientReq.destroy();
+                });
+            });
+            clientReq.on('close', () => resolve());
+            setTimeout(() => reject(new Error('client did not close')), 3000).unref();
+            clientReq.end(requestPayload);
+        });
+        const row = await waitFor(() => {
+            const r = db.prepare('SELECT * FROM requests WHERE request_id = ?').get('cloud-req-3');
+            return r && r.completed_at ? r : undefined;
+        });
+        expect(row.closed_at).toBeNull();
+        expect(row.error).toBeNull();
+    });
+});

package/dist/server/__tests__/server.test.js

@@ -105,22 +105,27 @@ describe('createServer', () => {
         expect(response).toBeDefined();
         expect(typeof response.statusCode).toBe('number');
     });
-    it('propagates request ID from x-request-id header', async () => {
+    it('uses x-request-id header value as request id when header present', async () => {
         server = await createServer();
+        server.get('/request-id-echo', async (request) => ({ id: request.id }));
         const response = await server.inject({
             method: 'GET',
-            url: '/test',
-            headers: { 'x-request-id': 'custom-id-123' }
+            url: '/request-id-echo',
+            headers: { 'x-request-id': 'my-trace-123' }
         });
-        expect(response).toBeDefined();
+        expect(JSON.parse(response.body).id).toBe('my-trace-123');
     });
-    it('handles request without x-request-id header', async () => {
+    it('generates non-default nanoid request id without header, unique per request', async () => {
         server = await createServer();
-        const response = await server.inject({
-            method: 'GET',
-            url: '/test'
-        });
-        expect(response).toBeDefined();
+        server.get('/request-id-echo', async (request) => ({ id: request.id }));
+        const response1 = await server.inject({ method: 'GET', url: '/request-id-echo' });
+        const response2 = await server.inject({ method: 'GET', url: '/request-id-echo' });
+        const id1 = JSON.parse(response1.body).id;
+        const id2 = JSON.parse(response2.body).id;
+        expect(id1).not.toMatch(/^req-\d+$/);
+        expect(id2).not.toMatch(/^req-\d+$/);
+        expect(id1).toHaveLength(16);
+        expect(id1).not.toBe(id2);
     });
     it('server closes cleanly', async () => {
         server = await createServer();

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

@@ -1,4 +1,5 @@
 import Fastify from 'fastify';
+import * as statsAggregator from '@utils/stats-aggregator';
 import { setupUiRoutes } from '../ui-route';
 // Mock PM2 utils
 jest.mock('@utils/pm2', () => ({
@@ -372,4 +373,46 @@ describe('setupUiRoutes', () => {
             expect(body.error).toContain('Disk write failed');
         });
     });
+    describe('GET /ui/api/stats', () => {
+        let aggregateSpy;
+        let getStatsSpy;
+        beforeEach(() => {
+            aggregateSpy = jest.spyOn(statsAggregator, 'aggregateStats').mockImplementation(() => { });
+            getStatsSpy = jest.spyOn(statsAggregator, 'getStatsData').mockReturnValue({ hourly: {}, lastUpdated: null });
+        });
+        afterEach(() => {
+            aggregateSpy.mockRestore();
+            getStatsSpy.mockRestore();
+        });
+        it('读前触发 aggregateStats 并返回 200', async () => {
+            const response = await server.inject({ method: 'GET', url: '/ui/api/stats' });
+            expect(aggregateSpy).toHaveBeenCalledTimes(1);
+            expect(aggregateSpy).toHaveBeenCalledWith(7);
+            expect(getStatsSpy).toHaveBeenCalledTimes(1);
+            // 必须先聚合再读取
+            expect(aggregateSpy.mock.invocationCallOrder[0]).toBeLessThan(getStatsSpy.mock.invocationCallOrder[0]);
+            expect(response.statusCode).toBe(200);
+            expect(JSON.parse(response.body)).toEqual({ hourly: {}, lastUpdated: null });
+        });
+        it('聚合失败只记录不阻断读取，仍返回 200', async () => {
+            aggregateSpy.mockImplementation(() => { throw new Error('agg boom'); });
+            // inject 请求的 request.log 来自 server.log.child()，替换为可观测的 mock
+            const logError = jest.fn();
+            jest.spyOn(server.log, 'child').mockReturnValue({
+                level: 'info',
+                fatal: jest.fn(),
+                error: logError,
+                warn: jest.fn(),
+                info: jest.fn(),
+                debug: jest.fn(),
+                trace: jest.fn(),
+                child: jest.fn()
+            });
+            const response = await server.inject({ method: 'GET', url: '/ui/api/stats' });
+            expect(response.statusCode).toBe(200);
+            expect(getStatsSpy).toHaveBeenCalledTimes(1);
+            // 聚合异常必须记录日志
+            expect(logError).toHaveBeenCalledTimes(1);
+        });
+    });
 });

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