mu-agent-bridge 1.0.4 → 1.0.12

package/README.md

@@ -1,7 +1,7 @@
 # mu-agent-bridge 动态插件平台
 
 运行时使用 TypeScript/Node.js，实现一个可动态发现、启动、停止、重载和安装插件的 daemon。
-当前插件包括千问办公 `qwenwork`、DeepSeek Harness `dsh`、豆包 `doubao`，以及插件化管理后台
+当前插件包括千问办公 `qwenwork`、DeepSeek Harness `dsh`、豆包 `doubao`、基于 CodeBuddy CLI 的 `workbuddy`，以及插件化管理后台
 `abweb`。插件之间独立失败，管理 API 和 OpenAI 兼容接口由同一个本地控制服务提供。
 
 ## 快速开始
@@ -19,23 +19,22 @@ OpenAI 兼容 API 为 `/v1/models` 和 `/v1/chat/completions`。管理页面位
 
 安装后使用 `mab start` 启动。旧桥仍可使用 `17893`，不会与管理页面冲突。局域网访问时设置
 `AGENT_BRIDGE_HOST=0.0.0.0` 和 `AGENT_BRIDGE_TOKEN`，然后访问
-`http://<Windows 主机 IP>:26107/abweb/`。页面输入令牌后可管理插件；请只在可信网络使用。
-已有 AID 从 EvolCore 的 `ec agent list/show` 读取，只显示当前 AUN 已连接且本机有私钥的身份，
-禁用和断线身份不列出。管理页可指定新 AID 与 owner AID，调用 EvolCore 创建 Agent 和身份；
-新身份连接成功后才会进入列表。
-“已连接 AID”按来源分为 EvolCore 和 mu-agent-bridge 两组；后者只包含通过本页面新建、
-且当前已连接的 AID。分组由 mab 状态目录中的创建记录决定，不改变 EvolCore 的身份存储。
-关联 DSH 或千问办公插件时，管理服务会将所选 AID 的 EvolCore 执行基座分别配置为本机
+`http://<Windows 主机 IP>:26107/abweb/`。页面使用一次性配置码配对后管理插件；请只在可信网络使用。
+已有 AID 的连接状态由 AUN 插件查询，只有当前已连接的身份才能关联 Agent。
+核心可以只读扫描 EvolCore 本地身份；ABWeb 只展示已连接 AID，并按 EvolCore 与 mu-agent-bridge 分组，未连接身份不显示。
+创建新 AID 必须填写 Owner AID，并安装、启动 AUN 插件；创建与通信由该插件完成。
+已连接身份按来源分为 EvolCore 和 mu-agent-bridge 两组；后者保存在 AUN 插件自身的密钥库和配置中。
+关联 EvolCore 身份到 DSH 或千问办公时，AUN 插件会将所选身份的执行基座分别配置为本机
 `/dsh/v1` 或 `/v1` OpenAI 接口，然后重载该 Agent；AUN 入站消息由 EvolCore 转给插件，
 回复仍由 EvolCore 经 AUN 发送。该操作会覆盖所选 AID 当前的执行基座。
-其他插件的 AID 关联目前只保存配置项，不自动改变 EvolCore 执行基座。
+其他 Agent 插件可关联 AUN 插件自己创建的身份，由通道直接转发来信和回复。
 Windows 可运行 `start-mab.ps1` 注册并启动登录时自动运行的计划任务；令牌保存在
 `%USERPROFILE%\.mab\token.txt`，页面输入该令牌即可使用管理 API。
 
 本机打开 `http://127.0.0.1:26107/abweb/` 无需配置码。局域网管理页可用一次性配置码配对。
 在 Windows 主机运行 `mab pair`，将显示的 6 位码输入
 abweb 的“配置码”栏；配对码 10 分钟有效，只能使用一次，连续输错 5 次后需重新执行
