mu-agent-bridge 1.0.73 → 1.0.78

package/README.md

@@ -1,7 +1,7 @@
 # mu-agent-bridge 动态插件平台
 
 运行时使用 TypeScript/Node.js，实现一个可动态发现、启动、停止、重载和安装插件的 daemon。
-当前插件包括千问办公 `qwenwork`、DeepSeek Harness `dsh`、豆包 `doubao`、基于 CodeBuddy CLI 的 `workbuddy`、远程 ChatGPT/Codex CDP 插件 `chatgpt`、个人助理管理 Agent `personal-assistant`，以及插件化管理后台 `abweb`。插件之间独立失败，管理 API 和 OpenAI 兼容接口由同一个本地控制服务提供。
+当前插件包括千问办公 `qwenwork`、DeepSeek Harness `dsh`、豆包 `doubao`、基于 CodeBuddy CLI 的 `workbuddy`、ZCode 桌面端 CDP 插件 `zcode`、远程 ChatGPT/Codex CDP 插件 `chatgpt`、个人助理管理 Agent `personal-assistant`，以及插件化管理后台 `abweb`。插件之间独立失败，管理 API 和 OpenAI 兼容接口由同一个本地控制服务提供。
 
 ## 快速开始
 
@@ -22,7 +22,7 @@ OpenAI 兼容 API 为 `/v1/models` 和 `/v1/chat/completions`。管理页面位
 `AGENT_BRIDGE_HOST=0.0.0.0` 和 `AGENT_BRIDGE_TOKEN`，然后访问
 `http://<Windows 主机 IP>:26107/abweb/`。页面使用一次性配置码配对后管理插件；请只在可信网络使用。
 如果 26107 被旧的 mab 进程占用，可执行 `mab restart`；Windows 会扫描并结束同一 CLI 安装路径的全部旧 daemon，并重新启动。`mab stop` 只停止 daemon，
-`mab update` 会结束旧 daemon、安装最新核心包并启动新版本。不会把自己的旧进程误当成新的 daemon，也不会因此默认改用临时端口。
+`mab update` 和 ABWeb 的后台升级按钮使用相同规则：只有 npmjs 的 `mu-agent-bridge@latest` 高于当前版本时才升级，并启动新版本。全局安装、测试目录和源码目录按同一版本规则处理；测试时请设置高于 npmjs 的版本，避免被正式版覆盖。不会把自己的旧进程误当成新的 daemon，也不会因此默认改用临时端口。
 已有 AID 的连接状态由 AUN 插件查询，只有当前已连接的身份才能关联 Agent。
 本机 AID 来自 AUN 插件自身的密钥库，不依赖 `ec` 命令，`ec stop` 后仍会显示。
 未配置 `aun_path` 时密钥库默认使用共享 AUN 目录（`AUN_HOME`/`EVOLCORE_HOME` 或
@@ -43,24 +43,26 @@ abweb 的“配置码”栏；配对码 10 分钟有效，只能使用一次，
 `AGENT_BRIDGE_PLUGINS_DIR`、`AGENT_BRIDGE_STATE_DIR`。默认插件目录是仓库的 `plugins/`，状态目录
 是 Windows 的 `%APPDATA%\agent-bridge\state`。
 
-跨会话读取支持按来源授权的 AUN/飞书托管记录，以及另外授权的 ChatGPT、WorkBuddy 受限原生历史，并通过独立无工具端点总结。归档默认关闭，千问办公暂不支持原生历史。配置与 `/sessions` 命令见[跨会话读取说明](docs/cross-session-reading.md)。
+跨会话读取默认 `allowFrom: []`（白名单留空），允许所有 Peer 查询本机各来源的 AUN/飞书归档和插件已提供的原生历史，可通过独立无工具端点总结。归档采集默认关闭；读取范围仍受各插件历史能力限制。个人助理也默认接受所有 Peer、允许调用所有已就绪的普通 Agent；需要限制时可配置名单。配置与 `/sessions` 命令见[跨会话读取说明](docs/cross-session-reading.md)。
 
 ## npm 插件
 
-默认包 `mu-agent-bridge` 已内置 abweb、AUN、千问办公、DSH、豆包、飞书、WorkBuddy、ChatGPT/Codex、Codex CLI、Claude CLI 和个人助理共十一个插件，直接安装即可使用：
+默认包 `mu-agent-bridge` 已内置 abweb、AUN、千问办公、DSH、豆包、飞书、WorkBuddy、ZCode、ChatGPT/Codex、Codex CLI、Claude CLI 和个人助理共十二个插件，直接安装即可使用：
 
 ```powershell
 npm install -g mu-agent-bridge@latest
 mab start
 ```
 
