mu-agent-bridge 1.0.22 → 1.0.24

package/dist/src-ts/plugins/chatgpt/index.js

@@ -2,9 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChatgptCdpClient = exports.ChatgptPlugin = exports.chatgptManifest = void 0;
 const cdp_client_1 = require("./cdp-client");
+const session_store_1 = require("./session-store");
 exports.chatgptManifest = {
     id: "chatgpt",
-    version: "1.0.0",
+    version: "1.0.1",
     displayName: "ChatGPT（Codex）",
     type: "agent",
     entry: "dist/index.js",
@@ -25,6 +26,8 @@ class ChatgptPlugin {
     failure;
     remote = false;
     queue = Promise.resolve();
+    store;
+    logger;
     constructor(options = {}) {
         this.options = options;
     }
@@ -48,6 +51,11 @@ class ChatgptPlugin {
             localPort: port(config.localCdpPort, 9230),
         } : undefined;
         this.remote = Boolean(ssh);
+        this.logger = context.logger;
+        this.store = new session_store_1.ChatgptSessionStore(context.dataDir, JSON.stringify(ssh
+            ? [ssh.host, ssh.user, ssh.port, ssh.remotePort]
+            : ["local", port(config.localCdpPort, 9230)]));
+        await this.store.load();
         this.failure = undefined;
         this.client = this.options.client ?? new cdp_client_1.ChatgptCdpClient({
             port: port(config.localCdpPort, 9230),
@@ -60,11 +68,13 @@ class ChatgptPlugin {
         catch (error) {
             this.failure = error instanceof Error ? error.message : String(error);
             context.logger.warn(this.failure);
-            throw error;
+            if (!this.store.sessions.length)
+                throw error;
         }
     }
     async deactivate() {
         await this.queue;
+        await this.store?.drain();
         this.client?.close();
         this.client = undefined;
         this.remote = false;
@@ -72,17 +82,111 @@ class ChatgptPlugin {
     async health() {
         return this.client?.connected()
             ? { status: "ready", details: { transport: "cdp", remote: this.remote } }
-            : { status: "failed", message: this.failure ?? "ChatGPT CDP 未连接", details: { transport: "cdp", remote: this.remote } };
+            : { status: this.client && this.store?.sessions.length ? "degraded" : "failed", message: this.failure ?? "ChatGPT CDP 未连接", details: { transport: "cdp", remote: this.remote } };
     }
     async handle(request) {
         if (!request.task.trim())
             throw new Error("消息内容不能为空");
-        if (!this.client?.connected())
-            throw new Error("ChatGPT CDP 未连接");
-        const run = this.queue.then(() => this.client.direct(request.task, request.timeoutMs));
+        if (!this.client || !this.store)
+            throw new Error("ChatGPT 插件未启动");
+        const run = this.queue.then(() => this.run(request));
         this.queue = run.then(() => undefined, () => undefined);
         return { text: await run, sessionId: request.sessionId };
     }
+    persist() {
+        void this.store.save().catch(error => this.logger?.warn("ChatGPT 会话缓存保存失败", { error: String(error) }));
+    }
+    async synchronize() {
+        if (!this.client.connected())
+            await this.client.connect();
+        if (!this.client.listSessions)
+            throw new Error("当前 ChatGPT 客户端不支持会话列表");
+        this.store.synchronize(await this.client.listSessions());
+        this.persist();
+    }
+    async select(session) {
+        if (!this.client.connected())
+            await this.client.connect();
+        if (!this.client.switchSession)
+            throw new Error("当前 ChatGPT 客户端不支持会话切换");
+        const active = await this.client.activeSession?.();
+        if (active?.id === session.id && active.host === session.host)
+            return;
+        try {
+            await this.client.switchSession(session);
+        }
+        catch (error) {
+            // 目标消失时只重新同步一次；不在其他会话中代替发送。
+            if (!String(error).includes("找不到目标会话"))
+                throw error;
+            await this.synchronize();
+            const updated = this.store.sessions.find(item => item.id === session.id && item.host === session.host);
+            if (!updated)
+                throw new Error("ChatGPT 目标会话已删除或不在当前侧栏，请刷新最近任务");
+            await this.client.switchSession(updated);
+        }
+    }
+    async run(request) {
+        const store = this.store;
+        const text = request.task.trim();
+        const refresh = /^(?:刷新最近任务|刷新任务列表|刷新最近会话)$/.test(text);
+        const listing = /^(?:最近任务|列出最近会话|有哪些已保存的 ChatGPT 任务)[？?。]?$/.test(text);
+        if (refresh || listing) {
+            if (refresh || !store.fresh()) {
+                try {
+                    await this.synchronize();
+                }
+                catch (error) {
+                    if (refresh || !store.sessions.length)
+                        throw error;
+                    return `远程暂不可用，以下是本地缓存（同步时间：${store.updatedAt}）：\n${(0, session_store_1.formatSessions)(store.sessions)}`;
+                }
+            }
+            return `最近会话（当前侧栏缓存；同步时间：${store.updatedAt}）：\n${(0, session_store_1.formatSessions)(store.sessions)}`;
+        }
+        const explicit = text.match(/^切换会话\s*[:：]\s*([^；;\n]+)(?:[；;\n]\s*([\s\S]+))?$/);
+        const natural = text.match(/^(?:继续处理|接着处理|继续任务|切换到)\s*(.+?)[。]?$/);
+        const query = explicit?.[1].trim() ?? natural?.[1].trim();
+        let selected;
+        if (query) {
+            if (!store.fresh())
+                await this.synchronize();
+            let matches = store.match(query);
+            if (!matches.length) {
+                await this.synchronize();
+                matches = store.match(query);
+            }
+            if (!matches.length)
+                return `没有找到会话：${query}。请发送“最近任务”查看可用标题。`;
+            if (matches.length > 1)
+                return `找到多个会话，请用完整标题或会话 ID 指定：\n${(0, session_store_1.formatSessions)(matches)}`;
+            selected = matches[0];
+            await this.select(selected);
+            if (request.sessionId)
+                store.bindings[request.sessionId] = selected;
+            this.persist();
+            if ((explicit && !explicit[2]) || text.startsWith("切换到"))
+                return `已切换到：${selected.title}。后续消息将继续此会话。`;
+        }
+        else if (request.sessionId && store.bindings[request.sessionId]) {
+            selected = store.bindings[request.sessionId];
+            await this.select(selected);
+        }
+        if (!this.client.connected())
+            await this.client.connect();
+        selected ??= await this.client.activeSession?.();
+        const message = explicit?.[2]?.trim() || request.task;
+        const reply = await this.client.direct(message, request.timeoutMs);
+        if (selected) {
+            const current = await this.client.activeSession?.().catch(() => undefined);
+            const entry = current?.id === selected.id && current.host === selected.host ? current : selected;
+            store.remember(entry, message, reply);
+            if (request.sessionId)
+                store.bindings[request.sessionId] = entry;
+            this.persist();
+        }
+        return reply;
+    }
 }
 exports.ChatgptPlugin = ChatgptPlugin;
 var cdp_client_2 = require("./cdp-client");

package/dist/src-ts/plugins/chatgpt/session-store.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatgptSessionStore = void 0;
+exports.validSession = validSession;
+exports.formatSessions = formatSessions;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+function validSession(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const item = value;
+    return ["id", "host", "title"].every(key => typeof item[key] === "string" && Boolean(item[key]))
+        && ["updatedAt", "lastUserMessage", "lastAssistantReply"].every(key => item[key] === undefined || typeof item[key] === "string");
+}
+class ChatgptSessionStore {
+    directory;
+    endpoint;
+    sessions = [];
+    bindings = {};
+    updatedAt = "";
+    writes = Promise.resolve();
+    constructor(directory, endpoint) {
+        this.directory = directory;
+        this.endpoint = endpoint;
+    }
+    async load() {
+        if (!this.directory)
+            return;
+        try {
+            const value = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.join)(this.directory, "chatgpt-sessions.json"), "utf8"));
+            if (value.version !== 1 || value.endpoint !== this.endpoint || !Array.isArray(value.sessions)
+                || !value.sessions.every(validSession) || typeof value.updatedAt !== "string"
+                || !value.bindings || typeof value.bindings !== "object" || Array.isArray(value.bindings)
+                || !Object.values(value.bindings).every(validSession))
+                return;
+            this.sessions = value.sessions.slice(0, 20);
+            this.bindings = Object.fromEntries(Object.entries(value.bindings));
+            this.updatedAt = value.updatedAt;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT" && !(error instanceof SyntaxError))
+                throw error;
+        }
+    }
+    fresh() { return Date.now() - Date.parse(this.updatedAt) < 10 * 60_000; }
+    synchronize(entries) {
+        const previous = this.sessions;
+        const seen = new Set();
+        this.sessions = entries.filter(validSession).filter(item => {
+            const key = JSON.stringify([item.host, item.id]);
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        }).map(item => ({ ...previous.find(old => old.id === item.id && old.host === item.host), ...item }))
+            .sort((a, b) => (b.updatedAt ?? "").localeCompare(a.updatedAt ?? "")).slice(0, 20);
+        this.updatedAt = new Date().toISOString();
+    }
+    remember(entry, user, reply) {
+        const next = { ...entry, lastUserMessage: user.slice(0, 500), lastAssistantReply: reply.slice(0, 500), updatedAt: new Date().toISOString() };
+        this.sessions = [next, ...this.sessions.filter(old => old.id !== entry.id || old.host !== entry.host)].slice(0, 20);
+    }
+    match(query) {
+        const text = query.trim().toLocaleLowerCase();
+        if (!text)
+            return [];
+        const exact = this.sessions.filter(item => item.id === query || item.title.toLocaleLowerCase() === text);
+        return exact.length ? exact : this.sessions.filter(item => `${item.title}\n${item.lastUserMessage ?? ""}`.toLocaleLowerCase().includes(text));
+    }
+    save() {
+        const snapshot = { version: 1, endpoint: this.endpoint, updatedAt: this.updatedAt, sessions: this.sessions, bindings: this.bindings };
+        const text = `${JSON.stringify(snapshot, null, 2)}\n`;
+        const write = this.writes.catch(() => { }).then(async () => {
+            if (!this.directory)
+                return;
+            await (0, promises_1.mkdir)(this.directory, { recursive: true });
+            const file = (0, node_path_1.join)(this.directory, "chatgpt-sessions.json");
+            await (0, promises_1.writeFile)(`${file}.tmp`, text, { mode: 0o600 });
+            await (0, promises_1.rename)(`${file}.tmp`, file);
+        });
+        this.writes = write;
+        return write;
+    }
+    async drain() { await this.writes.catch(() => { }); }
+}
+exports.ChatgptSessionStore = ChatgptSessionStore;
+function formatSessions(entries) {
+    if (!entries.length)
+        return "当前侧栏暂无可用会话。";
+    return entries.map((item, index) => `${index + 1}. ${item.title}\n   主机：${item.host}；会话：${item.id}${item.updatedAt ? `；最近使用：${item.updatedAt}` : ""}`).join("\n");
+}

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

@@ -56,6 +56,8 @@ function createContext(config = {}) {
     strict_1.default.doesNotMatch(String(response.body), /id="plugin-picker"/);
     strict_1.default.match(String(response.body), /id="channel-tabs"/);
     strict_1.default.match(String(response.body), /id="channel-panel"/);
+    strict_1.default.match(String(response.body), /id="plugin-trust"/);
+    strict_1.default.match(String(response.body), /自动升级信任/);
     strict_1.default.match(String(response.body), /id="pair-code"/);
     strict_1.default.doesNotMatch(String(response.body), /id="access-token"|访问令牌/);
     strict_1.default.doesNotMatch(String(response.body), /id="create-aid-form"/);
@@ -67,6 +69,7 @@ function createContext(config = {}) {
     strict_1.default.match(String(script.body), /"已安装"/);
     strict_1.default.match(String(script.body), /\/update/);
     strict_1.default.match(String(script.body), /managementPage/);
+    strict_1.default.match(String(script.body), /\/api\/plugin-trust/);
     strict_1.default.doesNotMatch(String(script.body), /mab-token/);
     strict_1.default.match(String(script.body), /setInterval/);
     strict_1.default.match(String(script.body), /300000/);

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

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -110,3 +143,179 @@ const chatgpt_1 = require("../src-ts/plugins/chatgpt");
         client.close();
     }
 });
+(0, node_test_1.default)("ChatGPT 最近任务走缓存，频道切换后后续消息回到绑定会话", 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(), "chatgpt-memory-"));
+    const sessions = [
+        { id: "s1", host: "h", title: "语音插件", updatedAt: "2026-10-13T00:00:00.000Z" },
+        { id: "s2", host: "h", title: "远程测试", updatedAt: "2026-10-13T00:00:00.000Z" },
+    ];
+    let selected = sessions[0];
+    let lists = 0;
+    const sent = [];
+    const switched = [];
+    const client = { connect: async () => { }, close() { }, connected: () => true,
+        listSessions: async () => { lists++; return sessions; },
+        activeSession: async () => selected,
+        switchSession: async (entry) => { selected = entry; switched.push(entry.id); },
+        direct: async (text) => { sent.push(`${selected.id}:${text}`); return "收到"; },
+    };
+    const plugin = new chatgpt_1.ChatgptPlugin({ client });
+    const context = { config: {}, dataDir, logger: { info() { }, warn() { }, error() { } } };
+    try {
+        await plugin.activate(context);
+        strict_1.default.match((await plugin.handle({ task: "最近任务", sessionId: "channel-a" })).text, /语音插件/);
+        await plugin.handle({ task: "最近任务", sessionId: "channel-a" });
+        strict_1.default.equal(lists, 1);
+        strict_1.default.deepEqual(sent, []);
+        strict_1.default.match((await plugin.handle({ task: "切换会话：远程测试", sessionId: "channel-a" })).text, /已切换/);
+        await plugin.handle({ task: "继续处理语音插件", sessionId: "channel-b" });
+        await plugin.handle({ task: "检查进度", sessionId: "channel-a" });
+        strict_1.default.equal(sent.at(-1), "s2:检查进度");
+        strict_1.default.ok(switched.includes("s2"));
+        await plugin.deactivate();
+        const second = new chatgpt_1.ChatgptPlugin({ client });
+        await second.activate(context);
+        await second.handle({ task: "最近任务" });
+        strict_1.default.equal(lists, 1);
+        await second.deactivate();
+    }
+    finally {
+        await rm(dataDir, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)("ChatGPT 切换歧义或失败时不发送消息，普通消息不按标题自动切换", async () => {
+    const sessions = [{ id: "a", host: "h", title: "语音接口" }, { id: "b", host: "h", title: "语音测试" }];
+    let sends = 0;
+    const client = { connect: async () => { }, close() { }, connected: () => true,
+        listSessions: async () => sessions, activeSession: async () => undefined,
+        switchSession: async () => { throw new Error("目标不可用"); },
+        direct: async () => { sends++; return "收到"; },
+    };
+    const plugin = new chatgpt_1.ChatgptPlugin({ client });
+    await plugin.activate({ config: {}, logger: { info() { }, warn() { }, error() { } } });
+    strict_1.default.match((await plugin.handle({ task: "继续处理语音" })).text, /多个/);
+    strict_1.default.equal(sends, 0);
+    await strict_1.default.rejects(plugin.handle({ task: "切换会话：语音接口" }), /不可用/);
+    strict_1.default.equal(sends, 0);
+    strict_1.default.equal((await plugin.handle({ task: "语音接口怎么写" })).text, "收到");
+    strict_1.default.equal(sends, 1);
+    await plugin.deactivate();
+});
+(0, node_test_1.default)("ChatGPT 固定 CDP 操作读取侧栏并按主机和 ID 切换，未发送内容阻止切换", async () => {
+    const { runInNewContext } = await Promise.resolve().then(() => __importStar(require("node:vm")));
+    const entries = [{ id: 'a"\\', host: "h1", title: "旧会话" }, { id: 'a"\\', host: "h2", title: "目标会话" }];
+    let selected = 0;
+    const editor = { innerText: "" };
+    const nodes = entries.map((entry, index) => ({
+        getAttribute: (key) => key.endsWith("selected") ? String(index === selected)
+            : key.endsWith("host-id") ? entry.host : key.endsWith("thread-id") ? entry.id : entry.title,
+        click: () => { selected = index; },
+    }));
+    const document = {
+        querySelectorAll: () => nodes,
+        querySelector: (selector) => selector.includes("selected") ? nodes[selected] : selector.includes("composer") ? editor : null,
+    };
+    let onMessage = null;
+    const client = new chatgpt_1.ChatgptCdpClient({
+        fetchImpl: async () => new Response(JSON.stringify([{ type: "page", url: "app://-/index.html", webSocketDebuggerUrl: "ws://localhost:9230/a" }])),
+        webSocketFactory: () => ({
+            set onmessage(fn) { onMessage = fn; },
+            set onopen(fn) { queueMicrotask(fn); },
+            set onclose(_) { }, set onerror(_) { }, close() { },
+            send(raw) {
+                const command = JSON.parse(raw);
+                let result;
+                try {
+                    result = { result: { value: JSON.parse(JSON.stringify(runInNewContext(command.params.expression, { document }))) } };
+                }
+                catch (error) {
+                    result = { exceptionDetails: { text: String(error) } };
+                }
+                queueMicrotask(() => onMessage?.({ data: JSON.stringify({ id: command.id, result }) }));
+            },
+        }),
+    });
+    await client.connect();
+    try {
+        strict_1.default.deepEqual(await client.listSessions(), entries);
+        await client.switchSession(entries[1]);
+        strict_1.default.equal(selected, 1);
+        strict_1.default.deepEqual(await client.activeSession(), entries[1]);
+        editor.innerText = "未发送草稿";
+        await strict_1.default.rejects(client.switchSession(entries[0]), /未发送内容/);
+        strict_1.default.equal(selected, 1);
+    }
+    finally {
+        client.close();
+    }
+});
+(0, node_test_1.default)("ChatGPT 缓存限制容量、可恢复并按连接隔离，损坏或未知版本可重新生成", async () => {
+    const { ChatgptSessionStore } = await Promise.resolve().then(() => __importStar(require("../src-ts/plugins/chatgpt/session-store")));
+    const { mkdtemp, readFile, writeFile, 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 dir = await mkdtemp(join(tmpdir(), "chatgpt-store-"));
+    const file = join(dir, "chatgpt-sessions.json");
+    try {
+        const store = new ChatgptSessionStore(dir, "remote-a");
+        store.synchronize(Array.from({ length: 25 }, (_, i) => ({ id: String(i), host: "h", title: `任务${i}` })));
+        strict_1.default.equal(store.sessions.length, 20);
+        store.remember(store.sessions[2], "HELLO".repeat(200), "回复".repeat(500));
+        await store.save();
+        const loaded = new ChatgptSessionStore(dir, "remote-a");
+        await loaded.load();
+        strict_1.default.equal(loaded.sessions[0].id, "2");
+        strict_1.default.equal(loaded.sessions[0].lastUserMessage?.length, 500);
+        strict_1.default.equal(loaded.match("hello")[0].id, "2");
+        const isolated = new ChatgptSessionStore(dir, "remote-b");
+        await isolated.load();
+        strict_1.default.equal(isolated.sessions.length, 0);
+        const value = JSON.parse(await readFile(file, "utf8"));
+        await writeFile(file, JSON.stringify({ ...value, version: 999 }));
+        const future = new ChatgptSessionStore(dir, "remote-a");
+        await future.load();
+        strict_1.default.equal(future.sessions.length, 0);
+        await writeFile(file, "{broken");
+        const broken = new ChatgptSessionStore(dir, "remote-a");
+        await broken.load();
+        strict_1.default.equal(broken.sessions.length, 0);
+    }
+    finally {
+        await rm(dir, { recursive: true, force: true });
+    }
+});
+(0, node_test_1.default)("ChatGPT 远程断开后仍可查询已保存索引，刷新失败不覆盖缓存", 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 dir = await mkdtemp(join(tmpdir(), "chatgpt-offline-"));
+    let online = true;
+    let calls = 0;
+    const client = { connect: async () => { if (!online)
+            throw new Error("远程不可达"); },
+        close() { }, connected: () => online, direct: async () => "回复",
+        listSessions: async () => { calls++; return [{ id: "s", title: "记住的任务", host: "h" }]; },
+    };
+    const context = { config: {}, dataDir: dir, logger: { info() { }, warn() { }, error() { } } };
+    try {
+        const initial = new chatgpt_1.ChatgptPlugin({ client });
+        await initial.activate(context);
+        await initial.handle({ task: "最近任务" });
+        await initial.deactivate();
+        online = false;
+        const offline = new chatgpt_1.ChatgptPlugin({ client });
+        await offline.activate(context);
+        strict_1.default.equal((await offline.health()).status, "degraded");
+        strict_1.default.match((await offline.handle({ task: "最近任务" })).text, /记住的任务/);
+        strict_1.default.equal(calls, 1);
+        await strict_1.default.rejects(offline.handle({ task: "刷新最近任务" }), /不可达/);
+        strict_1.default.match((await offline.handle({ task: "最近任务" })).text, /记住的任务/);
+        await offline.deactivate();
+    }
+    finally {
+        await rm(dir, { recursive: true, force: true });
+    }
+});

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

@@ -92,6 +92,42 @@ const plugin_manager_1 = require("../src-ts/plugin-manager");
         await server.stop();
     }
 });
