mu-agent-bridge 1.0.71 → 1.0.78

package/dist/tests-ts/plugin-upgrade-deadline.test.js

@@ -0,0 +1,354 @@
+"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_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_test_1 = __importDefault(require("node:test"));
+const agent_1 = require("../src-ts/agent");
+const plugin_manager_1 = require("../src-ts/plugin-manager");
+const version_manager_1 = require("../src-ts/version-manager");
+const TWO_HOURS = 2 * 60 * 60 * 1000;
+const flush = () => new Promise(resolve => setImmediate(resolve));
+async function until(check) {
+    for (let i = 0; i < 2_000; i++) {
+        if (check())
+            return;
+        await flush();
+    }
+    strict_1.default.ok(check(), "等待预期状态超时");
+}
+function deferred() {
+    let resolve;
+    const promise = new Promise(done => { resolve = done; });
+    return { promise, resolve };
+}
+function cancelled(task, pattern = /PLUGIN_UPGRADE_WAIT_TIMEOUT/) {
+    const checked = strict_1.default.rejects(task, pattern);
+    void checked.catch(() => undefined);
+    return checked;
+}
+async function fixture(t, run) {
+    const root = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "mab-upgrade-deadline-"));
+    const key = `upgrade-${(0, node_crypto_1.randomUUID)()}`;
+    const gate = deferred();
+    const cleanup = deferred();
+    const state = { contexts: {}, signals: [], stopping: [], cleanupOptions: [], fail: false, holdCleanup: false, ignoreSignal: false };
+    state.run = async (request) => {
+        state.signals.push(request.signal);
+        state.request = request;
+        await (state.ignoreSignal ? gate.promise : (0, agent_1.abortable)(gate.promise, request.signal));
+        await request.onMessage?.("旧任务的迟到回复");
+        return { text: "旧任务完成" };
+    };
+    globalThis[key] = state;
+    const stateDir = (0, node_path_1.join)(root, "state");
+    await (0, promises_1.mkdir)((0, node_path_1.join)(stateDir, "npm"), { recursive: true });
+    const manager = new plugin_manager_1.PluginManager({ pluginsDir: (0, node_path_1.join)(root, "plugins"), stateDir,
+        versions: new version_manager_1.VersionManager({ stateDir, npm: async () => '"1.0.1"' }), publisherResolver: async () => "m2lihui" });
+    const pending = [];
+    const add = async (id, type = "agent") => {
+        for (const [dir, version] of [[(0, node_path_1.join)(root, "plugins", id), "1.0.0"], [(0, node_path_1.join)(stateDir, "downloads", `agent-bridge-${id}`, "1.0.1", "node_modules", `agent-bridge-${id}`), "1.0.1"]]) {
+            await (0, promises_1.mkdir)(dir, { recursive: true });
+            await (0, promises_1.writeFile)((0, node_path_1.join)(dir, "package.json"), JSON.stringify({ name: `agent-bridge-${id}`, version, agentBridge: { plugin: "./plugin.json" } }));
+            await (0, promises_1.writeFile)((0, node_path_1.join)(dir, "plugin.json"), JSON.stringify({ id, type, version, entry: "index.js", apiVersion: "1", capabilities: type === "channel" ? ["channel"] : id === "personal-assistant" ? ["chat", "management"] : ["chat", "model-provider"] }));
+            await (0, promises_1.writeFile)((0, node_path_1.join)(dir, "index.js"), `
+const state=globalThis[${JSON.stringify(key)}];
+module.exports=class {
+  constructor(){this.pending=new Set();this.modelProvider={complete:r=>this.handle({task:r.prompt,...r})}}
+  get sessionOperations(){return ['new']}
+  async controlSession(r){return {...await this.handle({task:'/new'}),sessionId:r.sessionId}}
+  async activate(c){this.context=c;state.contexts[${JSON.stringify(id)}]=${JSON.stringify(type)}==='channel'?{...c,ingress:{publish:async m=>{const task=c.ingress.publish(m);this.pending.add(task);try{return await task}finally{this.pending.delete(task)}}}}:c;this.dispose=c.http.register('GET','/${id}/deadline',(_q,r)=>r.end('${version}'));if('${version}'==='1.0.1'&&state.fail)throw Error('新版启动失败')}
+  async deactivate(reason,options){state.stopping.push('${id}@${version}');state.cleanupOptions.push(options);await Promise.allSettled([...this.pending]);if('${version}'==='1.0.0'&&state.failCleanup){state.failCleanup=false;throw Error('旧插件清理失败')}if('${version}'==='1.0.0'&&state.holdCleanup)await state.cleanup;this.dispose();this.context.http.unregister()}
+  async health(){return {status:'ready'}}
+  async handle(r){if('${version}'!=='1.0.0')return {text:'新版完成'};const task=state.run(r);this.pending.add(task);try{return await task}finally{this.pending.delete(task)}}
+};`);
+        }
+        await manager.discover();
+        await manager.start(id);
+    };
+    state.cleanup = cleanup.promise;
+    const upgrade = (id = "demo") => {
+        const promise = manager.upgradePackage(id, `agent-bridge-${id}`, "1.0.1");
+        pending.push(promise);
+        void promise.catch(() => undefined);
+        return promise;
+    };
+    try {
+        await add("demo");
+        t.mock.timers.enable({ apis: ["setTimeout"] });
+        await run({ manager, gate, cleanup, state, upgrade, add });
+    }
+    finally {
+        gate.resolve();
+        cleanup.resolve();
+        t.mock.timers.reset();
+        await Promise.allSettled(pending);
+        for (const plugin of manager.list())
+            if (manager.get(plugin.id)?.instance)
+                await manager.stop(plugin.id);
+        await manager.logs.flush();
+        delete globalThis[key];
+        await (0, promises_1.rm)(root, { recursive: true, force: true, maxRetries: 5, retryDelay: 10 });
+    }
+}
+(0, node_test_1.default)("插件升级等待满两小时才取消旧任务并继续安装", async (t) => {
+    await fixture(t, async ({ manager, state, upgrade }) => {
+        const task = manager.handle("demo", { task: "长任务" });
+        const failure = cancelled(task, /PLUGIN_UPGRADE_WAIT_TIMEOUT.*两小时/);
+        await until(() => state.signals.length === 1);
+        const updated = upgrade();
+        await until(() => manager.get("demo").record.status === "stopping");
+        t.mock.timers.tick(TWO_HOURS - 1);
+        await flush();
+        strict_1.default.equal(Boolean(state.signals[0]?.aborted), false);
+        strict_1.default.equal(manager.get("demo").record.version, "1.0.0");
+        strict_1.default.deepEqual(state.stopping, [], "两小时内不能提前调用可能取消任务的 deactivate");
+        t.mock.timers.tick(1);
+        await flush();
+        strict_1.default.equal(state.signals[0]?.aborted, true);
+        await failure;
+        await updated;
+        strict_1.default.deepEqual(state.cleanupOptions, [{ preserveDesktop: true }]);
+        strict_1.default.equal((await manager.handle("demo", { task: "新任务" })).text, "新版完成");
+        await manager.logs.flush();
+        const logs = (await manager.logs.page()).logs;
+        strict_1.default.ok(logs.some(log => log.fields?.waitMs === TWO_HOURS && typeof log.fields?.deadline === "string"));
+        strict_1.default.ok(logs.some(log => log.fields?.code === "PLUGIN_UPGRADE_WAIT_TIMEOUT"));
+    });
+});
+(0, node_test_1.default)("旧任务及时完成则正常升级且清除强制取消定时器", async (t) => {
+    await fixture(t, async ({ manager, state, gate, upgrade }) => {
+        const task = manager.handle("demo", { task: "短任务" });
+        await until(() => state.signals.length === 1);
+        const updated = upgrade();
+        await until(() => manager.get("demo").record.status === "stopping");
+        gate.resolve();
+        strict_1.default.equal((await task).text, "旧任务完成");
+        await updated;
+        t.mock.timers.tick(TWO_HOURS);
+        await flush();
+        await manager.logs.flush();
+        strict_1.default.ok(!(await manager.logs.page()).logs.some(log => log.fields?.code === "PLUGIN_UPGRADE_WAIT_TIMEOUT"));
+        strict_1.default.equal((await manager.handle("demo", { task: "新任务" })).text, "新版完成");
+    });
+});
+(0, node_test_1.default)("不响应取消的旧任务不能继续阻塞升级、发送迟到回复或注销新版路由", async (t) => {
+    await fixture(t, async ({ manager, state, cleanup, gate, upgrade, add }) => {
+        await add("other");
+        state.ignoreSignal = true;
+        state.holdCleanup = true;
+        const replies = [];
+        const task = manager.handle("demo", { task: "挂起任务", onMessage: async (text) => { replies.push(text); } });
+        const failure = cancelled(task);
+        await until(() => state.signals.length === 1);
+        const oldContext = state.contexts.demo;
+        const updated = upgrade();
+        await until(() => manager.get("demo").record.status === "stopping");
+        t.mock.timers.tick(TWO_HOURS);
+        await flush();
+        strict_1.default.equal(state.signals[0]?.aborted, true);
+        t.mock.timers.tick(5_000);
+        await flush();
+        await failure;
+        await updated;
+        let reply = "";
+        const readRoute = () => manager.dispatchHttp({ method: "GET", url: "/demo/deadline" }, { end: (text) => { reply = text; } });
+        strict_1.default.equal(await readRoute(), true);
+        strict_1.default.equal(reply, "1.0.1");
+        gate.resolve();
+        cleanup.resolve();
+        await flush();
+        await flush();
+        strict_1.default.deepEqual(replies, []);
+        strict_1.default.equal(await readRoute(), true);
+        strict_1.default.equal(reply, "1.0.1");
+        strict_1.default.throws(() => oldContext.http.register("GET", "/stale", () => undefined), /停止|取消|结束/);
+        await strict_1.default.rejects(oldContext.callPlugin("other", { task: "过期调用" }), /停止|取消|结束|PLUGIN_UPGRADE_WAIT_TIMEOUT/);
+    });
+});
+(0, node_test_1.default)("模型来源任务也在插件升级等待两小时后取消", async (t) => {
+    await fixture(t, async ({ manager, state, upgrade }) => {
+        const task = manager.completeModelProvider("demo", { prompt: "模型任务", sessionId: "model-session", timeoutMs: 120_000, signal: new AbortController().signal });
+        const failure = cancelled(task);
+        await until(() => state.signals.length === 1);
+        const updated = upgrade();
+        await until(() => manager.get("demo").record.status === "stopping");
+        t.mock.timers.tick(TWO_HOURS);
+        await flush();
+        strict_1.default.equal(state.signals[0]?.aborted, true);
+        await failure;
+        await updated;
+    });
+});
+(0, node_test_1.default)("通道升级期限取消来源任务并传递到目标 Agent，保留原会话记录", async (t) => {
+    await fixture(t, async ({ manager, state, add, upgrade }) => {
+        await add("aun", "channel");
+        const source = state.contexts.aun;
+        const task = source.ingress.publish({ channel: "aun", peerId: "peer.agentid.cn", agentPlugin: "demo", text: "长任务", reply: async () => undefined });
+        const failure = cancelled(task);
+        await until(() => state.signals.length === 1);
+        const updated = upgrade("aun");
+        await until(() => manager.get("aun").record.status === "stopping");
+        t.mock.timers.tick(TWO_HOURS);
+        await flush();
+        strict_1.default.equal(state.signals[0]?.aborted, true);
+        await failure;
+        await updated;
+        strict_1.default.equal(manager.get("demo").record.status, "ready");
+        strict_1.default.equal(manager.sessions.isBusy('["aun","","","peer.agentid.cn",""]'), false);
+    });
+});
+(0, node_test_1.default)("插件间调用随来源插件的升级期限取消，不取消无关插件实例", async (t) => {
+    await fixture(t, async ({ manager, state, add, upgrade }) => {
+        await add("parent");
+        const original = state.run;
+        state.run = (request) => request.task === "父任务"
+            ? state.contexts.parent.callPlugin("demo", { task: "子任务" })
+            : original(request);
+        const task = manager.handle("parent", { task: "父任务" });
+        const failure = cancelled(task);
+        await until(() => state.signals.length === 1);
+        const updated = upgrade("parent");
+        await until(() => manager.get("parent").record.status === "stopping");
+        t.mock.timers.tick(TWO_HOURS);
+        await flush();
+        strict_1.default.equal(state.signals[0]?.aborted, true);
+        await failure;
+        await updated;
+        strict_1.default.equal(manager.get("demo").record.status, "ready");
+    });
+});
+(0, node_test_1.default)("强制取消后新版启动失败能回滚，下一次升级重新等待两小时", async (t) => {
+    await fixture(t, async ({ manager, state, add, upgrade }) => {
+        state.fail = true;
+        const first = cancelled(manager.handle("demo", { task: "第一项任务" }));
+        await until(() => state.signals.length === 1);
+        const updated = upgrade();
+        const rollback = strict_1.default.rejects(updated, /新版启动失败/);
+        await until(() => manager.get("demo").record.status === "stopping");
+        t.mock.timers.tick(TWO_HOURS);
+        await flush();
+        await first;
+        await rollback;
+        strict_1.default.equal(manager.get("demo").record.version, "1.0.0");
+        strict_1.default.equal(manager.get("demo").record.status, "ready");
+        strict_1.default.deepEqual(state.cleanupOptions, [{ preserveDesktop: true }, { preserveDesktop: true }]);
+        state.fail = false;
+        await add("demo");
+        const second = cancelled(manager.handle("demo", { task: "第二项任务" }));
+        await until(() => state.signals.length === 2);
+        strict_1.default.equal(state.signals[1].aborted, false);
+        const retried = upgrade();
+        await until(() => manager.get("demo").record.status === "stopping");
+        t.mock.timers.tick(TWO_HOURS - 1);
+        await flush();
+        strict_1.default.equal(state.signals[1].aborted, false);
+        t.mock.timers.tick(1);
+        await flush();
+        await second;
+        await retried;
+        strict_1.default.equal(manager.get("demo").record.version, "1.0.1");
+    });
+});
+(0, node_test_1.default)("旧插件清理失败时恢复旧版本并清除升级期限", async (t) => {
+    await fixture(t, async ({ manager, state, upgrade }) => {
+        state.failCleanup = true;
+        await strict_1.default.rejects(upgrade(), /旧插件清理失败/);
+        strict_1.default.equal(manager.get("demo").record.version, "1.0.0");
+        strict_1.default.equal(manager.get("demo").record.status, "ready");
+        t.mock.timers.tick(TWO_HOURS);
+        await flush();
+        await manager.logs.flush();
+        strict_1.default.ok(!(await manager.logs.page()).logs.some(log => log.fields?.code === "PLUGIN_UPGRADE_WAIT_TIMEOUT"));
+    });
+});
+(0, node_test_1.default)("普通停止不套用升级的两小时强制取消期限", async (t) => {
+    await fixture(t, async ({ manager, state, gate }) => {
+        const task = manager.handle("demo", { task: "普通任务" });
+        await until(() => state.signals.length === 1);
+        const stopping = manager.stop("demo");
+        await until(() => state.stopping.length === 1);
+        t.mock.timers.tick(TWO_HOURS + 5_000);
+        await flush();
+        strict_1.default.equal(state.signals[0].aborted, false);
+        gate.resolve();
+        await task;
+        await stopping;
+        strict_1.default.deepEqual(state.cleanupOptions, [undefined]);
+        strict_1.default.equal(manager.get("demo").record.status, "disabled");
+    });
+});
+(0, node_test_1.default)("个人助理升级期限传递到管理能力启动的子 Agent 任务", async (t) => {
+    await fixture(t, async ({ manager, state, add, upgrade }) => {
+        await add("personal-assistant");
+        await add("aun", "channel");
+        await manager.saveConfig("personal-assistant", { allowedPeers: ["*"], allowedAgents: ["demo"] });
+        const original = state.run;
+        state.run = (request) => request.task === "助理任务"
+            ? request.management.callAgent("demo", "子任务")
+            : original(request);
+        const failure = cancelled(state.contexts.aun.ingress.publish({ channel: "aun", peerId: "peer.agentid.cn", agentPlugin: "personal-assistant", text: "助理任务", reply: async () => undefined }));
+        await until(() => state.signals.length === 1);
+        const updated = upgrade("personal-assistant");
+        await until(() => manager.get("personal-assistant").record.status === "stopping");
+        t.mock.timers.tick(TWO_HOURS);
+        await flush();
+        strict_1.default.equal(state.signals[0]?.aborted, true, "助理取消不能留下仍在执行的桥接子任务");
+        await failure;
+        await updated;
+        strict_1.default.equal(manager.get("demo").record.status, "ready");
+    });
+});
+(0, node_test_1.default)("挂起的新建会话操作同样受插件升级期限约束", async (t) => {
+    await fixture(t, async ({ manager, state, upgrade }) => {
+        let rejected = false;
+        const task = manager.controlSession("demo", { operation: "new", sessionId: "new-session" }).catch(error => { rejected = true; throw error; });
+        const failure = cancelled(task);
+        await until(() => state.signals.length === 1);
+        const updated = upgrade();
+        await until(() => manager.get("demo").record.status === "stopping");
+        t.mock.timers.tick(TWO_HOURS);
+        await flush();
+        strict_1.default.equal(rejected, true);
+        t.mock.timers.tick(5_000);
+        await flush();
+        await failure;
+        await updated;
+        strict_1.default.equal(manager.get("demo").record.version, "1.0.1");
+    });
+});
+for (const delivery of ["文本", "附件"])
+    (0, node_test_1.default)(`升级取消挂起的${delivery}回传后释放来源忙碌状态并记录具体错误`, async (t) => {
+        await fixture(t, async ({ manager, state, add, gate, upgrade }) => {
+            await add("aun", "channel");
+            await manager.sessionManagement.saveConfig({ enabled: true, grants: [] });
+            state.run = async () => ({ text: "回传结果", ...(delivery === "附件" ? { attachments: [{ kind: "file", data: new Uint8Array([42]), filename: "结果.txt", contentType: "text/plain" }] } : {}) });
+            let delivering = false;
+            const deliver = async () => { delivering = true; await gate.promise; };
+            const message = { channel: "aun", peerId: "peer.agentid.cn", agentPlugin: "demo", text: "生成文件", reply: deliver, replyAttachments: deliver };
+            const failure = cancelled(state.contexts.aun.ingress.publish(message));
+            await until(() => delivering);
+            const binding = await manager.sessions.current(message, "demo");
+            const updated = upgrade("aun");
+            await until(() => manager.get("aun").record.status === "stopping");
+            t.mock.timers.tick(TWO_HOURS);
+            await flush();
+            t.mock.timers.tick(5_000);
+            await flush();
+            await failure;
+            await updated;
+            const sessions = await manager.sessionManagement.command("/sessions list", { source: binding.source, sessionId: "另一个管理会话" });
+            strict_1.default.match(sessions, new RegExp(binding.logicalSessionId));
+            strict_1.default.doesNotMatch(sessions, /正在运行/);
+            strict_1.default.ok(manager.recentMessages().some(item => item.direction === "error" && item.text.includes("PLUGIN_UPGRADE_WAIT_TIMEOUT")));
+            gate.resolve();
+            await flush();
+            strict_1.default.ok(!manager.recentMessages().some(item => item.direction === "reply"));
+            strict_1.default.equal((await manager.sessionManagement.archive.snapshotSessions()).sessions.length, 0);
+        });
+    });