-`mab pair`。配对成功后浏览器在当前会话保存访问凭证。配置码只能从 Windows 本机的
+`mab pair`。配对成功后登录有效期为 24 小时，浏览器关闭再打开仍可使用；过期后需重新配对。后台重启会使配对登录失效。本机免配对和手动配置的管理令牌按原有规则使用。配置码只能从 Windows 本机的
 `127.0.0.1` 接口取得，远程浏览器不能读取。
 
 环境变量：`AGENT_BRIDGE_PORT`、`AGENT_BRIDGE_HOST`、`AGENT_BRIDGE_TOKEN`、
@@ -52,6 +51,8 @@ abweb 的“配置码”栏；配对码 10 分钟有效，只能使用一次，
 升级失败会恢复旧插件并继续启动。Windows 的 `start-mab.ps1` 登录计划任务会在启动 daemon 前
 更新全局核心包，健康检查失败时恢复备份。全局单独安装的插件及 Linux 核心自动升级暂不受管理。
 
+插件更新策略可在 ABWeb 的“版本管理”中选择：默认“自动下载并安装”；“自动下载，手动安装”会把新版本缓存到状态目录并等待页面操作；“手动下载和安装”只检查版本。策略保存在 `state/update-policy.json`，插件下载缓存位于 `state/downloads`。
+
 运行时会发现核心包依赖和 `AGENT_BRIDGE_PLUGIN_PACKAGES` 中声明的 npm 包。插件包在自己的
 `package.json` 中声明 `agentBridge.plugin`，平台复用统一的 `activate`、`deactivate`、`health`、
 `handle` 生命周期。已加载插件可以通过管理 API 重载；新增 npm 包后重启 daemon 最可靠。
@@ -59,7 +60,7 @@ abweb 的“配置码”栏；配对码 10 分钟有效，只能使用一次，
 abweb 插件目录从 npm 搜索带 `mu-agent-bridge-plugin` 关键词的包，按包元数据中的
 `agentBridge.type` 展示 Agent、Channel 和管理插件；安装后以 `plugin.json` 的类型和能力
 再次校验，不根据包名推断类型。搜索结果有收录延迟，可在页面直接输入 `agent-bridge-*`
-包名安装。已安装插件按清单能力兼容旧版分类。AUN 通道插件包名为 `agent-bridge-aun`，安装后配置 AID 并启动即可；来信默认交给千问办公，也可通过 `agent_plugin` 指定其他已安装 Agent。
+包名安装。已安装插件按清单能力兼容旧版分类。AUN 通道插件包名为 `agent-bridge-aun`，安装后配置 AID 并启动即可；来信默认交给千问办公，也可通过 `agent_plugin` 指定其他已安装 Agent。`workbuddy` 插件包名为 `agent-bridge-workbuddy`，将 AUN 的 `agent_plugin` 设为 `workbuddy` 即可按对端保持 CodeBuddy 会话。默认问答使用独立的 `@tencent-ai/codebuddy-code` CLI，须单独登录；没有 CLI 时使用 WorkBuddy 桌面端 CDP，并默认自动启动桌面应用。CLI 未登录时不会自动切换到桌面端账号；可设置 `transport` 为 `cdp` 显式使用桌面端。
 
 插件仍在 daemon 的同一个 Node.js 进程内运行。修改插件入口依赖后应重启 daemon，避免模块缓存
 影响新代码。
@@ -124,3 +125,7 @@ npm run self-test -- hi
 
 Agent 通过 `AgentRegistry` 注册；DSH 也可以作为动态 `dsh` 插件加载。DeepSeek Harness 不在默认
 Windows 路径时，可设置 `DSH_INSTALL_DIR`。
+
+## AUN 身份管理
+
+创建、连接、关联和 AUN 通信统一由独立 `agent-bridge-aun` 插件完成。未安装并启动该插件时，ABWeb 禁用创建 AID；页面仅展示已连接身份。详细规则见 [AUN 插件与 AID 身份管理](docs/aun-plugin-identities.md)。

package/dist/src-ts/cli.js

