mu-agent-bridge 1.0.35 → 1.0.39

package/dist/tests-ts/control-server.test.js

@@ -438,3 +438,42 @@ const plugin_manager_1 = require("../src-ts/plugin-manager");
     }
     strict_1.default.deepEqual(calls, [{ task: "测试" }]);
 });
+(0, node_test_1.default)("会话归档接口只允许本机或认证调用方，并限制配置请求大小", async () => {
+    const calls = [];
+    const sessionManagement = {
+        providers: () => [{ pluginId: "demo", scope: "local:one", mode: "current", limitation: "仅当前会话", status: "ready" }],
+        config: async () => ({ enabled: false, grants: [] }),
+        saveConfig: async (...args) => { calls.push(["config", ...args]); },
+        deleteSession: async (...args) => { calls.push(["session", ...args]); },
+        deleteSource: async (...args) => { calls.push(["source", ...args]); },
+        clear: async (...args) => { calls.push(["clear", ...args]); },
+    };
+    const server = new control_server_1.ControlServer({ manager: { sessionManagement, dispatchHttp: async () => false }, token: "local-secret" });
+    const invoke = async (method, path, body, remote = false, token) => {
+        const req = Object.assign(node_stream_1.Readable.from(body === undefined ? [] : [JSON.stringify(body)]), {
+            method, url: path, headers: token ? { authorization: `Bearer ${token}` } : {},
+            socket: { remoteAddress: remote ? "192.168.31.10" : "127.0.0.1" },
+        });
+        let result = "";
+        const res = { statusCode: 0, setHeader() { }, end(text) { result = text; } };
+        await server.handle(req, res);
+        return { status: res.statusCode, body: JSON.parse(result) };
+    };
+    strict_1.default.equal((await invoke("GET", "/api/session-history/providers", undefined, true)).status, 401);
+    strict_1.default.deepEqual((await invoke("GET", "/api/session-history/providers")).body, sessionManagement.providers());
+    strict_1.default.deepEqual((await invoke("GET", "/api/session-history/providers", undefined, true, "local-secret")).body, sessionManagement.providers());
+    strict_1.default.equal((await invoke("GET", "/api/session-history/config", undefined, true)).status, 401);
+    strict_1.default.deepEqual((await invoke("GET", "/api/session-history/config")).body, { enabled: false, grants: [] });
+    strict_1.default.equal((await invoke("PATCH", "/api/session-history/config", { enabled: true, grants: [] }, true, "local-secret")).status, 200);
+    strict_1.default.equal((await invoke("DELETE", "/api/session-history/sessions/session-1")).status, 200);
+    strict_1.default.equal((await invoke("POST", "/api/session-history/delete-source", { source: "source-1" })).status, 200);
+    strict_1.default.equal((await invoke("DELETE", "/api/session-history")).status, 200);
+    strict_1.default.equal((await invoke("POST", "/api/session-history/delete-source", { source: 42 })).status, 400);
+    strict_1.default.equal((await invoke("PATCH", "/api/session-history/config", { payload: "字".repeat(30_000) })).status, 413);
+    strict_1.default.deepEqual(calls.map((call) => call[0]), ["config", "session", "source", "clear"]);
+    strict_1.default.ok(!JSON.stringify(calls).includes("local-secret"));
+    const anonymousServer = new control_server_1.ControlServer({ manager: { sessionManagement } });
+    const response = { setHeader() { }, end() { } };
+    await anonymousServer.handle({ method: "DELETE", url: "/api/session-history", headers: {}, socket: { remoteAddress: "192.168.31.10" } }, response);
+    strict_1.default.equal(response.statusCode, 401);
+});

