mu-agent-bridge 1.0.29 → 1.0.31

package/README.md

@@ -22,10 +22,12 @@ OpenAI 兼容 API 为 `/v1/models` 和 `/v1/chat/completions`。管理页面位
 `http://<Windows 主机 IP>:26107/abweb/`。页面使用一次性配置码配对后管理插件；请只在可信网络使用。
 如果 26107 被旧的 mab 进程占用，可执行 `mab restart`；Windows 会扫描并结束同一 CLI 安装路径的全部旧 daemon，并重新启动。`mab stop` 只停止 daemon，
 `mab update` 会结束旧 daemon、安装最新核心包并启动新版本。不会把自己的旧进程误当成新的 daemon，也不会因此默认改用临时端口。
-已有 AID 的连接状态由 AUN 插件自己建立和查询，只有当前已连接的身份才能关联 Agent。
-AUN 插件通过 SDK 枚举 EvolCore 的本地 AID，并逐个建立连接；ABWeb 只展示已连接 AID，并按 EvolCore 与 mu-agent-bridge 分组，未连接身份不显示。状态检测不调用 `ec agent list/show`。
+已有 AID 的连接状态由 AUN 插件查询，只有当前已连接的身份才能关联 Agent。
+本机 AID 来自 AUN 插件自身的密钥库，不依赖 `ec` 命令，`ec stop` 后仍会显示。
+未配置 `aun_path` 时密钥库默认使用共享 AUN 目录（`AUN_HOME`/`EVOLCORE_HOME` 或
+`~/.evolcore`），已注册的 AID 无需迁移；插件启动时自动连接密钥库中的全部 AID。
 创建新 AID 必须填写 Owner AID，并安装、启动 AUN 插件；创建与通信由该插件完成。
-本工程创建的身份由 AUN 插件保持连接并收发消息；EvolCore 来源身份只用于连接状态检测，不订阅消息，避免重复收信。将 EvolCore 身份关联到 Agent 时，AUN 插件仍执行既有 `ec agent set/reload` 路由配置；该命令不用于检测连接状态。
+已连接身份保存在 AUN 插件自身的密钥库和配置中。关联 AID 到 Agent 时，由 AUN 插件直接保持连接并转发来信和回复，不再执行 `ec agent set/reload`。
 其他 Agent 插件可关联 AUN 插件自己创建的身份，由通道直接转发来信和回复。
 Windows 可运行 `start-mab.ps1` 注册并启动登录时自动运行的计划任务；令牌保存在
 `%USERPROFILE%\.mab\token.txt`，页面输入该令牌即可使用管理 API。
@@ -139,4 +141,20 @@ Windows 路径时，可设置 `DSH_INSTALL_DIR`。
 
 ## AUN 身份管理
 
-创建、连接、关联和 AUN 通信统一由独立 `agent-bridge-aun` 插件完成。未安装并启动该插件时，ABWeb 禁用创建 AID；页面仅展示已连接身份。详细规则见 [AUN 插件与 AID 身份管理](docs/aun-plugin-identities.md)。
+创建、连接、关联和 AUN 通信统一由独立 `agent-bridge-aun` 插件完成。安装并启动 AUN 后，在 ABWeb 的“通道 → AUN”创建或选择身份，再将已连接 AID 关联到已启动的 Agent；用 `mab status` 查看状态。Owner AID 仅作本地归属配置，不代表 AUN Owner 关系已激活。完整步骤见 [AUN 插件与 AID 身份管理](docs/aun-plugin-identities.md)；给 Codex、Claude Code 直接执行的 CLI 说明见 [使用说明](使用说明.md)。
+
+### 飞书凭据与办公 Agent 关联
+
+在 ABWeb 的“飞书通道 → 手动配置凭据”中填写 App ID、App Secret，并选择“关联办公 Agent”。Secret 使用密码框显示；已保存的密钥保持掩码，不通过状态接口返回。WorkBuddy、千问办公、豆包根据运行后台的机器上是否存在可执行文件检测，文件缺失或插件未就绪的选项置灰。自定义安装位置请在对应插件配置中填写 `executablePath`。
+
+也可以使用 CLI，Secret 在命令执行后隐藏输入，不写在命令参数中：
+
+```bash
+mab feishu configure cli_你的应用ID --agent workbuddy
+mab feishu agents
+mab feishu list
+mab feishu bind cli_你的应用ID workbuddy
+mab feishu unbind cli_你的应用ID
+```
+
+`configure` 保存凭据及可选关联后，需要在 ABWeb 重载飞书插件以连接机器人。非交互终端请使用网页密码框；不要把 Secret 写进命令行、脚本或仓库。

package/dist/src-ts/agent-availability.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentAvailability = agentAvailability;
+const desktop_launch_1 = require("./plugins/desktop-launch");
+const workbuddy_1 = require("./plugins/workbuddy");
+async function agentAvailability(id, config, status) {
+    const configured = typeof config.executablePath === "string" ? config.executablePath : undefined;
+    const executable = id === "workbuddy" ? (0, workbuddy_1.findExecutable)(configured)
+        : id === "qwenwork" ? await (0, desktop_launch_1.findWindowsExecutable)("QwenWorkCN.exe", configured)
+            : id === "doubao" ? await (0, desktop_launch_1.findWindowsExecutable)("Doubao.exe", configured) : true;
+    if (!executable)
+        return { available: false, reason: "未找到可执行文件" };
+    return { available: status === "ready", reason: status === "ready" ? "" : "插件未就绪" };
+}