@@ -38,15 +38,19 @@ const node_path_1 = require("node:path");
 const node_http_1 = require("node:http");
 const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
 const control_server_1 = require("./control-server");
 const dsh_agent_1 = require("./dsh-agent");
 const registry_1 = require("./registry");
 const bridge_1 = require("./bridge");
 const plugin_manager_1 = require("./plugin-manager");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+let activeManager;
 const logger = {
-    info(message, fields) { console.log(`[agent-bridge] ${message}`, fields ?? ""); },
-    warn(message, fields) { console.warn(`[agent-bridge] ${message}`, fields ?? ""); },
-    error(message, fields) { console.error(`[agent-bridge] ${message}`, fields ?? ""); },
+    info(message, fields) { console.log(`[agent-bridge] ${message}`, fields ?? ""); activeManager?.log("info", message, fields, "mab"); },
+    warn(message, fields) { console.warn(`[agent-bridge] ${message}`, fields ?? ""); activeManager?.log("warn", message, fields, "mab"); },
+    error(message, fields) { console.error(`[agent-bridge] ${message}`, fields ?? ""); activeManager?.log("error", message, fields, "mab"); },
 };
 function stateDirectory() {
     if (process.env.AGENT_BRIDGE_STATE_DIR)
@@ -95,33 +99,27 @@ async function pair() {
     console.log(`配对码: ${result.code}（约 ${minutes} 分钟内有效，仅可使用一次）`);
     return 0;
 }
+async function update() {
+    if (process.platform !== "win32") {
+        console.error("当前平台未配置后台升级器");
+        return 2;
+    }
+    await execFileAsync("npm.cmd", ["install", "-g", "mu-agent-bridge@latest", "--no-fund", "--no-audit"], { timeout: 120_000 });
+    await execFileAsync("schtasks.exe", ["/Run", "/TN", "mab"]);
+    console.log("核心已更新，已请求 mab 计划任务重新启动");
+    return 0;
+}
 async function serve() {
     const manager = new plugin_manager_1.PluginManager({
         pluginsDir: (0, node_path_1.resolve)(process.env.AGENT_BRIDGE_PLUGINS_DIR ?? (0, node_path_1.resolve)(__dirname, "..", "..", "plugins")),
         stateDir: stateDirectory(),
         logger,
     });
+    activeManager = manager;
     await manager.discover();
     await manager.versions.load();
     const coreVersion = await Promise.resolve().then(() => __importStar(require("node:fs/promises"))).then(({ readFile }) => readFile((0, node_path_1.resolve)(__dirname, "../../package.json"), "utf8").then((value) => JSON.parse(value).version).catch(() => "0.0.0"));
-    const checkedVersions = await Promise.all([manager.versions.checkPackage("mu-agent-bridge", coreVersion), ...manager.list().map((plugin) => {
-            const info = manager.packageInfo(plugin.id);
-            return info.packageName && info.managed ? manager.versions.checkPackage(info.packageName, plugin.version) : Promise.resolve(undefined);
-        })]);
-    for (const status of checkedVersions.slice(1)) {
-        if (status?.state !== "update-available")
-            continue;
-        const plugin = manager.list().find((record) => manager.packageInfo(record.id).packageName === status.packageName);
-        if (!plugin)
-            continue;
-        try {
-            await manager.upgradePackage(plugin.id, status.packageName, status.latestVersion);
-            logger.info(`插件已升级：${plugin.id}`, { version: status.latestVersion });
-        }
-        catch (error) {
-            logger.error(`插件升级失败，保留旧版本：${plugin.id}`, { error: error instanceof Error ? error.message : String(error) });
-        }
-    }
+    await checkAndUpgradePlugins(manager);
     const port = Number(process.env.AGENT_BRIDGE_PORT ?? "26107");
     const host = process.env.AGENT_BRIDGE_HOST ?? "127.0.0.1";
     if (host !== "127.0.0.1" && host !== "localhost" && host !== "::1" && !process.env.AGENT_BRIDGE_TOKEN) {
@@ -140,6 +138,9 @@ async function serve() {
             logger.error(`plugin failed: ${id}`, { error: error instanceof Error ? error.message : String(error) });
         }
     }
+    const intervalMs = Math.max(60_000, Number(process.env.AGENT_BRIDGE_PLUGIN_UPDATE_INTERVAL_MS ?? 300_000) || 300_000);
+    const updateTimer = setInterval(() => void checkAndUpgradePlugins(manager), intervalMs);
+    updateTimer.unref?.();
     let stopping = false;
     const shutdown = async () => {
         if (stopping)
@@ -154,20 +155,54 @@ async function serve() {
             }
         }
         await server.stop();
+        clearInterval(updateTimer);
     };
     process.once("SIGINT", () => void shutdown().finally(() => process.exit(0)));
     process.once("SIGTERM", () => void shutdown().finally(() => process.exit(0)));
     await new Promise(() => undefined);
     return 0;
 }
