@cc-monitoring/proxy-core 0.3.0 → 0.4.0

package/dist/utils/__tests__/learn-tasks-db.test.js

@@ -0,0 +1,82 @@
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { configureDbPath, initDatabase, closeDatabase, getDatabase } from '../db.js';
+import { insertRunning, markCompleted, markFailed, markAborted, recoverCrashedTasks, } from '../learn-tasks-db.js';
+describe('learn-tasks-db', () => {
+    let tempDir;
+    beforeEach(() => {
+        tempDir = mkdtempSync(path.join(tmpdir(), 'ccm-lt-'));
+        configureDbPath(path.join(tempDir, 'test.db'));
+        initDatabase();
+    });
+    afterEach(() => {
+        closeDatabase();
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    function getRow(taskId) {
+        return getDatabase().prepare('SELECT * FROM learn_tasks WHERE task_id = ?').get(taskId);
+    }
+    test('insertRunning 落 running 行且字段正确', () => {
+        const { taskId } = insertRunning(getDatabase(), {
+            slug: 'my-slug',
+            sourceType: 'url',
+            label: 'https://x.com/',
+        });
+        const row = getRow(taskId);
+        expect(row).toMatchObject({
+            task_id: taskId,
+            slug: 'my-slug',
+            source_type: 'url',
+            label: 'https://x.com/',
+            status: 'running',
+        });
+        expect(row.error).toBeNull();
+        expect(row.ended_at).toBeNull();
+        expect(typeof row.created_at).toBe('string');
+    });
+    test('不同 slug 可同时 running；同 slug 第二次 insertRunning 撞 partial unique 约束', () => {
+        const db = getDatabase();
+        insertRunning(db, { slug: 'slug-a', sourceType: 'url', label: 'a' });
+        expect(() => insertRunning(db, { slug: 'slug-b', sourceType: 'file', label: 'b' })).not.toThrow();
+        expect(() => insertRunning(db, { slug: 'slug-a', sourceType: 'file', label: 'a2' })).toThrow(/UNIQUE constraint failed/);
+    });
+    const terminalCases = [
+        ['completed', (db, taskId) => markCompleted(db, taskId)],
+        ['failed', (db, taskId) => markFailed(db, taskId, 'boom')],
+        ['aborted', (db, taskId) => markAborted(db, taskId)],
+    ];
+    test.each(terminalCases)('终态 %s：写 ended_at 后同 slug 可再次 insertRunning', (status, transition) => {
+        const db = getDatabase();
+        const { taskId } = insertRunning(db, { slug: 'slug-x', sourceType: 'url', label: 'a' });
+        transition(db, taskId);
+        const row = getRow(taskId);
+        expect(row.status).toBe(status);
+        expect(typeof row.ended_at).toBe('string');
+        const again = insertRunning(db, { slug: 'slug-x', sourceType: 'url', label: 'a2' });
+        expect(getRow(again.taskId).status).toBe('running');
+    });
+    test('markFailed 写入 error 与 ended_at', () => {
+        const db = getDatabase();
+        const { taskId } = insertRunning(db, { slug: 'f', sourceType: 'file', label: 'f.md' });
+        markFailed(db, taskId, 'something broke');
+        const row = getRow(taskId);
+        expect(row.status).toBe('failed');
+        expect(row.error).toBe('something broke');
+        expect(typeof row.ended_at).toBe('string');
+    });
+    test('recoverCrashedTasks：running → crashed 且返回计数；非 running 行不动；recover 后同 slug 可再跑', () => {
+        const db = getDatabase();
+        const r1 = insertRunning(db, { slug: 's1', sourceType: 'url', label: 'a' });
+        const r2 = insertRunning(db, { slug: 's2', sourceType: 'url', label: 'b' });
+        markCompleted(db, r2.taskId);
+        expect(recoverCrashedTasks(db)).toBe(1);
+        const crashed = getRow(r1.taskId);
+        expect(crashed.status).toBe('crashed');
+        expect(typeof crashed.ended_at).toBe('string');
+        expect(getRow(r2.taskId).status).toBe('completed');
+        // crashed 释放 partial unique 守卫，同 slug 可再跑
+        const again = insertRunning(db, { slug: 's1', sourceType: 'url', label: 'c' });
+        expect(getRow(again.taskId).status).toBe('running');
+    });
+});

package/dist/utils/__tests__/openai-converter.test.js

@@ -0,0 +1,25 @@
+import { createStreamTransformer } from '../openai-converter.js';
+describe('createStreamTransformer', () => {
+    it('收到 [DONE] 后正常关闭且不产生 error（不 double callback）', (done) => {
+        const stream = createStreamTransformer('test-model');
+        let output = '';
+        let errored = null;
+        let closed = false;
+        stream.on('data', (chunk) => { output += chunk.toString(); });
+        stream.on('error', (err) => { errored = err; });
+        stream.on('close', () => { closed = true; });
+        // 正常帧：含 delta.content
+        stream.write('data: {"choices":[{"delta":{"content":"hi"}}]}\n\n');
+        // finish_reason 帧 + [DONE] 放同一 chunk
+        stream.write('data: {"choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}\n\ndata: [DONE]\n\n');
+        setTimeout(() => {
+            // double callback 若将来被 Node 升级为抛错，会在这里以 error/未关闭暴露
+            expect(errored).toBeNull();
+            expect(closed).toBe(true);
+            // 收尾帧中存在 message_delta（携带 stop_reason）
+            expect(output).toContain('message_delta');
+            expect(output).toContain('stop_reason');
+            done();
+        }, 100);
+    });
+});

package/dist/utils/__tests__/pi-crawl-tools.test.js

@@ -270,14 +270,25 @@ describe('CrawlGuard signal 透传', () => {
     it('crawl_open/crawl_visit 的 execute 把 signal 透传给 guard.navigate', async () => {
         const nav = jest.fn(async () => ({ title: 'A', text: 'A text', links: ['https://pi.dev/b'] }));
         const guard = new CrawlGuard({ entryUrl: 'https://pi.dev/', docsDir: docsDir(), slug: 'pi', navigate: nav });
-        const tools = createCrawlTools(guard);
-        const byName = Object.fromEntries(tools.map((t) => [t.name, t]));
         const signal = new AbortController().signal;
+        const tools = createCrawlTools(guard, signal);
+        const byName = Object.fromEntries(tools.map((t) => [t.name, t]));
         await byName.crawl_open.execute('id-1', {}, signal, undefined, {});
         expect(nav).toHaveBeenNthCalledWith(1, 'https://pi.dev/', signal);
         await byName.crawl_visit.execute('id-2', { url: 'https://pi.dev/b' }, signal, undefined, {});
         expect(nav).toHaveBeenNthCalledWith(2, 'https://pi.dev/b', signal);
     });
+    it('createCrawlTools 传入已 abort 的外部 signal：crawl_open 把中止 signal 透传给 runEgoBrowser', async () => {
+        mockRunEgoBrowser.mockResolvedValue(JSON.stringify({ title: 'A', text: 'A text', links: [] }));
+        const guard = new CrawlGuard({ entryUrl: 'https://pi.dev/', docsDir: docsDir(), slug: 'pi' });
+        const external = new AbortController();
+        external.abort();
+        const tools = createCrawlTools(guard, external.signal);
+        const byName = Object.fromEntries(tools.map((t) => [t.name, t]));
+        // 未传 SDK tool signal 时直接使用外部 signal 原引用
+        await byName.crawl_open.execute('id-3', {}, undefined, undefined, {});
+        expect(mockRunEgoBrowser).toHaveBeenCalledWith(expect.any(String), { timeoutMs: 60000, signal: external.signal });
+    });
 });
 describe('createCrawlTools', () => {
     function makeGuard() {
@@ -292,13 +303,13 @@ describe('createCrawlTools', () => {
         });
     }
     it('提供 crawl_open/crawl_visit/save_source/crawl_finish 四个工具', () => {
-        const tools = createCrawlTools(makeGuard());
+        const tools = createCrawlTools(makeGuard(), new AbortController().signal);
         expect(tools.map((t) => t.name)).toEqual(['crawl_open', 'crawl_visit', 'save_source', 'crawl_finish']);
     });
     it('工具错误以可读文本返回（不抛异常）', async () => {
         mockRunEgoBrowser.mockResolvedValue('closed');
         const guard = makeGuard();
-        const tools = createCrawlTools(guard);
+        const tools = createCrawlTools(guard, new AbortController().signal);
         const byName = Object.fromEntries(tools.map((t) => [t.name, t]));
         const textOf = (res) => res.content.map((c) => c.text ?? '').join('\n');
         // execute 签名 5 参（id/params/signal/onUpdate/ctx），测试只需前 2 个

package/dist/utils/__tests__/pi-dedup-reconcile.test.js

@@ -5,6 +5,8 @@ import path from 'path';
 import { runJsonPrompt } from '../pi-runtime.js';
 import { reconcileTopics, readAllTopics, readTopicDetail, mintSlug } from '../pi-dedup.js';
 const mockJson = runJsonPrompt;
+// 本文件用例只验证裁定/降级逻辑，signal 不触发，复用一个常驻 signal
+const signal = new AbortController().signal;
 let tmp;
 beforeEach(async () => {
     tmp = await mkdtemp(path.join(os.tmpdir(), 'pi-dedup-'));
@@ -15,7 +17,7 @@ test('预筛命中 → 调 LLM，match=true 透传 targetSlug/mergedTitle/itemsT
         confidence: 0.62, itemsToAdd: [{ id: 'x', title: 'X', oneLine: 'x' }] });
     const r = await reconcileTopics({ port: 1, docsDir: tmp, wantItems: true,
         candidate: { slug: 'new', title: 'React Hooks', tags: [] },
-        targets: [{ slug: 'a', title: 'React Hooks', summary: '', tags: [], chunks: [] }] });
+        targets: [{ slug: 'a', title: 'React Hooks', summary: '', tags: [], chunks: [] }], signal });
     expect(r.match).toBe(true);
     expect(r.targetSlug).toBe('a');
     expect(r.itemsToAdd).toHaveLength(1);
@@ -24,7 +26,7 @@ test('LLM 抛错（坏 JSON）→ 安全返回 match=false', async () => {
     mockJson.mockRejectedValue(new Error('no json object in response'));
     await expect(reconcileTopics({ port: 1, docsDir: tmp, wantItems: false,
         candidate: { slug: 'new', title: 'T', tags: [] },
-        targets: [{ slug: 'a', title: 'T', summary: '', tags: [], chunks: [] }] }))
+        targets: [{ slug: 'a', title: 'T', summary: '', tags: [], chunks: [] }], signal }))
         .resolves.toMatchObject({ match: false });
 });
 test('正载荷回显候选自身 slug（未提供的目标）→ match=false', async () => {
@@ -32,26 +34,26 @@ test('正载荷回显候选自身 slug（未提供的目标）→ match=false',
         mergedSummary: 's', itemsToAdd: [] });
     const r = await reconcileTopics({ port: 1, docsDir: tmp, wantItems: true,
         candidate: { slug: 'new', title: 'React Hooks', tags: [] },
-        targets: [{ slug: 'a', title: 'React Hooks', summary: '', tags: [], chunks: [] }] });
+        targets: [{ slug: 'a', title: 'React Hooks', summary: '', tags: [], chunks: [] }], signal });
     expect(r).toEqual({ match: false });
 });
 test('正载荷缺 mergedTitle → match=false', async () => {
     mockJson.mockResolvedValue({ match: true, targetSlug: 'a', mergedSummary: 's', itemsToAdd: [] });
     const r = await reconcileTopics({ port: 1, docsDir: tmp, wantItems: true,
         candidate: { slug: 'new', title: 'React Hooks', tags: [] },
-        targets: [{ slug: 'a', title: 'React Hooks', summary: '', tags: [], chunks: [] }] });
+        targets: [{ slug: 'a', title: 'React Hooks', summary: '', tags: [], chunks: [] }], signal });
     expect(r).toEqual({ match: false });
 });
 test('空目标 → 不调 LLM，match=false', async () => {
     const r = await reconcileTopics({ port: 1, docsDir: tmp, wantItems: false,
-        candidate: { slug: 'new', title: 'zzz', tags: [] }, targets: [] });
+        candidate: { slug: 'new', title: 'zzz', tags: [] }, targets: [], signal });
     expect(r).toEqual({ match: false });
     expect(mockJson).not.toHaveBeenCalled();
 });
 test('预筛空且目标>20 → 不调 LLM，match=false', async () => {
     const targets = Array.from({ length: 21 }, (_, i) => ({ slug: `s${i}`, title: `Distinct ${i}`, summary: '', tags: [], chunks: [] }));
     const r = await reconcileTopics({ port: 1, docsDir: tmp, wantItems: false,
-        candidate: { slug: 'new', title: 'zzzz-noise', tags: [] }, targets });
+        candidate: { slug: 'new', title: 'zzzz-noise', tags: [] }, targets, signal });
     expect(r.match).toBe(false);
     expect(mockJson).not.toHaveBeenCalled();
 });