package/dist/tests-ts/publish-packages.test.js

@@ -0,0 +1,42 @@
+"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_child_process_1 = require("node:child_process");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_util_1 = require("node:util");
+const node_test_1 = __importDefault(require("node:test"));
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+(0, node_test_1.default)("发布预检按真实 npm 包名选择原目录并实际加载入口", { skip: process.platform === "win32" }, async () => {
+    const root = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "mab-publish-name-"));
+    const bin = (0, node_path_1.join)(root, "bin");
+    const packageRoot = (0, node_path_1.join)(root, "packages", "personal-assistant");
+    try {
+        const ids = ["qwenwork", "abweb", "dsh", "doubao", "aun", "workbuddy", "zcode", "feishu", "chatgpt", "codex-cli", "claude-cli", "personal-assistant"];
+        await (0, promises_1.writeFile)((0, node_path_1.join)(root, "package.json"), JSON.stringify({ name: "mu-agent-bridge", version: "1.0.0" }));
+        for (const id of ids) {
+            const directory = (0, node_path_1.join)(root, "packages", id);
+            await (0, promises_1.mkdir)(directory, { recursive: true });
+            await (0, promises_1.writeFile)((0, node_path_1.join)(directory, "package.json"), JSON.stringify({ name: id === "personal-assistant" ? "agent-bridge-pa" : `agent-bridge-${id}`, version: "1.0.0", main: "index.js", agentBridge: { id, plugin: "./plugin.json" } }));
+            await (0, promises_1.writeFile)((0, node_path_1.join)(directory, "plugin.json"), JSON.stringify({ id, version: "1.0.0", entry: "index.js" }));
+            await (0, promises_1.writeFile)((0, node_path_1.join)(directory, "index.js"), `module.exports=class { manifest={id:${JSON.stringify(id)},version:'1.0.0'}; };`);
+        }
+        await (0, promises_1.mkdir)(bin);
+        await (0, promises_1.writeFile)((0, node_path_1.join)(bin, "npm"), `#!${process.execPath}\nif(process.argv[2]==='pack')process.stdout.write(JSON.stringify([{files:['index.js','plugin.json','config.schema.json'].map(path=>({path}))}]));`);
+        await (0, promises_1.chmod)((0, node_path_1.join)(bin, "npm"), 0o755);
+        const env = { ...process.env, PATH: `${bin}:${process.env.PATH ?? ""}` };
+        const script = (0, node_path_1.join)(process.cwd(), "scripts", "publish-packages.mjs");
+        const result = await execFileAsync(process.execPath, [script, "--only=agent-bridge-pa"], { cwd: root, env });
+        strict_1.default.match(result.stdout, /agent-bridge-pa@1.0.0：打包预检通过/);
+        await strict_1.default.rejects(execFileAsync(process.execPath, [script, "--only=agent-bridge-personal-assistant"], { cwd: root, env }), /未知发布包/);
+        await (0, promises_1.writeFile)((0, node_path_1.join)(packageRoot, "index.js"), "throw new Error('入口加载失败');");
+        await strict_1.default.rejects(execFileAsync(process.execPath, [script, "--only=agent-bridge-pa"], { cwd: root, env }), /入口加载失败/);
+    }
+    finally {
+        await (0, promises_1.rm)(root, { recursive: true, force: true });
+    }
+});

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