+async function checkAndUpgradePlugins(manager) {
+    try {
+        const policy = await manager.updatePolicy();
+        const statuses = await manager.checkPackageUpdates();
+        for (const status of statuses.slice(1)) {
+            if (status.state !== "update-available")
+                continue;
+            const plugin = manager.list().find((record) => record.packageName === status.packageName);
+            if (!plugin)
+                continue;
+            if (policy.mode === "manual" || (!plugin.autoUpdate && policy.mode === "auto-install")) {
+                manager.log("info", `第三方插件有可用更新：${plugin.id}`, { packageName: status.packageName, version: status.latestVersion }, "升级检查");
+                continue;
+            }
+            try {
+                if (policy.mode === "download-only") {
+                    await manager.downloadPackage(status.packageName, status.latestVersion);
+                    continue;
+                }
+                if (!plugin.autoUpdate) {
+                    manager.log("info", `第三方插件有可用更新：${plugin.id}`, { packageName: status.packageName, version: status.latestVersion }, "升级检查");
+                    continue;
+                }
+                await manager.upgradePackage(plugin.id, status.packageName, status.latestVersion);
+                logger.info(`插件已升级：${plugin.id}`, { version: status.latestVersion });
+            }
+            catch (error) {
+                logger.error(`插件升级失败，保留旧版本：${plugin.id}`, { error: error instanceof Error ? error.message : String(error) });
+            }
+        }
+    }
+    catch (error) {
+        logger.warn("插件更新检查失败", { error: error instanceof Error ? error.message : String(error) });
+    }
+}
 async function main() {
     const args = process.argv.slice(2);
     if (args.includes("pair"))
         return pair();
-    if (args[0] === "update" && args.includes("--startup")) {
-        console.log("核心升级由 Windows 启动器执行；请更新全局 mu-agent-bridge 后重新启动。");
-        return 0;
-    }
+    if (args[0] === "update")
+        return update();
     const selfTestIndex = args.indexOf("--self-test");
     if (selfTestIndex >= 0)
         return selfTest(args[selfTestIndex + 1] ?? "hi");

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

@@ -1,63 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ControlServer = void 0;
-exports.configureAidForPlugin = configureAidForPlugin;
-exports.listExistingAids = listExistingAids;
-exports.listConnectedAids = listConnectedAids;
+exports.ControlServer = exports.listExistingAids = void 0;
 const node_http_1 = require("node:http");
-const promises_1 = require("node:fs/promises");
 const node_child_process_1 = require("node:child_process");
-const node_util_1 = require("node:util");
-const node_os_1 = require("node:os");
-const node_path_1 = require("node:path");
 const node_crypto_1 = require("node:crypto");
-const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const local_aids_1 = require("./local-aids");
+const openai_adapter_1 = require("./plugins/qwenwork/openai-adapter");
+var local_aids_2 = require("./local-aids");
+Object.defineProperty(exports, "listExistingAids", { enumerable: true, get: function () { return local_aids_2.listExistingAids; } });
 const AID_PATTERN = /^[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?){2,}$/;
-async function runEc(args) {
-    const command = process.platform === "win32" ? process.env.ComSpec ?? "cmd.exe" : "ec";
-    const argv = process.platform === "win32" ? ["/d", "/s", "/c", `ec ${args.join(" ")}`] : args;
-    try {
-        const { stdout } = await execFileAsync(command, argv, { timeout: 120_000, maxBuffer: 1024 * 1024 });
-        return JSON.parse(stdout);
-    }
-    catch (error) {
-        const stdout = error.stdout;
-        if (stdout) {
-            try {
-                return JSON.parse(stdout);
-            }
-            catch { /* 保留原始命令错误 */ }
-        }
-        throw error;
-    }
-}
-async function configureAidForPlugin(pluginId, aid, port, run = runEc) {
-    if (!aid || (pluginId !== "dsh" && pluginId !== "qwenwork"))
-        return;
-    const model = pluginId === "dsh" ? "dsh" : "qwenwork";
-    const path = pluginId === "dsh" ? "/dsh/v1" : "/v1";
-    const settings = [
-        ["baseagents.ecagent.baseUrl", `http://127.0.0.1:${port}${path}`],
-        ["baseagents.ecagent.apiKey", "mab-local"],
-        ["baseagents.ecagent.model", model],
-        ["active_baseagent", "ecagent"],
-    ];
-    for (const [key, value] of settings) {
-        const result = await run(["agent", "set", aid, key, value, "--format", "json"]);
-        if (!result?.ok)
-            throw new Error(`配置 AID ${aid} 失败：${key}`);
-    }
-    const reloaded = await run(["agent", "reload", aid, "--format", "json"]);
-    if (!reloaded?.ok)
-        throw new Error(`重载 AID ${aid} 失败：${reloaded?.error ?? reloaded?.code ?? "未知错误"}`);
-}
 class ControlServer {
     options;
     server;
     address;
     pairingCode = String((0, node_crypto_1.randomInt)(0, 1_000_000)).padStart(6, "0");
     pairingExpiresAt = Date.now() + 10 * 60 * 1000;
-    pairedTokens = new Set();
+    pairedTokens = new Map();
     pairingUsed = false;
     pairingFailures = 0;
     constructor(options) {
@@ -94,35 +52,67 @@ class ControlServer {
                 }
                 this.pairingUsed = true;
                 const token = (0, node_crypto_1.randomBytes)(32).toString("hex");
-                this.pairedTokens.add(token);
-                return this.json(res, 200, { ok: true, token });
+                const expiresAt = Date.now() + 24 * 60 * 60 * 1000;
+                for (const [storedToken, expiry] of this.pairedTokens)
+                    if (expiry <= Date.now())
+                        this.pairedTokens.delete(storedToken);
+                this.pairedTokens.set(token, expiresAt);
+                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.has(authorization.slice(7)));
+            const authorized = authorization === `Bearer ${this.options.token}` || (authorization?.startsWith("Bearer ") && (this.pairedTokens.get(authorization.slice(7)) ?? 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) });
+                await adapter.handle(req, res);
+                return;
+            }
             if (method === "GET" && url.pathname === "/api/health")
                 return this.json(res, 200, { status: "ok", plugins: this.options.manager.list().length });
             if (method === "GET" && url.pathname === "/api/versions")
                 return this.json(res, 200, { core: this.options.manager.versions.get("mu-agent-bridge") ?? null, plugins: this.options.manager.list().map((plugin) => ({ ...plugin, versionStatus: this.options.manager.versions.get(`agent-bridge-${plugin.id}`) ?? null })) });
