mu-agent-bridge 1.0.73 → 1.0.78

package/dist/src-ts/plugin-manager.js

@@ -25,6 +25,7 @@ const desktop_launch_1 = require("./plugins/desktop-launch");
 const workbuddy_1 = require("./plugins/workbuddy");
 const logger = { info() { }, warn() { }, error() { } };
 const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const PLUGIN_UPGRADE_WAIT_MS = 2 * 60 * 60 * 1000;
 class PluginManager {
     options;
     controlUrl;
@@ -220,8 +221,22 @@ class PluginManager {
             if (manifest.id !== id || (0, plugin_catalog_1.resolvePluginId)(packageName, meta.agentBridge.id) !== id || manifest.version !== meta.version)
                 throw new agent_1.AgentError("npm 包插件 ID 或版本不匹配");
             this.validateCandidate(manifest, meta.agentBridge);
-            await this.stop(id, "reload");
-            stopped = true;
+            const deadline = new AbortController();
+            const cancellation = loaded.cancellation;
+            const error = new agent_1.AgentOperationError("PLUGIN_UPGRADE_WAIT_TIMEOUT", "等待旧插件任务结束", new Error("升级已等待两小时，强制结束桥接任务并继续升级"));
+            this.log("info", `插件升级等待旧任务结束：${id}`, { waitMs: PLUGIN_UPGRADE_WAIT_MS, deadline: new Date(Date.now() + PLUGIN_UPGRADE_WAIT_MS).toISOString() }, "插件升级");
+            const timer = setTimeout(() => {
+                this.log("warn", `插件升级等待超时，强制结束桥接任务：${id}`, { code: error.code, waitMs: PLUGIN_UPGRADE_WAIT_MS }, "插件升级");
+                cancellation?.abort(error);
+                deadline.abort(error);
+            }, PLUGIN_UPGRADE_WAIT_MS);
+            try {
+                await this.stop(id, "reload", deadline.signal);
+            }
+            finally {
+                clearTimeout(timer);
+                stopped = !loaded.instance;
+            }
             if (hadPrefix)
                 await (0, promises_1.rename)(prefix, backup);
             await (0, promises_1.rename)(staging, prefix);
@@ -280,12 +295,12 @@ class PluginManager {
         if (!(request.signal instanceof AbortSignal))
             throw new agent_1.AgentError("模型来源请求缺少取消信号");
         // 模型来源只接收最小调用契约，避免把未来扩展字段误传给桌面或 CLI 插件。
-        const result = await loaded.instance.modelProvider.complete({
+        const result = await this.runPluginTask(loaded, request.signal, signal => loaded.instance.modelProvider.complete({
             prompt: request.prompt,
             sessionId: request.sessionId,
             timeoutMs: request.timeoutMs,
-            signal: request.signal,
-        });
+            signal,
+        }));
         if (!result || typeof result.text !== "string" || !result.text.trim() || Buffer.byteLength(result.text) > 1024 * 1024)
             throw new agent_1.AgentError(`模型来源插件“${loaded.record.displayName}”返回空内容或超大响应`);
         return { text: result.text };
@@ -366,7 +381,7 @@ class PluginManager {
         }
         if (loaded.instance) {
             try {
-                await loaded.instance.deactivate("reload");
+                await loaded.instance.deactivate("reload", this.upgrades.has(id) ? { preserveDesktop: true } : undefined);
             }
             catch (error) {
                 this.log("warn", `插件恢复前清理失败：${id}`, { error: error instanceof Error ? error.message : String(error) }, "插件生命周期");
@@ -396,14 +411,12 @@ class PluginManager {
         let instance;
         try {
             instance = await this.load(loaded.record);
+            const cancellation = loaded.cancellation = new AbortController();
+            loaded.tasks = new Set();
+            const http = loaded.http = this.createHttpRegistry(id);
             const dataDir = (0, node_path_1.join)(this.options.stateDir, id);
             await (0, promises_1.mkdir)(dataDir, { recursive: true });
-            const configPath = (0, node_path_1.join)(dataDir, "config.json");
-            let config = {};
-            try {
-                config = JSON.parse(await (0, promises_1.readFile)(configPath, "utf8"));
-            }
-            catch { /* defaults */ }
+            const config = await this.config(id);
             const pluginLogger = {
                 info: (message, fields) => { this.log("info", message, fields, id); this.options.logger?.info(message, fields); if (fields?.direction && typeof fields.text === "string")
                     this.recordMessage(id, fields.direction, fields.text, typeof fields.peer === "string" ? fields.peer : undefined, typeof fields.agentAid === "string" ? fields.agentAid : undefined); },
@@ -414,23 +427,33 @@ class PluginManager {
                 dataDir,
                 config,
                 logger: pluginLogger,
-                http: this.createHttpRegistry(id),
+                http,
                 modelInputGuard: true,
                 callPlugin: async (targetId, request) => {
                     if (targetId === id)
                         throw new agent_1.AgentError(`插件不能调用自身: ${id}`);
                     if (request.management)
                         throw new agent_1.AgentError("插件间调用不能传递管理能力");
-                    return this.handle(targetId, request);
+                    cancellation.signal.throwIfAborted();
+                    if (loaded.cancellation !== cancellation || !loaded.instance)
+                        throw new agent_1.AgentError("插件实例已停止，旧调用已失效");
+                    return this.handle(targetId, { ...request, signal: request.signal ? AbortSignal.any([request.signal, cancellation.signal]) : cancellation.signal });
                 },
                 callModelProvider: async (targetId, request) => {
                     if (targetId === id)
                         throw new agent_1.AgentError(`插件不能调用自身: ${id}`);
-                    return this.completeModelProvider(targetId, request);
+                    cancellation.signal.throwIfAborted();
+                    if (loaded.cancellation !== cancellation || !loaded.instance)
+                        throw new agent_1.AgentError("插件实例已停止，旧调用已失效");
+                    return this.completeModelProvider(targetId, { ...request, signal: AbortSignal.any([request.signal, cancellation.signal]) });
                 },
                 pluginStatus: (targetId) => this.plugins.get(targetId)?.record.status,
                 ingress: {
-                    publish: async (message) => {
+                    publish: message => this.runPluginTask(loaded, undefined, async (signal) => {
+                        if (loaded.cancellation !== cancellation || loaded.instance !== instance)
+                            throw new agent_1.AgentError("通道插件实例已停止，旧调用已失效");
+                        if (loaded.record.status !== "ready")
+                            throw new agent_1.AgentError("通道插件正在停止或尚未就绪，不再接收新任务");
                         if (message.channel !== id)
                             throw new agent_1.AgentError("消息来源与通道插件身份不一致");
                         const trustedChannel = loaded.record.type === "channel" && (id === "aun" || id === "feishu");
@@ -444,7 +467,8 @@ class PluginManager {
                                 throw new agent_1.AgentError("当前通道不支持会话管理");
                             const current = await this.sessions.current(message, target);
                             const result = await this.sessionManagement.command(message.text, { source: current.source, sessionId: current.logicalSessionId });
-                            await message.reply(result);
+                            signal.throwIfAborted();
+                            await (0, agent_1.abortable)(message.reply(result, signal), signal);
                             return;
                         }
                         if (trustedChannel)
@@ -457,15 +481,17 @@ class PluginManager {
                         try {
                             const agentInstance = this.plugins.get(target)?.instance;
                             const control = agentInstance?.sessionOperations?.includes("new")
-                                ? (request) => this.controlSession(target, request)
+                                ? (request) => this.controlSession(target, request, signal)
                                 : undefined;
                             const task = !message.text.trim() && message.attachments?.length ? "请处理收到的附件" : message.text;
                             const forwarded = new Set();
                             const sent = [];
                             const onMessage = async (text) => {
+                                signal.throwIfAborted();
                                 if (!text.trim() || forwarded.has(text))
                                     return;
-                                await message.reply(text);
+                                await (0, agent_1.abortable)(message.reply(text, signal), signal);
+                                signal.throwIfAborted();
                                 forwarded.add(text);
                                 sent.push({ text });
                                 this.recordMessage(target, "reply", text, message.peerId);
@@ -473,9 +499,10 @@ class PluginManager {
                             const response = await this.sessions.run(message, target, async (sessionId, newSession, logicalSessionId) => {
                                 const targetRecord = this.plugins.get(target)?.record;
                                 const config = targetRecord?.type === "agent" && targetRecord.capabilities.includes("management") ? await this.config(target) : undefined;
-                                const ability = trustedChannel && id === "aun" && loaded.instance === instance && loaded.record.status === "ready" && Array.isArray(config?.allowedPeers) && (config.allowedPeers.includes("*") || config.allowedPeers.includes(message.peerId))
-                                    ? this.createRequestManagement(target, message.peerId, source, logicalSessionId) : undefined;
-                                const request = { task, sessionId, onMessage, ...(newSession ? { newSession: true } : {}), ...(message.attachments ? { attachments: message.attachments } : {}), ...(ability ? { management: ability } : {}) };
+                                const ability = trustedChannel && id === "aun" && loaded.instance === instance && loaded.record.status === "ready" && Array.isArray(config?.allowedPeers) && (config.allowedPeers.length === 0 || config.allowedPeers.includes("*") || config.allowedPeers.includes(message.peerId))
+                                    ? this.createRequestManagement(target, message.peerId, source, logicalSessionId, { signal, onMessage, ...(message.replyAttachments ? { attachmentOutput: true } : {}) }) : undefined;
+                                signal.throwIfAborted();
+                                const request = { task, sessionId, signal, onMessage, ...(newSession ? { newSession: true } : {}), ...(message.attachments ? { attachments: message.attachments } : {}), ...(message.replyAttachments ? { attachmentOutput: true } : {}), ...(ability ? { management: ability } : {}) };
                                 const issued = ability ? this.issuedManagement.get(ability) : undefined;
                                 if (issued)
                                     issued.active = true;
@@ -487,14 +514,16 @@ class PluginManager {
                                         issued.active = false;
                                 }
                             }, control);
+                            signal.throwIfAborted();
                             const attachments = response.attachments?.length ? response.attachments : (0, attachments_1.asAttachments)(response.images);
                             (0, attachments_1.validateAttachments)(attachments);
                             if (attachments.length) {
                                 if (!message.replyAttachments) {
-                                    await message.reply("当前通道不支持附件回传");
+                                    await (0, agent_1.abortable)(message.reply("当前通道不支持附件回传", signal), signal);
                                     throw new agent_1.AgentError("当前通道不支持附件回传");
                                 }
-                                await message.replyAttachments(attachments, response.text);
+                                await (0, agent_1.abortable)(message.replyAttachments(attachments, response.text, signal), signal);
+                                signal.throwIfAborted();
                                 sent.push({ text: response.text, attachments });
                                 this.recordMessage(target, "reply", response.text, message.peerId);
                             }
@@ -526,7 +555,7 @@ class PluginManager {
                             else
                                 this.activeIngress.delete(source);
                         }
-                    },
+                    }),
                 },
                 runtime: { controlUrl: this.controlUrl, ports: {
                         qwenwork: Number(process.env.AGENT_BRIDGE_QWEN_CDP_PORT ?? process.env.QWEN_CDP_PORT ?? "9228"),
@@ -542,13 +571,15 @@ class PluginManager {
         catch (error) {
             if (instance) {
                 try {
-                    await instance.deactivate("reload");
+                    await instance.deactivate("reload", this.upgrades.has(id) ? { preserveDesktop: true } : undefined);
                 }
                 catch (cleanupError) {
                     this.log("warn", `插件启动失败后的清理失败：${id}`, { error: cleanupError instanceof Error ? cleanupError.message : String(cleanupError) }, "插件生命周期");
                 }
                 this.unregisterHttpRoutes(id);
             }
+            loaded.http?.unregister();
+            loaded.cancellation?.abort(new agent_1.AgentError("插件启动失败，调用已取消"));
             loaded.instance = undefined;
             loaded.record.status = "failed";
             loaded.record.error = error instanceof Error ? error.message : String(error);
@@ -556,17 +587,44 @@ class PluginManager {
             throw error;
         }
     }
-    async stop(id, reason = "stop") {
+    async stop(id, reason = "stop", deadline) {
         const loaded = this.plugins.get(id);
         if (!loaded)
             throw new agent_1.AgentError(`unknown plugin: ${id}`);
         if (loaded.instance) {
             loaded.record.status = "stopping";
+            const instance = loaded.instance;
+            const stopping = Promise.resolve().then(async () => {
+                if (deadline)
+                    await Promise.allSettled([...(loaded.tasks ?? [])]);
+                await instance.deactivate(reason, deadline ? { preserveDesktop: true } : undefined);
+            });
             try {
-                await loaded.instance.deactivate(reason);
+                try {
+                    await (0, agent_1.abortable)(stopping, deadline);
+                }
+                catch (error) {
+                    if (!deadline?.aborted)
+                        throw error;
+                    let cleanupTimer;
+                    try {
+                        const cleaned = await Promise.race([
+                            stopping.then(() => true, () => false),
+                            new Promise(resolve => { cleanupTimer = setTimeout(() => resolve(false), 5_000); }),
+                        ]);
+                        if (!cleaned)
+                            this.log("warn", `旧插件未完成清理，已隔离并继续升级：${id}`, { code: "PLUGIN_UPGRADE_CLEANUP_TIMEOUT" }, "插件升级");
+                    }
+                    finally {
+                        clearTimeout(cleanupTimer);
+                    }
+                }
             }
             finally {
+                loaded.http?.unregister();
                 this.unregisterHttpRoutes(id);
+                if (deadline)
+                    loaded.cancellation?.abort(new agent_1.AgentError("插件已停止，旧实例调用已取消"));
                 loaded.instance = undefined;
             }
         }
@@ -647,13 +705,31 @@ class PluginManager {
         }
     }
     async setAid(id, aid) { await this.saveConfig(id, { ...await this.config(id), aid }); }
-    async config(id) { if (!this.plugins.has(id))
-        throw new agent_1.AgentError(`unknown plugin: ${id}`); try {
-        return JSON.parse(await (0, promises_1.readFile)((0, node_path_1.join)(this.options.stateDir, id, "config.json"), "utf8"));
+    async config(id) {
+        const loaded = this.plugins.get(id);
+        if (!loaded)
+            throw new agent_1.AgentError(`unknown plugin: ${id}`);
+        let defaults = {};
+        if (loaded.record.manifest.configSchema) {
+            try {
+                const schema = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.resolve)(loaded.record.path, loaded.record.manifest.configSchema), "utf8"));
+                if (schema.default && typeof schema.default === "object" && !Array.isArray(schema.default))
+                    defaults = schema.default;
+            }
+            catch { /* 默认声明不可读时保留已有配置 */ }
+        }
+        try {
+            const saved = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.join)(this.options.stateDir, id, "config.json"), "utf8"));
+            if (!saved || typeof saved !== "object" || Array.isArray(saved))
+                throw new agent_1.AgentError("插件配置必须是对象");
+            return { ...defaults, ...saved };
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return defaults;
+            throw new agent_1.AgentError(`插件 ${id} 的配置无法读取或格式无效`);
+        }
     }
-    catch {
-        return {};
-    } }
     async reloadStrategy(record) { if (!record.manifest.configSchema)
         return "reload"; try {
         const schema = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.resolve)(record.path, record.manifest.configSchema), "utf8"));
@@ -684,26 +760,28 @@ class PluginManager {
             ...await (0, agent_availability_1.agentAvailability)(plugin.id, await this.config(plugin.id), plugin.status),
         })));
     }
-    createRequestManagement(pluginId, peerId, source, logicalSessionId) {
+    createRequestManagement(pluginId, peerId, source, logicalSessionId, output) {
         const issued = { pluginId, instance: this.plugins.get(pluginId)?.instance, active: false };
+        const cancellation = this.plugins.get(pluginId)?.cancellation;
         const checkActive = () => {
             const current = this.plugins.get(pluginId);
             if (!issued.active || !current?.instance || current.instance !== issued.instance)
                 throw new agent_1.AgentError("管理能力请求已结束或已撤销");
+            cancellation?.signal.throwIfAborted();
         };
         const allowed = async (agentId) => {
             checkActive();
             const loaded = this.plugins.get(pluginId);
-            if (!loaded?.instance || loaded.record.status !== "ready" || !loaded.record.capabilities.includes("management"))
+            if (!loaded?.instance || (loaded.record.status !== "ready" && !(loaded.record.status === "stopping" && this.upgrades.has(pluginId))) || !loaded.record.capabilities.includes("management"))
                 throw new agent_1.AgentError("当前插件未声明管理能力或未就绪");
             const config = await this.config(pluginId);
             checkActive();
-            const peers = Array.isArray(config.allowedPeers) ? config.allowedPeers : [];
-            if (!peers.includes("*") && !peers.includes(peerId))
+            const peers = config.allowedPeers;
+            if (!Array.isArray(peers) || (peers.length > 0 && !peers.includes("*") && !peers.includes(peerId)))
                 throw new agent_1.AgentError("当前 AUN 身份无权使用管理能力");
             if (agentId !== undefined) {
-                const agents = Array.isArray(config.allowedAgents) ? config.allowedAgents : [];
-                if (!agents.includes(agentId))
+                const agents = config.allowedAgents;
+                if (!Array.isArray(agents) || (agents.length > 0 && !agents.includes("*") && !agents.includes(agentId)))
                     throw new agent_1.AgentError("目标 Agent 不在允许列表中");
             }
             return { loaded, config };
@@ -739,7 +817,7 @@ class PluginManager {
                     const aids = identitiesAvailable
                         ? Object.entries(bindings).filter(([aid, bound]) => /^[a-z0-9][a-z0-9_-]{2,63}\.[a-z0-9-]+(?:\.[a-z0-9-]+)+$/.test(aid) && agentIds.has(bound) && bound === record.id).map(([aid]) => aid).sort()
                         : [];
-                    const callable = Boolean(latest?.instance) && latestRecord.type === "agent" && latestRecord.id !== pluginId && latestRecord.status === "ready" && availability.available && !latestRecord.capabilities.includes("management") && (Array.isArray(config.allowedAgents) && config.allowedAgents.includes(record.id));
+                    const callable = Boolean(latest?.instance) && latestRecord.type === "agent" && latestRecord.id !== pluginId && latestRecord.status === "ready" && availability.available && !latestRecord.capabilities.includes("management") && (Array.isArray(config.allowedAgents) && (config.allowedAgents.length === 0 || config.allowedAgents.includes("*") || config.allowedAgents.includes(record.id)));
                     result.push({ id: latestRecord.id, displayName: latestRecord.displayName, status: latestRecord.status, ...availability, reason: !identitiesAvailable && !availability.reason ? "AUN 身份数据不可用" : availability.reason, capabilities: [...latestRecord.capabilities], aids, callable });
                 }
                 await allowed();
@@ -759,14 +837,35 @@ class PluginManager {
                 const sessionId = id === "workbuddy" && target.instance?.sessionOperations?.includes("new")
                     ? `management-${(0, node_crypto_1.createHash)("sha256").update(`${logicalSessionId}\0${id}`).digest("hex")}`
                     : undefined;
-                const response = await this.handle(id, { task, ...(sessionId ? { sessionId } : {}) });
+                const signal = output?.signal ? AbortSignal.any([output.signal, cancellation.signal]) : cancellation.signal;
+                const response = await this.handle(id, { task, ...output, signal, ...(sessionId ? { sessionId } : {}) });
                 if (loaded.instance !== this.plugins.get(pluginId)?.instance)
                     throw new agent_1.AgentError("管理插件已重载");
                 await allowed(id);
                 return response;
             },
-            listAunIdentities: async () => { await allowed(); const aun = this.plugins.get("aun")?.instance; if (!aun?.aunManagement)
-                throw new agent_1.AgentError("AUN 身份管理不可用"); const result = await aun.aunManagement.list(); await allowed(); return result; },
+            listAunIdentities: async () => {
+                await allowed();
+                const aun = this.plugins.get("aun")?.instance;
+                let result;
+                if (aun?.aunManagement)
+                    result = await aun.aunManagement.list();
+                else if (aun?.identity) {
+                    // 旧 AUN 只有身份列表和健康绑定；兼容只读查询，不开放创建或绑定操作。
+                    const groups = await aun.identity.list();
+                    const health = await aun.health();
+                    const aidPattern = /^[A-Za-z0-9][A-Za-z0-9._-]{2,255}$/;
+                    const aids = [...new Set([...groups.evolcore, ...groups.muAgentBridge, ...(groups.localMuAgentBridge ?? [])])].filter(aid => aidPattern.test(aid)).sort();
+                    const raw = health.details?.bindings;
+                    const bindings = raw && typeof raw === "object" && !Array.isArray(raw)
+                        ? Object.fromEntries(Object.entries(raw).filter(([aid, id]) => aidPattern.test(aid) && typeof id === "string" && /^[a-z0-9][a-z0-9-]{0,63}$/.test(id))) : {};
+                    result = { aids, bindings };
+                }
+                else
+                    throw new agent_1.AgentError("AUN 身份管理不可用");
+                await allowed();
+                return result;
+            },
             createAunIdentity: async (input) => { await allowed(); const aun = this.plugins.get("aun")?.instance; if (!aun?.aunManagement)
                 throw new agent_1.AgentError("AUN 身份管理不可用"); const result = await aun.aunManagement.create(input); await allowed(); return result; },
             bindAunIdentity: async (input) => { await allowed(input.agentId); const target = this.plugins.get(input.agentId); if (!target?.instance || target.record.type !== "agent" || target.record.status !== "ready")
@@ -784,6 +883,20 @@ class PluginManager {
     async health(id) { const loaded = this.plugins.get(id); if (!loaded)
         throw new agent_1.AgentError(`unknown plugin: ${id}`); if (!loaded.instance)
         return { status: loaded.record.status }; return loaded.instance.health(); }
+    async runPluginTask(loaded, upstream, work) {
+        const local = loaded.cancellation.signal;
+        const signal = upstream ? AbortSignal.any([upstream, local]) : local;
+        signal.throwIfAborted();
+        const task = (0, agent_1.abortable)(work(signal), signal);
+        const tasks = loaded.tasks;
+        tasks.add(task);
+        try {
+            return await task;
+        }
+        finally {
+            tasks.delete(task);
+        }
+    }
     async handle(id, request) {
         const loaded = this.plugins.get(id);
         if (!loaded?.instance || loaded.record.status !== "ready") {
@@ -803,17 +916,22 @@ class PluginManager {
         (0, attachments_1.validateAttachments)(request.attachments);
         if (request.attachments?.length && !loaded.instance.attachmentInput)
             throw new agent_1.AgentError(`插件 ${id} 不支持接收附件`);
-        return loaded.instance.handle(request);
+        const instance = loaded.instance;
+        return this.runPluginTask(loaded, request.signal, signal => instance.handle({
+            ...request, signal,
+            ...(request.onMessage ? { onMessage: async (text) => { signal.throwIfAborted(); await request.onMessage(text); } } : {}),
+        }));
     }
-    async controlSession(id, request) {
+    async controlSession(id, request, signal) {
         const loaded = this.plugins.get(id);
         if (!loaded?.instance || loaded.record.status !== "ready")
             throw new agent_1.AgentError(`插件 ${id} 未就绪，无法控制会话`);
         if (!loaded.instance.sessionOperations?.includes(request.operation))
             throw new agent_1.AgentError(`插件 ${id} 不支持新建会话`);
-        const response = loaded.instance.controlSession
-            ? await loaded.instance.controlSession(request)
-            : { text: `${loaded.record.displayName} 已创建新会话`, sessionId: request.sessionId };
+        const instance = loaded.instance;
+        const response = await this.runPluginTask(loaded, signal, async () => instance.controlSession
+            ? instance.controlSession(request)
+            : { text: `${loaded.record.displayName} 已创建新会话`, sessionId: request.sessionId });
         if (typeof response.sessionId !== "string" || !response.sessionId.trim())
             throw new agent_1.AgentError("插件未返回有效的新会话标识，原会话绑定保持不变");
         return response;
@@ -831,18 +949,25 @@ class PluginManager {
         return true;
     }
     createHttpRegistry(pluginId) {
+        const disposers = new Set();
+        let closed = false;
+        const check = () => { if (closed)
+            throw new agent_1.AgentError("插件 HTTP 注册表已停止"); };
+        const remember = (dispose) => { disposers.add(dispose); return () => { dispose(); disposers.delete(dispose); }; };
         return {
             register: (routeOrMethod, pathOrHandler, maybeHandler) => {
+                check();
                 if (typeof routeOrMethod === "object")
-                    return this.registerHttpRoute(pluginId, routeOrMethod.method, routeOrMethod.path, routeOrMethod.handler);
+                    return remember(this.registerHttpRoute(pluginId, routeOrMethod.method, routeOrMethod.path, routeOrMethod.handler));
                 if (typeof pathOrHandler === "string" && maybeHandler)
-                    return this.registerHttpRoute(pluginId, routeOrMethod, pathOrHandler, maybeHandler);
+                    return remember(this.registerHttpRoute(pluginId, routeOrMethod, pathOrHandler, maybeHandler));
                 if (typeof pathOrHandler === "function")
-                    return this.registerLegacyRoute(pluginId, routeOrMethod, pathOrHandler);
+                    return remember(this.registerLegacyRoute(pluginId, routeOrMethod, pathOrHandler));
                 throw new agent_1.AgentError("invalid plugin HTTP route");
             },
-            registerRoute: (path, handler) => this.registerLegacyRoute(pluginId, path, handler),
-            unregister: () => this.unregisterHttpRoutes(pluginId),
+            registerRoute: (path, handler) => { check(); return remember(this.registerLegacyRoute(pluginId, path, handler)); },
+            unregister: () => { closed = true; for (const dispose of disposers)
+                dispose(); disposers.clear(); },
         };
     }
     registerHttpRoute(pluginId, method, path, handler) {
@@ -854,8 +979,9 @@ class PluginManager {
         const existing = this.httpRoutes.get(key);
         if (existing)
             throw new agent_1.AgentError(`HTTP route already registered: ${normalizedMethod} ${normalizedPath}`);
-        this.httpRoutes.set(key, { pluginId, method: normalizedMethod, path: normalizedPath, handler });
-        return () => { if (this.httpRoutes.get(key)?.pluginId === pluginId)
+        const route = { pluginId, method: normalizedMethod, path: normalizedPath, handler };
+        this.httpRoutes.set(key, route);
+        return () => { if (this.httpRoutes.get(key) === route)
             this.httpRoutes.delete(key); };
     }
     registerLegacyRoute(pluginId, path, handler) {
@@ -876,8 +1002,9 @@ class PluginManager {
                     response.setHeader(name, value);
             response.end(result?.body ?? "");
         };
-        this.httpRoutes.set(key, { pluginId, method: "*", path: normalizedPath, handler: nativeHandler });
-        return () => { if (this.httpRoutes.get(key)?.pluginId === pluginId)
+        const route = { pluginId, method: "*", path: normalizedPath, handler: nativeHandler };
+        this.httpRoutes.set(key, route);
+        return () => { if (this.httpRoutes.get(key) === route)
             this.httpRoutes.delete(key); };
     }
     unregisterHttpRoutes(pluginId) { for (const [key, route] of this.httpRoutes)

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

@@ -5,7 +5,7 @@ const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const MANIFEST = {
     id: "abweb",
-    version: "1.0.13",
+    version: "1.0.15",
     displayName: "Agent Bridge Web",
     entry: "dist/index.js",
     apiVersion: "1",

package/dist/src-ts/plugins/abweb/public/app.js

@@ -219,7 +219,8 @@
         versionsNode.replaceChildren(...entries.map((entry) => {
             const row = document.createElement("div");
             row.className = "version-row";
-            row.textContent = `${entry.packageName} · 当前 ${entry.currentVersion} · ${entry.latestVersion ? `最新 ${entry.latestVersion}` : "最新版本未知"} · ${entry.state}${entry.error ? ` · ${entry.error}` : ""}`;
+            const state = entry.state === "unpublished" ? "未发布" : entry.state;
+            row.textContent = `${entry.packageName} · 当前 ${entry.currentVersion} · ${entry.latestVersion ? `最新 ${entry.latestVersion}` : "最新版本未知"} · ${state}${entry.error ? ` · ${entry.error}` : ""}`;
             return row;
         }));
         if (!entries.length)
@@ -427,8 +428,8 @@
         node("#assistant-api-key").value = "";
         node("#assistant-api-key").placeholder = config.apiKey ? "已配置，留空保留" : "可选，本地免认证服务可留空";
         node("#assistant-timeout").value = String(config.timeoutMs ?? 120000);
-        node("#assistant-allowed-peers").value = (config.allowedPeers ?? []).join("\n");
-        node("#assistant-allowed-agents").value = (config.allowedAgents ?? []).join("\n");
+        node("#assistant-allowed-peers").value = config.allowedPeers?.includes("*") ? "" : (config.allowedPeers ?? []).join("\n");
+        node("#assistant-allowed-agents").value = config.allowedAgents?.includes("*") ? "" : (config.allowedAgents ?? []).join("\n");
         node("#assistant-config-error").hidden = true;
         node("#assistant-config-dialog").showModal();
     }
@@ -457,7 +458,8 @@
         if (timeoutMs !== Number(assistantOriginal.timeoutMs ?? 120000))
             body.timeoutMs = timeoutMs;
         for (const [field, selector] of [["allowedPeers", "#assistant-allowed-peers"], ["allowedAgents", "#assistant-allowed-agents"]]) {
-            const values = [...new Set(node(selector).value.split(/[\s,，]+/).filter(Boolean))];
+            const entries = [...new Set(node(selector).value.split(/[\s,，]+/).filter(Boolean))];
+            const values = entries.includes("*") ? [] : entries;
             if (JSON.stringify(values) !== JSON.stringify(assistantOriginal[field]))
                 body[field] = values;
         }
@@ -519,8 +521,8 @@
     node("#check-versions").onclick = () => void request("/api/versions/check", "POST", {}).then(() => load()).catch((cause) => error(String(cause)));
     node("#save-update-policy").onclick = () => void request("/api/update-policy", "PATCH", { mode: policyNode.value }).then(() => load()).catch((cause) => error(String(cause)));
     node("#save-plugin-trust").onclick = () => { const button = node("#save-plugin-trust"); button.disabled = true; trustStatusNode.textContent = "正在保存…"; void request("/api/plugin-trust", "PATCH", pluginTrustConfig).then(() => { pluginTrustDirty = false; trustStatusNode.textContent = "信任设置已保存"; return load(false); }).catch((cause) => { trustStatusNode.textContent = String(cause); }).finally(() => { button.disabled = false; }); };
-    node("#update-core").onclick = () => { if (confirm("确认升级后台并自动重启？"))
-        void request("/api/update", "POST", {}).then(() => { error("后台正在升级，页面将在几秒后恢复"); }).catch((cause) => error(String(cause))); };
+    node("#update-core").onclick = () => { if (confirm("确认检查后台更新？有更高版本时将升级并自动重启"))
+        void request("/api/update", "POST", {}).then(() => { error("后台正在检查更新，有更高版本时升级并重启；结果请查看运行日志"); }).catch((cause) => error(String(cause))); };
     node("#pair-button").onclick = () => {
         const code = pairCodeNode.value.trim();
         if (!/^\d{6}$/.test(code))

package/dist/src-ts/plugins/abweb/public/index.html

@@ -39,9 +39,9 @@
       <label for="assistant-endpoint">OpenAI 兼容地址</label><input id="assistant-endpoint" type="url" placeholder="http://127.0.0.1:11434/v1/chat/completions">
       <label for="assistant-api-key">API 密钥（留空保留已有密钥）</label><input id="assistant-api-key" type="password" autocomplete="new-password">
       <label for="assistant-timeout">模型超时（毫秒）</label><input id="assistant-timeout" type="number" min="1000" max="120000" required>
-      <label for="assistant-allowed-peers">允许使用助理的 Peer AID（每行一个）</label><textarea id="assistant-allowed-peers" rows="3" placeholder="example.agentid.cn"></textarea>
-      <label for="assistant-allowed-agents">允许调用的 Agent 插件 ID（每行一个）</label><textarea id="assistant-allowed-agents" rows="3" placeholder="workbuddy&#10;dsh"></textarea>
-      <p class="muted">插件来源沿用客户端登录及当前模型；留空白名单表示不授权。AID 关联请在 Channel 设置中完成。</p>
+      <label for="assistant-allowed-peers">允许使用助理的 Peer AID（每行一个，留空接受所有）</label><textarea id="assistant-allowed-peers" rows="3" placeholder="留空接受所有 Peer"></textarea>
+      <label for="assistant-allowed-agents">允许调用的 Agent 插件 ID（每行一个，留空允许所有）</label><textarea id="assistant-allowed-agents" rows="3" placeholder="留空允许所有已就绪 Agent"></textarea>
+      <p class="muted">默认留空，接受所有 Peer 并允许调用所有已就绪的普通 Agent；填写具体名单后才限制。插件来源沿用客户端登录及当前模型，AID 关联请在 Channel 设置中完成。</p>
       <p id="assistant-config-error" class="error" role="alert" hidden></p>
       <div><button id="assistant-config-save" type="submit">保存配置</button><button id="assistant-config-cancel" type="button">取消</button></div>
     </form>

package/dist/src-ts/plugins/aun/attachments.js

@@ -250,30 +250,12 @@ async function uploadAunAttachments(client, ownerAid, peerAid, items) {
         const objectKey = `shared/${(0, node_crypto_1.randomUUID)()}/${filename.replace(/[^A-Za-z0-9._-]/g, "_")}`;
         const sha256 = digest(item.data);
         const contentType = item.contentType.toLowerCase();
-        // 视频播放器不携带 AID 凭据，沿用 EvolCore 的标准可读对象上传方式。
-        const video = contentType.startsWith("video/");
+        // 会话媒体控件不携带 AID 凭据，沿用 ec msg 的标准可读对象上传方式。
         const ref = { ownerAid, bucket: "default", objectKey, filename, contentType, sizeBytes: item.data.byteLength, sha256 };
-        const uploaded = await client.storage.writeBytes(`/${objectKey}`, item.data, { contentType, public: video, overwrite: video })
+        const uploaded = await client.storage.writeBytes(`/${objectKey}`, item.data, { contentType, public: true, overwrite: true })
             .catch(error => { throw new agent_1.AgentOperationError("AUN_FS_UPLOAD_FAILED", `上传 AUN FS 文件“${filename}”`, error); });
         checkedMetadata({ ...uploaded, size: uploaded.size ?? uploaded.size_bytes ?? item.data.byteLength }, ref);
-        if (video) {
-            result.push({ owner_aid: ownerAid, object_key: objectKey, filename, content_type: contentType, size_bytes: item.data.byteLength, sha256 });
-            continue;
-        }
-        const share = await client.storage.lowlevel.createShareLink({ owner: ownerAid, bucket: "default", objectKey, allowedAids: [peerAid], expireInSeconds: 86400 })
-            .catch(error => { throw new agent_1.AgentOperationError("AUN_FS_SHARE_FAILED", `创建 AUN FS 文件“${filename}”的接收方授权`, error); });
-        if (share.owner_aid && share.owner_aid !== ownerAid || share.bucket && share.bucket !== "default" || share.object_key && share.object_key !== objectKey)
-            throw new Error("AUN 附件分享对象不一致");
-        if (share.allowed_aids !== undefined && (!Array.isArray(share.allowed_aids) || share.allowed_aids.length !== 1 || share.allowed_aids[0] !== peerAid))
-            throw new Error("AUN 附件分享授权不一致");
-        const shareId = typeof share.share_id === "string" && /^[A-Za-z0-9]{10}$/.test(share.share_id) ? share.share_id : undefined;
-        if (share.share_id !== undefined && !shareId)
-            throw new Error("AUN 附件分享标识无效");
-        const url = typeof share.path_url === "string" && share.path_url ? share.path_url : shareId ? `https://${ownerAid}/${objectKey}?t=${shareId}` : "";
-        const token = url ? pathToken(url, ownerAid, objectKey) : undefined;
-        if (!token || shareId && shareId !== token)
-            throw new Error("AUN 附件分享链接无效");
-        result.push({ owner_aid: ownerAid, bucket: "default", object_key: objectKey, url, filename, content_type: item.contentType, size_bytes: item.data.byteLength, sha256 });
+        result.push({ owner_aid: ownerAid, object_key: objectKey, filename, content_type: contentType, size_bytes: item.data.byteLength, sha256 });
     }
     return result;
 }