-十一个插件会从核心包的 `plugins/` 目录自动发现。插件仍分别发布为独立 npm 包，可用于单独测试、升级或替换版本。安装与发布说明见
+十二个插件会从核心包的 `plugins/` 目录自动发现。插件仍分别发布为独立 npm 包，可用于单独测试、升级或替换版本。安装与发布说明见
 [`docs/npm-publishing.md`](docs/npm-publishing.md)。
 
 `mab start` 启动时会查询核心包和托管插件的 npm 最新版本，检查状态保存于 mab 状态目录的
 `versions.json`，abweb 的“版本管理”区域可查看。托管插件发现新版本后会自动下载、验证并替换；
-升级失败会恢复旧插件并继续启动。Windows 的 `start-mab.ps1` 登录计划任务会在启动 daemon 前
-更新全局核心包，健康检查失败时恢复备份。全局单独安装的插件及 Linux 核心自动升级暂不受管理。
+升级失败会恢复旧插件并继续启动。核心在启动及运行中定时检查 npmjs，仅升级较低版本，不降级高版本测试包。
+核心先暂存并验证新包与依赖，再备份和更新当前启动目录中的发布文件；保留其他本地文件，新 daemon 健康检查失败时恢复旧文件。Windows 的 `start-mab.ps1` 登录任务、命令行和 ABWeb 共用核心升级器，计划任务不必更换启动路径。全局单独安装的插件暂不自动升级。
+
+插件候选包校验通过后，最多等待旧任务两小时；到期以 `PLUGIN_UPGRADE_WAIT_TIMEOUT` 结束桥接任务，最多再给旧插件五秒清理，然后继续升级，失败仍回滚。升级清理会要求保留桌面进程；千问、豆包和 ChatGPT 需使用支持该选项的配套插件。桌面原生生成可能继续，核心会拦截迟到回复；普通停止和重载不套用此期限。详见[升级等待设计](docs/superpowers/specs/2026-10-30-plugin-upgrade-deadline-design.md)。
 
 可用 `mab status` 查看后台、插件以及 AUN 已连接 AID 和关联 Agent 的状态。AUN 插件自己加载本地
 `~/.evolcore/AIDs` 并建立连接，不要求先启动 `ec start`，也不调用 `ec agent list/show`。
@@ -82,10 +84,12 @@ abweb 插件目录从 npm 搜索带 `mu-agent-bridge-plugin` 关键词的包，
 
 `workbuddy` 插件包名为 `agent-bridge-workbuddy`，显式关联后按对端保持会话。默认问答使用独立的 `@tencent-ai/codebuddy-code` CLI，须单独登录；没有 CLI 时使用桌面端 CDP。CLI 未登录时不会自动切换到桌面账号。个人助理选择 WorkBuddy 桌面模型来源时请设置 `transport: "cdp"`。
 
+`zcode` 插件包名为 `agent-bridge-zcode`，通过 ZCode v4 桌面端 CDP 收发文本。Windows 后台启动或重载插件时，会自动从注册信息和开始菜单查找并带 CDP 参数启动 ZCode；默认端口为 `9231`，可在插件配置设置 `cdpPort`，或使用 `ZCODE_CDP_PORT` 覆盖。插件保护未发送的草稿；已人工启动但未开启 CDP 时，请先从托盘退出再重载。启动参数和会话说明见 [插件文档](packages/zcode/README.md)。
+
 插件仍在 daemon 的同一个 Node.js 进程内运行。修改插件入口依赖后应重启 daemon，避免模块缓存
 影响新代码。
 
-npm 尚未发布时，核心包内置的十一个默认插件仍会出现在插件列表。abweb 的“安装本地插件”
+npm 尚未发布时，核心包内置的十二个默认插件仍会出现在插件列表。abweb 的“安装本地插件”
 可填写 **Windows 主机上**包含 `plugin.json` 的目录路径，例如编译后的
 `C:\path\to\agent_bridge\packages\dsh`；安装后可在下拉框中启动。已内置的千问办公无需再次安装。
 “安装 npm 插件”只适用于包已经公开发布的情况。npm 发布令牌仅供发布脚本向 npm 官网认证，

