@cc-monitoring/proxy-core 0.3.1 → 0.4.1

package/dist/utils/__tests__/pi-learn-orchestrator.test.js

@@ -261,6 +261,8 @@ function tagCaptureHandler(captured) {
 }
 // ---------- Test scaffolding ----------
 let tmpDir;
+// 现有用例不触发取消，复用一个常驻 signal（同一引用贯穿各阶段）
+const externalSignal = new AbortController().signal;
 beforeEach(async () => {
     tmpDir = await fsp.mkdtemp(path.join(os.tmpdir(), 'learn-pipe-'));
     mockCreatePiSession.mockReset();
@@ -307,6 +309,7 @@ describe('pi-learn-orchestrator', () => {
             port: 9999,
             events: makeEvents(),
             docsDir: tmpDir,
+            signal: externalSignal,
         })).rejects.toThrow(/outline 未生成/);
         expect(mockCreatePiSession).toHaveBeenCalledTimes(1);
         expect(mockCreatePiSession.mock.calls[0][0].mode).toBe('outline');
@@ -350,6 +353,7 @@ describe('pi-learn-orchestrator', () => {
             port: 9999,
             events,
             docsDir: tmpDir,
+            signal: externalSignal,
         });
         expect(result.slug).toBe('my-topic');
         expect(result.chunksWritten).toBe(2);
@@ -387,6 +391,7 @@ describe('pi-learn-orchestrator', () => {
             port: 9999,
             events,
             docsDir: tmpDir,
+            signal: externalSignal,
         });
         expect(result.slug).toBe(slug);
         expect(events.calls).toContain('stageEnd:outline');
@@ -408,6 +413,7 @@ describe('pi-learn-orchestrator', () => {
             port: 9999,
             events,
             docsDir: tmpDir,
+            signal: externalSignal,
         })).rejects.toThrow();
         // stageEnd 必须在 throw 之前发出
         expect(events.calls).toContain('stageEnd:outline');
@@ -450,6 +456,7 @@ describe('pi-learn-orchestrator', () => {
             port: 9999,
             events,
             docsDir: tmpDir,
+            signal: externalSignal,
         });
         // item0 失败（port down），item1 成功
         expect(result.itemsFailed).toBe(1);
@@ -493,6 +500,7 @@ describe('pi-learn-orchestrator', () => {
             port: 9999,
             events,
             docsDir: tmpDir,
+            signal: externalSignal,
         });
         expect(result.slug).toBe(slug);
         expect(events.calls).toContain('stageEnd:tag');
@@ -529,6 +537,7 @@ describe('pi-learn-orchestrator', () => {
             port: 9999,
             events,
             docsDir: tmpDir,
+            signal: externalSignal,
         });
         expect(result.slug).toBe(slug);
         expect(events.calls).toContain('stageEnd:tag');
@@ -564,6 +573,7 @@ describe('pi-learn-orchestrator', () => {
             port: 9999,
             events,
             docsDir: tmpDir,
+            signal: externalSignal,
         });
         expect(result.chunksWritten).toBe(0);
         expect(result.itemsFailed).toBe(1);
@@ -597,10 +607,11 @@ describe('pi-learn-orchestrator', () => {
             port: 9999,
             events,
             docsDir: tmpDir,
+            signal: externalSignal,
         })).rejects.toThrow();
-        // 轮次必须闭合：roundStart:0 有且仅有一次配对的 roundEnd:0
-        expect(events.calls).toContain('roundStart:0');
-        expect(events.calls.filter((c) => c === 'roundEnd:0')).toHaveLength(1);
+        // 轮次必须闭合：roundStart:1 有且仅有一次配对的 roundEnd:1
+        expect(events.calls).toContain('roundStart:1');
+        expect(events.calls.filter((c) => c === 'roundEnd:1')).toHaveLength(1);
     });
     // ============================================================
     // url 模式：crawl 阶段由 LLM agent 驱动