package/dist/src-ts/channel-sessions.js

@@ -4,6 +4,7 @@ exports.ChannelSessions = void 0;
 const node_crypto_1 = require("node:crypto");
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
+const unsupportedCommands = /^(?:\/(?:s|session|slist|name|rename|del|status|stop|pause|resume|compact|fork|rewind|rw|repair|renew))(?:[ \t]+[^\r\n]*)?$/;
 class ChannelSessions {
     directory;
     sessions = {};
@@ -21,7 +22,7 @@ class ChannelSessions {
                     throw new Error("通道会话文件格式无效");
                 for (const [key, value] of Object.entries(data)) {
                     const entry = value;
-                    if (!entry || typeof entry.sessionId !== "string" || typeof entry.source !== "string" || typeof entry.agentPlugin !== "string" || typeof entry.updatedAt !== "string")
+                    if (!entry || typeof entry.sessionId !== "string" || typeof entry.source !== "string" || typeof entry.agentPlugin !== "string" || typeof entry.updatedAt !== "string" || (entry.newSession !== undefined && typeof entry.newSession !== "boolean"))
                         throw new Error("通道会话记录无效");
                     this.sessions[key] = entry;
                 }
@@ -34,15 +35,37 @@ class ChannelSessions {
         await this.loaded;
     }
     async list() { await this.load(); return Object.values(this.sessions).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)); }