package/dist/src-ts/cli.js

@@ -79,7 +79,7 @@ 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 { host: typeof address.host === "string" ? address.host : "127.0.0.1", port: address.port };
+            return { host: typeof address.host === "string" ? address.host : "127.0.0.1", port: address.port, pid: address.pid };
     }
     catch { /* 后台未写入地址时使用配置端口 */ }
     return { host: process.env.AGENT_BRIDGE_HOST ?? "127.0.0.1", port: Number(process.env.AGENT_BRIDGE_PORT ?? "26107") };
@@ -114,17 +114,28 @@ async function pair() {
     return 0;
 }
 async function update() {
-    if (process.platform !== "win32") {
-        console.error("当前平台未配置后台升级器");
-        return 2;
-    }
-    await stopDaemon();
-    await execFileAsync("npm.cmd", ["install", "-g", "mu-agent-bridge@latest", "--no-fund", "--no-audit"], { timeout: 120_000, shell: true, windowsHide: true });
-    await startDaemon();
-    console.log("核心已更新，旧 daemon 已结束并启动新版本");
+    const updated = await checkCoreUpdate();
+    console.log(updated ? "核心已更新，新版本健康检查通过" : "核心未升级，版本检查结果及失败原因见后台日志");
     return 0;
 }
-async function stopDaemon(stopTask = true) {
+async function checkCoreUpdate() {
+    const logs = new log_store_1.LogStore((0, node_path_1.resolve)(stateDirectory(), "logs"));
+    let launched;
+    try {
+        return await (0, core_updater_1.updateCoreAtStartup)({
+            packageRoot: (0, node_path_1.resolve)(__dirname, "..", ".."),
+            stateDir: stateDirectory(),
+            stopDaemon: (additionalPid) => stopDaemon(false, additionalPid),
+            startDaemon: async () => { launched = await startUpdatedDaemon(); return launched; },
+            waitForHealth: async () => launched?.healthy() ?? false,
+            log: (level, message, fields) => logs.append({ time: new Date().toISOString(), level, source: "核心升级", message, fields }),
+        });
+    }
+    finally {
+        await logs.flush();
+    }
+}
+async function stopDaemon(stopTask = true, additionalPid) {
     let pid;
     try {
         const address = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.resolve)(stateDirectory(), "daemon-address.json"), "utf8"));
@@ -144,11 +155,42 @@ async function stopDaemon(stopTask = true) {
             console.log(`已结束旧 daemon：${old.ProcessId}`);
         }
     }