+(0, node_test_1.default)("信任管理 API 支持查询、变更和拒绝无效配置", async () => {
+    const root = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "mab-trust-api-"));
+    const previous = process.env.AGENT_BRIDGE_TRUSTED_PACKAGES;
+    try {
+        process.env.AGENT_BRIDGE_TRUSTED_PACKAGES = "";
+        const dir = (0, node_path_1.join)(root, "plugins", "sample");
+        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-sample", version: "1.0.0", _npmUser: { name: "m2lihui" } }));
+        await (0, promises_1.writeFile)((0, node_path_1.join)(dir, "plugin.json"), JSON.stringify({ id: "sample", version: "1.0.0", entry: "index.js", apiVersion: "1", capabilities: [] }));
+        const manager = new plugin_manager_1.PluginManager({ pluginsDir: (0, node_path_1.join)(root, "plugins"), stateDir: (0, node_path_1.join)(root, "state"), publisherResolver: async () => "m2lihui" });
+        await manager.discover();
+        const server = new control_server_1.ControlServer({ manager, host: "127.0.0.1", port: 0 });
+        const address = await server.start();
+        try {
+            const base = `http://${address.host}:${address.port}`;
+            const initial = await (await fetch(`${base}/api/plugin-trust`)).json();
+            strict_1.default.equal(initial.entries.find((entry) => entry.id === "sample").trusted, true);
+            const saved = await fetch(`${base}/api/plugin-trust`, { method: "PATCH", headers: { "content-type": "application/json" }, body: JSON.stringify({ providers: { m2lihui: "deny" }, plugins: { sample: "allow" } }) });
+            strict_1.default.equal(saved.status, 200);
+            const after = await (await fetch(`${base}/api/plugin-trust`)).json();
+            strict_1.default.equal(after.entries.find((entry) => entry.id === "sample").trusted, true);
+            strict_1.default.equal(after.entries.find((entry) => entry.id === "sample").pluginOverride, "allow");
+            strict_1.default.equal((await fetch(`${base}/api/plugin-trust`, { method: "PATCH", headers: { "content-type": "application/json" }, body: JSON.stringify({ providers: { m2lihui: "sometimes" }, plugins: {} }) })).status, 400);
+        }
+        finally {
+            await server.stop();
+        }
+    }
+    finally {
+        if (previous === undefined)
+            delete process.env.AGENT_BRIDGE_TRUSTED_PACKAGES;
+        else
+            process.env.AGENT_BRIDGE_TRUSTED_PACKAGES = previous;
+        await (0, promises_1.rm)(root, { recursive: true, force: true });
+    }
+});
 (0, node_test_1.default)("首选后台端口被占用时回退到可用端口", async () => {
     const occupied = (0, node_net_1.createServer)();
     await new Promise((resolve) => occupied.listen(0, "127.0.0.1", resolve));