@@ -617,18 +628,19 @@ describe('pi-learn-orchestrator', () => {
             port: 9999,
             events,
             docsDir: tmpDir,
+            signal: externalSignal,
         });
         // sources：入口 + 同站子页共 2 份
         const files = await fsp.readdir(path.join(tmpDir, 'pi', 'sources'));
         expect(files.filter((f) => f.endsWith('.md'))).toHaveLength(2);
         expect(result.slug).toBe('pi');
         expect(result.chunksWritten).toBe(1);
-        // round：crawl + outline + refine + tag = 4 轮，起止索引严格配对
+        // round：crawl + outline + refine + tag = 4 轮，起止索引严格配对（1-based）
         expect(events.calls.filter((c) => c.startsWith('roundStart:'))).toEqual([
-            'roundStart:0', 'roundStart:1', 'roundStart:2', 'roundStart:3',
+            'roundStart:1', 'roundStart:2', 'roundStart:3', 'roundStart:4',
         ]);
         expect(events.calls.filter((c) => c.startsWith('roundEnd:'))).toEqual([
-            'roundEnd:0', 'roundEnd:1', 'roundEnd:2', 'roundEnd:3',
+            'roundEnd:1', 'roundEnd:2', 'roundEnd:3', 'roundEnd:4',
         ]);
     });
     test('url 首轮 0 页 → 全新 guard+session 重试 1 次后成功', async () => {
@@ -645,6 +657,7 @@ describe('pi-learn-orchestrator', () => {
             port: 9999,
             events,
             docsDir: tmpDir,
+            signal: externalSignal,
         });
         // 两个 crawl session（guard 也重建）+ outline/refine/tag
         const crawlSessions = mockCreatePiSession.mock.calls.filter(([o]) => o.mode === 'crawl');
@@ -669,6 +682,7 @@ describe('pi-learn-orchestrator', () => {
             port: 9999,
             events,
             docsDir: tmpDir,
+            signal: externalSignal,
         })).rejects.toThrow(/crawl 未收集到页面/);
         // 建了 2 个 guard 且都被 close（finally 关闭当前 guard；首个 guard 在替换时关闭）
         expect(crawlToolsMock.CrawlGuard).toHaveBeenCalledTimes(2);
@@ -710,6 +724,7 @@ describe('pi-learn-orchestrator', () => {
             port: 9999,
             events: makeEvents(),
             docsDir: tmpDir,
+            signal: externalSignal,
         });
         // 返回目标 slug；refine 只写了 1 个新增 chunk
         expect(result.slug).toBe('oldt');
@@ -764,6 +779,7 @@ describe('pi-learn-orchestrator', () => {
             port: 9999,
             events: makeEvents(),
             docsDir: tmpDir,
+            signal: externalSignal,
         });
         expect(result.slug).toBe('oldt');
         expect(result.chunksWritten).toBe(1);
@@ -810,6 +826,7 @@ describe('pi-learn-orchestrator', () => {
             port: 9999,
             events: makeEvents(),
             docsDir: tmpDir,
+            signal: externalSignal,
         });
         expect(result.slug).toBe('dup');
         expect(result.chunksWritten).toBe(1);
@@ -848,6 +865,7 @@ describe('pi-learn-orchestrator', () => {
             port: 9999,
             events: makeEvents(),
             docsDir: tmpDir,
+            signal: externalSignal,
         });
         expect(result.slug).toBe('dup-new');
         expect(result.chunksWritten).toBe(1);
@@ -879,7 +897,199 @@ describe('pi-learn-orchestrator', () => {
             port: 9999,
             events: makeEvents(),
             docsDir: tmpDir,
+            signal: externalSignal,
         })).rejects.toThrow(/检测到未清理的旁挂目录/);
         expect(mockCreatePiSession).not.toHaveBeenCalled();
     });