-    else if (pid) {
-        try {
-            process.kill(pid);
+    else {
+        for (const targetPid of new Set([pid, additionalPid].filter((value) => Boolean(value && value !== process.pid)))) {
+            let command;
+            try {
+                command = process.platform === "linux"
+                    ? (await (0, promises_1.readFile)(`/proc/${targetPid}/cmdline`, "utf8")).split("\0").filter(Boolean)
+                    : (await execFileAsync("ps", ["-ww", "-p", String(targetPid), "-o", "command="], { timeout: 5000 })).stdout;
+            }
+            catch (error) {
+                if (["ENOENT", "ESRCH", 1].includes(error.code))
+                    continue;
+                throw error;
+            }
+            if (!(0, daemon_process_1.isDaemonCommand)(command, (0, node_path_1.resolve)(__dirname, "cli.js")))
+                continue;
+            try {
+                process.kill(targetPid);
+            }
+            catch (error) {
+                if (error.code !== "ESRCH")
+                    throw error;
+            }
+            for (let attempt = 0;; attempt++) {
+                try {
+                    process.kill(targetPid, 0);
+                }
+                catch (error) {
+                    if (error.code === "ESRCH")
+                        break;
+                    throw error;
+                }
+                if (attempt >= 150)
+                    throw new Error(`等待旧 daemon 退出超时：${targetPid}`);
+                await new Promise(done => setTimeout(done, 100));
+            }
         }
-        catch { /* 进程已退出 */ }
     }
     if (stopTask && process.platform === "win32") {
         try {
@@ -193,19 +235,21 @@ async function startUpdatedDaemon() {
                 return false;
             const address = await daemonAddress();
             try {
-                const response = await fetch(`http://127.0.0.1:${address.port}/api/health`, {
-                    headers: env.AGENT_BRIDGE_TOKEN ? { authorization: `Bearer ${env.AGENT_BRIDGE_TOKEN}` } : undefined,
-                    signal: AbortSignal.timeout(1000),
-                });
-                if (response.ok && (await response.json()).status === "ok")
-                    return true;
+                if (address.pid === child?.pid) {
+                    const response = await fetch(`http://127.0.0.1:${address.port}/api/health`, {
+                        headers: env.AGENT_BRIDGE_TOKEN ? { authorization: `Bearer ${env.AGENT_BRIDGE_TOKEN}` } : undefined,
+                        signal: AbortSignal.timeout(1000),
+                    });
+                    if (response.ok && (await response.json()).status === "ok")
+                        return true;
+                }
             }
             catch { /* daemon 尚未就绪 */ }
             await new Promise((done) => setTimeout(done, 1000));
         }
         return false;
     };
-    return { healthy };
+    return { pid: child.pid, healthy };
 }
 let coreUpdateCheckRunning = false;
 function scheduleCoreUpdateCheck() {
@@ -399,24 +443,10 @@ async function main() {
             delete process.env.AGENT_BRIDGE_CORE_UPDATE_CHILD;
             return serve();
         }
-        const logs = new log_store_1.LogStore((0, node_path_1.resolve)(stateDirectory(), "logs"));
-        let launched;
-        const updated = await (0, core_updater_1.updateCoreAtStartup)({
-            packageRoot: (0, node_path_1.resolve)(__dirname, "..", ".."),
-            stateDir: stateDirectory(),
-            stopDaemon: () => stopDaemon(false),
-            startDaemon: async () => { launched = await startUpdatedDaemon(); },
-            waitForHealth: async () => launched?.healthy() ?? false,
-            log: (level, message, fields) => logs.append({ time: new Date().toISOString(), level, source: "核心升级", message, fields }),
-        });
-        if (updated) {
-            await logs.flush();
+        if (await checkCoreUpdate())
             return 0;
-        }
-        if (process.env.AGENT_BRIDGE_CORE_UPDATE_ONLY === "1") {
-            await logs.flush();
+        if (process.env.AGENT_BRIDGE_CORE_UPDATE_ONLY === "1")
             return 0;
-        }
         await stopDaemon(false);
         return serve();
     }

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

@@ -199,34 +199,13 @@ class ControlServer {
             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 logFile = `${process.env.APPDATA ?? process.cwd()}\\agent-bridge\\state\\core-update.log`;
-                    const script = [
-                        "$ErrorActionPreference='Continue'",
-                        `$log = '${logFile.replace(/'/g, "''")}'`,
-                        "$dir = Split-Path -Parent $log",
-                        "New-Item -ItemType Directory -Force $dir | Out-Null",
-                        "function Write-UpdateLog($text) { \"$(Get-Date -Format o) $text\" | Out-File -FilePath $log -Append -Encoding utf8 }",
-                        "Start-Sleep -Seconds 3",
-                        "Write-UpdateLog '停止旧 daemon'",
-                        "schtasks.exe /End /TN mab 2>&1 | ForEach-Object { Write-UpdateLog $_ }",
-                        "Start-Sleep -Seconds 2",
-                        "Write-UpdateLog '开始安装 mu-agent-bridge@latest'",
-                        "npm.cmd install -g mu-agent-bridge@latest --no-fund --no-audit 2>&1 | ForEach-Object { Write-UpdateLog $_ }",
-                        "Write-UpdateLog '重新启动 mab 计划任务'",
-                        "schtasks.exe /Run /TN mab 2>&1 | ForEach-Object { Write-UpdateLog $_ }",
-                        "Write-UpdateLog '后台升级脚本结束'",
-                    ].join('; ');
-                    setTimeout(() => {
-                        const child = (0, node_child_process_1.spawn)("powershell.exe", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", script], { detached: true, stdio: "ignore", windowsHide: true });
-                        child.unref();
-                    }, 1500).unref();
-                }
-                else {
-                    return this.json(res, 501, { error: "当前平台未配置后台升级器" });
-                }
-                return this.json(res, 202, { ok: true, message: "后台正在升级，服务将自动重启" });
+                this.options.manager.log("info", "已请求检查后台更新，有更高版本时自动升级", undefined, "后台升级");
+                setTimeout(() => {
+                    const child = (0, node_child_process_1.spawn)(process.execPath, [(0, node_path_1.resolve)(__dirname, "cli.js"), "update"], { detached: true, stdio: "ignore", windowsHide: true });
+                    child.once("error", error => this.options.manager.log("error", "后台升级进程启动失败", { error: error.message }, "后台升级"));
+                    child.unref();
+                }, 1500).unref();
+                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() });

package/dist/src-ts/core-updater.js

@@ -7,72 +7,180 @@ const node_child_process_1 = require("node:child_process");
 const node_util_1 = require("node:util");
 const version_manager_1 = require("./version-manager");
 const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
-function normalizePath(value) {
-    const path = (0, node_path_1.resolve)(value).replace(/[\\/]+$/, "");
-    return process.platform === "win32" ? path.toLowerCase() : path;
-}
-async function sameDirectory(left, right) {
-    try {
-        return normalizePath(await (0, promises_1.realpath)(left)) === normalizePath(await (0, promises_1.realpath)(right));
-    }
-    catch {
-        return normalizePath(left) === normalizePath(right);
-    }
-}
 async function runNpm(args) {
-    const command = process.platform === "win32" ? "npm.cmd" : "npm";
-    const { stdout } = await execFileAsync(command, args, { timeout: 180_000, maxBuffer: 4 * 1024 * 1024, windowsHide: true, ...(process.platform === "win32" ? { shell: true } : {}) });
+    const options = { timeout: 180_000, maxBuffer: 4 * 1024 * 1024, windowsHide: true };
+    let command = "npm";
+    if (process.platform === "win32") {
+        // 直接调用 npm 的 Node 入口，保证带空格的暂存路径不会被 cmd 拆分。
+        const { stdout } = await execFileAsync("where.exe", ["npm.cmd"], options);
+        args = [(0, node_path_1.join)((0, node_path_1.dirname)(stdout.trim().split(/\r?\n/)[0]), "node_modules", "npm", "bin", "npm-cli.js"), ...args];
+        command = process.execPath;
+    }
+    const { stdout } = await execFileAsync(command, args, options);
     return stdout.trim();
 }
 async function updateCoreAtStartup(options) {
     const npm = options.npm ?? runNpm;
+    let workRoot;
+    let lockPath;
+    let lockCandidate;
+    let locked = false;
+    let busy = false;
+    let keepBackup = false;
     try {
-        const globalRoot = options.globalRoot ?? await npm(["root", "-g"]);
         const packageRoot = (0, node_path_1.resolve)(options.packageRoot);
-        if (!await sameDirectory(packageRoot, (0, node_path_1.join)(globalRoot, "mu-agent-bridge")))
-            return false;
+        await (0, promises_1.mkdir)(options.stateDir, { recursive: true });
+        lockPath = (0, node_path_1.join)((0, node_path_1.resolve)(options.stateDir), "core-update.lock");
+        try {
+            lockCandidate = await (0, promises_1.mkdtemp)((0, node_path_1.join)(options.stateDir, "core-update-lock-"));
+            await (0, promises_1.writeFile)((0, node_path_1.join)(lockCandidate, String(process.pid)), "");
+            await (0, promises_1.rename)(lockCandidate, lockPath);
+            lockCandidate = undefined;
+            locked = true;
+        }
+        catch (error) {
+            if (!["EEXIST", "ENOTEMPTY", "EPERM"].includes(error.code ?? ""))
+                throw error;
+            const owners = await (0, promises_1.readdir)(lockPath);
+            for (const owner of owners.filter(value => /^\d+$/.test(value) && Number(value) > 0)) {
+                try {
+                    process.kill(Number(owner), 0);
+                }
+                catch (ownerError) {
+                    if (ownerError.code === "ESRCH")
+                        await (0, promises_1.rm)((0, node_path_1.join)(lockPath, owner), { force: true });
+                }
+            }
+            // 只删除空锁目录，避免并发清理误删新执行者的锁。
+            if (!await (0, promises_1.readdir)(lockPath).then(entries => entries.length)) {
+                await (0, promises_1.rmdir)(lockPath).catch(() => undefined);
+                return updateCoreAtStartup(options);
+            }
+            busy = true;
+            throw new Error("已有核心升级检查正在运行，请等待完成后重试");
+        }
         const metadata = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.join)(packageRoot, "package.json"), "utf8"));
         if (metadata.name !== "mu-agent-bridge" || !metadata.version)