+            if (method === "GET" && url.pathname === "/api/update-policy")
+                return this.json(res, 200, await this.options.manager.updatePolicy());
+            if (method === "PATCH" && url.pathname === "/api/update-policy")
+                return this.json(res, 200, await this.options.manager.saveUpdatePolicy(await this.body(req)).then(() => ({ ok: true })));
             if (method === "POST" && url.pathname === "/api/versions/check")
                 return this.json(res, 200, { versions: await this.options.manager.checkPackageUpdates() });
+            if (method === "POST" && url.pathname === "/api/update") {
+                this.options.manager.log("info", "已请求后台升级，准备重启 daemon", undefined, "后台升级");
+                if (process.platform === "win32") {
+                    const script = "$ErrorActionPreference='Continue'; Start-Sleep -Seconds 2; schtasks.exe /End /TN mab | Out-Null; npm.cmd install -g mu-agent-bridge@latest --no-fund --no-audit; schtasks.exe /Run /TN mab | Out-Null";
+                    const child = (0, node_child_process_1.spawn)("powershell.exe", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", script], { detached: true, stdio: "ignore", windowsHide: true });
+                    child.unref();
+                }
+                else {
+                    return this.json(res, 501, { error: "当前平台未配置后台升级器" });
+                }
+                return this.json(res, 202, { ok: true, message: "后台正在升级，服务将自动重启" });
+            }
             if (method === "GET" && url.pathname === "/api/messages")
                 return this.json(res, 200, { messages: this.options.manager.recentMessages() });
+            if (method === "GET" && url.pathname === "/api/logs") {
+                const page = Number(url.searchParams.get("page") ?? "1");
+                const pageSize = Number(url.searchParams.get("pageSize") ?? "100");
+                return this.json(res, 200, await this.options.manager.logs.page(page, pageSize));
+            }
             if (method === "GET" && url.pathname === "/api/aids") {
-                const aids = await listConnectedAids();
-                const created = new Set(await this.options.manager.createdAids?.() ?? []);
-                return this.json(res, 200, { aids, groups: { evolcore: aids.filter((aid) => !created.has(aid)), muAgentBridge: aids.filter((aid) => created.has(aid)) } });
+                const identity = this.identity();
+                const groups = identity ? await identity.list() : { evolcore: [], muAgentBridge: [] };
+                const aids = [...new Set([...groups.evolcore, ...groups.muAgentBridge])];
+                return this.json(res, 200, { aids, groups, localAids: (await (0, local_aids_1.listExistingAids)()).filter((aid) => !aids.includes(aid)), canCreate: Boolean(identity), message: identity ? "" : "请先安装并启动 AUN 插件，才能创建或关联 AID" });
             }
             if (method === "POST" && url.pathname === "/api/aids") {
                 const body = await this.body(req);
                 if (typeof body.aid !== "string" || !AID_PATTERN.test(body.aid) || typeof body.ownerAid !== "string" || !AID_PATTERN.test(body.ownerAid))
                     return this.json(res, 400, { error: "需要有效的 AID 和 owner AID" });
-                const project = (0, node_path_1.join)((0, node_os_1.homedir)(), ".mab", "projects", body.aid);
-                const result = await runEc(["agent", "new", body.aid, "--non-interactive", "--owner", body.ownerAid, "--project", project, "--name", body.aid, "--description", `mu-agent-bridge 的 ${body.aid} Agent`, "--format", "json"]);
-                if (result.ok)
-                    await this.options.manager.recordCreatedAid(body.aid);
-                return this.json(res, result.ok ? 201 : 400, result);
+                const identity = this.identity();
+                if (!identity)
+                    return this.json(res, 409, { error: "请先安装并启动 AUN 插件，才能创建 AID" });
+                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/plugins")
                 return this.json(res, 200, { ok: true, plugins: this.options.manager.list() });
@@ -148,6 +138,10 @@ class ControlServer {
                     const body = await this.body(req);
                     return this.json(res, 200, { ok: true, plugin: await this.options.manager.upgradePackage(id, body.packageName, body.version) });
                 }
+                if (method === "POST" && parts[3] === "download") {
+                    const body = await this.body(req);
+                    return this.json(res, 200, { ok: true, path: await this.options.manager.downloadPackage(body.packageName ?? `agent-bridge-${id}`, body.version) });
+                }
                 if (method === "DELETE" && parts.length === 3) {
                     await this.options.manager.uninstall(id);
                     return this.json(res, 200, { ok: true });
@@ -156,17 +150,27 @@ class ControlServer {
                     return this.json(res, 200, maskSecrets(await this.options.manager.config(id)));
                 if (method === "PATCH" && parts[3] === "aid") {
                     const body = await this.body(req);
-                    if (typeof body.aid !== "string" || (body.aid && !(await listConnectedAids()).includes(body.aid)))
-                        return this.json(res, 400, { error: "AID 当前未连接" });
+                    if (typeof body.aid !== "string" || (body.aid && !AID_PATTERN.test(body.aid)))
+                        return this.json(res, 400, { error: "AID 格式无效" });
                     if (body.aid && (id === "dsh" || id === "qwenwork") && this.options.manager.get(id)?.record.status !== "ready")
                         return this.json(res, 409, { error: "插件未启动" });
-                    await configureAidForPlugin(id, body.aid, this.address.port);
-                    await this.options.manager.setAid(id, body.aid);
+                    const identity = this.identity();
+                    if (body.aid && !identity)
+                        return this.json(res, 409, { error: "请先安装并启动 AUN 插件，才能关联 AID" });
+                    try {
+                        if (identity)
+                            await identity.bind(id, body.aid, this.address.port);
+                        await this.options.manager.setAid(id, body.aid);
+                        this.options.manager.log("info", "AID 关联已保存", { aid: body.aid, pluginId: id });
+                    }
+                    catch (error) {
+                        this.options.manager.log("error", "AID 关联失败", { aid: body.aid, pluginId: id, error: error instanceof Error ? error.message : String(error) });
+                        throw error;
+                    }
                     return this.json(res, 200, { ok: true });
                 }
                 if (method === "PATCH" && parts[3] === "config") {
-                    await this.options.manager.saveConfig(id, await this.body(req));
-                    return this.json(res, 200, { ok: true });
+                    return this.json(res, 200, { ok: true, ...(await this.options.manager.saveConfig(id, await this.body(req))) });
                 }
                 if (method === "GET" && parts[3] === "health")
                     return this.json(res, 200, await this.options.manager.health(id));
@@ -190,6 +194,10 @@ class ControlServer {
             return this.json(res, status, { error: error instanceof Error ? error.message : String(error) });
         }
     }
+    identity() {
+        const loaded = this.options.manager.get("aun");
+        return loaded?.record.status === "ready" ? loaded.instance?.identity : undefined;
+    }
     async body(req) { let raw = ""; for await (const chunk of req)
         raw += chunk; if (!raw)
         return {}; try {
@@ -204,35 +212,6 @@ exports.ControlServer = ControlServer;
 function isLoopback(address) {
     return address === "127.0.0.1" || address === "::1" || address === "::ffff:127.0.0.1";
 }
-async function listExistingAids() {
-    const root = (0, node_path_1.resolve)(process.env.EVOLCORE_HOME ?? (0, node_path_1.join)((0, node_os_1.homedir)(), ".evolcore"), "AIDs");
-    let names;
-    try {
-        names = await (0, promises_1.readdir)(root);
-    }
-    catch {
-        return [];
-    }
-    const available = await Promise.all(names.filter((name) => /^[a-zA-Z0-9.-]+$/.test(name)).map(async (name) => {
-        try {
-            await (0, promises_1.access)((0, node_path_1.join)(root, name, "private", "key.json"));
-            return name;
-        }
-        catch {
-            return undefined;
-        }
-    }));
-    return available.filter((name) => Boolean(name)).sort();
-}
-async function listConnectedAids(run = runEc) {
-    const result = await run(["agent", "list", "--format", "json"]);
-    if (!result.ok || !Array.isArray(result.agents))
-        throw new Error("读取 EvolCore Agent 列表失败");
-    const candidates = result.agents.filter((agent) => agent.status === "running" && typeof agent.aid === "string" && AID_PATTERN.test(agent.aid) && agent.channels?.some((channel) => channel.startsWith("aun#")));
-    const details = await Promise.all(candidates.map((agent) => run(["agent", "show", agent.aid, "--format", "json"]).catch(() => null)));
-    const local = new Set(await listExistingAids());
-    return details.filter((detail) => detail?.ok && detail.status === "running" && detail.connection?.status === "connected" && local.has(detail.aid)).map((detail) => detail.aid).sort();
-}
 function maskSecrets(value) {
     if (Array.isArray(value))
         return value.map(maskSecrets);

package/dist/src-ts/local-aids.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listExistingAids = listExistingAids;
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+async function listExistingAids() {
+    const root = (0, node_path_1.resolve)(process.env.EVOLCORE_HOME ?? (0, node_path_1.join)((0, node_os_1.homedir)(), ".evolcore"), "AIDs");
+    let names;
+    try {
+        names = await (0, promises_1.readdir)(root);
+    }
+    catch {
+        return [];
+    }
+    const available = await Promise.all(names.filter((name) => /^[a-zA-Z0-9.-]+$/.test(name)).map(async (name) => {
+        try {
+            await (0, promises_1.access)((0, node_path_1.join)(root, name, "private", "key.json"));
+            return name;
+        }
+        catch {
+            return undefined;
+        }
+    }));
+    return available.filter((name) => Boolean(name)).sort();
+}

package/dist/src-ts/log-store.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogStore = void 0;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const MAX_BYTES = 500 * 1024 * 1024;
+class LogStore {
+    directory;
+    maxBytes;
+    queue = Promise.resolve();
+    constructor(directory, maxBytes = MAX_BYTES) {
+        this.directory = directory;
+        this.maxBytes = maxBytes;
+    }
+    append(entry) {
+        this.queue = this.queue.catch(() => undefined).then(async () => {
+            await (0, promises_1.mkdir)(this.directory, { recursive: true });
+            const file = (0, node_path_1.join)(this.directory, "mab.log");
+            const line = `${JSON.stringify(entry)}\n`;
+            let size = 0;
+            try {
+                size = (await (0, promises_1.stat)(file)).size;
+            }
+            catch { /* 首次写入 */ }
+            if (size + Buffer.byteLength(line) > this.maxBytes / 2) {
+                const archive = (0, node_path_1.join)(this.directory, "mab.log.1");
+                try {
+                    await (0, promises_1.unlink)(archive);
+                }
+                catch { /* 无归档 */ }
+                try {
+                    await (0, promises_1.rename)(file, archive);
+                }
+                catch { /* 并发首次写入 */ }
+            }
+            await (0, promises_1.appendFile)(file, line, "utf8");
+        });
+    }
+    async flush() { await this.queue; }
+    async page(page = 1, pageSize = 100) {
+        const size = Math.min(100, Math.max(1, Math.floor(pageSize) || 100));
+        const current = Math.max(1, Math.floor(page) || 1);
+        const files = [(0, node_path_1.join)(this.directory, "mab.log.1"), (0, node_path_1.join)(this.directory, "mab.log")];
+        const entries = [];
+        for (const file of files) {
+            try {
+                const text = await (0, promises_1.readFile)(file, "utf8");
+                for (const line of text.split("\n")) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        entries.push(JSON.parse(line));
+                    }
+                    catch { /* 忽略损坏行 */ }
+                }
+            }
+            catch { /* 文件尚未创建 */ }
+        }
+        entries.sort((a, b) => b.time.localeCompare(a.time));
+        const start = (current - 1) * size;
+        return { logs: entries.slice(start, start + size), page: current, pageSize: size, total: entries.length, hasNext: start + size < entries.length };
+    }
+}
+exports.LogStore = LogStore;