package/dist/tests-ts/doubao-history.test.js

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_test_1 = __importDefault(require("node:test"));
+const node_vm_1 = require("node:vm");
+const session_history_1 = require("../src-ts/plugins/doubao/session-history");
+const cdp_client_1 = require("../src-ts/plugins/doubao/cdp-client");
+const rawConversation = {
+    conversation_id: "conv-1", name: "今天的问题", create_time: "1792555702", update_time: "1792555770",
+    latest_index: "2", messages: [
+        { message_id: "user-1", user_type: 2, index_in_conv: "1", create_time: "1792555702", tts_content: "修复图片回传" },
+        { message_id: "assistant-1", user_type: 1, index_in_conv: "2", create_time: "1792555770", tts_content: "已修复并验证" },
+    ],
+};
+(0, node_test_1.default)("豆包只读历史脚本解析原生会话目录、Unix 时间与角色文本", async () => {
+    const require = (id) => {
+        strict_1.default.equal(id, 55807);
+        return { V: async (query) => {
+                strict_1.default.equal(query.conv_version, "cursor-1");
+                strict_1.default.equal(query.message_count_per_conv, 100);
+                return { code: 0, data: { cells: [{ conversation: rawConversation }], has_more: false, next_cursor: "" } };
+            } };
+    };
+    const chunks = [];
+    chunks.push = (...items) => {
+        for (const item of items) {
+            const install = item[2];
+            install(require);
+        }
+        return items.length;
+    };
+    const window = { "@flow-web/desktop:stable": chunks };
+    const execute = (0, node_vm_1.runInNewContext)(`(${cdp_client_1.doubaoHistoryPageScript})`, { window });
+    const page = await execute("cursor-1", 20);
+    strict_1.default.equal(page.complete, true);
+    strict_1.default.equal(JSON.stringify(page.conversations[0].messages.map(({ id, role, text }) => ({ id, role, text }))), JSON.stringify([
+        { id: "user-1", role: "user", text: "修复图片回传" },
+        { id: "assistant-1", role: "assistant", text: "已修复并验证" },
+    ]));
+    strict_1.default.equal(page.conversations[0].messages[0].time, new Date(1_792_555_702_000).toISOString());
+    strict_1.default.equal(JSON.stringify(page.missingReasons), "[]");
+});
+(0, node_test_1.default)("豆包历史 provider 使用原生正文游标分页并校验会话 ID", async () => {
+    let next;
+    const client = {
+        connected: () => true,
+        listHistory: async (cursor) => {
+            next = cursor;
+            return { conversations: [{ id: "conv-1", title: "会话", messages: [], truncated: true }], nextCursor: "next", complete: false, missingReasons: [] };
+        },
+        readHistory: async (id, cursor) => {
+            strict_1.default.equal(id, "conv-1");
+            strict_1.default.equal(cursor, undefined);
+            return { conversationId: id, messages: [{ id: "m-1", role: "user", text: "正文", time: new Date().toISOString() }], nextCursor: "42", hasMore: true, complete: true, missingReasons: [] };
+        },
+    };
+    const provider = new session_history_1.DoubaoSessionHistoryProvider({ scope: "doubao:9227", client: () => client });
+    strict_1.default.equal(provider.mode, "all");
+    const listed = await provider.listSessions({ limit: 20, cursor: "before" });
+    strict_1.default.equal(next, "before");
+    strict_1.default.equal(listed.supported && listed.nextCursor, "next");
+    strict_1.default.equal(listed.supported && listed.complete, false);
+    const result = await provider.readSession({ sessionId: "conv-1", limit: 100 });
+    strict_1.default.equal(result.supported && result.complete, true);
+    strict_1.default.equal(result.supported && result.nextCursor, "42");
+    strict_1.default.equal(result.supported && result.turns.length, 1);
+});
+(0, node_test_1.default)("豆包正文分页脚本使用原生单会话链游标并排除思考字段", async () => {
+    let nativeQuery;
+    const require = (id) => {
+        strict_1.default.equal(id, 77049);
+        return { J: async (query) => {
+                nativeQuery = query;
+                return { code: 0, data: { messages: [
+                            { conversation_id: "conv-1", message_id: "m-1", user_type: 1, create_time: "1792555770", thinking_content: "不可见思考", content_block: [{ thinking_content: { text_block: { text: "不可见嵌套思考" } }, reasoning_block: { text_block: { text: "不可见推理" } }, text_block: { text: "可见正文" } }] },
+                        ], has_more: true, next_index: "41" } };
+            } };
+    };
+    const chunks = [];
+    chunks.push = (...items) => { for (const item of items)
+        item[2](require); return items.length; };
+    const execute = (0, node_vm_1.runInNewContext)(`(${cdp_client_1.doubaoHistoryReadPageScript})`, { window: { "@flow-web/desktop:stable": chunks } });
+    const page = await execute("conv-1", "50", 50);
+    strict_1.default.equal(page.error, undefined);
+    strict_1.default.equal(nativeQuery?.conversation_id, "conv-1");
+    strict_1.default.equal(nativeQuery?.anchor_index, 50);
+    strict_1.default.equal(nativeQuery?.direction, 1);
+    strict_1.default.equal(JSON.stringify(page.messages.map(({ id, role, text }) => ({ id, role, text }))), JSON.stringify([{ id: "m-1", role: "assistant", text: "可见正文" }]));
+    strict_1.default.equal(page.nextCursor, "41");
+    strict_1.default.equal(page.complete, true);
+});
+(0, node_test_1.default)("豆包今日正文先按时间排除旧附件消息，未知时间仍报告不完整", async () => {
+    const messages = [
+        { conversation_id: "conv-1", message_id: "m-today", user_type: 1, create_time: "1792555770", tts_content: "今天的答复" },
+        { conversation_id: "conv-1", message_id: "m-old", user_type: 2, create_time: "1792497638", content_block: [{ content: { thinking_block: {}, creation_block: { creations: [{ image: {} }] } } }] },
+    ];
+    const require = (_id) => ({ J: async () => ({ code: 0, data: { messages, has_more: true, next_index: "41" } }) });
+    const chunks = [];
+    chunks.push = (...items) => { for (const item of items)
+        item[2](require); return items.length; };
+    const execute = (0, node_vm_1.runInNewContext)(`(${cdp_client_1.doubaoHistoryReadPageScript})`, { window: { "@flow-web/desktop:stable": chunks } });
+    const page = await execute("conv-1", "", 100, "2026-10-21T00:00:00+08:00");
+    strict_1.default.equal(page.complete, true);
+    strict_1.default.equal(page.reachedSince, true);
+    strict_1.default.equal(page.messages.length, 1);
+    strict_1.default.equal(page.messages[0].text, "今天的答复");
+    messages.push({ conversation_id: "conv-1", message_id: "m-unknown", user_type: 1, thinking_content: "仅思考" });
+    const incomplete = await execute("conv-1", "", 100, "2026-10-21T00:00:00+08:00");
+    strict_1.default.equal(incomplete.complete, false);
+    strict_1.default.ok(incomplete.missingReasons.some(reason => reason.includes("时间")));
+});
+(0, node_test_1.default)("豆包今日 provider 转交起点并在原生已越过起点时结束正文分页", async () => {
+    const since = "2026-10-21T00:00:00+08:00";
+    const client = {
+        connected: () => true,
+        listHistory: async () => ({ conversations: [{ id: "conv-1", title: "会话", messages: [], truncated: true }], complete: true, missingReasons: [] }),
+        readHistory: async (id, _cursor, _limit, nativeSince) => {
+            strict_1.default.equal(nativeSince, since);
+            return { conversationId: id, messages: [{ id: "m-1", role: "assistant", text: "今日答复", time: "2026-10-21T01:00:00Z" }], hasMore: true, nextCursor: "42", reachedSince: true, complete: true, missingReasons: [] };
+        },
+    };
+    const provider = new session_history_1.DoubaoSessionHistoryProvider({ scope: "doubao:9227", client: () => client });
+    await provider.listSessions({ limit: 20 });
+    const result = await provider.readSession({ sessionId: "conv-1", limit: 100, since });
+    strict_1.default.equal(result.supported && result.complete, true);
+    strict_1.default.equal(result.supported && result.nextCursor, undefined);
+    strict_1.default.equal(result.supported && result.turns.length, 1);
+});
+(0, node_test_1.default)("豆包历史脚本重复调用兼容 webpack 已安装 chunk 缓存", async () => {
+    const installed = new Set();
+    let calls = 0;
+    const require = (_id) => ({ V: async () => {
+            calls++;
+            return { code: 0, data: { cells: [{ conversation: rawConversation }], has_more: false } };
+        } });
+    const chunks = [];
+    chunks.push = (...items) => {
+        for (const item of items) {
+            const [ids, , install] = item;
+            // webpack 仅在存在未安装的 chunk 时执行 runtime callback。
+            if (ids.some(id => !installed.has(id)))
+                install(require);
+            for (const id of ids)
+                installed.add(id);
+        }
+        return items.length;
+    };
+    const execute = (0, node_vm_1.runInNewContext)(`(${cdp_client_1.doubaoHistoryPageScript})`, { window: { "@flow-web/desktop:stable": chunks } });
+    const first = await execute("", 20);
+    const second = await execute("", 20);
+    strict_1.default.equal(first.error, undefined);
+    strict_1.default.equal(second.error, undefined);
+    strict_1.default.equal(second.conversations?.length, 1);
+    strict_1.default.equal(calls, 2);
+});
+(0, node_test_1.default)("豆包历史目录 has_more 但游标缺失时报告不完整", async () => {
+    const require = (_id) => ({ V: async () => ({ code: 0, data: { cells: [], has_more: true, next_cursor: "" } }) });
+    const chunks = [];
+    chunks.push = (...items) => {
+        for (const item of items)
+            item[2](require);
+        return items.length;
+    };
+    const execute = (0, node_vm_1.runInNewContext)(`(${cdp_client_1.doubaoHistoryPageScript})`, { window: { "@flow-web/desktop:stable": chunks } });
+    const page = await execute("", 20);
+    strict_1.default.equal(page.complete, false);
+    strict_1.default.equal(page.nextCursor, undefined);
+    strict_1.default.ok(page.missingReasons.some(reason => reason.includes("游标")));
+});