-            throw new Error("当前全局核心包信息无效");
-        const rawVersion = await npm(["view", "mu-agent-bridge", "version", "--json"]);
+            throw new Error("当前核心包信息无效");
+        const rawVersion = await npm(["view", "mu-agent-bridge@latest", "version", "--json", "--registry=https://registry.npmjs.org"]);
         const latestVersion = (() => { try {
             return String(JSON.parse(rawVersion));
         }
         catch {
             return rawVersion.replace(/^['\"]|['\"]$/g, "");
         } })();
-        if ((0, version_manager_1.compareVersions)(latestVersion, metadata.version) <= 0)
+        if ((0, version_manager_1.compareVersions)(latestVersion, metadata.version) <= 0) {
+            options.log?.("info", "当前核心版本不低于 npmjs 最新版本，保留当前版本", { currentVersion: metadata.version, latestVersion });
             return false;
+        }
         options.log?.("info", "发现 daemon 新版本，开始自动升级", { currentVersion: metadata.version, latestVersion });
-        await (0, promises_1.mkdir)(options.stateDir, { recursive: true });
-        const backupRoot = await (0, promises_1.mkdtemp)((0, node_path_1.join)(options.stateDir, "mab-core-update-"));
-        const backup = (0, node_path_1.join)(backupRoot, "package");
-        await (0, promises_1.cp)(packageRoot, backup, { recursive: true });
+        workRoot = await (0, promises_1.mkdtemp)((0, node_path_1.join)(options.stateDir, "mab-core-update-"));
+        const staging = (0, node_path_1.join)(workRoot, "staging");
+        const candidate = (0, node_path_1.join)(staging, "node_modules", "mu-agent-bridge");
+        const backup = (0, node_path_1.join)(workRoot, "backup");
+        await npm(["install", "--prefix", staging, "--install-strategy=nested", `mu-agent-bridge@${latestVersion}`, "--registry=https://registry.npmjs.org", "--no-fund", "--no-audit"]);
+        const downloaded = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.join)(candidate, "package.json"), "utf8"));
+        if (downloaded.name !== "mu-agent-bridge" || downloaded.version !== latestVersion)
+            throw new Error(`核心包名称或版本不匹配：${downloaded.version ?? "未知版本"}`);
+        await (0, promises_1.readFile)((0, node_path_1.join)(candidate, "dist", "src-ts", "cli.js"));
+        const entries = (await (0, promises_1.readdir)(candidate)).filter(entry => entry !== "plugins" && entry !== "node_modules");
+        for (const entry of await (0, promises_1.readdir)((0, node_path_1.join)(candidate, "node_modules"), { withFileTypes: true }).catch(error => {
+            if (error.code === "ENOENT")
+                return [];
+            throw error;
+        })) {
+            if (entry.name === ".package-lock.json")
+                continue;
+            if (entry.name === ".bin" && entry.isDirectory()) {
+                for (const binary of await (0, promises_1.readdir)((0, node_path_1.join)(candidate, "node_modules", entry.name)))
+                    entries.push((0, node_path_1.join)("node_modules", entry.name, binary));
+            }
+            else if (entry.name.startsWith("@") && entry.isDirectory()) {
+                for (const scoped of await (0, promises_1.readdir)((0, node_path_1.join)(candidate, "node_modules", entry.name)))
+                    entries.push((0, node_path_1.join)("node_modules", entry.name, scoped));
+            }
+            else
+                entries.push((0, node_path_1.join)("node_modules", entry.name));
+        }
+        // 本地安装的插件及其高版本也在 plugins 下，只替换发布包管理的文件。
+        for (const plugin of await (0, promises_1.readdir)((0, node_path_1.join)(candidate, "plugins"), { withFileTypes: true }).catch(error => {
+            if (error.code === "ENOENT")
+                return [];
+            throw error;
+        })) {
+            const pluginPath = (0, node_path_1.join)("plugins", plugin.name);
+            if (plugin.isDirectory()) {
+                for (const entry of await (0, promises_1.readdir)((0, node_path_1.join)(candidate, pluginPath)))
+                    entries.push((0, node_path_1.join)(pluginPath, entry));
+            }
+            else
+                entries.push(pluginPath);
+        }
+        const previousEntries = new Set();
+        await (0, promises_1.mkdir)(backup);
+        for (const entry of entries) {
+            const exists = await (0, promises_1.lstat)((0, node_path_1.join)(packageRoot, entry)).then(() => true, error => {
+                if (error.code === "ENOENT")
+                    return false;
+                throw error;
+            });
+            if (exists) {
+                previousEntries.add(entry);
+                await (0, promises_1.mkdir)((0, node_path_1.dirname)((0, node_path_1.join)(backup, entry)), { recursive: true });
+                await (0, promises_1.cp)((0, node_path_1.join)(packageRoot, entry), (0, node_path_1.join)(backup, entry), { recursive: true, verbatimSymlinks: true });
+            }
+        }
+        let stopped = false;
+        let startedPid;
         try {
             await options.stopDaemon();
-            await npm(["install", "-g", `mu-agent-bridge@${latestVersion}`, "--no-fund", "--no-audit"]);
+            stopped = true;
+            for (const entry of entries) {
+                await (0, promises_1.rm)((0, node_path_1.join)(packageRoot, entry), { recursive: true, force: true });
+                await (0, promises_1.mkdir)((0, node_path_1.dirname)((0, node_path_1.join)(packageRoot, entry)), { recursive: true });
+                await (0, promises_1.cp)((0, node_path_1.join)(candidate, entry), (0, node_path_1.join)(packageRoot, entry), { recursive: true, verbatimSymlinks: true });
+            }
             const installed = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.join)(packageRoot, "package.json"), "utf8"));
             if (installed.name !== "mu-agent-bridge" || installed.version !== latestVersion)
                 throw new Error(`核心安装结果不匹配：${installed.version ?? "未知版本"}`);
