mu-agent-bridge 1.0.71 → 1.0.78

package/dist/tests-ts/local-cli.test.js

@@ -10,13 +10,14 @@ const node_path_1 = require("node:path");
 const node_test_1 = __importDefault(require("node:test"));
 const codex_cli_1 = __importDefault(require("../src-ts/plugins/codex-cli"));
 const claude_cli_1 = __importDefault(require("../src-ts/plugins/claude-cli"));
+const personal_assistant_1 = require("../src-ts/plugins/personal-assistant");
 const agent_1 = require("../src-ts/plugins/local-cli/agent");
 const plugin_manifest_1 = require("../src-ts/plugin-manifest");
 const fixture = String.raw `
 const fs = require('node:fs'); const {randomUUID}=require('node:crypto');
 const args=process.argv.slice(2);
 if(args.includes('--version')) { console.log('1.0.0'); process.exit(0); }
-if(args.includes('--help')) { console.log('exec resume --json --print --output-format --resume'); process.exit(0); }
+if(args.includes('--help')) { console.log('exec resume --json --print --output-format --resume --json-schema --tools --strict-mcp-config --mcp-config --no-session-persistence --settings --setting-sources --output-schema --ephemeral --sandbox --disable --config --ignore-rules'); process.exit(0); }
 let input=''; process.stdin.setEncoding('utf8'); process.stdin.on('data',x=>input+=x);
 process.stdin.on('end',()=>{
  fs.appendFileSync('calls.jsonl',JSON.stringify({args,input})+'\n');
@@ -25,6 +26,10 @@ process.stdin.on('end',()=>{
  if(input==='permission') {console.error('permission denied EACCES'); process.exit(9);}
  if(input==='structured-error') { if(args[0]==='exec') console.log(JSON.stringify({type:'turn.failed',error:{message:'E_AUTH_42 登录失败'}})); else console.log(JSON.stringify({type:'result',is_error:true,errors:['E_AUTH_42 登录失败']})); return; }
  if(input==='malformed') {console.log('{}'); return;}
+ let decision={text:'模型回复'};
+ try { const prompt=JSON.parse(input); if(prompt.messages) decision=prompt.messages.at(-1).role==='tool' ? {role:'assistant',content:'已查询千问办公',tool_calls:[]} : {role:'assistant',content:null,tool_calls:[{id:'list-1',type:'function',function:{name:'agents_list',arguments:'{}'}}]}; } catch {}
+ if(args.includes('--json-schema')) {console.log(JSON.stringify({type:'result',session_id:randomUUID(),is_error:false,result:'',...(input==='missing-structured'?{}:{structured_output:decision})}));return;}
+ if(args.includes('--output-schema')) { const id=randomUUID(); console.log(JSON.stringify({type:'thread.started',thread_id:id})); console.log(JSON.stringify({type:'item.completed',item:{type:'agent_message',text:JSON.stringify(decision)}})); console.log(JSON.stringify({type:'turn.completed'})); return; }
  const codex=args[0]==='exec'; const resume=codex?args.indexOf('resume'):args.indexOf('--resume');
  let id=resume>=0?args[resume+1]:randomUUID();
  if(input==='wrong-session') id=randomUUID();
@@ -44,6 +49,30 @@ async function setup(t) {
     return { root, context };
 }
 for (const [name, Constructor] of [["Codex", codex_cli_1.default], ["Claude", claude_cli_1.default]]) {
+    (0, node_test_1.default)(`个人助理通过 ${name} 真实插件入口完成模型决策和工具回合`, async (t) => {
+        const { root, context } = await setup(t);
+        const cli = new Constructor();
+        const assistant = new personal_assistant_1.PersonalAssistantPlugin();
+        await cli.activate(context);
+        let queried = 0;
+        try {
+            await assistant.activate({ ...context, config: { modelProvider: "plugin", modelPlugin: cli.manifest.id, allowedPeers: [], allowedAgents: [] }, callModelProvider: async (id, request) => {
+                    strict_1.default.equal(id, cli.manifest.id);
+                    return cli.modelProvider.complete(request);
+                } });
+            const result = await assistant.handle({ task: "请列出 Agent", sessionId: "private-thread", management: { listAgents: async () => { queried++; return [{ id: "qwenwork", displayName: "千问办公" }]; } } });
+            strict_1.default.equal(result.text, "已查询千问办公");
+            strict_1.default.equal(queried, 1);
+            const calls = (await (0, promises_1.readFile)((0, node_path_1.join)(root, "calls.jsonl"), "utf8")).trim().split("\n").map(line => JSON.parse(line));
+            strict_1.default.equal(calls.length, 2);
+            strict_1.default.match(JSON.parse(calls[1].input).messages.at(-1).content, /千问办公/);
+            await strict_1.default.rejects((0, promises_1.readFile)((0, node_path_1.join)(context.dataDir, "cli-sessions.json")), /ENOENT/);
+        }
+        finally {
+            await assistant.deactivate("stop");
+            await cli.deactivate("stop");
+        }
+    });
     (0, node_test_1.default)(`${name} 隔离双会话、精确恢复、重载和新建，不覆盖模型及权限`, async (t) => {
         const { root, context } = await setup(t);
         let plugin = new Constructor();
@@ -108,6 +137,122 @@ for (const [name, Constructor] of [["Codex", codex_cli_1.default], ["Claude", cl
         await strict_1.default.rejects(plugin.handle({ task: "recall" }), /未启动|停止/);
     });
 }
+(0, node_test_1.default)("Claude 无工具模型请求使用默认模型及结构化输出，不保存聊天映射", async (t) => {
+    const { root, context } = await setup(t);
+    const plugin = new claude_cli_1.default();
+    await plugin.activate(context);
+    try {
+        const modelResponseSchema = { type: "object", properties: { text: { type: "string" } }, required: ["text"], additionalProperties: false };
+        const response = await plugin.handle({ task: "模型请求", modelResponseSchema });
+        strict_1.default.deepEqual(JSON.parse(response.text), { text: "模型回复" });
+        strict_1.default.equal(response.sessionId, undefined);
+        const call = JSON.parse((await (0, promises_1.readFile)((0, node_path_1.join)(root, "calls.jsonl"), "utf8")).trim());
+        strict_1.default.equal(call.args[call.args.indexOf("--tools") + 1], "");
+        strict_1.default.ok(call.args.includes("--strict-mcp-config"));
+        strict_1.default.deepEqual(JSON.parse(call.args[call.args.indexOf("--mcp-config") + 1]), { mcpServers: {} });
+        strict_1.default.deepEqual(JSON.parse(call.args[call.args.indexOf("--settings") + 1]), { disableAllHooks: true });
+        strict_1.default.ok(call.args.includes("--no-session-persistence"));
+        strict_1.default.ok(!call.args.includes("--model"));
+        strict_1.default.deepEqual(JSON.parse(call.args[call.args.indexOf("--json-schema") + 1]), modelResponseSchema);
+        await strict_1.default.rejects((0, promises_1.readFile)((0, node_path_1.join)(context.dataDir, "cli-sessions.json")), /ENOENT/);
+        await strict_1.default.rejects(plugin.handle({ task: "missing-structured", modelResponseSchema }), /结构化/);
+        const controller = new AbortController();
+        const pending = strict_1.default.rejects(plugin.handle({ task: "hang", modelResponseSchema, signal: controller.signal }), /取消/);
+        setTimeout(() => controller.abort(), 100);
+        await pending;
+    }
+    finally {
+        await plugin.deactivate("stop");
+    }
+});
+(0, node_test_1.default)("Claude 独立模型来源解析 prompt Schema，不保存管理会话", async (t) => {
+    const { root, context } = await setup(t);
+    const plugin = new claude_cli_1.default();
+    strict_1.default.equal(plugin.modelProvider, undefined);
+    await plugin.activate(context);
+    try {
+        const responseSchema = { type: "object", properties: { text: { type: "string" } }, required: ["text"], additionalProperties: false };
+        const provider = plugin.modelProvider;
+        strict_1.default.ok(provider);
+        plugin.handle = async () => { throw new Error("模型来源不能委托普通 handle"); };
+        const response = await provider.complete({
+            prompt: JSON.stringify({ instructions: "只返回结构化结果", responseSchema }),
+            sessionId: "pa-model",
+            timeoutMs: 2_000,
+            signal: new AbortController().signal,
+        });
+        strict_1.default.deepEqual(JSON.parse(response.text), { text: "模型回复" });
+        await strict_1.default.rejects((0, promises_1.readFile)((0, node_path_1.join)(context.dataDir, "cli-sessions.json")), /ENOENT/);
+        await strict_1.default.rejects(provider.complete({ prompt: JSON.stringify({ instructions: "缺少 Schema" }), sessionId: "pa-model", timeoutMs: 2_000, signal: new AbortController().signal }), /Schema/);
+        const call = JSON.parse((await (0, promises_1.readFile)((0, node_path_1.join)(root, "calls.jsonl"), "utf8")).trim());
+        strict_1.default.equal(call.args[call.args.indexOf("--tools") + 1], "");
+        strict_1.default.ok(call.args.includes("--strict-mcp-config"));
+        strict_1.default.deepEqual(JSON.parse(call.args[call.args.indexOf("--mcp-config") + 1]), { mcpServers: {} });
+        strict_1.default.deepEqual(JSON.parse(call.args[call.args.indexOf("--settings") + 1]), { disableAllHooks: true });
+        strict_1.default.deepEqual(JSON.parse(call.args[call.args.indexOf("--json-schema") + 1]), responseSchema);
+        strict_1.default.ok(call.args.includes("--no-session-persistence"));
+        strict_1.default.ok(!call.args.includes("--model"));
+    }
+    finally {
+        await plugin.deactivate("stop");
+    }
+    strict_1.default.equal(plugin.modelProvider, undefined);
+});
+(0, node_test_1.default)("Codex CLI 提供隔离模型来源，且普通对话仍可用", async (t) => {
+    const { root, context } = await setup(t);
+    const plugin = new codex_cli_1.default();
+    strict_1.default.ok(plugin.manifest.capabilities.includes("model-provider"));
+    strict_1.default.equal(plugin.modelProvider, undefined);
+    await plugin.activate(context);
+    try {
+        strict_1.default.equal(plugin.modelInput, true);
+        const responseSchema = { type: "object", properties: { text: { type: "string" } }, required: ["text"], additionalProperties: false };
+        const provider = plugin.modelProvider;
+        strict_1.default.ok(provider);
+        const response = await provider.complete({
+            prompt: JSON.stringify({ instructions: "只返回结构化结果", responseSchema }),
+            sessionId: "pa-codex-model",
+            timeoutMs: 2_000,
+            signal: new AbortController().signal,
+        });
+        strict_1.default.deepEqual(JSON.parse(response.text), { text: "模型回复" });
+        const call = JSON.parse((await (0, promises_1.readFile)((0, node_path_1.join)(root, "calls.jsonl"), "utf8")).trim());
+        strict_1.default.equal(call.args[0], "exec");
+        strict_1.default.ok(call.args.includes("--ephemeral"));
+        strict_1.default.deepEqual(call.args.slice(call.args.indexOf("--sandbox"), call.args.indexOf("--sandbox") + 2), ["--sandbox", "read-only"]);
+        for (const feature of ["shell_tool", "apps", "plugins", "hooks"]) {
+            const index = call.args.indexOf(feature);
+            strict_1.default.ok(index > 0);
+            strict_1.default.equal(call.args[index - 1], "--disable");
+        }
+        strict_1.default.ok(call.args.includes("--ignore-rules"));
+        strict_1.default.ok(call.args.includes("mcp_servers={}"));
+        strict_1.default.ok(call.args.includes("--output-schema"));
+        strict_1.default.ok(!call.args.includes("resume"));
+        strict_1.default.ok(!call.args.includes("--model"));
+        await strict_1.default.rejects((0, promises_1.readFile)((0, node_path_1.join)(context.dataDir, "cli-sessions.json")), /ENOENT/);
+        strict_1.default.equal((await plugin.handle({ task: "普通 Codex 请求" })).text, "普通 Codex 请求");
+        const calls = (await (0, promises_1.readFile)((0, node_path_1.join)(root, "calls.jsonl"), "utf8")).trim().split("\n").map(line => JSON.parse(line));
+        strict_1.default.ok(calls.some(entry => entry.args[0] === "exec" && entry.args.includes("--json")));
+    }
+    finally {
+        await plugin.deactivate("stop");
+    }
+});
+(0, node_test_1.default)("CLI 模型失败保留退出码但不记录外部错误夹带的提示正文", async (t) => {
+    const { context } = await setup(t);
+    const records = [];
+    const plugin = new codex_cli_1.default();
+    await plugin.activate({ ...context, logger: { info() { }, warn() { }, error: (_message, fields) => records.push(fields) } });
+    plugin.run = async () => { throw new Error("codex CLI 退出码 5：请检查 CLI 配置及网络；外部回显的私密用户提示"); };
+    try {
+        await strict_1.default.rejects(plugin.modelProvider.complete({ prompt: JSON.stringify({ responseSchema: { type: "object" } }), sessionId: "model", timeoutMs: 1000, signal: new AbortController().signal }), error => /退出码 5/.test(String(error)) && !/私密用户提示/.test(String(error)));
+        strict_1.default.doesNotMatch(JSON.stringify(records), /私密用户提示/);
+    }
+    finally {
+        await plugin.deactivate("stop");
+    }
+});
 (0, node_test_1.default)("配置无效和 CLI 未安装时不冒充就绪", async (t) => {
     const { context } = await setup(t);
     const plugin = new codex_cli_1.default();

package/dist/tests-ts/model-provider-cancellation.test.js

@@ -0,0 +1,152 @@
+"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/qwenwork/cdp-client");
+const cdp_client_2 = require("../src-ts/plugins/chatgpt/cdp-client");
+const cdp_client_3 = require("../src-ts/plugins/workbuddy/cdp-client");
+const cdp_client_4 = require("../src-ts/plugins/doubao/cdp-client");
+const flush = () => new Promise(resolve => setImmediate(resolve));
+(0, node_test_1.default)("千问取消后保留生成中的任务，确认本轮空回复结束才收尾", async (t) => {
+    t.mock.timers.enable({ apis: ["setTimeout", "Date"] });
+    const client = new cdp_client_1.QwenCdpClient();
+    const controller = new AbortController();
+    let submitted = false;
+    let generating = false;
+    let error;
+    client.ensureVisible = client.recoverDraft = client.waitFor = async () => undefined;
+    client.readArtifacts = async () => [];
+    client.cdp = async () => { submitted = true; };
+    client.close = () => strict_1.default.fail("取消不应关闭桌面连接");
+    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: "current", text: "" }] : []);
+        if (expression.startsWith("Boolean(document.querySelector('button"))
+            return generating;
+        return true;
+    };
+    const running = client.complete("模型提示", 10, controller.signal).catch((value) => { error = value; });
+    await flush();
+    controller.abort();
+    for (let index = 0; index < 2; index++) {
+        t.mock.timers.tick(2000);
+        await flush();
+    }
+    strict_1.default.equal(error, undefined, "尚未观察到本轮生成时不能猜测任务结束");
+    generating = true;
+    t.mock.timers.tick(2000);
+    await flush();
+    strict_1.default.equal(error, undefined);
+    generating = false;
+    t.mock.timers.tick(2000);
+    await flush();
+    strict_1.default.equal(error, undefined, "单次未生成状态不能释放任务");
+    t.mock.timers.tick(2000);
+    await flush();
+    strict_1.default.match(String(error), /QWEN_REQUEST_CANCELLED.*已取消.*本轮.*结束/);
+    await running;
+});
+(0, node_test_1.default)("ChatGPT 取消后等待本轮生成结束，空回复不永久占用原任务", async (t) => {
+    t.mock.timers.enable({ apis: ["setTimeout", "Date"] });
+    const client = new cdp_client_2.ChatgptCdpClient();
+    const controller = new AbortController();
+    let active = false;
+    let error;
+    client.waitFor = client.waitForGeneration = client.recoverDraft = async () => undefined;
+    client.activeSession = async () => ({ id: "model", host: "local", title: "模型会话" });
+    client.cdp = async () => undefined;
+    client.close = () => strict_1.default.fail("取消不应关闭桌面连接");
+    client.evaluate = async (expression) => {
+        if (expression.includes("findLast((item, index)"))
+            return JSON.stringify({ submitted: true, active, reply: "", hasArtifacts: false, artifacts: [{ conversationId: "model", messageId: "current" }] });
+        if (expression.startsWith("JSON.stringify("))
+            return "[]";
+        if (expression.endsWith(".length"))
+            return 0;
+        return true;
+    };
+    const running = client.direct("模型提示", 10, undefined, controller.signal).catch((value) => { error = value; });
+    await flush();
+    controller.abort();
+    for (let index = 0; index < 2; index++) {
+        t.mock.timers.tick(800);
+        await flush();
+    }
+    strict_1.default.equal(error, undefined, "消息已提交但尚未开始生成时不能释放任务");
+    active = true;
+    t.mock.timers.tick(800);
+    await flush();
+    strict_1.default.equal(error, undefined);
+    active = false;
+    t.mock.timers.tick(800);
+    await flush();
+    strict_1.default.equal(error, undefined, "单次停止状态不能释放任务");
+    t.mock.timers.tick(800);
+    await flush();
+    strict_1.default.match(String(error), /ChatGPT.*已取消.*本轮.*结束/);
+    await running;
+});
+(0, node_test_1.default)("WorkBuddy 取消后等待本轮完成标记，空回复也能结束等待", async (t) => {
+    t.mock.timers.enable({ apis: ["setTimeout", "Date"] });
+    const client = new cdp_client_3.WorkbuddyCdpClient();
+    const controller = new AbortController();
+    let finished = false;
+    let error;
+    client.evaluate = async () => JSON.stringify([{ id: "current", text: "", finished, stopped: false }]);
+    client.readInteraction = async () => undefined;
+    client.readArtifacts = async () => [];
+    client.close = () => strict_1.default.fail("取消不应关闭桌面连接");
+    const running = client.waitForReply(new Set(), 10, undefined, undefined, "model", undefined, controller.signal).catch((value) => { error = value; });
+    controller.abort();
+    t.mock.timers.tick(1000);
+    await flush();
+    strict_1.default.equal(error, undefined);
+    finished = true;
+    t.mock.timers.tick(1000);
+    await flush();
+    strict_1.default.match(String(error), /WORKBUDDY_REQUEST_CANCELLED.*已取消.*本轮.*结束/);
+    await running;
+});
+(0, node_test_1.default)("豆包取消后的空 SSE 终态释放队列，下一轮不会接到前轮结果", async (t) => {
+    t.mock.timers.enable({ apis: ["setTimeout", "Date"] });
+    const client = new cdp_client_4.DoubaoCdpClient({ timeoutMs: 10 });
+    const controller = new AbortController();
+    let requests = 0;
+    let finished = false;
+    let error;
+    client.connect = async () => undefined;
+    client.close = () => strict_1.default.fail("取消不应关闭桌面连接");
+    client.evaluate = async (expression) => {
+        if (expression === "window.__mab_doubao_progress")
+            return undefined;
+        if (expression !== "window.__mab_doubao_result") {
+            requests++;
+            return "started";
+        }
+        if (requests === 1)
+            return finished ? JSON.stringify({ ok: true, reply: "", pending: false, conversationId: "123" }) : null;
+        return JSON.stringify({ ok: true, reply: "只属于下一轮的回复", conversationId: "456" });
+    };
+    const first = client.complete("取消提示", controller.signal, undefined, "").catch((value) => { error = value; });
+    await flush();
+    const second = client.complete("新请求", undefined, undefined, "");
+    controller.abort();
+    t.mock.timers.tick(1000);
+    await flush();
+    strict_1.default.equal(error, undefined);
+    strict_1.default.equal(requests, 1, "页面请求未结束时，下一轮不得提交");
+    finished = true;
+    t.mock.timers.tick(1000);
+    await flush();
+    strict_1.default.match(String(error), /豆包.*已取消.*本轮.*结束/);
+    strict_1.default.equal(requests, 2, "已确认空结果后应释放原队列");
+    t.mock.timers.tick(1000);
+    await flush();
+    strict_1.default.deepEqual(await second, { text: "只属于下一轮的回复", sessionId: "456" });
+    await first;
+});

package/dist/tests-ts/native-session-management.test.js

@@ -13,7 +13,7 @@ const session_management_1 = require("../src-ts/session-management");
 const source = (peer) => JSON.stringify(["aun", "local", "", peer, ""]);
 const context = { source: source("admin"), sessionId: "manager" };
 const readAt = "2026-10-21T00:00:00.000Z";
-const settings = { enabled: false, grants: [], nativeGrants: [{ managerSource: context.source, managerSessionId: context.sessionId, providers: [{ pluginId: "demo", scope: "instance:one" }] }] };
+const settings = { enabled: false, allowFrom: ["history-admin.agentid.cn"], grants: [], nativeGrants: [{ managerSource: context.source, managerSessionId: context.sessionId, providers: [{ pluginId: "demo", scope: "instance:one" }] }] };
 const refOf = (text) => text.match(/[a-f0-9]{12}\.1/)[0];
 async function setup() {
     const root = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "mab-native-"));
@@ -29,10 +29,10 @@ async function setup() {
     const service = new session_management_1.SessionManagement(root, undefined, undefined, () => [{ pluginId: "demo", provider: current, identity, status }]);
     return { service, provider, calls, close: () => (0, promises_1.rm)(root, { recursive: true, force: true }), replace: () => { identity = {}; }, scope: () => { current = { ...provider, scope: "instance:two" }; }, offline: () => { status = "failed"; } };
 }
-(0, node_test_1.default)("原生授权独立于归档授权，无授权或新逻辑会话不调用 provider", async () => {
+(0, node_test_1.default)("限制模式下原生授权独立于归档授权，无授权或新逻辑会话不调用 provider", async () => {
     const f = await setup();
     try {
-        await f.service.saveConfig({ enabled: true, grants: [{ managerSource: context.source, managerSessionId: context.sessionId, sources: [source("other")] }] });
+        await f.service.saveConfig({ enabled: true, allowFrom: ["history-admin.agentid.cn"], grants: [{ managerSource: context.source, managerSessionId: context.sessionId, sources: [source("other")] }] });
         strict_1.default.match((await f.service.command("/sessions native-list demo", context)), /无权/);
         strict_1.default.deepEqual(f.calls, []);
         await f.service.saveConfig(settings);
@@ -52,10 +52,10 @@ async function setup() {
         await f.close();
     }
 });
-(0, node_test_1.default)("原生配置保持旧输出兼容，并拒绝通配符、重复及多余字段", async () => {
+(0, node_test_1.default)("原生精确授权保持兼容，并拒绝 scope 通配符、重复及多余字段", async () => {
     const f = await setup();
     try {
-        strict_1.default.deepEqual(await f.service.config(), { enabled: false, grants: [] });
+        strict_1.default.deepEqual(await f.service.config(), { enabled: false, allowFrom: [], grants: [] });
         await f.service.saveConfig(settings);
         strict_1.default.deepEqual((await f.service.config()).nativeGrants, settings.nativeGrants);
         for (const invalid of [
@@ -77,7 +77,7 @@ async function setup() {
             await f.service.saveConfig(settings);
             const ref = refOf((await f.service.command("/sessions native-list demo", context)));
             if (change === "revoke")
-                await f.service.saveConfig({ enabled: false, grants: [], nativeGrants: [] });
+                await f.service.saveConfig({ enabled: false, allowFrom: ["history-admin.agentid.cn"], grants: [], nativeGrants: [] });
             else
                 f[change]();
             strict_1.default.match((await f.service.command(`/sessions native-show ${ref}`, context)), /编号|无权|离线/);
@@ -142,10 +142,11 @@ async function setup() {
         await f.service.saveConfig(settings);
         const ref = refOf((await f.service.command("/sessions native-list demo", context)));
         const original = f.provider.readSession;
-        f.provider.readSession = async (query) => { const result = await original(query); await f.service.saveConfig({ enabled: false, grants: [] }); return result; };
+        f.provider.readSession = async (query) => { const result = await original(query); await f.service.saveConfig({ enabled: false, allowFrom: ["history-admin.agentid.cn"], grants: [] }); return result; };
         const result = (await f.service.command(`/sessions native-show ${ref}`, context));
         strict_1.default.match(result, /权限|编号/);
         strict_1.default.ok(!result.includes("不可信正文"));
+        strict_1.default.match((await f.service.command("/sessions native-list demo", context)), /无权/);
         await f.service.saveConfig(settings);
         f.provider.listSessions = async () => { throw new Error("secret-token"); };
         strict_1.default.ok(!(await f.service.command("/sessions native-list demo", context)).includes("secret-token"));

package/dist/tests-ts/personal-assistant-coordination.test.js

@@ -0,0 +1,92 @@
+"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_test_1 = require("node:test");
+const coordination_1 = require("../src-ts/plugins/personal-assistant/coordination");
+const tools_1 = require("../src-ts/plugins/personal-assistant/tools");
+async function fixture(responses) {
+    const dir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "pa-coordination-"));
+    const logPath = (0, node_path_1.join)(dir, "args.jsonl");
+    const ecPath = (0, node_path_1.join)(dir, "ec");
+    const responder = `const fs=require('node:fs');const args=process.argv.slice(2);fs.appendFileSync(${JSON.stringify(logPath)},JSON.stringify(args)+'\\n');const value=(${responses.toString()})(args);process.stdout.write(JSON.stringify(value));`;
+    await (0, promises_1.writeFile)(ecPath, `#!/usr/bin/env node\n${responder}\n`);
+    await (0, promises_1.chmod)(ecPath, 0o755);
+    return {
+        ecPath,
+        coordinator: (0, coordination_1.createCoordinator)({ ecPath, selfAid: "self.agentid.cn", allowedAgents: [{ id: "worker", aids: ["worker.agentid.cn"] }] }),
+        args: async () => { try {
+            return (await (0, promises_1.readFile)(logPath, "utf8")).trim().split("\n").filter(Boolean).map((line) => JSON.parse(line));
+        }
+        catch {
+            return [];
+        } },
+        cleanup: () => (0, promises_1.rm)(dir, { recursive: true, force: true }),
+    };
+}
+(0, node_test_1.test)("Agent 名单留空可协调派活，但仍校验核心的可调用状态和真实 AID 绑定", async () => {
+    const value = await fixture(args => args[0] === "thread" ? { thread_id: "thread-all" } : { ok: true });
+    const management = { listAgents: async () => [{ id: "worker", aids: ["worker.agentid.cn"], callable: true }] };
+    try {
+        const runtime = { selfAid: "self.agentid.cn", ecPath: value.ecPath };
+        await strict_1.default.rejects((0, tools_1.executeTool)("coordination_dispatch", { agentId: "worker", aid: "other.agentid.cn", task: "派活" }, management, [], runtime), /不可派活/);
+        const result = await (0, tools_1.executeTool)("coordination_dispatch", { agentId: "worker", aid: "worker.agentid.cn", task: "派活" }, management, [], runtime);
+        strict_1.default.deepEqual(result, { status: "pending", agentId: "worker", aid: "worker.agentid.cn", threadId: "thread-all" });
+        strict_1.default.equal((await value.args()).length, 2);
+    }
+    finally {
+        await value.cleanup();
+    }
+});
+(0, node_test_1.test)("派活只允许白名单内匹配的 Agent 与 AID", async () => {
+    const value = await fixture(() => ({ thread_id: "thread-1" }));
+    try {
+        await strict_1.default.rejects(value.coordinator.dispatch({ agentId: "other", aid: "worker.agentid.cn", task: "工作" }), /白名单/);
+        await strict_1.default.rejects(value.coordinator.dispatch({ agentId: "worker", aid: "other.agentid.cn", task: "工作" }), /白名单/);
+        await strict_1.default.rejects(value.coordinator.dispatch({ agentId: "worker; touch /tmp/no", aid: "worker.agentid.cn", task: "工作" }), /白名单/);
+        strict_1.default.deepEqual(await value.args(), []);
+    }
+    finally {
+        await value.cleanup();
+    }
+});
+(0, node_test_1.test)("创建 thread 后用 argv 派活，特殊字符作为普通任务文本传入", async () => {
+    const value = await fixture((args) => args[0] === "thread" ? { ok: true, thread_id: "thread-1" } : { ok: true, status: "completed" });
+    try {
+        const task = "检查 x; touch /tmp/no && $(whoami)";
+        const dispatched = await value.coordinator.dispatch({ agentId: "worker", aid: "worker.agentid.cn", task });
+        strict_1.default.deepEqual(dispatched, { status: "pending", agentId: "worker", aid: "worker.agentid.cn", threadId: "thread-1" });
+        strict_1.default.deepEqual(await value.args(), [
+            ["thread", "create", "worker.agentid.cn", "--name", "个人助理派活-worker", "--format", "json"],
+            ["msg", "send", "self.agentid.cn", "worker.agentid.cn", "--text", task, "--thread", "thread-1", "--return", "required", "--format", "json"],
+        ]);
+    }
+    finally {
+        await value.cleanup();
+    }
+});
+(0, node_test_1.test)("thread history 未明确标记完成时保持 pending，且不重发任务", async () => {
+    const value = await fixture((args) => {
+        if (args[0] === "thread" && args[1] === "create")
+            return { thread_id: "thread-1" };
+        if (args[0] === "msg")
+            return { ok: true, status: "completed" };
+        return { messages: [{ from: "worker.agentid.cn", text: "仍在处理" }] };
+    });
+    try {
+        await value.coordinator.dispatch({ agentId: "worker", aid: "worker.agentid.cn", task: "执行任务" });
+        const result = await value.coordinator.getStatus({ aid: "worker.agentid.cn", threadId: "thread-1" });
+        strict_1.default.deepEqual(result, { status: "pending", aid: "worker.agentid.cn", threadId: "thread-1", history: { messages: [{ from: "worker.agentid.cn", text: "仍在处理" }] } });
+        const calls = await value.args();
+        strict_1.default.equal(calls.filter((args) => args[0] === "msg" && args[1] === "send").length, 1);
+        strict_1.default.deepEqual(calls.at(-1), ["thread", "history", "thread-1", "--format", "json"]);
+    }
+    finally {
+        await value.cleanup();
+    }
+});

