mu-agent-bridge 1.0.73 → 1.0.78

package/dist/tests-ts/workbuddy-cdp-recovery.test.js

@@ -0,0 +1,311 @@
+"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 cdp_client_1 = require("../src-ts/plugins/workbuddy/cdp-client");
+const flush = () => new Promise(resolve => setImmediate(resolve));
+async function tick(t, seconds = 1) {
+    for (let i = 0; i < seconds; i++) {
+        t.mock.timers.tick(1000);
+        await flush();
+    }
+}
+async function disconnected(client) {
+    return client.cdp("Runtime.evaluate").then(() => strict_1.default.fail("断线调用必须失败"), (error) => error);
+}
+(0, node_test_1.default)("WorkBuddy 每 30 秒回传等待提示，完成后不再提示且不混入最终正文", async (t) => {
+    t.mock.timers.enable({ apis: ["setTimeout", "setInterval", "Date"] });
+    const client = new cdp_client_1.WorkbuddyCdpClient();
+    let finished = false;
+    const messages = [];
+    client.evaluate = async () => JSON.stringify([{ id: "new", text: finished ? "完成结果" : "", finished, stopped: false }]);
+    client.readInteraction = async () => undefined;
+    client.readArtifacts = async () => [];
+    const result = client.waitForReply(new Set(), 1_200_000, undefined, undefined, "peer", async (text) => { messages.push(text); });
+    await tick(t, 29);
+    strict_1.default.deepEqual(messages, []);
+    await tick(t);
+    strict_1.default.equal(messages.length, 1);
+    strict_1.default.match(messages[0], /WorkBuddy.*30 秒.*未.*完成/);
+    await tick(t, 30);
+    strict_1.default.equal(messages.length, 2);
+    strict_1.default.match(messages[1], /60 秒/);
+    finished = true;
+    await tick(t);
+    strict_1.default.deepEqual(await result, { text: "完成结果" });
+    await tick(t, 60);
+    strict_1.default.equal(messages.length, 2);
+});
+(0, node_test_1.default)("WorkBuddy CDP 超时清理待处理请求和定时器", async (t) => {
+    t.mock.timers.enable({ apis: ["setTimeout", "setInterval", "Date"] });
+    const client = new cdp_client_1.WorkbuddyCdpClient({ timeoutMs: 2000 });
+    client.socket = { readyState: WebSocket.OPEN, send() { } };
+    const result = strict_1.default.rejects(client.cdp("Runtime.evaluate"), /CDP.*Runtime.evaluate.*超时/);
+    await tick(t, 2);
+    await result;
+    strict_1.default.equal(client.pending.size, 0);
+});
+for (const kind of ["断线", "发送失败", "请求超时", "发送确认丢失"]) {
+    (0, node_test_1.default)(`WorkBuddy ${kind}后重连继续读取原任务，保留已回传正文且只发送一次`, async (t) => {
+        t.mock.timers.enable({ apis: ["setTimeout", "setInterval", "Date"] });
+        const client = new cdp_client_1.WorkbuddyCdpClient({ timeoutMs: 1000 });
+        let failure;
+        if (kind === "断线")
+            failure = await disconnected(client);
+        else {
+            client.socket = { readyState: WebSocket.OPEN, send() { if (kind !== "请求超时")
+                    throw new Error("socket 已关闭"); }, close() { } };
+            const pending = client.cdp("Runtime.evaluate").catch((error) => error);
+            if (kind === "请求超时")
+                await tick(t);
+            failure = await pending;
+        }
+        let polls = 0;
+        let sends = 0;
+        let inputs = 0;
+        let reconnects = 0;
+        client.socket = { readyState: WebSocket.OPEN, close() { } };
+        const messages = [];
+        const attachment = { kind: "file", filename: "结果.pdf", contentType: "application/pdf", data: new Uint8Array([1]) };
+        client.cdp = async (method) => { if (method === "Input.insertText")
+            inputs++; };
+        client.connect = async () => { reconnects++; };
+        client.conversationId = async () => "original";
+        client.readInteraction = async () => undefined;
+        client.readArtifacts = async () => [attachment];
+        client.evaluate = async (expression) => {
+            if (expression.includes("finished:")) {
+                polls++;
+                if (polls === 3 && kind !== "发送确认丢失")
+                    throw failure;
+                return JSON.stringify([{ id: "new", text: "已完成第一步", finished: polls >= 4, stopped: false, conversationId: "original" }]);
+            }
+            if (expression.includes("button.click(); return true;")) {
+                sends++;
+                if (kind === "发送确认丢失")
+                    throw failure;
+            }
+            if (expression.includes(".map(element => ({ id:"))
+                return "[]";
+            return true;
+        };
+        const result = client.complete({ task: "生成 PDF", sessionId: "peer", timeoutMs: 20_000, onMessage: async (text) => { messages.push(text); } }, undefined, false, "original");
+        void result.catch(() => undefined);
+        await flush();
+        await tick(t, 5);
+        strict_1.default.deepEqual(await result, { text: "", attachments: [attachment] });
+        strict_1.default.equal(reconnects, 1);
+        strict_1.default.equal(inputs, 1);
+        strict_1.default.equal(sends, 1);
+        strict_1.default.equal(messages.filter(text => text === "已完成第一步").length, 1);
+        strict_1.default.ok(messages.some(text => /CDP.*恢复/.test(text)));
+    });
+}
+(0, node_test_1.default)("WorkBuddy CDP 重连失败报告端口和具体原因并有界重试", async (t) => {
+    t.mock.timers.enable({ apis: ["setTimeout", "setInterval", "Date"] });
+    const client = new cdp_client_1.WorkbuddyCdpClient({ port: 19229, fetchImpl: async () => new Response("[]") });
+    let attempts = 0;
+    client.fetchImpl = async () => { attempts++; return new Response("[]"); };
+    const failure = await disconnected(client);
+    client.evaluate = async () => { throw failure; };
+    client.conversationId = async () => "original";
+    const messages = [];
+    const result = strict_1.default.rejects(client.waitForReply(new Set(["old"]), 20_000, undefined, undefined, "peer", async (text) => { messages.push(text); }, undefined, "original"), /WORKBUDDY_CDP_RECOVERY_FAILED.*19229.*未找到 WorkBuddy 页面 target.*未.*停止/);
+    void result.catch(() => undefined);
+    await tick(t, 5);
+    await result;
+    strict_1.default.equal(attempts, 3);
+    strict_1.default.ok(messages.some(text => /CDP/.test(text)));
+});
+(0, node_test_1.default)("WorkBuddy 页面脚本错误不会当成断线重连", async (t) => {
+    t.mock.timers.enable({ apis: ["setTimeout", "setInterval", "Date"] });
+    const client = new cdp_client_1.WorkbuddyCdpClient();
+    client.evaluate = async () => { throw new Error("WorkBuddy 页面 JS 异常：socket 已关闭"); };
+    client.connect = () => strict_1.default.fail("页面错误不能重连");
+    const result = strict_1.default.rejects(client.waitForReply(new Set(), 2000), /页面 JS 异常/);
+    await tick(t);
+    await result;
+});
+(0, node_test_1.default)("WorkBuddy CDP 成功、发送失败和主动关闭均清理 pending", async (t) => {
+    t.mock.timers.enable({ apis: ["setTimeout", "setInterval", "Date"] });
+    const client = new cdp_client_1.WorkbuddyCdpClient();
+    client.socket = { readyState: WebSocket.OPEN, send(raw) { client.onMessage(JSON.stringify({ id: JSON.parse(raw).id, result: {} })); }, close() { } };
+    await client.cdp("Runtime.evaluate");
+    strict_1.default.equal(client.pending.size, 0);
+    client.socket.send = () => { throw new Error("socket 写入失败"); };
+    await strict_1.default.rejects(client.cdp("Runtime.evaluate"), /socket 写入失败/);
+    strict_1.default.equal(client.pending.size, 0);
+    client.socket.send = () => undefined;
+    const result = strict_1.default.rejects(client.cdp("Runtime.evaluate"), /CDP.*关闭/);
+    client.close();
+    await result;
+    strict_1.default.equal(client.pending.size, 0);
+    await tick(t, 60);
+});
+(0, node_test_1.default)("WorkBuddy 重连后桌面会话变化时不读取或切换另一个任务", async (t) => {
+    t.mock.timers.enable({ apis: ["setTimeout", "setInterval", "Date"] });
+    const client = new cdp_client_1.WorkbuddyCdpClient();
+    const failure = await disconnected(client);
+    let polls = 0;
+    client.evaluate = async () => { polls++; throw failure; };
+    client.connect = async () => undefined;
+    client.conversationId = async () => "other";
+    client.activateConversation = () => strict_1.default.fail("重连不得切换桌面任务");
+    const result = strict_1.default.rejects(client.waitForReply(new Set(), 20_000, undefined, undefined, "peer", undefined, undefined, "original"), /WORKBUDDY_CDP_RECOVERY_FAILED.*会话.*不一致/);
+    void result.catch(() => undefined);
+    await tick(t, 5);
+    await result;
+    strict_1.default.equal(polls, 1);
+});
+(0, node_test_1.default)("WorkBuddy AUN 进度发送失败不触发 CDP 重连", async (t) => {
+    t.mock.timers.enable({ apis: ["setTimeout", "setInterval", "Date"] });
+    const client = new cdp_client_1.WorkbuddyCdpClient();
+    client.evaluate = async () => JSON.stringify([]);
+    client.readInteraction = async () => undefined;
+    client.connect = () => strict_1.default.fail("AUN 发送失败不是 CDP 断线");
+    const result = strict_1.default.rejects(client.waitForReply(new Set(), 60_000, undefined, undefined, "peer", async () => { throw new Error("AUN_TEXT_SEND_FAILED"); }), /AUN_TEXT_SEND_FAILED/);
+    void result.catch(() => undefined);
+    await tick(t, 60);
+    await result;
+});
+(0, node_test_1.default)("WorkBuddy CDP 恢复不重新计算任务的截止时间", async (t) => {
+    t.mock.timers.enable({ apis: ["setTimeout", "setInterval", "Date"] });
+    const client = new cdp_client_1.WorkbuddyCdpClient();
+    const failure = await disconnected(client);
+    let polls = 0;
+    client.evaluate = async () => { if (++polls === 1)
+        throw failure; return "[]"; };
+    client.readInteraction = async () => undefined;
+    client.connect = async () => undefined;
+    client.conversationId = async () => "original";
+    const result = strict_1.default.rejects(client.waitForReply(new Set(), 2000, undefined, undefined, "peer", undefined, undefined, "original"), /WORKBUDDY_REPLY_TIMEOUT.*2 秒/);
+    void result.catch(() => undefined);
+    await tick(t, 2);
+    await result;
+});
+for (const cancelled of [false, true]) {
+    (0, node_test_1.default)(`WorkBuddy ${cancelled ? "取消后的收尾" : "旧版长等待"}也不超过二十分钟`, async (t) => {
+        t.mock.timers.enable({ apis: ["setTimeout", "setInterval", "Date"] });
+        const client = new cdp_client_1.WorkbuddyCdpClient();
+        const controller = new AbortController();
+        const messages = [];
+        client.evaluate = async () => "[]";
+        client.readInteraction = async () => undefined;
+        const result = strict_1.default.rejects(client.waitForReply(new Set(), cancelled ? 10 : 3_600_000, undefined, undefined, "peer", async (text) => { messages.push(text); }, controller.signal), /WORKBUDDY_REPLY_TIMEOUT.*1200 秒/);
+        if (cancelled)
+            controller.abort();
+        await tick(t, 1200);
+        await result;
+        if (cancelled)
+            strict_1.default.deepEqual(messages, []);
+    });
+}
+(0, node_test_1.default)("WorkBuddy 缺少原会话标识时拒绝猜测或切换任务", async (t) => {
+    t.mock.timers.enable({ apis: ["setTimeout", "setInterval", "Date"] });
+    const client = new cdp_client_1.WorkbuddyCdpClient();
+    const failure = await disconnected(client);
+    client.evaluate = async () => { throw failure; };
+    client.connect = async () => undefined;
+    client.conversationId = async () => "unknown";
+    const result = strict_1.default.rejects(client.waitForReply(new Set(), 20_000), /WORKBUDDY_CDP_RECOVERY_FAILED.*原会话 未知/);
+    await tick(t, 5);
+    await result;
+});
+(0, node_test_1.default)("WorkBuddy 读取已完成产物断线后只重读原任务产物", async (t) => {
+    t.mock.timers.enable({ apis: ["setTimeout", "setInterval", "Date"] });
+    const client = new cdp_client_1.WorkbuddyCdpClient();
+    const failure = await disconnected(client);
+    let attempts = 0;
+    client.evaluate = async () => JSON.stringify([{ id: "new", text: "完成结果", finished: true, conversationId: "original" }]);
+    client.readInteraction = async () => undefined;
+    client.readArtifacts = async (ids) => { strict_1.default.deepEqual([...ids], ["new"]); if (++attempts === 1)
+        throw failure; return []; };
+    client.connect = async () => undefined;
+    client.conversationId = async () => "original";
+    const result = client.waitForReply(new Set(), 20_000);
+    await tick(t);
+    strict_1.default.deepEqual(await result, { text: "完成结果" });
+    strict_1.default.equal(attempts, 2);
+});
+(0, node_test_1.default)("WorkBuddy CDP WebSocket 建连不响应时也有超时", async (t) => {
+    t.mock.timers.enable({ apis: ["setTimeout", "setInterval", "Date"] });
+    let closed = false;
+    const OriginalWebSocket = globalThis.WebSocket;
+    t.after(() => { globalThis.WebSocket = OriginalWebSocket; });
+    globalThis.WebSocket = class {
+        static OPEN = 1;
+        readyState = 0;
+        close() { closed = true; }
+    };
+    const client = new cdp_client_1.WorkbuddyCdpClient({ timeoutMs: 2000, fetchImpl: async () => new Response(JSON.stringify([{ type: "page", title: "WorkBuddy", webSocketDebuggerUrl: "ws://127.0.0.1:9229/page" }])) });
+    const result = strict_1.default.rejects(client.connect(), /CDP WebSocket 连接超时.*9229/);
+    await flush();
+    await tick(t, 2);
+    await result;
+    strict_1.default.equal(closed, true);
+    strict_1.default.equal(client.connected(), false);
+});
+(0, node_test_1.default)("WorkBuddy 截止时 CDP 超时仍报告端口和具体方法", async (t) => {
+    t.mock.timers.enable({ apis: ["setTimeout", "setInterval", "Date"] });
+    const client = new cdp_client_1.WorkbuddyCdpClient({ port: 19229, timeoutMs: 10_000 });
+    client.socket = { readyState: WebSocket.OPEN, send() { }, close() { } };
+    const result = strict_1.default.rejects(client.waitForReply(new Set(), 2000), /WORKBUDDY_REPLY_TIMEOUT.*19229.*Runtime.evaluate.*超时/);
+    await tick(t, 2);
+    await result;
+});
+(0, node_test_1.default)("WorkBuddy CDP 读取阻塞期间仍每三十秒提示", async (t) => {
+    t.mock.timers.enable({ apis: ["setTimeout", "setInterval", "Date"] });
+    const client = new cdp_client_1.WorkbuddyCdpClient();
+    const messages = [];
+    let release;
+    client.evaluate = () => new Promise(resolve => { release = resolve; });
+    client.readInteraction = async () => undefined;
+    client.readArtifacts = async () => [];
+    const result = client.waitForReply(new Set(), 120_000, undefined, undefined, "peer", async (text) => { messages.push(text); });
+    await tick(t, 60);
+    try {
+        strict_1.default.equal(messages.length, 2);
+        strict_1.default.match(messages[0], /30 秒/);
+        strict_1.default.match(messages[1], /60 秒/);
+    }
+    finally {
+        release(JSON.stringify([{ id: "new", text: "完成结果", finished: true }]));
+        await result;
+    }
+    await tick(t, 60);
+    strict_1.default.equal(messages.length, 2);
+});
+(0, node_test_1.default)("WorkBuddy 恢复耗尽截止时间仍保留首次故障和末次恢复原因", async (t) => {
+    t.mock.timers.enable({ apis: ["setTimeout", "setInterval", "Date"] });
+    const client = new cdp_client_1.WorkbuddyCdpClient({ port: 19229 });
+    client.socket = { readyState: WebSocket.OPEN, send() { throw new Error("EPIPE"); }, close() { } };
+    const failure = await disconnected(client);
+    client.evaluate = async () => { throw failure; };
+    client.connect = async () => { await new Promise(resolve => setTimeout(resolve, 2000)); throw new Error("ECONNREFUSED"); };
+    const result = strict_1.default.rejects(client.waitForReply(new Set(), 3000), /WORKBUDDY_REPLY_TIMEOUT.*19229.*EPIPE.*ECONNREFUSED/);
+    void result.catch(() => undefined);
+    await tick(t, 3);
+    await result;
+});
+(0, node_test_1.default)("WorkBuddy 再次断线耗尽重试时保留整个任务的首次故障", async (t) => {
+    t.mock.timers.enable({ apis: ["setTimeout", "setInterval", "Date"] });
+    const client = new cdp_client_1.WorkbuddyCdpClient({ port: 19229 });
+    client.socket = { readyState: WebSocket.OPEN, send() { throw new Error("FIRST_EPIPE"); }, close() { } };
+    const first = await disconnected(client);
+    client.socket.send = () => { throw new Error("SECOND_DISCONNECT"); };
+    const second = await disconnected(client);
+    let polls = 0;
+    let attempts = 0;
+    client.evaluate = async () => { throw ++polls === 1 ? first : second; };
+    client.connect = async () => { if (++attempts > 1)
+        throw new Error("LAST_ECONNREFUSED"); };
+    client.conversationId = async () => "original";
+    const result = strict_1.default.rejects(client.waitForReply(new Set(), 20_000, undefined, undefined, "peer", undefined, undefined, "original"), /WORKBUDDY_CDP_RECOVERY_FAILED.*首次故障：.*FIRST_EPIPE.*LAST_ECONNREFUSED/);
+    void result.catch(() => undefined);
+    await tick(t, 5);
+    await result;
+    strict_1.default.equal(attempts, 3);
+});