-            await options.startDaemon();
+            startedPid = (await options.startDaemon())?.pid;
             if (!await options.waitForHealth())
                 throw new Error("新 daemon 健康检查失败");
             options.log?.("info", "daemon 自动升级成功", { version: latestVersion });
-            await (0, promises_1.rm)(backupRoot, { recursive: true, force: true });
             return true;
         }
         catch (error) {
-            await options.stopDaemon().catch(() => undefined);
-            await (0, promises_1.rm)(packageRoot, { recursive: true, force: true });
-            await (0, promises_1.cp)(backup, packageRoot, { recursive: true });
+            if (!stopped)
+                throw error;
+            keepBackup = true;
+            await options.stopDaemon(startedPid);
+            for (const entry of entries) {
+                await (0, promises_1.rm)((0, node_path_1.join)(packageRoot, entry), { recursive: true, force: true });
+                if (previousEntries.has(entry))
+                    await (0, promises_1.cp)((0, node_path_1.join)(backup, entry), (0, node_path_1.join)(packageRoot, entry), { recursive: true, verbatimSymlinks: true });
+            }
             options.log?.("error", "daemon 自动升级失败，已恢复旧版本", { error: error instanceof Error ? error.message : String(error), version: metadata.version });
-            await options.startDaemon().catch((restartError) => options.log?.("error", "旧 daemon 恢复启动失败", { error: restartError instanceof Error ? restartError.message : String(restartError), version: metadata.version }));
-            await (0, promises_1.rm)(backupRoot, { recursive: true, force: true });
+            startedPid = (await options.startDaemon())?.pid;
+            if (!await options.waitForHealth()) {
+                await options.stopDaemon(startedPid);
+                throw new Error("旧 daemon 恢复后的健康检查失败");
+            }
+            keepBackup = false;
             return false;
         }
     }
     catch (error) {
-        options.log?.("warn", "daemon 自动升级检查失败，继续使用当前版本", { error: error instanceof Error ? error.message : String(error) });
+        options.log?.("warn", keepBackup ? "daemon 恢复失败，升级备份已保留" : "daemon 自动升级检查失败，继续使用当前版本", { error: error instanceof Error ? error.message : String(error), ...(keepBackup ? { backup: workRoot } : {}) });
+        if (keepBackup || busy)
+            throw error;
         return false;
     }