package/dist/tests-ts/personal-assistant-extensions.test.js

@@ -0,0 +1,35 @@
+"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 = require("node:test");
+const tools_1 = require("../src-ts/plugins/personal-assistant/tools");
+const management = {
+    listAgents: async () => [{ id: "worker", displayName: "工作 Agent", status: "ready", available: true, reason: "", capabilities: ["chat"], aids: ["worker.agentid.cn"], callable: true }],
+    callAgent: async () => ({ text: "" }), listAunIdentities: async () => ({}), createAunIdentity: async () => ({}), bindAunIdentity: async () => ({}),
+    runSessionCommand: async () => "", summarizeToday: async () => ({ supported: false, text: "", sources: [], complete: false }),
+};
+(0, node_test_1.test)("扩展工具只向配置的 Provider 访问远程 Ability", async () => {
+    let calls = 0;
+    const remoteAbility = { discover: async () => { calls++; return []; }, call: async () => { calls++; return { status: "completed" }; }, getRequest: async () => { calls++; return { status: "pending" }; } };
+    await strict_1.default.rejects((0, tools_1.executeTool)("ability_discover", { providerAid: "other.agentid.cn" }, management, [], { allowedProviders: ["provider.agentid.cn"], remoteAbility: remoteAbility }));
+    strict_1.default.deepEqual(await (0, tools_1.executeTool)("ability_discover", { providerAid: "provider.agentid.cn" }, management, [], { allowedProviders: ["provider.agentid.cn"], remoteAbility: remoteAbility }), []);
+    strict_1.default.equal(calls, 1);
+});
+(0, node_test_1.test)("协调派活要求核心可用状态、Agent 白名单和绑定 AID 同时匹配", async () => {
+    const args = { agentId: "worker", aid: "worker.agentid.cn", task: "执行工作" };
+    await strict_1.default.rejects((0, tools_1.executeTool)("coordination_dispatch", args, management, ["other"], { selfAid: "assistant.agentid.cn" }), /白名单/);
+    await strict_1.default.rejects((0, tools_1.executeTool)("coordination_dispatch", { ...args, aid: "other.agentid.cn" }, management, ["worker"], { selfAid: "assistant.agentid.cn" }), /不可派活/);
+    strict_1.default.deepEqual((0, tools_1.toolDefinitions)().map((tool) => tool.function.name).slice(-6), ["ability_discover", "ability_call", "ability_request_get", "coordination_dispatch", "coordination_status", "owner_context_read"]);
+});
+(0, node_test_1.test)("thread 状态查询只允许当前插件进程已派发的 thread", async () => {
+    await strict_1.default.rejects((0, tools_1.executeTool)("coordination_status", { aid: "worker.agentid.cn", threadId: "thread-1" }, management, [], { selfAid: "assistant.agentid.cn", threads: new Map() }), /不属于/);
+});
+(0, node_test_1.test)("Agent 名单留空允许列举和调用，填写名单后限制目标", async () => {
+    const agents = await (0, tools_1.executeTool)("agents_list", {}, management, []);
+    strict_1.default.equal(agents[0].callable, true);
+    strict_1.default.deepEqual(await (0, tools_1.executeTool)("agents_call", { id: "worker", task: "测试" }, management, []), { text: "" });
+    await strict_1.default.rejects((0, tools_1.executeTool)("agents_call", { id: "worker", task: "测试" }, management, ["other"]), /白名单/);
+});