-    async run(message, agentPlugin, call) {
+    async run(message, agentPlugin, call, control) {
         const source = JSON.stringify([message.channel, message.recipientId || "", message.chatId || "", message.peerId, message.threadId || ""]);
+        const command = message.text?.trim().match(/^\/new(?:[ \t]+([^\r\n]+))?$/);
+        const unsupported = message.text?.trim().match(unsupportedCommands);
+        if (unsupported)
+            return { text: `会话命令 ${unsupported[0].split(/[ \t]/, 1)[0]} 本期暂不支持` };
+        if (/^\/clear(?:[ \t]+[^\r\n]*)?$/.test(message.text?.trim() ?? ""))
+            return { text: "/clear 已移除，请使用 /new 新建会话" };
+        if (message.text?.trim() === "/help")
+            return { text: [
+                    control ? "/new [名称]：新建并切换会话" : "/new [名称]：当前 Agent 插件不支持新建会话",
+                    "话题中不支持 /new；/renew 及其他会话命令当前暂不支持",
+                    "/clear 已移除，请使用 /new",
+                ].join("\n") };
+        if (command && message.threadId)
+            return { text: "话题中不支持 /new，请使用 /renew 轮换话题会话（当前尚未支持）" };
+        if (command && !control)
+            return { text: "当前 Agent 插件不支持新建会话" };
+        if (command && this.pending.has(source))
+            throw new Error("当前会话正在执行任务，请等待完成后再新建会话");
         const previous = this.pending.get(source) ?? Promise.resolve();
         const turn = previous.catch(() => { }).then(async () => {
             await this.load();
             const entry = this.sessions[source];
-            const sessionId = entry?.agentPlugin === agentPlugin ? entry.sessionId : (0, node_crypto_1.randomUUID)();
-            const response = await call(sessionId);
-            const next = { source, agentPlugin, sessionId: response.sessionId || sessionId, updatedAt: new Date().toISOString() };
+            const sessionId = !command && entry?.agentPlugin === agentPlugin ? entry.sessionId : (0, node_crypto_1.randomUUID)();
+            const response = command
+                ? await control({ operation: "new", sessionId, ...(command[1]?.trim() ? { name: command[1].trim() } : {}) })
+                : await call(sessionId, !entry || entry.agentPlugin !== agentPlugin || entry.newSession === true);
+            if (command && (typeof response.sessionId !== "string" || !response.sessionId.trim()))
+                throw new Error("插件未返回有效的新会话标识，原会话绑定保持不变");
+            const next = { source, agentPlugin, sessionId: response.sessionId || sessionId, updatedAt: new Date().toISOString(), ...(command ? { newSession: true } : {}) };
             const save = this.writes.catch(() => { }).then(async () => {
                 const snapshot = { ...this.sessions, [source]: next };
                 await (0, promises_1.mkdir)(this.directory, { recursive: true });

package/dist/src-ts/cli-commands.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CORE_HELP = void 0;
+exports.resolveLocalControlHost = resolveLocalControlHost;
+exports.controlUrl = controlUrl;
+exports.runPluginCommand = runPluginCommand;
+exports.runCoreHelp = runCoreHelp;
+const secret_input_1 = require("./secret-input");
+const node_http_1 = require("node:http");
+const MAX_BODY_BYTES = 1024 * 1024;
+const PLUGIN_ID = /^[a-z][a-z0-9-]{1,63}$/;
+const RESERVED_COMMANDS = new Set(["start", "stop", "restart", "status", "pair", "update", "help"]);
+exports.CORE_HELP = "用法：mab --help\n      mab start | stop | restart | update | status | pair\n      mab --self-test <任务> | --serve\n      mab <插件 ID> help [命令]\n      mab <插件 ID> <命令> [参数...] [--json]\n";
+class CliError extends Error {
+    exitCode;
+    constructor(message, exitCode = 1) {
+        super(message);
+        this.exitCode = exitCode;
+    }
+}
+function resolveLocalControlHost(host) {
+    if (host === "0.0.0.0")
+        return "127.0.0.1";
+    if (host === "::")
+        return "::1";
+    if (host === "127.0.0.1" || host === "::1" || host === "localhost")
+        return host;
+    throw new CliError("动态 CLI 仅支持本机 loopback 控制地址；请将 AGENT_BRIDGE_HOST 设置为 127.0.0.1、localhost、::1 或通配地址");
+}
+function controlUrl(host, port) {
+    const localHost = resolveLocalControlHost(host);
+    return `http://${localHost.includes(":") ? `[${localHost}]` : localHost}:${port}`;
+}
+function object(value) { return value !== null && typeof value === "object" && !Array.isArray(value); }
+function extractOptions(args) {
+    const argv = [];
+    let json = false;
+    let terminated = false;
+    for (const argument of args) {
+        if (!terminated && argument === "--json") {
+            json = true;
+            continue;
+        }
+        if (argument === "--")
+            terminated = true;
+        argv.push(argument);
+    }
+    return { argv, json };
+}
+function output(result, exitCode, json) {
+    if (json)
+        return { exitCode, stdout: `${JSON.stringify(result)}\n`, stderr: "" };
+    return { exitCode, stdout: exitCode === 0 ? `${result.message}\n` : "", stderr: exitCode === 0 ? "" : `${result.message}\n` };
+}
+async function requestJson(port, path, options, payload) {
+    const body = payload === undefined ? undefined : JSON.stringify(payload);
+    if (body && Buffer.byteLength(body) > MAX_BODY_BYTES)
+        throw new CliError("命令请求超过 1 MiB 上限");
+    return new Promise((resolve, reject) => {
+        const headers = { accept: "application/json" };
+        const token = options.token ?? process.env.AGENT_BRIDGE_TOKEN;
+        if (token)
+            headers.authorization = `Bearer ${token}`;
+        if (body !== undefined) {
+            headers["content-type"] = "application/json";
+            headers["content-length"] = Buffer.byteLength(body);
+        }
+        const req = (0, node_http_1.request)({ host: resolveLocalControlHost(options.host ?? "127.0.0.1"), port, path, method: body === undefined ? "GET" : "POST", headers }, (res) => {
+            const chunks = [];
+            let bytes = 0;
+            res.on("data", (chunk) => {
+                bytes += chunk.length;
+                if (bytes > MAX_BODY_BYTES) {
+                    req.destroy(new CliError("后台响应超过 1 MiB 上限"));
+                    return;
+                }
+                chunks.push(chunk);
+            });
+            res.on("error", reject);
+            res.on("end", () => {
+                try {
+                    resolve({ status: res.statusCode ?? 500, value: JSON.parse(Buffer.concat(chunks).toString("utf8")) });
+                }
+                catch {
+                    reject(new CliError("后台响应不是有效 JSON"));
+                }
+            });
+        });
+        const timer = setTimeout(() => req.destroy(new CliError("连接后台超时；请检查 daemon 状态")), options.timeoutMs ?? 10_000);
+        req.on("close", () => clearTimeout(timer));
+        req.on("error", (error) => reject(error instanceof CliError ? error : new CliError(`后台无法访问；请先执行 mab start：${error.message}`)));
+        req.end(body);
+    });
+}
+async function discover(port, options) {
+    const { status, value } = await requestJson(port, "/api/plugins", options);
+    if (status < 200 || status >= 300)
+        throw new CliError(`插件发现失败（HTTP ${status}）`);
+    if (!object(value) || !Array.isArray(value.plugins) || value.plugins.some((entry) => !object(entry)
+        || typeof entry.id !== "string" || !PLUGIN_ID.test(entry.id) || typeof entry.version !== "string"
+        || typeof entry.displayName !== "string" || typeof entry.status !== "string"
+        || !Array.isArray(entry.capabilities) || entry.capabilities.some((capability) => typeof capability !== "string"))) {
+        throw new CliError("后台插件清单格式无效");
+    }
+    return value.plugins;
+}
+function commandManifest(value, plugin) {
+    if (!object(value) || value.protocolVersion !== 1 || value.plugin !== plugin || typeof value.version !== "string"
+        || !Array.isArray(value.commands) || value.commands.some((command) => !object(command)
+        || typeof command.name !== "string" || !/^[a-z][a-z0-9-]*$/.test(command.name)
+        || typeof command.summary !== "string" || !command.summary.trim() || typeof command.usage !== "string" || !command.usage.trim()
+        || (command.secretPrompt !== undefined && (typeof command.secretPrompt !== "string" || !command.secretPrompt.trim()))
+        || (command.examples !== undefined && (!Array.isArray(command.examples) || command.examples.some((example) => typeof example !== "string"))))) {
+        throw new CliError("插件命令清单协议无效（需要 protocolVersion: 1）");
+    }
+    if (new Set(value.commands.map((command) => command.name)).size !== value.commands.length)
+        throw new CliError("插件命令清单包含重复命令");
+    return value;
+}
+async function runPluginCommand(id, args, port, options = {}) {
+    const extracted = extractOptions(args);
+    const json = options.json ?? extracted.json;
+    try {
+        if (!PLUGIN_ID.test(id) || RESERVED_COMMANDS.has(id))
+            throw new CliError("插件 ID 无效或使用了核心保留命令", 2);
+        const plugin = (await discover(port, options)).find((entry) => entry.id === id);
+        if (!plugin)
+            throw new CliError(`插件“${id}”未安装；请先到 ABWeb 安装插件`, 2);
+        if (!plugin.capabilities.includes("cli"))
+            throw new CliError(`插件“${plugin.displayName}”未提供 CLI 命令；请升级对应插件`, 2);
+        if (!["ready", "degraded"].includes(plugin.status))
+            throw new CliError(`插件“${plugin.displayName}”未就绪（${plugin.status}）`, 2);
+        const path = `/api/plugins/${id}/commands`;
+        const response = await requestJson(port, path, options);
+        if (response.status < 200 || response.status >= 300)
+            throw new CliError(`插件命令清单读取失败（HTTP ${response.status}）`);
+        const manifest = commandManifest(response.value, id);
+        const argv = extracted.argv;
+        if (argv.length === 0 || argv[0] === "help" || argv[0] === "--help") {
+            const helpArgs = argv.slice(argv[0] === "help" || argv[0] === "--help" ? 1 : 0);
+            if (helpArgs.length > 1)
+                throw new CliError(`用法：mab ${id} help [命令]`, 2);
+            const selected = helpArgs.length === 0 ? manifest.commands : manifest.commands.filter((command) => command.name === helpArgs[0]);
+            if (helpArgs.length > 0 && selected.length === 0)
+                throw new CliError(`插件“${id}”没有命令：${helpArgs[0]}`, 2);
+            const message = [`${plugin.displayName}（${manifest.version}）`, ...selected.flatMap((command) => [
+                    `${command.name}：${command.summary}`, `  ${command.usage}`, ...(command.examples ?? []).map((example) => `  示例：${example}`),
+                ])].join("\n");
+            return output({ ok: true, message, data: { ...manifest, commands: selected } }, 0, json);
+        }
+        const prompt = manifest.commands.find((command) => command.name === argv[0])?.secretPrompt;
+        const secret = prompt ? await (options.readSecret ?? secret_input_1.readSecret)(prompt) : undefined;
+        const executed = await requestJson(port, path, options, { protocolVersion: 1, argv, ...(secret === undefined ? {} : { secret }) });
+        const result = executed.value;
+        if (!object(result) || typeof result.ok !== "boolean" || typeof result.message !== "string"
+            || (executed.status >= 200 && executed.status < 300 ? !result.ok : result.ok)
+            || executed.status < 200 || (executed.status >= 300 && executed.status < 400)) {
+            throw new CliError("插件命令响应协议无效");
+        }
+        const exitCode = executed.status >= 500 ? 1 : executed.status >= 400 ? 2 : 0;
+        return output(result, exitCode, json);
+    }
+    catch (error) {
+        return output({ ok: false, message: error instanceof Error ? error.message : String(error) }, error instanceof CliError ? error.exitCode : 1, json);
+    }
+}
+async function runCoreHelp(port, options = {}) {
+    let help = exports.CORE_HELP;
+    try {
+        const plugins = (await discover(port, options)).filter((plugin) => plugin.capabilities.includes("cli") && !RESERVED_COMMANDS.has(plugin.id));
+        if (plugins.length)
+            help += `\n插件命令（mab <插件 ID> help 查看详情）：\n${plugins.map((plugin) => `  ${plugin.id}：${plugin.displayName}（${plugin.status}）`).join("\n")}\n`;
+    }
+    catch { /* 后台不可达时仍显示核心静态帮助 */ }
+    return { exitCode: 0, stdout: help, stderr: "" };
+}

package/dist/src-ts/cli.js

@@ -47,6 +47,7 @@ const registry_1 = require("./registry");
 const bridge_1 = require("./bridge");
 const plugin_manager_1 = require("./plugin-manager");
 const daemon_process_1 = require("./daemon-process");
+const cli_commands_1 = require("./cli-commands");
 const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
 let activeManager;
 const logger = {
@@ -72,19 +73,19 @@ async function selfTest(task) {
         console.error(`session=${response.sessionId}`);
     return 0;
 }
-async function daemonPort() {
+async function daemonAddress() {
     try {
         const address = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.resolve)(stateDirectory(), "daemon-address.json"), "utf8"));
         if (Number.isInteger(address.port) && address.port > 0)
-            return address.port;
+            return { host: typeof address.host === "string" ? address.host : "127.0.0.1", port: address.port };
     }
     catch { /* 后台未写入地址时使用配置端口 */ }
-    return Number(process.env.AGENT_BRIDGE_PORT ?? "26107");
+    return { host: process.env.AGENT_BRIDGE_HOST ?? "127.0.0.1", port: Number(process.env.AGENT_BRIDGE_PORT ?? "26107") };
 }
 async function pair() {
-    const port = await daemonPort();
+    const { host, port } = await daemonAddress();
     const result = await new Promise((resolve, reject) => {
-        const req = (0, node_http_1.request)({ host: "127.0.0.1", port, path: "/api/pair-code", method: "GET" }, (res) => {
+        const req = (0, node_http_1.request)({ host: (0, cli_commands_1.resolveLocalControlHost)(host), port, path: "/api/pair-code", method: "GET" }, (res) => {
             let body = "";
             res.setEncoding("utf8");
             res.on("data", (chunk) => body += chunk);
@@ -181,9 +182,9 @@ async function restart() {
     return 0;
 }
 async function status() {
-    const port = await daemonPort();
+    const { host, port } = await daemonAddress();
     const get = (path) => new Promise((resolve, reject) => {
-        const req = (0, node_http_1.request)({ host: "127.0.0.1", port, path, method: "GET" }, (res) => {
+        const req = (0, node_http_1.request)({ host: (0, cli_commands_1.resolveLocalControlHost)(host), port, path, method: "GET" }, (res) => {
             let body = "";
             res.setEncoding("utf8");
             res.on("data", (chunk) => body += chunk);
@@ -243,6 +244,12 @@ async function serve() {
     const fallbackPorts = (process.env.AGENT_BRIDGE_FALLBACK_PORTS ?? "").split(",").map((value) => Number(value.trim())).filter((value) => Number.isInteger(value) && value >= 0);
     const server = new control_server_1.ControlServer({ manager, host, port, fallbackPorts, token: process.env.AGENT_BRIDGE_TOKEN, sessionFile: (0, node_path_1.resolve)(stateDirectory(), "paired-sessions.json") });
     const address = await server.start();
+    try {
+        manager.setControlUrl((0, cli_commands_1.controlUrl)(address.host, address.port));
+    }
+    catch {
+        logger.warn("当前监听地址仅提供网络 API，插件动态 CLI 需要本机 loopback 或通配监听地址");
+    }
     const addressFile = (0, node_path_1.resolve)(stateDirectory(), "daemon-address.json");
     await (0, promises_1.mkdir)(stateDirectory(), { recursive: true });
     await (0, promises_1.writeFile)(addressFile, JSON.stringify({ host: address.host, port: address.port, pid: process.pid }));
@@ -324,7 +331,7 @@ async function checkAndUpgradePlugins(manager) {
 }
 async function main() {
     const args = process.argv.slice(2);
-    if (args.includes("pair"))
+    if (args[0] === "pair")
         return pair();
     if (args[0] === "status")
         return status();
@@ -334,15 +341,23 @@ async function main() {
         return restart();
     if (args[0] === "update")
         return update();
-    const selfTestIndex = args.indexOf("--self-test");
-    if (selfTestIndex >= 0)
-        return selfTest(args[selfTestIndex + 1] ?? "hi");
-    if (args.includes("--serve") || args.includes("start")) {
+    if (args[0] === "--self-test")
+        return selfTest(args[1] ?? "hi");
+    if (args[0] === "--serve" || args[0] === "start") {
         await stopDaemon(false);
         return serve();
     }
-    console.error("用法：mab start | mab stop | mab restart | mab update | mab status | mab --self-test <任务>");
-    return 2;
+    if (!args[0]) {
+        process.stderr.write(cli_commands_1.CORE_HELP);
+        return 2;
+    }
+    const address = await daemonAddress();
+    const result = args[0] === "--help" || args[0] === "help"
+        ? await (0, cli_commands_1.runCoreHelp)(address.port, { host: address.host, timeoutMs: 1000 })
+        : await (0, cli_commands_1.runPluginCommand)(args[0], args.slice(1), address.port, { host: address.host });
+    process.stdout.write(result.stdout);
+    process.stderr.write(result.stderr);
+    return result.exitCode;
 }
 main().then((code) => { process.exitCode = code; }).catch((error) => {
     console.error(error instanceof Error ? error.stack ?? error.message : error);

package/dist/src-ts/control-server.js

@@ -54,7 +54,7 @@ class ControlServer {
                             reject(new Error("后台监听地址无效"));
                             return;
                         }
-                        resolve({ host, port: info.port });
+                        resolve({ host: info.address, port: info.port });
                     };
                     this.server.once("error", onError);
                     this.server.once("listening", onListening);
@@ -132,12 +132,21 @@ class ControlServer {
                 return this.json(res, 200, { ok: true, token, expiresAt });
             }
             const authorization = req.headers.authorization;
-            const authorized = authorization === `Bearer ${this.options.token}` || (authorization?.startsWith("Bearer ") && (this.pairedTokens.get((0, node_crypto_1.createHash)("sha256").update(authorization.slice(7)).digest("hex")) ?? 0) > Date.now());
+            const authorized = (Boolean(this.options.token) && authorization === `Bearer ${this.options.token}`) || (authorization?.startsWith("Bearer ") && (this.pairedTokens.get((0, node_crypto_1.createHash)("sha256").update(authorization.slice(7)).digest("hex")) ?? 0) > Date.now());
             if (this.options.token && !isLoopback(req.socket.remoteAddress) && !authorized && !(method === "GET" && url.pathname.startsWith("/abweb")))
                 return this.json(res, 401, { error: "unauthorized" });
             if (parts[0] === "api" && parts[1] === "agents" && parts[2] && parts[3] === "v1") {
                 const id = decodeURIComponent(parts[2]);
-                const adapter = new openai_adapter_1.OpenAIAdapter(async (task) => (await this.options.manager.handle(id, { task })).text, { model: id, prefix: `/api/agents/${encodeURIComponent(id)}/v1`, onExchange: (direction, text, peer, aid) => this.options.manager.recordMessage(id, direction, text, peer, aid) });
+                if (req.headers["x-evolcore-session-id"] !== undefined && !authorized && !isLoopback(req.socket.remoteAddress))
+                    return this.json(res, 401, { error: "会话身份仅允许已认证或本机调用方使用" });
+                const adapter = new openai_adapter_1.OpenAIAdapter(async (task, _signal, context) => {
+                    if (!context)
+                        return (await this.options.manager.handle(id, { task })).text;
+                    // 客户端标识只在认证调用方或本机信任范围内生效，不能直接恢复其他入口的会话。
+                    const caller = authorized ? (0, node_crypto_1.createHash)("sha256").update(authorization).digest("hex") : "loopback";
+                    const sessionId = `openai:${(0, node_crypto_1.createHash)("sha256").update(JSON.stringify([caller, id, context.agentAid ?? "", context.peerId ?? "", context.sessionId])).digest("hex")}`;
+                    return (await this.options.manager.handle(id, { task, sessionId })).text;
+                }, { model: id, prefix: `/api/agents/${encodeURIComponent(id)}/v1`, onExchange: (direction, text, peer, aid) => this.options.manager.recordMessage(id, direction, text, peer, aid) });
                 await adapter.handle(req, res);
                 return;
             }
@@ -212,6 +221,8 @@ class ControlServer {
                 const result = await identity.create(body.aid, body.ownerAid);
                 return this.json(res, result.status === "等待 Owner 确认" ? 202 : result.status === "existing" ? 200 : 201, result);
             }
+            if (method === "GET" && url.pathname === "/api/agents/availability")
+                return this.json(res, 200, { agents: await this.options.manager.availableAgents() });
             if (method === "GET" && url.pathname === "/api/plugins")
                 return this.json(res, 200, { ok: true, plugins: this.options.manager.list() });
             if (method === "GET" && url.pathname === "/api/plugins/catalog")

package/dist/src-ts/daemon-process.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isDaemonCommand = isDaemonCommand;
 /** 只识别直接运行本安装 CLI 的后台进程，避免旧地址文件中的 PID 被其他程序复用。 */
 function isDaemonCommand(commandLine, cli) {
-    const args = [...commandLine.matchAll(/"([^"]*)"|(\S+)/g)].map((match) => (match[1] ?? match[2]).replaceAll("\\", "/").toLowerCase());
-    return args[1] === cli.replaceAll("\\", "/").toLowerCase() && ["start", "--serve"].includes(args[2]);
+    const normalize = (value) => value.replace(/[\\/]+/g, "/").toLowerCase();
+    const args = [...commandLine.matchAll(/"([^"]*)"|(\S+)/g)].map((match) => normalize(match[1] ?? match[2]));
+    return args[1] === normalize(cli) && ["start", "--serve"].includes(args[2]);
 }

package/dist/src-ts/dsh-agent.js

@@ -18,7 +18,7 @@ class DshAgent {
         if (!request.task.trim())
             throw new agent_1.AgentError("DSH task must not be empty");
         const args = ["--expose-internals", this.paths.cli, "--profile", "headless", "--patch", this.paths.patch, "--json"];
-        if (request.sessionId)
+        if (request.sessionId && !request.newSession)
             args.push("--session-id", request.sessionId);
         args.push("-");
         const child = this.spawnProcess(this.paths.executable, args, {
@@ -29,7 +29,7 @@ class DshAgent {
         child.stdin.end(request.task, "utf8");
         let output = "";
         let errors = "";
-        let sessionId = request.sessionId;
+        let sessionId = request.newSession ? undefined : request.sessionId;
         let finalText = "";
         child.stdout.setEncoding?.("utf8");
         child.stderr.setEncoding?.("utf8");
@@ -64,6 +64,8 @@ class DshAgent {
         });
         if (!finalText)
             throw new agent_1.AgentError("DSH returned no final text");
+        if (request.newSession && !sessionId)
+            throw new agent_1.AgentError("DSH 未返回真实新会话标识，无法确认后续续聊目标");
         return { text: finalText, sessionId };
     }
 }

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

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PluginManager = void 0;
+const agent_availability_1 = require("./agent-availability");
 const promises_1 = require("node:fs/promises");
 const node_fs_1 = require("node:fs");
 const node_module_1 = require("node:module");
@@ -22,6 +23,7 @@ const logger = { info() { }, warn() { }, error() { } };
 const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
 class PluginManager {
     options;
+    controlUrl;
     plugins = new Map();
     httpRoutes = new Map();
     root;
@@ -41,6 +43,7 @@ class PluginManager {
         this.sessions = new channel_sessions_1.ChannelSessions(options.stateDir);
     }
     log(level, message, fields, source = "mab") { this.logs.append({ time: new Date().toISOString(), level, source, message, ...(fields ? { fields } : {}) }); }
+    setControlUrl(url) { this.controlUrl = url; }
     async updatePolicy() { try {
         const value = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.join)(this.options.stateDir, "update-policy.json"), "utf8"));
         return isUpdatePolicy(value) ? value : { mode: "auto-install" };
@@ -230,6 +233,8 @@ class PluginManager {
     get(id) { return this.plugins.get(id); }
     recentMessages(id) { return this.messages.filter((item) => !id || item.pluginId === id).slice(-200).reverse(); }
     recordMessage(pluginId, direction, text, peer, agentAid) {
+        if (direction === "error" && isNoisyAgentError(text))
+            return;
         this.messages.push({ pluginId, direction, text: text.slice(0, 10000), time: new Date().toISOString(), ...(peer ? { peer } : {}), ...(agentAid ? { agentAid } : {}) });
         if (this.messages.length > 200)
             this.messages.shift();
@@ -355,7 +360,11 @@ class PluginManager {
                         const target = message.agentPlugin || "qwenwork";
                         this.recordMessage(target, "request", message.text, message.peerId);
                         try {
-                            const response = await this.sessions.run(message, target, (sessionId) => this.handle(target, { task: message.text, sessionId }));
+                            const instance = this.plugins.get(target)?.instance;
+                            const control = instance?.sessionOperations?.includes("new")
+                                ? (request) => this.controlSession(target, request)
+                                : undefined;
+                            const response = await this.sessions.run(message, target, (sessionId, newSession) => this.handle(target, { task: message.text, sessionId, ...(newSession ? { newSession: true } : {}) }), control);
                             await message.reply(response.text);
                             this.recordMessage(target, "reply", response.text, message.peerId);
                         }
@@ -365,7 +374,7 @@ class PluginManager {
                         }
                     },
                 },
-                runtime: { ports: {
+                runtime: { controlUrl: this.controlUrl, ports: {
                         qwenwork: Number(process.env.AGENT_BRIDGE_QWEN_CDP_PORT ?? process.env.QWEN_CDP_PORT ?? "9228"),
                         doubao: Number(process.env.AGENT_BRIDGE_DOUBAO_CDP_PORT ?? process.env.DOUBAO_CDP_PORT ?? "9227"),
                         workbuddy: Number(process.env.AGENT_BRIDGE_WORKBUDDY_CDP_PORT ?? process.env.WORKBUDDY_CDP_PORT ?? "9229"),
@@ -501,11 +510,39 @@ class PluginManager {
             throw error;
         throw new agent_1.AgentError(`插件配置校验失败：${error instanceof Error ? error.message : String(error)}`);
     } }
+    async availableAgents() {
+        return Promise.all(this.list().filter((plugin) => plugin.type === "agent").map(async (plugin) => ({
+            id: plugin.id, displayName: plugin.displayName, status: plugin.status,
+            ...await (0, agent_availability_1.agentAvailability)(plugin.id, await this.config(plugin.id), plugin.status),
+        })));
+    }
     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 handle(id, request) { const loaded = this.plugins.get(id); if (!loaded?.instance || loaded.record.status !== "ready")
-        throw new agent_1.AgentError(`plugin not ready: ${id}`); return loaded.instance.handle(request); }
+    async handle(id, request) {
+        const loaded = this.plugins.get(id);
+        if (!loaded?.instance || loaded.record.status !== "ready") {
+            const name = loaded?.record.displayName ?? id;
+            const processName = loaded ? pluginProcessName(loaded.record.id) : undefined;
+            const processText = processName ? `目标进程 ${processName} 不可用；` : "";
+            const reason = loaded?.record.error ? `启动错误：${loaded.record.error}` : `当前状态：${loaded?.record.status ?? "未发现"}`;
+            throw new agent_1.AgentError(`插件“${name}”无法调用，插件未就绪：${processText}${reason}`);
+        }
+        return loaded.instance.handle(request);
+    }
+    async controlSession(id, request) {
+        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 };
+        if (typeof response.sessionId !== "string" || !response.sessionId.trim())
+            throw new agent_1.AgentError("插件未返回有效的新会话标识，原会话绑定保持不变");
+        return response;
+    }
     async dispatchHttp(request, response) {
         const method = (request.method ?? "GET").toUpperCase();
         const pathname = new URL(request.url ?? "/", "http://localhost").pathname;
@@ -576,10 +613,13 @@ class PluginManager {
         const packagedFile = (0, node_path_1.join)(record.path, record.manifest.entry);
         const developmentFile = (0, node_path_1.resolve)(__dirname, "plugins", record.id, (0, node_path_1.basename)(record.manifest.entry));
         const file = (0, node_fs_1.existsSync)(packagedFile) ? packagedFile : developmentFile;
-        // CommonJS is the platform's compiled format; evict the module cache for reload.
+        // 同时刷新插件内部依赖，避免升级后仍运行旧版 CDP 客户端。
         const req = (0, node_module_1.createRequire)(file);
         const resolved = req.resolve(file);
-        delete req.cache[resolved];
+        const moduleRoot = (0, node_fs_1.existsSync)(packagedFile) ? (0, node_path_1.resolve)(record.path) : (0, node_path_1.dirname)(file);
+        for (const cached of Object.keys(req.cache))
+            if (cached === resolved || cached.startsWith(`${moduleRoot}${node_path_1.sep}`))
+                delete req.cache[cached];
         const mod = req(resolved);
         let value = mod.default ?? mod.plugin ?? mod;
         // Entries may export a ready instance, a factory, or a class. Supporting all
@@ -808,7 +848,14 @@ class PluginManager {
     } }
 }
 exports.PluginManager = PluginManager;
+function isNoisyAgentError(text) {
+    const value = text.trim();
+    return /^(?:千问生成接口不可用(?:，已触发后台恢复)?|千问办公 UI 超时未返回回复|(?:API|接口)\s*(?:暂时)?不可用[。.!！]?)$/i.test(value);
+}
 function isUpdatePolicy(value) { return Boolean(value && typeof value === "object" && ["auto-install", "download-only", "manual"].includes(value.mode)); }
+function pluginProcessName(id) {
+    return { qwenwork: "QwenWorkCN.exe", doubao: "Doubao.exe", workbuddy: "WorkBuddy.exe", chatgpt: "ChatGPT/Codex" }[id];
+}
 function defaultPluginTrustConfig() { return { providers: { m2lihui: "allow" }, plugins: {} }; }
 function mergeDefaultPluginTrustConfig(value) { return { providers: { m2lihui: "allow", ...value.providers }, plugins: { ...value.plugins } }; }
 function normalizeProvider(value) { return value.trim().toLowerCase(); }

package/dist/src-ts/plugins/aun/certs/root.crt

@@ -0,0 +1,13 @@
+-----BEGIN CERTIFICATE-----
+MIIB/TCCAYOgAwIBAgIUI/WLfQXFR9KpvBlhnvJFIAtylNQwCgYIKoZIzj0EAwMw
+KzEUMBIGA1UEAwwLQVVOIFJvb3QgQ0ExEzARBgNVBAoMCkFnZW50VW5pb24wIBcN
+MjYwMzE3MDE1NDUyWhgPMjA1NjAzMDkwMTU5NTJaMCsxFDASBgNVBAMMC0FVTiBS
+b290IENBMRMwEQYDVQQKDApBZ2VudFVuaW9uMHYwEAYHKoZIzj0CAQYFK4EEACID
+YgAEbuQMkmsHjhtwsgoFhfgC4514k2IMQVECNeBtxiwiEe5OTY0D7MvqwtEzz67r
+1jo2OXOuA+BajSW/ZOw89HH2zrWIshw2qVo5WP4ELnrKk/dipfiJBm9IrJXsO0kN
+ope4o2YwZDASBgNVHRMBAf8ECDAGAQH/AgECMA4GA1UdDwEB/wQEAwIBhjAdBgNV
+HQ4EFgQULmOUMJCtK8VatDpoo/iigMIu3hwwHwYDVR0jBBgwFoAULmOUMJCtK8Va
+tDpoo/iigMIu3hwwCgYIKoZIzj0EAwMDaAAwZQIwPcby4jt32sKANZhUuFaOcWiy
+V8rgbF0pF+ROrlg+9JdQ3yRyGWTU2VRNyzd+FlNbAjEAgVKYzN6mpxnVfjk8dHYH
+vh6o6LY9oqw8rdZ/2Q1k1eUSaFxykTZQ9ipR84GIGXrc
+-----END CERTIFICATE-----

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

@@ -26,7 +26,8 @@ async function configureAidForPlugin(pluginId, aid, port, run = runEc) {
         return;
     if (!/^[a-z0-9_-]+$/.test(pluginId))
         throw new Error("插件 ID 格式无效");
-    const path = pluginId === "dsh" ? "/dsh/v1" : pluginId === "qwenwork" ? "/v1" : `/api/agents/${pluginId}/v1`;
+    // 通过 daemon 的统一插件代理访问所有 Agent；否则 qwenwork 的裸 /v1 路由在有插件 HTTP 注册表时不存在。
+    const path = pluginId === "dsh" ? "/dsh/v1" : `/api/agents/${pluginId}/v1`;
     for (const [key, value] of [
         ["baseagents.ecagent.baseUrl", `http://127.0.0.1:${port}${path}`],
         ["baseagents.ecagent.apiKey", "mab-local"],