package/dist/tests-ts/doubao-plugin.test.js

@@ -39,6 +39,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const strict_1 = __importDefault(require("node:assert/strict"));
 const node_test_1 = __importDefault(require("node:test"));
 const node_vm_1 = require("node:vm");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
 const doubao = __importStar(require("../src-ts/plugins/doubao/cdp-client"));
 const doubao_1 = require("../src-ts/plugins/doubao");
 const cdp_client_1 = require("../src-ts/plugins/doubao/cdp-client");
@@ -276,7 +279,7 @@ function deferred() {
             return new Response(`event: STREAM_MSG_NOTIFY\ndata: ${JSON.stringify({ content: { content_block: text === "请求甲" ? [block] : [{ content: { text_block: { text: "第二轮回复" } } }] } })}\n\nevent: CHUNK_DELTA\ndata: ${JSON.stringify({ text: text === "请求甲" ? "第一轮回复" : "" })}\n\n`);
         },
     };
-    const client = new cdp_client_1.DoubaoCdpClient({ timeoutMs: 5000, fetchImpl: async () => {
+    const client = new cdp_client_1.DoubaoCdpClient({ conversationId: "test", timeoutMs: 5000, fetchImpl: async () => {
             downloadStarted.resolve();
             await downloadGate.promise;
             return new Response(png, { headers: { "content-type": "image/png" } });
@@ -320,7 +323,7 @@ for (const late of ["成功", "失败"]) {
             fetch: () => { if (++requests === 1)
                 return firstResponse.promise; nextStarted.resolve(); return nextResponse.promise; },
         };
-        const client = new cdp_client_1.DoubaoCdpClient({ timeoutMs: 20 });
+        const client = new cdp_client_1.DoubaoCdpClient({ conversationId: "test", timeoutMs: 20 });
         client.connect = async () => { };
         client.evaluate = async (expression) => (0, node_vm_1.runInNewContext)(expression, page);
         await strict_1.default.rejects(client.complete("请求甲"), /等待豆包回复超时/);
@@ -350,7 +353,16 @@ for (const late of ["成功", "失败"]) {
     const block = { block_type: 2074, is_finish: true, content: { creation_block: { creations: [{ image: { status: 2, image_ori: { url: imageUrl } } }] } } };
     let stream = `event: STREAM_CHUNK\ndata: ${JSON.stringify({ patch_op: [{ patch_value: { content_block: [block], tts_content: "生成宇航员橘猫图片已为你生成。" } }] })}\n\nevent: SSE_REPLY_END\ndata: {}\n\n`;
     const requests = [];
+    const bodies = [];
+    let draft = "", messages = 2;
     const page = {
+        location: { pathname: "/chat/123", href: "chrome://doubao-chat/chat/123" },
+        document: {
+            querySelector: (selector) => selector.includes("create_conversation_button")
+                ? { getAttribute() { return null; }, click() { page.location.pathname = "/chat"; messages = 0; } }
+                : { get innerText() { return draft; } },
+            querySelectorAll: () => Array.from({ length: messages }),
+        },
         window: {}, navigator: { userAgent: "Chrome/147.0.0.0 SamanthaDoubao/2.32.6" },
         performance: { getEntriesByType: () => [
                 { name: "https://www.doubao.com/settings?pc_version=2.32.6&device_id=current-device&tea_uuid=current-device&web_id=current-web&web_tab_id=current-tab" },
@@ -358,7 +370,7 @@ for (const late of ["成功", "失败"]) {
                 { name: "https://evil.example/chat/completion?device_id=untrusted" },
             ] },
         URL, AbortController, TextDecoder,
-        fetch: async (address) => { requests.push(new URL(address)); return new Response(stream); },
+        fetch: async (address, options) => { requests.push(new URL(address)); bodies.push(JSON.parse(options.body)); return new Response(stream); },
     };
     class TestWebSocket {
         readyState = 1;
@@ -412,6 +424,24 @@ for (const late of ["成功", "失败"]) {
             strict_1.default.equal(requests.at(-1)?.searchParams.get("pc_version"), "2.33.0");
             strict_1.default.equal(requests.at(-1)?.searchParams.get("chromium_version"), "148.0.1.2");
         }
+        strict_1.default.equal(typeof client.createSession, "function");
+        draft = "用户尚未发送的内容";
+        await strict_1.default.rejects(client.createSession(), /未发送内容/);
+        draft = "";
+        const count = bodies.length;
+        await client.createSession();
+        strict_1.default.equal(page.location.pathname, "/chat");
+        strict_1.default.equal(bodies.length, count, "新建入口不发送占位消息");
+        stream = 'event: SSE_ACK\ndata: {"ack_client_meta":{"conversation_id":"456"}}\n\nevent: CHUNK_DELTA\ndata: {"text":"新会话已回复"}\n\n';
+        const fresh = await client.complete("新会话首条消息", undefined, undefined, "");
+        strict_1.default.equal(fresh.sessionId, "456");
+        strict_1.default.equal(bodies.at(-1).client_meta.conversation_id, "");
+        strict_1.default.match(bodies.at(-1).client_meta.local_conversation_id, /^local_/);
+        strict_1.default.equal(bodies.at(-1).option.need_create_conversation, true);
+        strict_1.default.equal(bodies.at(-1).option.conversation_init_option.need_ack_conversation, true);
+        await client.complete("继续回复", undefined, undefined, fresh.sessionId);
+        strict_1.default.equal(bodies.at(-1).client_meta.conversation_id, "456");
+        strict_1.default.equal(bodies.at(-1).option.need_create_conversation, false);
     }
     finally {
         await client.close();
@@ -483,6 +513,25 @@ for (const late of ["成功", "失败"]) {
 (0, node_test_1.default)("豆包错误兼容旧版 code 字段", () => {
     strict_1.default.equal((0, cdp_client_1.doubaoStreamErrorMessage)(JSON.stringify({ code: "E_LIMIT" })), "豆包平台返回流式错误（错误码 E_LIMIT）");
 });
+(0, node_test_1.default)("豆包风控滑块验证优先于 rate limited 文案，且不泄露验证令牌", () => {
+    const decision = { type: "verify", subtype: "slide", detail: "private-challenge", log_id: "private-log" };
+    for (const value of [decision, JSON.stringify(decision)]) {
+        const message = (0, cdp_client_1.doubaoStreamErrorMessage)(JSON.stringify({ error_code: 710022004, error_msg: "rate limited", extra: { decision: value } }));
+        strict_1.default.match(message, /710022004.*滑块验证.*豆包桌面端/);
+        strict_1.default.doesNotMatch(message, /限流|rate limited|private-/);
+    }
+    strict_1.default.doesNotThrow(() => (0, cdp_client_1.doubaoStreamErrorMessage)('{"extra":{"decision":"无效 JSON"}}'));
+});
+(0, node_test_1.default)("豆包新建会话协议区分空会话和已有会话", () => {
+    const fresh = JSON.parse((0, cdp_client_1.requestBody)("你好", "", "bot"));
+    strict_1.default.equal(fresh.option.need_create_conversation, true);
+    strict_1.default.equal(fresh.option.conversation_init_option.need_ack_conversation, true);
+    strict_1.default.match(fresh.client_meta.local_conversation_id, /^local_/);
+    strict_1.default.notEqual(fresh.client_meta.local_conversation_id, JSON.parse((0, cdp_client_1.requestBody)("你好", "", "bot")).client_meta.local_conversation_id);
+    const existing = JSON.parse((0, cdp_client_1.requestBody)("继续", "123", "bot"));
+    strict_1.default.equal(existing.option.need_create_conversation, false);
+    strict_1.default.equal(existing.client_meta.local_conversation_id, undefined);
+});
 (0, node_test_1.default)("停止豆包客户端时向页面发送请求取消指令", async () => {
     const original = globalThis.WebSocket;
     const messages = [];
@@ -633,3 +682,75 @@ for (const late of ["成功", "失败"]) {
         await plugin.deactivate();
     }
 });
+(0, node_test_1.default)("豆包 /new 切换独立会话，重载后仍使用服务端会话标识", async () => {
+    const dataDir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "doubao-sessions-"));
+    const targets = [];
+    let created = 0, failCreate = false;
+    const client = {
+        async connect() { }, async close() { }, connected: () => true, async direct() { return "旧接口"; },
+        async createSession() { if (failCreate)
+            throw new Error("未发送内容"); created++; },
+        async complete(_text, _signal, _attachments, conversationId) {
+            targets.push(conversationId);
+            return { text: "回复", sessionId: conversationId || String(100 + targets.length) };
+        },
+    };
+    let plugin = new doubao_1.DoubaoPlugin(client);
+    try {
+        await plugin.activate({ config: {}, dataDir });
+        strict_1.default.deepEqual(plugin.sessionOperations, ["new"]);
+        const first = await plugin.handle({ task: "首条消息", sessionId: "peer-a" });
+        strict_1.default.equal(first.sessionId, "peer-a");
+        strict_1.default.equal(targets.at(-1), "");
+        await plugin.handle({ task: "继续", sessionId: "peer-a" });
+        strict_1.default.equal(targets.at(-1), "101");
+        strict_1.default.deepEqual(await plugin.controlSession({ operation: "new", sessionId: "peer-b", name: "新会话" }), { text: "豆包已创建新会话", sessionId: "peer-b" });
+        strict_1.default.equal(created, 1);
+        await plugin.deactivate();
+        plugin = new doubao_1.DoubaoPlugin(client);
+        await plugin.activate({ config: {}, dataDir });
+        await plugin.handle({ task: "新会话消息", sessionId: "peer-b", newSession: true });
+        strict_1.default.equal(targets.at(-1), "");
+        await plugin.handle({ task: "继续新会话", sessionId: "peer-b" });
+        strict_1.default.equal(targets.at(-1), "103");
+        await plugin.handle({ task: "回到旧会话", sessionId: "peer-a" });
+        strict_1.default.equal(targets.at(-1), "101");
+        failCreate = true;
+        await strict_1.default.rejects(plugin.controlSession({ operation: "new", sessionId: "peer-c" }), /未发送内容/);
+        await plugin.handle({ task: "失败后继续原会话", sessionId: "peer-b" });
+        strict_1.default.equal(targets.at(-1), "103");
+        const saved = await (0, promises_1.readFile)((0, node_path_1.join)(dataDir, "sessions.json"), "utf8");
+        strict_1.default.doesNotMatch(saved, /首条消息|新会话消息|回到旧会话/);
+    }
+    finally {
+        await plugin.deactivate();
+        await (0, promises_1.rm)(dataDir, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)("豆包跨来源请求串行执行，忙时不允许新建会话", async () => {
+    let release;
+    const blocked = new Promise(resolve => { release = resolve; });
+    let started;
+    const running = new Promise(resolve => { started = resolve; });
+    let calls = 0, active = 0, peak = 0;
+    const plugin = new doubao_1.DoubaoPlugin({
+        async connect() { }, async close() { }, connected: () => true, async direct() { return ""; }, async createSession() { },
+        async complete() { calls++; active++; peak = Math.max(peak, active); started(); if (calls === 1)
+            await blocked; active--; return { text: "回复", sessionId: String(calls) }; },
+    });
+    try {
+        await plugin.activate({ config: {} });
+        const first = plugin.handle({ task: "一", sessionId: "a" });
+        const second = plugin.handle({ task: "二", sessionId: "b" });
+        await running;
+        await strict_1.default.rejects(plugin.controlSession({ operation: "new", sessionId: "c" }), /当前忙/);
+        release();
+        await Promise.all([first, second]);
+        strict_1.default.equal(peak, 1);
+        strict_1.default.equal(calls, 2);
+    }
+    finally {
+        release();
+        await plugin.deactivate();
+    }
+});

package/dist/tests-ts/dsh-history.test.js

@@ -0,0 +1,165 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const strict_1 = __importDefault(require("node:assert/strict"));
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_zlib_1 = require("node:zlib");
+const node_test_1 = __importDefault(require("node:test"));
+const session_history_1 = require("../src-ts/plugins/dsh/session-history");
+async function fixture() {
+    const root = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "dsh-history-"));
+    const provider = new session_history_1.DshSessionHistoryProvider({ sessionsRoot: (0, node_path_1.join)(root, "sessions") });
+    async function session(id, events, options = {}) {
+        const directory = (0, node_path_1.join)(root, "sessions", "--project--", `session-${id}`);
+        await (0, promises_1.mkdir)(directory, { recursive: true });
+        const header = { type: "session", version: 4, id: `session-${id}`, createdAt: 1792512000000, cwd: "C:\\project", isSeeded: false, delegationDepth: 0 };
+        const content = [header, ...events].map(value => JSON.stringify(value)).join("\n") + "\n";
+        // DSH 的持久化器把头部和每次追加事件分别压成独立帧，不能只解首帧。
+        const bytes = options.compressed === false ? Buffer.from(content) : Buffer.concat(content.trimEnd().split("\n").map(line => (0, node_zlib_1.zstdCompressSync)(Buffer.from(`${line}\n`))));
+        await (0, promises_1.writeFile)((0, node_path_1.join)(directory, `session.v${options.generation ?? "4"}.jsonl${options.compressed === false ? "" : ".zstd"}`), bytes);
+    }
+    return { root, provider, session, close: () => (0, promises_1.rm)(root, { recursive: true, force: true }) };
+}
+const event = (seq, type, data, time = "2026-10-21T02:00:00.000Z") => ({ seq, type, time: Date.parse(time), data });
+(0, node_test_1.default)("DSH 原生日志枚举全部持久会话并读取用户/助手正文与事件时间", async () => {
+    const f = await fixture();
+    try {
+        await f.session("one", [
+            event(0, "user/message", { content: [{ type: "text", text: "今天的问题" }] }),
+            event(1, "assistant/message", { message: { content: [{ type: "reasoning", text: "思考不回传" }, { type: "text", text: "已经解决" }] } }, "2026-10-21T02:01:00.000Z"),
+        ]);
+        await f.session("two", [event(0, "user/message", { content: [{ type: "text", text: "另一会话" }] })], { compressed: false });
+        const list = await f.provider.listSessions({ limit: 1 });
+        strict_1.default.equal(list.supported, true);
+        if (!list.supported)
+            return;
+        strict_1.default.equal(f.provider.mode, "all");
+        strict_1.default.equal(list.complete, true);
+        strict_1.default.ok(list.nextCursor);
+        const page = await f.provider.listSessions({ limit: 10, cursor: list.nextCursor });
+        strict_1.default.equal(page.supported && page.sessions.length, 1);
+        const body = await f.provider.readSession({ sessionId: "session-one", limit: 10 });
+        strict_1.default.equal(body.supported, true);
+        if (!body.supported)
+            return;
+        strict_1.default.deepEqual(body.turns.map(turn => [turn.role, turn.text, turn.time]), [
+            ["user", "今天的问题", "2026-10-21T02:00:00.000Z"],
+            ["assistant", "已经解决", "2026-10-21T02:01:00.000Z"],
+        ]);
+        strict_1.default.equal(body.complete, true);
+    }
+    finally {
+        await f.close();
+    }
+});
+(0, node_test_1.default)("DSH 遇到未知事件、未知代际或越界游标时显式报告不完整/拒绝", async () => {
+    const f = await fixture();
+    try {
+        await f.session("known", [event(0, "user/message", { content: [{ type: "text", text: "保留正文" }] })]);
+        await f.session("future", [event(0, "user/message", { content: [{ type: "text", text: "不读取" }] })], { generation: "5" });
+        const list = await f.provider.listSessions({ limit: 10 });
+        strict_1.default.equal(list.supported && list.complete, false);
+        strict_1.default.equal(list.supported && list.missingReasons.some(reason => /代际/.test(reason)), true);
+        const body = await f.provider.readSession({ sessionId: "session-known", limit: 10 });
+        strict_1.default.equal(body.supported && body.complete, true);
+        await strict_1.default.rejects(f.provider.listSessions({ limit: 1, cursor: "fake" }), /游标/);
+    }
+    finally {
+        await f.close();
+    }
+});
+(0, node_test_1.default)("DSH 拒绝损坏/超大/角色不明的日志，不静默声称完整", async () => {
+    const f = await fixture();
+    try {
+        await f.session("bad", [event(1, "user/message", { content: [{ type: "text", text: "错序" }] })]);
+        const list = await f.provider.listSessions({ limit: 10 });
+        strict_1.default.equal(list.supported && list.complete, true);
+        const body = await f.provider.readSession({ sessionId: "session-bad", limit: 10 });
+        strict_1.default.equal(body.supported, true);
+        if (body.supported) {
+            strict_1.default.equal(body.complete, false);
+            strict_1.default.equal(body.turns.length, 0);
+        }
+    }
+    finally {
+        await f.close();
+    }
+});
+(0, node_test_1.default)("DSH 分页游标绑定日志快照，目录中的符号链接不会被读取", async () => {
+    const f = await fixture();
+    const outside = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "dsh-history-outside-"));
+    try {
+        await f.session("one", [event(0, "user/message", { content: [{ type: "text", text: "第一条" }] }), event(1, "assistant/message", { message: { role: "assistant", content: [{ type: "text", text: "第二条" }] } })]);
+        const first = await f.provider.readSession({ sessionId: "session-one", limit: 1 });
+        strict_1.default.ok(first.supported && first.nextCursor);
+        if (!first.supported)
+            return;
+        await f.session("one", [event(0, "user/message", { content: [{ type: "text", text: "内容变化" }] })]);
+        await strict_1.default.rejects(f.provider.readSession({ sessionId: "session-one", limit: 1, cursor: first.nextCursor }), /游标/);
+        await (0, promises_1.symlink)(outside, (0, node_path_1.join)(f.root, "sessions", "外部目录"), process.platform === "win32" ? "junction" : "dir");
+        const listed = await f.provider.listSessions({ limit: 100 });
+        strict_1.default.equal(listed.supported && listed.complete, false);
+        strict_1.default.ok(listed.supported && listed.missingReasons.some(reason => /符号链接/.test(reason)));
+        strict_1.default.equal((await f.provider.readSession({ sessionId: "../../外部目录", limit: 10 })).supported, false);
+    }
+    finally {
+        await f.close();
+        await (0, promises_1.rm)(outside, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)("DSH 多帧解压拒绝截断帧和非 zstd 尾部，避免只读首帧后声称完整", () => {
+    const first = (0, node_zlib_1.zstdCompressSync)(Buffer.from("第一帧\n")), second = (0, node_zlib_1.zstdCompressSync)(Buffer.from("第二帧\n"));
+    strict_1.default.equal((0, session_history_1.decodeDshZstdFrames)(Buffer.concat([first, second])).toString(), "第一帧\n第二帧\n");
+    strict_1.default.throws(() => (0, session_history_1.decodeDshZstdFrames)(Buffer.concat([first, second.subarray(0, -1)])), /截断/);
+    strict_1.default.throws(() => (0, session_history_1.decodeDshZstdFrames)(Buffer.concat([first, Buffer.from("invalid")])), /魔数/);
+});
+(0, node_test_1.default)("DSH since 在完整解析后筛选正文，且游标绑定时间范围和读取类型", async () => {
+    const f = await fixture();
+    try {
+        await f.session("since", [
+            event(0, "user/message", { content: [{ type: "text", text: "较早消息" }] }, "2026-10-20T23:59:59.000Z"),
+            event(1, "assistant/message", { message: { content: [{ type: "text", text: "今天回复" }] } }, "2026-10-21T00:00:00.000Z"),
+            event(2, "user/message", { content: [{ type: "text", text: "今天问题" }] }, "2026-10-21T01:00:00.000Z"),
+        ]);
+        const page = await f.provider.readSession({ sessionId: "session-since", limit: 1, since: "2026-10-21T00:00:00+00:00" });
+        strict_1.default.equal(page.supported, true);
+        if (!page.supported)
+            return;
+        strict_1.default.deepEqual(page.turns.map(turn => turn.text), ["今天回复"]);
+        strict_1.default.ok(page.nextCursor);
+        await strict_1.default.rejects(f.provider.readSession({ sessionId: "session-since", limit: 1, since: "2026-10-21T00:00:01Z", cursor: page.nextCursor }), /游标/);
+        await strict_1.default.rejects(f.provider.listSessions({ limit: 1, cursor: page.nextCursor }), /游标/);
+        const all = await f.provider.readSession({ sessionId: "session-since", limit: 10 });
+        strict_1.default.equal(all.supported && all.turns.length, 3);
+        const invalid = await f.provider.readSession({ sessionId: "session-since", limit: 10, since: "今天" });
+        strict_1.default.equal(invalid.supported, false);
+        if (!invalid.supported)
+            strict_1.default.match(invalid.reason, /ISO/);
+    }
+    finally {
+        await f.close();
+    }
+});
+(0, node_test_1.default)("DSH since 过滤旧消息后不足一页的末页不生成尾游标", async () => {
+    const f = await fixture();
+    try {
+        await f.session("since-last", [
+            event(0, "user/message", { content: [{ type: "text", text: "昨天的问题" }] }, "2026-10-20T23:59:59.000Z"),
+            event(1, "user/message", { content: [{ type: "text", text: "今天的问题" }] }, "2026-10-21T00:00:00.000Z"),
+        ]);
+        const page = await f.provider.readSession({ sessionId: "session-since-last", limit: 10, since: "2026-10-21T00:00:00Z" });
+        strict_1.default.equal(page.supported, true);
+        if (!page.supported)
+            return;
+        strict_1.default.deepEqual(page.turns.map(turn => turn.text), ["今天的问题"]);
+        strict_1.default.equal(page.nextCursor, undefined);
+        strict_1.default.equal(page.complete, true);
+    }
+    finally {
+        await f.close();
+    }
+});