@@ -67,15 +69,15 @@ test('readAllTopics: 空/缺失目录返回 []', async () => {
 describe('mintSlug', () => {
     test('LLM 返回合法且空闲的 slug → 直接使用', async () => {
         mockJson.mockResolvedValue({ slug: 'react-hooks' });
-        await expect(mintSlug({ port: 1, title: 'React Hooks', existing: [] })).resolves.toBe('react-hooks');
+        await expect(mintSlug({ port: 1, title: 'React Hooks', existing: [], signal })).resolves.toBe('react-hooks');
     });
     test('LLM 返回非法 slug → 降级 slugFromLabel(title)', async () => {
         mockJson.mockResolvedValue({ slug: 'Bad Slug!' });
-        await expect(mintSlug({ port: 1, title: 'Hello World', existing: [] })).resolves.toBe('hello-world');
+        await expect(mintSlug({ port: 1, title: 'Hello World', existing: [], signal })).resolves.toBe('hello-world');
     });
     test('LLM slug 与 slugFromLabel(title) 均被占 → 追加 -2', async () => {
         mockJson.mockResolvedValue({ slug: 'my-topic' });
-        await expect(mintSlug({ port: 1, title: 'My Topic', existing: ['my-topic'] }))
+        await expect(mintSlug({ port: 1, title: 'My Topic', existing: ['my-topic'], signal }))
             .resolves.toBe('my-topic-2');
     });
 });

package/dist/utils/__tests__/pi-events.test.js

@@ -0,0 +1,172 @@
+import { createPiEventEmitter, isAssistantMessage, extractAssistantDelta, extractToolResultText, } from '../pi-events.js';
+// 合成原始 pi SDK 事件的小构造器
+const messageStart = (role) => ({ type: 'message_start', message: { role } });
+const messageEnd = (role) => ({ type: 'message_end', message: { role } });
+const update = (ae) => ({ type: 'message_update', assistantMessageEvent: ae });
+const textDelta = (delta) => update({ type: 'text_delta', delta });
+const thinkingDelta = (delta) => update({ type: 'thinking_delta', delta });
+const toolStart = (over = {}) => ({
+    type: 'tool_execution_start',
+    toolCallId: 'call-1',
+    toolName: 'read_source',
+    args: { topic: 'x' },
+    ...over,
+});
+const toolEnd = (over = {}) => ({
+    type: 'tool_execution_end',
+    toolCallId: 'call-1',
+    toolName: 'read_source',
+    result: { content: [{ type: 'text', text: 'ok' }] },
+    ...over,
+});
+function collect() {
+    const events = [];
+    const { write } = createPiEventEmitter((ev) => events.push(ev));
+    return { events, write };
+}
+describe('pi-events 纯 helper', () => {
+    test('isAssistantMessage：只认 assistant 角色', () => {
+        expect(isAssistantMessage(messageStart('assistant'))).toBe(true);
+        expect(isAssistantMessage(messageEnd('assistant'))).toBe(true);
+        expect(isAssistantMessage(messageStart('user'))).toBe(false);
+        expect(isAssistantMessage(messageEnd('toolResult'))).toBe(false);
+        expect(isAssistantMessage({ message: {} })).toBe(false);
+        expect(isAssistantMessage(null)).toBe(false);
+    });
+    test('extractAssistantDelta：text / thinking 解包，其余 null', () => {
+        expect(extractAssistantDelta(textDelta('abc'))).toEqual({ kind: 'text', delta: 'abc' });
+        expect(extractAssistantDelta(thinkingDelta('嗯'))).toEqual({ kind: 'thinking', delta: '嗯' });
+        // 非 string delta
+        expect(extractAssistantDelta(textDelta(123))).toBeNull();
+        expect(extractAssistantDelta(thinkingDelta(null))).toBeNull();
+        // 其他 ae.type
+        expect(extractAssistantDelta(update({ type: 'text_start', delta: 'x' }))).toBeNull();
+        expect(extractAssistantDelta(update({ type: 'thinking_end' }))).toBeNull();
+        expect(extractAssistantDelta(update(undefined))).toBeNull();
+        // 非 message_update
+        expect(extractAssistantDelta({ type: 'other' })).toBeNull();
+        expect(extractAssistantDelta(null)).toBeNull();
+    });
+    test('extractToolResultText：多段 text 拼接，无 content 为空串', () => {
+        expect(extractToolResultText({ content: [
+                { type: 'text', text: 'a' },
+                { type: 'text', text: 'b' },
+            ] })).toBe('a\nb');
+        // 非数组 / 缺失
+        expect(extractToolResultText({})).toBe('');
+        expect(extractToolResultText(null)).toBe('');
+        expect(extractToolResultText({ content: 'nope' })).toBe('');
+    });
+});
+describe('createPiEventEmitter', () => {
+    test('非 assistant 的 message_start / message_end 被忽略', () => {
+        const { events, write } = collect();
+        write(messageStart('user'));
+        write(messageEnd('user'));
+        write(messageStart('toolResult'));
+        write(messageEnd('toolResult'));
+        expect(events).toEqual([]);
+    });
+    test('round 1-based：首轮 roundIndex=1，第二轮=2，end 与 start 索引一致', () => {
+        const { events, write } = collect();
+        write(messageStart('assistant'));
+        write(messageEnd('assistant'));
+        write(messageStart('assistant'));
+        write(messageEnd('assistant'));
+        expect(events).toEqual([
+            { type: 'round_start', roundIndex: 1 },
+            { type: 'round_end', roundIndex: 1 },
+            { type: 'round_start', roundIndex: 2 },
+            { type: 'round_end', roundIndex: 2 },
+        ]);
+    });
+    test('text_delta / thinking_delta 解包；无效 delta 与其他 ae.type 忽略', () => {
+        const { events, write } = collect();
+        write(textDelta('Hello '));
+        write(thinkingDelta('想想'));
+        write(textDelta(42));
+        write(update({ type: 'text_start', delta: 'ignored' }));
+        expect(events).toEqual([
+            { type: 'text_delta', content: 'Hello ' },
+            { type: 'thinking_delta', content: '想想' },
+        ]);
+    });
+    test('tool_start 字段透传', () => {
+        const { events, write } = collect();
+        write(toolStart({ toolName: 'add_topic', args: { slug: 's', tags: ['a'] } }));
+        expect(events).toEqual([{
+                type: 'tool_start',
+                toolCallId: 'call-1',
+                toolName: 'add_topic',
+                args: { slug: 's', tags: ['a'] },
+            }]);
+    });
+    test('tool_end：durationMs 缺失为 0、有值透传、isError 布尔化、多段 text 拼接、无 content 为空串', () => {
+        const { events, write } = collect();
+        // 缺 durationMs / isError
+        write(toolEnd({
+            result: { content: [
+                    { type: 'text', text: 'part1' },
+                    { type: 'text', text: 'part2' },
+                ] },
+        }));
+        // 有 durationMs、isError 真值
+        write(toolEnd({
+            toolCallId: 'call-2',
+            toolName: 'add_topic',
+            isError: 1,
+            durationMs: 88,
+            result: { content: [{ type: 'text', text: 'err' }] },
+        }));
+        // 无 content
+        write(toolEnd({ toolCallId: 'call-3', result: {} }));
+        expect(events).toEqual([
+            { type: 'tool_end', toolCallId: 'call-1', toolName: 'read_source', isError: false, durationMs: 0, result: 'part1\npart2' },
+            { type: 'tool_end', toolCallId: 'call-2', toolName: 'add_topic', isError: true, durationMs: 88, result: 'err' },
+            { type: 'tool_end', toolCallId: 'call-3', toolName: 'read_source', isError: false, durationMs: 0, result: '' },
+        ]);
+    });
+    test('未知/其他事件类型忽略（含 agent_end）', () => {
+        const { events, write } = collect();
+        write({ type: 'agent_end' });
+        write({ type: 'something_else', foo: 1 });
+        write(null);
+        expect(events).toEqual([]);
+    });
+    test('initialIndex：首轮自增在初始值之上继续（initialIndex=2 → roundIndex=3）', () => {
+        const events = [];
+        const { write } = createPiEventEmitter((ev) => events.push(ev), { initialIndex: 2 });
+        write(messageStart('assistant'));
+        write(messageEnd('assistant'));
+        expect(events).toEqual([
+            { type: 'round_start', roundIndex: 3 },
+            { type: 'round_end', roundIndex: 3 },
+        ]);
+    });
+    test('onIndexChange：以自增后的新值被调用；回调抛错不导致 write 抛错', () => {
+        const seen = [];
+        const events = [];
+        const { write } = createPiEventEmitter((ev) => events.push(ev), {
+            initialIndex: 1,
+            onIndexChange: (n) => {
+                seen.push(n);
+                throw new Error('callback boom');
+            },
+        });
+        expect(() => write(messageStart('assistant'))).not.toThrow();
+        expect(seen).toEqual([2]);
+        // 回调在 try 内、emit 之前，抛错被吞不波及 write；后续事件仍正常映射
+        expect(events).toEqual([]);
+        write(messageEnd('assistant'));
+        expect(events).toEqual([{ type: 'round_end', roundIndex: 2 }]);
+    });
+    test('emit 抛错不导致 write 抛错', () => {
+        const throwing = createPiEventEmitter(() => {
+            throw new Error('emit boom');
+        });
+        expect(() => throwing.write(messageStart('assistant'))).not.toThrow();
+        expect(() => throwing.write(textDelta('x'))).not.toThrow();
+        expect(() => throwing.write(toolStart())).not.toThrow();
+        expect(() => throwing.write(toolEnd())).not.toThrow();
+    });
+});