+    finally {
+        if (workRoot && !keepBackup)
+            await (0, promises_1.rm)(workRoot, { recursive: true, force: true });
+        if (locked && lockPath)
+            await (0, promises_1.rm)(lockPath, { recursive: true, force: true });
+        if (lockCandidate)
+            await (0, promises_1.rm)(lockCandidate, { recursive: true, force: true });
+    }
 }

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

@@ -11,6 +11,7 @@ function isDaemonCommand(commandLine, cli) {
         catch { /* 不存在的路径仍按原始路径比较。 */ }
         return value.replace(/[\\/]+/g, "/").toLowerCase();
     };
-    const args = [...commandLine.matchAll(/"([^"]*)"|(\S+)/g)].map((match) => normalize(match[1] ?? match[2]));
+    const values = Array.isArray(commandLine) ? commandLine : [...commandLine.matchAll(/"([^"]*)"|(\S+)/g)].map(match => match[1] ?? match[2]);
+    const args = values.map(normalize);
     return args[1] === normalize(cli) && ["start", "--serve"].includes(args[2]);
 }

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DshAgent = void 0;
+exports.readPresentedFiles = readPresentedFiles;
 const node_child_process_1 = require("node:child_process");
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
@@ -19,7 +20,7 @@ function digest(data) { return (0, node_crypto_1.createHash)("sha256").update(da
 function outputContentType(filename, data) {
     return (0, attachments_1.detectImageContentType)(data) ?? outputMimeTypes[(0, node_path_1.extname)(filename).toLowerCase()] ?? "application/octet-stream";
 }
-async function readPresentedFiles(directory, paths, cwd, inputs, returnPaths) {
+async function readPresentedFiles(directory, paths, cwd, inputs = [], returnPaths = []) {
     if (paths.length > attachments_1.MAX_ATTACHMENTS)
         throw new Error("单条消息最多包含 8 个附件");
     const result = [];
@@ -88,7 +89,11 @@ class DshAgent {
             const inputPaths = (request.attachments ?? []).map((item, index) => ({ path: (0, node_path_1.join)(workDirectory, `${index}-${(0, attachments_1.attachmentFilename)(item.filename)}`), returnPath: (0, node_path_1.join)(outputDirectory, `${index}-${(0, attachments_1.attachmentFilename)(item.filename)}`), filename: item.filename, contentType: item.contentType }));
             for (const [index, item] of (request.attachments ?? []).entries())
                 await (0, promises_1.writeFile)(inputPaths[index].returnPath, item.data, { mode: 0o600 });
-            const task = modelRequest ? request.task : `${request.task}\n\n请使用真实文件工具读取输入附件；生成的回传文件必须写入 outputDirectory 的直接子文件，并调用 present 工具声明文件。原附件已准备 returnPath 副本，原样回传时直接 present 此路径，无需 shell 复制。图片或视频无法理解时请明确说明，仍可原样回传。\n附件传输：\n${JSON.stringify({ inputs: inputPaths, outputDirectory })}`;
+            const task = modelRequest ? request.task : inputPaths.length
+                ? `${request.task}\n\n请读取输入附件；如需回传文件，将文件写入 outputDirectory 的直接子文件并调用 present。原附件可直接使用 returnPath。\n附件传输：\n${JSON.stringify({ inputs: inputPaths, outputDirectory })}`
+                : request.attachmentOutput
+                    ? `${request.task}\n\n如需回传文件，将文件写入 outputDirectory 的直接子文件并调用 present。\n附件传输：\n${JSON.stringify({ outputDirectory })}`
+                    : request.task;
             const args = ["--expose-internals", paths.cli, "--profile", "headless", "--patch", paths.patch, "--json"];
             if (request.sessionId && !request.newSession)
                 args.push("--session-id", request.sessionId);

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpAgent = void 0;
+const agent_1 = require("./agent");
+// 仅供独立 HTTP 通信验收使用，不接入桌面插件的生产调用链。
+class HttpAgent {
+    endpoint;
+    model;
+    name = "dsh-http";
+    constructor(endpoint, model = "qwenwork") {
+        this.endpoint = endpoint;
+        this.model = model;
+    }
+    async send(request) {
+        const response = await fetch(`${this.endpoint.replace(/\/$/, "")}/chat/completions`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ model: this.model, messages: [{ role: "user", content: request.task }], stream: false }),
+            signal: AbortSignal.timeout(request.timeoutMs ?? 300_000),
+        });
+        const body = await response.text();
+        if (!response.ok)
+            throw new agent_1.AgentError(`HTTP Agent 请求失败 (${response.status}): ${body.slice(0, 500)}`);
+        try {
+            const value = JSON.parse(body);
+            const text = value.choices?.[0]?.message?.content?.trim();
+            if (!text)
+                throw new Error("响应 choices[0].message.content 为空");
+            return { text };
+        }
+        catch (error) {
+            throw new agent_1.AgentError("HTTP Agent 返回了无效响应", { cause: error });
+        }
+    }
+}
+exports.HttpAgent = HttpAgent;