@@ -72,7 +72,7 @@ const cdp_client_1 = require("../src-ts/plugins/qwenwork/cdp-client");
 (0, node_test_1.default)("qwenwork manifest declares the dynamic plugin contract", () => {
     strict_1.default.equal(qwenwork_1.qwenworkManifest.id, "qwenwork");
     strict_1.default.equal(qwenwork_1.qwenworkManifest.entry, "dist/index.js");
-    strict_1.default.deepEqual(qwenwork_1.qwenworkManifest.capabilities, ["chat", "openai-compatible", "health"]);
+    strict_1.default.deepEqual(qwenwork_1.qwenworkManifest.capabilities, ["chat", "openai-compatible", "health", "model-provider"]);
     strict_1.default.equal(qwenwork_1.qwenworkManifest.defaults.cdpPort, 9228);
     strict_1.default.equal(qwenwork_1.qwenworkManifest.defaults.httpPort, 17893);
 });
@@ -251,6 +251,36 @@ const cdp_client_1 = require("../src-ts/plugins/qwenwork/cdp-client");
     await plugin.deactivate("stop");
     strict_1.default.equal((await plugin.health()).status, "stopped");
 });
+(0, node_test_1.default)("千问办公仅在重载时请求结束桌面进程", async () => {
+    let restarts = 0;
+    const client = {
+        connect: async () => undefined,
+        close: () => undefined,
+        connected: () => true,
+        send: async () => undefined,
+        direct: async () => "回复",
+    };
+    const plugin = new qwenwork_1.QwenworkPlugin({ client, httpPort: 0, restartDesktop: async () => { restarts++; } });
+    await plugin.activate({ config: {}, dataDir: "." });
+    await plugin.deactivate("reload");
+    strict_1.default.equal(restarts, 1);
+    await plugin.activate({ config: {}, dataDir: "." });
+    await plugin.deactivate("stop");
+    strict_1.default.equal(restarts, 1);
+});
+(0, node_test_1.default)("千问办公升级清理保留桌面进程", async () => {
+    let restarts = 0;
+    let closed = 0;
+    const plugin = new qwenwork_1.QwenworkPlugin({
+        httpPort: 0, restartDesktop: async () => { restarts++; },
+        client: { connect: async () => undefined, close: () => { closed++; }, connected: () => true, send: async () => undefined, direct: async () => "回复" },
+    });
+    await plugin.activate({ config: {}, dataDir: "." });
+    await plugin.deactivate("reload", { preserveDesktop: true });
+    strict_1.default.equal(restarts, 0);
+    strict_1.default.equal(closed, 1);
+    strict_1.default.equal((await plugin.health()).status, "stopped");
+});
 (0, node_test_1.default)("千问办公 /new 调用真实新任务并返回逻辑会话标识", async () => {
     let created = 0;
     const plugin = new qwenwork_1.QwenworkPlugin({
@@ -278,6 +308,33 @@ const cdp_client_1 = require("../src-ts/plugins/qwenwork/cdp-client");
         await plugin.deactivate("stop");
     }
 });
+(0, node_test_1.default)("千问模型来源按个人助理会话恢复桌面会话并保留取消信号", async (t) => {
+    const { mkdtemp, rm } = await Promise.resolve().then(() => __importStar(require("node:fs/promises")));
+    const { tmpdir } = await Promise.resolve().then(() => __importStar(require("node:os")));
+    const { join } = await Promise.resolve().then(() => __importStar(require("node:path")));
+    const dataDir = await mkdtemp(join(tmpdir(), "qwen-model-provider-"));
+    t.after(() => rm(dataDir, { recursive: true, force: true }));
+    const calls = [];
+    const plugin = new qwenwork_1.QwenworkPlugin({ httpPort: 0, healthIntervalMs: 60_000, client: {
+            connect: async () => undefined, close: () => undefined, connected: () => true,
+            send: async () => undefined, direct: async () => "不应使用普通入口",
+            currentSessionId: async () => "user-chat",
+            createSession: async () => { calls.push("create"); return "desktop-chat-a"; },
+            activateSession: async (id) => { calls.push(["activate", id]); },
+            complete: async (text, _timeout, signal) => { calls.push(["complete", text, signal]); return { text: "模型 JSON", sessionId: "desktop-chat-a" }; },
+        } });
+    await plugin.activate({ config: {}, dataDir });
+    const controller = new AbortController();
+    try {
+        const provider = plugin.modelProvider;
+        strict_1.default.deepEqual(await provider.complete({ prompt: "第一轮", sessionId: "pa-thread", timeoutMs: 5000, signal: controller.signal }), { text: "模型 JSON" });
+        strict_1.default.deepEqual(await provider.complete({ prompt: "第二轮", sessionId: "pa-thread", timeoutMs: 5000, signal: controller.signal }), { text: "模型 JSON" });
+        strict_1.default.deepEqual(calls, ["create", ["complete", "第一轮", controller.signal], ["activate", "user-chat"], ["activate", "desktop-chat-a"], ["complete", "第二轮", controller.signal], ["activate", "user-chat"]]);
+    }
+    finally {
+        await plugin.deactivate("stop");
+    }
+});
 (0, node_test_1.default)("千问 CDP 仅在新任务状态校验通过后确认创建成功", async () => {
     const { QwenCdpClient } = await Promise.resolve().then(() => __importStar(require("../src-ts/plugins/qwenwork/cdp-client")));
     const original = globalThis.WebSocket;
@@ -583,6 +640,24 @@ const cdp_client_1 = require("../src-ts/plugins/qwenwork/cdp-client");
     await strict_1.default.rejects(client.createSession(), /正在生成回复/);
     strict_1.default.equal(clicked, false);
 });
+(0, node_test_1.default)("千问模型新建、恢复和提交时保留用户草稿并拒绝切换", async () => {
+    const { QwenCdpClient } = await Promise.resolve().then(() => __importStar(require("../src-ts/plugins/qwenwork/cdp-client")));
+    for (const operation of ["create", "activate", "complete"]) {
+        const client = new QwenCdpClient();
+        const editor = { innerText: "用户尚未发送的内容" };
+        let edits = 0, clicks = 0, navigations = 0;
+        let href = "file:///index.html?chat=user";
+        client.recoverDraft = async () => { edits++; editor.innerText = ""; };
+        client.waitFor = async () => undefined;
+        client.evaluate = async (expression) => (0, node_vm_1.runInNewContext)(expression, {
+            URL, window: {}, location: { get href() { return href; }, set href(value) { navigations++; href = value; } },
+            document: { querySelector: (selector) => selector.includes("contenteditable") ? editor : selector.includes('aria-label="新任务"') ? { click() { clicks++; }, getAttribute() { return null; } } : null, querySelectorAll: () => [] },
+        });
+        const run = () => operation === "create" ? client.createSession(undefined, true, true) : operation === "activate" ? client.activateSession("model", true) : client.complete("模型提示", 1, undefined, undefined, undefined, undefined, true);
+        await strict_1.default.rejects(run(), /未发送内容|用户草稿/);
+        strict_1.default.deepEqual({ edits, clicks, navigations, text: editor.innerText }, { edits: 0, clicks: 0, navigations: 0, text: "用户尚未发送的内容" });
+    }
+});
 (0, node_test_1.default)("千问 socket 断开后先重连，重连成功不重启桌面", async () => {
     let connected = true;
     let restarts = 0;
@@ -623,3 +698,62 @@ const cdp_client_1 = require("../src-ts/plugins/qwenwork/cdp-client");
         await plugin.deactivate("stop");
     }
 });