+    // ============================================================
+    // 贯穿式 AbortSignal
+    // ============================================================
+    /**
+     * prompt 挂起直到 abort 被调。模拟真实 pi SDK：abort 被吞成 stopReason="aborted"
+     * 的 assistant 消息，在途 prompt 正常 resolve（不 reject）。
+     */
+    function makeBlockingSession() {
+        const listeners = new Set();
+        let resolvePrompt;
+        let aborted = false;
+        return {
+            sessionId: 'blocking',
+            subscribe: (fn) => {
+                listeners.add(fn);
+                return () => { listeners.delete(fn); };
+            },
+            prompt: jest.fn(async () => {
+                for (const l of listeners)
+                    l({ type: 'message_start', message: { role: 'assistant' } });
+                await new Promise((resolve) => { resolvePrompt = resolve; });
+            }),
+            waitForIdle: jest.fn(async () => { }),
+            abort: jest.fn(async () => {
+                if (aborted)
+                    return;
+                aborted = true;
+                // 真实 SDK：resolve 在途 prompt，不 rethrow
+                resolvePrompt?.();
+            }),
+        };
+    }
+    /** 等到 mock 被首次调用（prompt 真正在途） */
+    async function waitForCalled(mock) {
+        await new Promise((resolve) => {
+            const tick = () => (mock.mock.calls.length > 0 ? resolve() : setImmediate(tick));
+            tick();
+        });
+    }
+    test('signal 预先 abort：prompt 仍 resolve，runLearnPipeline 靠信号检查 reject', async () => {
+        const preAborted = new AbortController();
+        preAborted.abort();
+        const session = new FakeSession(async () => { });
+        const abortSpy = jest.spyOn(session, 'abort');
+        mockCreatePiSession.mockImplementation(async () => session);
+        await expect(runLearnPipeline({
+            sourceType: 'file',
+            input: '# body',
+            label: 'x.md',
+            port: 9999,
+            events: makeEvents(),
+            docsDir: tmpDir,
+            signal: preAborted.signal,
+        })).rejects.toThrow(/learn 运行已中止/);
+        // bindAbort 对已 abort signal 立即触发 session.abort()；prompt 本身正常 resolve
+        expect(abortSpy).toHaveBeenCalledTimes(1);
+        // 只发生 outline 一个 session 的尝试，后续阶段/查重零调用
+        expect(mockCreatePiSession).toHaveBeenCalledTimes(1);
+        expect(mockReconcile).not.toHaveBeenCalled();
+    });
+    test('运行中 abort：prompt 正常 resolve，runLearnPipeline 靠信号检查 reject、后续阶段不执行', async () => {
+        const session = makeBlockingSession();
+        mockCreatePiSession.mockImplementation(async () => session);
+        const controller = new AbortController();
+        const events = makeEvents();
+        const p = runLearnPipeline({
+            sourceType: 'file',
+            input: '# body',
+            label: 'x.md',
+            port: 9999,
+            events,
+            docsDir: tmpDir,
+            signal: controller.signal,
+        });
+        // 等 prompt 真正在途后再 abort（验证非"预先 abort"路径）
+        await waitForCalled(session.prompt);
+        expect(session.abort).not.toHaveBeenCalled();
+        controller.abort();
+        // 不是靠 prompt reject，而是 await 后 combined.aborted 检查主动抛错
+        await expect(p).rejects.toThrow(/learn 运行已中止/);
+        expect(session.abort).toHaveBeenCalledTimes(1);
+        // refine/tag 阶段零启动；查重也不执行
+        expect(mockCreatePiSession).toHaveBeenCalledTimes(1);
+        expect(events.calls).not.toContain('stageStart:refine');
+        expect(events.calls).not.toContain('stageStart:tag');
+        expect(mockReconcile).not.toHaveBeenCalled();
+    });
+    test('signal 透传到 reconcileTopics：门1 收到同一 signal 引用', async () => {
+        const mySignal = new AbortController().signal;
+        await runLearnPipeline({
+            sourceType: 'file',
+            input: '# body',
+            label: 'sig.md',
+            port: 9999,
+            events: makeEvents(),
+            docsDir: tmpDir,
+            signal: mySignal,
+        });
+        expect(mockReconcile.mock.calls[0][0].signal).toBe(mySignal);
+    });
+    test('signal 透传到 mintSlug：门0 slug 碰撞未合并时收到同一 signal 引用', async () => {
+        await seedDupTopic();
+        const mySignal = new AbortController().signal;
+        await runLearnPipeline({
+            sourceType: 'file',
+            input: '# new body',
+            label: 'dup.md',
+            port: 9999,
+            events: makeEvents(),
+            docsDir: tmpDir,
+            signal: mySignal,
+        });
+        expect(mockMintSlug).toHaveBeenCalledTimes(1);
+        expect(mockMintSlug.mock.calls[0][0].signal).toBe(mySignal);
+    });
+    test('onStart 钩子被调用，参数为算出的 slug', async () => {
+        const slug = 'hook-topic';
+        // S1: 写 outline.json + seed index.json + chunk（同 S3 happy path 模式）
+        mockCreatePiSession.mockImplementationOnce(async () => {
+            return new FakeSession(async () => {
+                await fsp.mkdir(path.join(tmpDir, slug, 'chunks'), { recursive: true });
+                await fsp.writeFile(path.join(tmpDir, slug, 'outline.json'), JSON.stringify({ slug, source: 'sources/', items: [{ id: 'a', title: '概念A', oneLine: 'aaa' }] }, null, 2));
+                await fsp.writeFile(path.join(tmpDir, slug, 'index.json'), JSON.stringify({ slug, title: 'Hook', summary: '(refining)', tags: [], chunks: [
+                        { id: 'chunk-001', title: '概念A', summary: 'aaa', tags: [] },
+                    ] }, null, 2));
+                await fsp.writeFile(path.join(tmpDir, slug, 'chunks', 'chunk-001.md'), '# 概念A');
+            });
+        });
+        mockCreatePiSession.mockImplementationOnce(async () => new FakeSession(FakeSession.readSourceThen(async () => { })));
+        mockCreatePiSession.mockImplementationOnce(async () => {
+            return new FakeSession(FakeSession.addTopicHandler(['a-tag']));
+        });
+        const onStart = jest.fn();
+        const result = await runLearnPipeline({
+            sourceType: 'file',
+            input: '# body',
+            label: `${slug}.md`,
+            port: 9999,
+            events: makeEvents(),
+            docsDir: tmpDir,
+            signal: externalSignal,
+            onStart,
+        });
+        expect(result.slug).toBe(slug);
+        expect(onStart).toHaveBeenCalledTimes(1);
+        expect(onStart).toHaveBeenCalledWith(slug);
+    });
+    test('onStart 抛错 → pipeline reject，docs 目录无任何改动且不创建 session', async () => {
+        const onStart = jest.fn(() => {
+            throw new Error('已有同主题的学习任务在运行');
+        });
+        await expect(runLearnPipeline({
+            sourceType: 'file',
+            input: '# body',
+            label: 'boom.md',
+            port: 9999,
+            events: makeEvents(),
+            docsDir: tmpDir,
+            signal: externalSignal,
+            onStart,
+        })).rejects.toThrow(/已有同主题的学习任务在运行/);
+        expect(await fsp.readdir(tmpDir)).toEqual([]);
+        expect(mockCreatePiSession).not.toHaveBeenCalled();
+    });
+    test('超时路径：5 分钟超时 signal 触发 → session.abort 调用、pipeline reject', async () => {
+        // Node 的 AbortSignal.timeout 内部 timer 不受 fake clock 控制，且 fake timers 下
+        // fs.promises IO 不 settle；mock 成等价 signal，prompt 在途后手动触发（模拟 5 分钟到点）
+        const timeoutController = new AbortController();
+        const timeoutSpy = jest
+            .spyOn(AbortSignal, 'timeout')
+            .mockReturnValue(timeoutController.signal);
+        const session = makeBlockingSession();
+        mockCreatePiSession.mockImplementation(async () => session);
+        const p = runLearnPipeline({
+            sourceType: 'file',
+            input: '# body',
+            label: 'x.md',
+            port: 9999,
+            events: makeEvents(),
+            docsDir: tmpDir,
+            signal: new AbortController().signal,
+        });
+        await waitForCalled(session.prompt);
+        expect(session.abort).not.toHaveBeenCalled();
+        // 模拟 5 分钟超时触发
+        timeoutController.abort();
+        expect(timeoutSpy).toHaveBeenCalledWith(5 * 60 * 1000);
+        expect(session.abort).toHaveBeenCalledTimes(1);
+        // prompt 正常 resolve，靠 combined.aborted 检查抛错中止
+        await expect(p).rejects.toThrow(/learn 运行已中止/);
+    });
 });