package/dist/tests-ts/personal-assistant-memory.test.js

@@ -0,0 +1,117 @@
+"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 = require("node:test");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const session_memory_1 = require("../src-ts/plugins/personal-assistant/session-memory");
+const turn = (content) => [{ role: "user", content }, { role: "assistant", content: `回答：${content}` }];
+const toolTurn = [
+    { role: "user", content: "调用 WorkBuddy 记住 PA_TOOL" },
+    { role: "assistant", content: null, tool_calls: [{ id: "call-1", type: "function", function: { name: "agents_call", arguments: '{"id":"workbuddy","task":"记住 PA_TOOL"}' } }] },
+    { role: "tool", tool_call_id: "call-1", name: "agents_call", content: '{"text":"已记住 PA_TOOL"}' },
+    { role: "assistant", content: "WorkBuddy 已记住" },
+];
+(0, node_test_1.test)("会话历史裁剪保留完整轮次和工具调用配对", async () => {
+    const dataDir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "pa-memory-trim-"));
+    try {
+        const memory = new session_memory_1.PersonalAssistantSessionMemory(dataDir);
+        await memory.save("thread", [...toolTurn, ...Array.from({ length: 19 }, (_, i) => turn(String(i))).flat()]);
+        const result = await memory.load("thread");
+        strict_1.default.equal(result.length, 38);
+        strict_1.default.equal(result[0].role, "user");
+        strict_1.default.equal(result.some(message => message.role === "tool"), false);
+        await memory.save("tool-thread", toolTurn);
+        strict_1.default.deepEqual(await new session_memory_1.PersonalAssistantSessionMemory(dataDir).load("tool-thread"), toolTurn);
+    }
+    finally {
+        await (0, promises_1.rm)(dataDir, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.test)("并发首次读取和保存不遗漏不同会话，文件保持私有", async () => {
+    const dataDir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "pa-memory-concurrent-"));
+    try {
+        await (0, promises_1.writeFile)((0, node_path_1.join)(dataDir, "model-sessions.json"), JSON.stringify({ old: turn("旧记录") }));
+        const memory = new session_memory_1.PersonalAssistantSessionMemory(dataDir);
+        strict_1.default.deepEqual(await Promise.all([memory.load("old"), memory.load("old")]), [turn("旧记录"), turn("旧记录")]);
+        await Promise.all(Array.from({ length: 10 }, (_, i) => memory.save(`thread-${i}`, turn(`内容-${i}`))));
+        const restored = new session_memory_1.PersonalAssistantSessionMemory(dataDir);
+        for (let i = 0; i < 10; i++)
+            strict_1.default.deepEqual(await restored.load(`thread-${i}`), turn(`内容-${i}`));
+        if (process.platform !== "win32")
+            strict_1.default.equal((await (0, promises_1.stat)((0, node_path_1.join)(dataDir, "model-sessions.json"))).mode & 0o777, 0o600);
+    }
+    finally {
+        await (0, promises_1.rm)(dataDir, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.test)("损坏历史不回显正文或把多余字段带入模型", async () => {
+    const dataDir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "pa-memory-invalid-"));
+    const warnings = [];
+    try {
+        const file = (0, node_path_1.join)(dataDir, "model-sessions.json");
+        await (0, promises_1.writeFile)(file, '{"private-token-secret-value": malformed');
+        const memory = new session_memory_1.PersonalAssistantSessionMemory(dataDir, (...args) => warnings.push(args));
+        strict_1.default.deepEqual(await memory.load("old"), []);
+        strict_1.default.equal(warnings.length, 1);
+        strict_1.default.doesNotMatch(JSON.stringify(warnings), /private-token-secret-value/);
+        await (0, promises_1.writeFile)(file, JSON.stringify({ good: turn("可用"), bad: [{ role: "user", content: "测试", secret: "private-token-secret-value" }, { role: "tool", content: "孤立工具结果", tool_call_id: "missing" }] }));
+        const restored = new session_memory_1.PersonalAssistantSessionMemory(dataDir);
+        strict_1.default.deepEqual(await restored.load("good"), turn("可用"));
+        strict_1.default.deepEqual(await restored.load("bad"), []);
+    }
+    finally {
+        await (0, promises_1.rm)(dataDir, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.test)("历史条数与字符数超限时丢弃完整旧轮次，容量超限淘汰最旧会话", async () => {
+    const dataDir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "pa-memory-limit-"));
+    try {
+        const memory = new session_memory_1.PersonalAssistantSessionMemory(dataDir);
+        await memory.save("large", turn("字".repeat(121_000)));
+        strict_1.default.ok(JSON.stringify(await memory.load("large")).length <= 120_000);
+        for (let i = 0; i < 130; i++)
+            await memory.save(`s-${i}`, turn(String(i)));
+        const raw = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.join)(dataDir, "model-sessions.json"), "utf8"));
+        strict_1.default.equal(Object.keys(raw).length, 128);
+        strict_1.default.deepEqual(await memory.load("s-0"), []);
+        strict_1.default.deepEqual(await memory.load("s-129"), turn("129"));
+    }
+    finally {
+        await (0, promises_1.rm)(dataDir, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.test)("历史写盘失败保留内存上下文并记录安全提示", async () => {
+    const dataDir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "pa-memory-write-failure-"));
+    const warnings = [];
+    try {
+        const blocked = (0, node_path_1.join)(dataDir, "不可写目录");
+        await (0, promises_1.writeFile)(blocked, "阻挡目录创建");
+        const memory = new session_memory_1.PersonalAssistantSessionMemory(blocked, (...args) => warnings.push(args));
+        await memory.save("thread", turn("有效回复"));
+        strict_1.default.deepEqual(await memory.load("thread"), turn("有效回复"));
+        strict_1.default.ok(JSON.stringify(warnings).includes("保存失败"));
+        strict_1.default.doesNotMatch(JSON.stringify(warnings), /有效回复|不可写目录/);
+    }
+    finally {
+        await (0, promises_1.rm)(dataDir, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.test)("格式错误的新历史不会删除先前可用的内存记录", async () => {
+    const dataDir = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "pa-memory-invalid-save-"));
+    const warnings = [];
+    try {
+        const memory = new session_memory_1.PersonalAssistantSessionMemory(dataDir, (...args) => warnings.push(args));
+        await memory.save("thread", turn("先前回复"));
+        await memory.save("thread", [{ role: "tool", content: "孤立结果", tool_call_id: "missing" }]);
+        strict_1.default.deepEqual(await memory.load("thread"), turn("先前回复"));
+        strict_1.default.ok(JSON.stringify(warnings).includes("格式无效"));
+    }
+    finally {
+        await (0, promises_1.rm)(dataDir, { recursive: true, force: true });
+    }
+});