+(0, node_test_1.default)("千问模型与普通任务按调用顺序进入同一队列并恢复用户会话", async () => {
+    const { mkdtemp, rm } = await Promise.resolve().then(() => __importStar(require("node:fs/promises")));
+    const { tmpdir } = await Promise.resolve().then(() => __importStar(require("node:os")));
+    const { join } = await Promise.resolve().then(() => __importStar(require("node:path")));
+    const dataDir = await mkdtemp(join(tmpdir(), "qwen-model-boundary-"));
+    let active = "user-chat";
+    const calls = [];
+    const plugin = new qwenwork_1.QwenworkPlugin({ httpPort: 0, healthIntervalMs: 60_000, client: {
+            connect: async () => undefined, close() { }, connected: () => true, send: async () => undefined, direct: async () => "回复",
+            currentSessionId: async () => active,
+            createSession: async () => { active = "model-chat"; return active; },
+            activateSession: async (id) => { active = id; },
+            complete: async (text) => { calls.push(`${active}:${text}`); return { text: "回复", sessionId: active }; },
+        } });
+    try {
+        await plugin.activate({ config: {}, dataDir });
+        const model = plugin.modelProvider.complete({ prompt: "模型提示", sessionId: "pa-fifo", timeoutMs: 5000, signal: new AbortController().signal });
+        const task = plugin.handle({ task: "用户续聊" });
+        await Promise.all([model, task]);
+        strict_1.default.deepEqual(calls, ["model-chat:模型提示", "user-chat:用户续聊"]);
+    }
+    finally {
+        await plugin.deactivate("stop");
+        await rm(dataDir, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)("千问取消后继续观察桌面生成直至结束，超过等待时限也不释放底层任务", async (t) => {
+    const { QwenCdpClient } = await Promise.resolve().then(() => __importStar(require("../src-ts/plugins/qwenwork/cdp-client")));
+    t.mock.timers.enable({ apis: ["setTimeout", "Date"] });
+    const client = new QwenCdpClient();
+    const controller = new AbortController();
+    let submitted = false;
+    let generating = true;
+    let settled = false;
+    client.ensureVisible = client.recoverDraft = client.waitFor = async () => undefined;
+    client.readArtifacts = async () => [];
+    client.cdp = async () => { submitted = true; };
+    client.evaluate = async (expression) => {
+        if (expression === "location.href")
+            return "file:///index.html?chat=model-chat";
+        if (expression.startsWith("JSON.stringify(["))
+            return JSON.stringify(submitted ? [{ id: "reply", text: "迟到回复" }] : []);
+        if (expression.startsWith("Boolean(document.querySelector('button"))
+            return generating;
+        return true;
+    };
+    const running = client.complete("模型提示", 10, controller.signal).then((value) => { settled = true; return value; });
+    await new Promise(resolve => setImmediate(resolve));
+    controller.abort(new Error("停止等待"));
+    t.mock.timers.tick(2000);
+    await new Promise(resolve => setImmediate(resolve));
+    strict_1.default.equal(settled, false);
+    generating = false;
+    for (let index = 0; index < 3; index++) {
+        t.mock.timers.tick(2000);
+        await new Promise(resolve => setImmediate(resolve));
+    }
+    strict_1.default.deepEqual(await running, { text: "迟到回复", sessionId: "model-chat" });
+});