package/dist/utils/__tests__/pi-runtime-json.test.js

@@ -1,7 +1,32 @@
 // pi-coding-agent 为 ESM-only（无 require 导出），jest CJS 无法加载；
-// mock 掉以加载真实 pi-runtime 模块测试纯函数（同 pi-browser-tools.test.ts 的 typebox mock 做法）
-jest.mock('@earendil-works/pi-coding-agent', () => ({ createWriteToolDefinition: () => ({}) }), { virtual: true });
-import { extractJsonObject } from '../pi-runtime.js';
+// mock 掉以加载真实 pi-runtime 模块测试纯函数 + runJsonPrompt 中止语义
+// （同 pi-browser-tools.test.ts 的 typebox mock 做法）
+jest.mock('@earendil-works/pi-coding-agent', () => {
+    // fake session：模拟真实 SDK——abort 后在途 prompt/waitForIdle 正常 resolve
+    const fakeSession = {
+        sessionId: 'fake-reconcile',
+        subscribe: jest.fn(() => () => { }),
+        prompt: jest.fn(async () => { }),
+        waitForIdle: jest.fn(async () => { }),
+        abort: jest.fn(async () => { }),
+    };
+    return {
+        createWriteToolDefinition: () => ({}),
+        createAgentSession: jest.fn(async () => ({ session: fakeSession })),
+        DefaultResourceLoader: function () {
+            this.reload = async () => { };
+        },
+        ModelRuntime: {
+            create: jest.fn(async () => ({
+                registerProvider: jest.fn(),
+                getModel: () => ({}),
+            })),
+        },
+        fakeSession,
+    };
+}, { virtual: true });
+import { extractJsonObject, runJsonPrompt } from '../pi-runtime.js';
+const { fakeSession } = jest.requireMock('@earendil-works/pi-coding-agent');
 test('extractJsonObject: 从含 prose/代码围栏文本取出第一个 JSON 对象', () => {
     const raw = 'Here:\n```json\n{"a":1,"b":[2,3]}\n```\ndone';
     expect(extractJsonObject(raw)).toEqual({ a: 1, b: [2, 3] });
@@ -9,3 +34,13 @@ test('extractJsonObject: 从含 prose/代码围栏文本取出第一个 JSON 对
 test('extractJsonObject: 无 JSON → throw', () => {
     expect(() => extractJsonObject('no json here')).toThrow(/no json object/);
 });
+test('runJsonPrompt：abort 后 prompt/waitForIdle 正常 resolve → 靠 combined.aborted 检查 reject，不返回 JSON', async () => {
+    const external = new AbortController();
+    external.abort();
+    // combined 因外部 signal 立即 abort，bindAbort 立即调 session.abort()；不等 300s 超时
+    await expect(runJsonPrompt({ port: 1, instructions: 'return json', prompt: '{}', signal: external.signal })).rejects.toThrow(/json prompt 已中止/);
+    expect(fakeSession.abort).toHaveBeenCalledTimes(1);
+    // prompt 确实被调用且正常 resolve（证明不是靠 prompt reject）
+    expect(fakeSession.prompt).toHaveBeenCalledTimes(1);
+    expect(fakeSession.waitForIdle).toHaveBeenCalledTimes(1);
+});

package/dist/utils/__tests__/providers-db.test.js

@@ -1,6 +1,6 @@
 import Database from 'better-sqlite3';
-import { applySchemaV2, applySchemaV3, applySchemaV7 } from '../db.js';
-import { listProviders, saveProviders, validateProvider, validateProviders } from '../providers-db.js';
+import { applySchemaV2, applySchemaV3, applySchemaV7, applySchemaV9 } from '../db.js';
+import { listProviders, saveProviders, getActiveProvider, validateProvider, validateProviders } from '../providers-db.js';
 describe('providers-db', () => {
     let db;
     beforeEach(() => {
@@ -10,6 +10,7 @@ describe('providers-db', () => {
         applySchemaV2(db);
         applySchemaV3(db);
         applySchemaV7(db);
+        applySchemaV9(db);
     });
     afterEach(() => {
         db.close();
@@ -41,6 +42,27 @@ describe('providers-db', () => {
             expect(inactive?.default).toBe(false);
         });
     });
+    describe('getActiveProvider', () => {
+        test('returns the is_default row with mapped auth_style', () => {
+            db.prepare(`INSERT INTO providers (name, base_url, api_key, model, provider, is_default, auth_style)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`).run('active', 'https://a.com', 'key', 'm', 'anthropic', 1, 'x-api-key');
+            db.prepare(`INSERT INTO providers (name, base_url, api_key, model, provider, is_default)
+         VALUES (?, ?, ?, ?, ?, ?)`).run('inactive', 'https://b.com', 'key2', 'm2', 'anthropic', 0);
+            const result = getActiveProvider(db);
+            expect(result).not.toBeNull();
+            expect(result?.name).toBe('active');
+            expect(result?.default).toBe(true);
+            expect(result?.auth_style).toBe('x-api-key');
+        });
+        test('returns null when no default row exists', () => {
+            db.prepare(`INSERT INTO providers (name, base_url, api_key, model, provider, is_default)
+         VALUES (?, ?, ?, ?, ?, ?)`).run('inactive', 'https://b.com', 'key2', 'm2', 'anthropic', 0);
+            expect(getActiveProvider(db)).toBeNull();
+        });
+        test('returns null on empty table', () => {
+            expect(getActiveProvider(db)).toBeNull();
+        });
+    });
     describe('saveProviders', () => {
         test('overwrites existing data', () => {
             db.prepare(`INSERT INTO providers (name, base_url, api_key, model, provider)
@@ -113,6 +135,22 @@ describe('providers-db', () => {
             expect(p1?.default).toBe(false);
             expect(p2?.default).toBe(true);
         });
+        test('preserves auth_style x-api-key after save', () => {
+            const input = [
+                { name: 'p1', base_url: 'https://p1.com', api_key: 'k1', model: 'm', provider: 'anthropic', auth_style: 'x-api-key' }
+            ];
+            saveProviders(db, input);
+            const result = listProviders(db);
+            expect(result[0].auth_style).toBe('x-api-key');
+        });
+        test('defaults auth_style to bearer when not provided', () => {
+            const input = [
+                { name: 'p1', base_url: 'https://p1.com', api_key: 'k1', model: 'm', provider: 'anthropic' }
+            ];
+            saveProviders(db, input);
+            const result = listProviders(db);
+            expect(result[0].auth_style).toBe('bearer');
+        });
     });
     describe('validateProvider', () => {
         test('accepts valid data', () => {