mu-agent-bridge 1.0.34 → 1.0.39

package/README.md

@@ -14,6 +14,8 @@ npm run start
 
 默认监听 `http://127.0.0.1:26107`，管理页面为 `http://127.0.0.1:26107/abweb/`，管理 API 为 `/api/health`、`/api/plugins`，千问办公的
 OpenAI 兼容 API 为 `/v1/models` 和 `/v1/chat/completions`。管理页面位于 `/abweb`。
+千问办公支持通过 AUN 输入文件、图片和视频附件，并从本轮“已展示最终文件”收集实际输出附件。输入附件文件名会追加本轮唯一后缀并保留扩展名，以便失败时只清理桥接自己的附件。插件等待生成结束后再回传，输出保留文件名和 MIME 类型；桌面客户端不支持的媒体能力以实际回复为准。
+
 千问办公插件使用 CDP `9228`；没有运行千问办公时，daemon 仍会启动，qwenwork 会显示为失败状态，
 可以通过管理 API 重载。
 
@@ -42,6 +44,8 @@ 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)。
+
 ## npm 插件
 
 默认包 `mu-agent-bridge` 已内置 abweb、AUN、千问办公、DSH、豆包、飞书、WorkBuddy 和 ChatGPT/Codex 八个插件，直接安装即可使用：
@@ -142,5 +146,3 @@ Windows 路径时，可设置 `DSH_INSTALL_DIR`。
 ## AUN 身份管理
 
 创建、连接、关联和 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)。
-
-WorkBuddy 执行中的可见消息可经原通道逐条回传，同一请求去重并排除思考过程；配合 `agent-bridge-workbuddy@1.1.11` 使用。插件升级同时刷新内部依赖，避免继续运行旧版客户端。

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

@@ -1,13 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChannelSessions = void 0;
+exports.channelSourceKey = channelSourceKey;
 const node_crypto_1 = require("node:crypto");
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
+function channelSourceKey(message) {
+    return JSON.stringify([message.channel, message.recipientId || "", message.chatId || "", message.peerId, message.threadId || ""]);
+}
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const validSession = (value) => {
+    if (!isRecord(value))
+        return false;
+    return [value.source, value.agentPlugin, value.sessionId, value.updatedAt].every(item => typeof item === "string")
+        && (value.newSession === undefined || typeof value.newSession === "boolean");
+};
 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 = {};
+    active = {};
     loaded;
     writes = Promise.resolve();
     pending = new Map();
@@ -18,25 +30,87 @@ class ChannelSessions {
         this.loaded ??= (async () => {
             try {
                 const data = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.join)(this.directory, "channel-sessions.json"), "utf8"));
-                if (!data || typeof data !== "object" || Array.isArray(data))
+                if (!isRecord(data))
                     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")
-                        throw new Error("通道会话记录无效");
-                    this.sessions[key] = entry;
+                const sessions = {};
+                const active = {};
+                if (data.version === 1) {
+                    if (!isRecord(data.sessions) || !isRecord(data.active))
+                        throw new Error("通道会话文件格式无效");
+                    for (const [id, entry] of Object.entries(data.sessions)) {
+                        if (!validSession(entry) || entry.logicalSessionId !== id || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(id))
+                            throw new Error("通道会话记录无效");
+                        sessions[id] = entry;
+                    }
+                    for (const [source, id] of Object.entries(data.active)) {
+                        if (typeof id !== "string" || sessions[id]?.source !== source)
+                            throw new Error("通道活动绑定无效");
+                        active[source] = id;
+                    }
+                }
+                else {
+                    for (const [source, entry] of Object.entries(data)) {
+                        if (!validSession(entry) || entry.source !== source)
+                            throw new Error("通道会话记录无效");
+                        const logicalSessionId = (0, node_crypto_1.randomUUID)();
+                        sessions[logicalSessionId] = { ...entry, logicalSessionId };
+                        active[source] = logicalSessionId;
+                    }
+                }
+                if (data.version !== 1)
+                    await this.persist(active, sessions);
+                else {
+                    this.sessions = sessions;
+                    this.active = active;
                 }
             }
             catch (error) {
-                if (error.code !== "ENOENT")
+                if (error.code !== "ENOENT") {
+                    this.loaded = undefined;
                     throw error;
+                }
             }
         })();
         await this.loaded;
     }
-    async list() { await this.load(); return Object.values(this.sessions).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)); }
+    async persist(active, sessions) {
+        await (0, promises_1.mkdir)(this.directory, { recursive: true, mode: 0o700 });
+        await (0, promises_1.chmod)(this.directory, 0o700);
+        const file = (0, node_path_1.join)(this.directory, "channel-sessions.json");
+        const temporary = `${file}.${process.pid}.${(0, node_crypto_1.randomUUID)()}.tmp`;
+        try {
+            await (0, promises_1.writeFile)(temporary, `${JSON.stringify({ version: 1, active, sessions }, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+            await (0, promises_1.rename)(temporary, file);
+        }
+        finally {
+            await (0, promises_1.rm)(temporary, { force: true });
+        }
+        this.active = active;
+        this.sessions = sessions;
+    }
+    save(entry) {
+        const save = this.writes.catch(() => { }).then(() => this.persist({ ...this.active, [entry.source]: entry.logicalSessionId }, { ...this.sessions, [entry.logicalSessionId]: entry }));
+        this.writes = save;
+        return save;
+    }
+    async list() { await this.load(); return Object.values(this.sessions).map(entry => ({ ...entry })).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)); }
+    isBusy(source) { return this.pending.has(source); }
+    async current(message, agentPlugin) {
+        await this.load();
+        const source = channelSourceKey(message);
+        const current = this.writes.catch(() => { }).then(async () => {
+            const entry = this.sessions[this.active[source]];
+            if (entry)
+                return { ...entry };
+            const next = { source, logicalSessionId: (0, node_crypto_1.randomUUID)(), agentPlugin, sessionId: (0, node_crypto_1.randomUUID)(), updatedAt: new Date().toISOString(), newSession: true };
+            await this.persist({ ...this.active, [source]: next.logicalSessionId }, { ...this.sessions, [next.logicalSessionId]: next });
+            return { ...next };
+        });
+        this.writes = current.then(() => undefined, () => undefined);
+        return current;
+    }
     async run(message, agentPlugin, call, control) {
-        const source = JSON.stringify([message.channel, message.recipientId || "", message.chatId || "", message.peerId, message.threadId || ""]);
+        const source = channelSourceKey(message);
         const hasAttachments = Boolean(message.attachments?.length);
         const command = hasAttachments ? undefined : message.text?.trim().match(/^\/new(?:[ \t]+([^\r\n]+))?$/);
         const unsupported = hasAttachments ? undefined : message.text?.trim().match(unsupportedCommands);
@@ -59,25 +133,17 @@ class ChannelSessions {
         const previous = this.pending.get(source) ?? Promise.resolve();
         const turn = previous.catch(() => { }).then(async () => {
             await this.load();
-            const entry = this.sessions[source];
-            const sessionId = !command && entry?.agentPlugin === agentPlugin ? entry.sessionId : (0, node_crypto_1.randomUUID)();
+            const active = this.sessions[this.active[source]];
+            const entry = !command && active?.agentPlugin === agentPlugin ? active : undefined;
+            const sessionId = 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);
+                : await call(sessionId, !entry || 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() };
-            const save = this.writes.catch(() => { }).then(async () => {
-                const snapshot = { ...this.sessions, [source]: next };
-                await (0, promises_1.mkdir)(this.directory, { recursive: true });
-                const file = (0, node_path_1.join)(this.directory, "channel-sessions.json");
-                await (0, promises_1.writeFile)(`${file}.tmp`, `${JSON.stringify(snapshot, null, 2)}\n`, { mode: 0o600 });
-                await (0, promises_1.rename)(`${file}.tmp`, file);
-                this.sessions = snapshot;
-            });
-            this.writes = save;
-            await save;
-            return response;
+            const next = { source, logicalSessionId: entry?.logicalSessionId ?? (0, node_crypto_1.randomUUID)(), agentPlugin, sessionId: response.sessionId || sessionId, updatedAt: new Date().toISOString(), ...(command ? { newSession: true } : {}) };
+            await this.save(next);
+            return command ? response : { ...response, source, logicalSessionId: next.logicalSessionId, agentPlugin, request: message, response };
         });
         this.pending.set(source, turn);
         try {

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

@@ -135,6 +135,36 @@ class ControlServer {
             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] === "session-history") {
+                if (!isLoopback(req.socket.remoteAddress) && !authorized)
+                    return this.json(res, 401, { error: "会话归档管理仅允许本机或已认证调用方" });
+                const history = this.options.manager.sessionManagement;
+                const actor = authorized ? "authenticated" : "local";
+                if (method === "GET" && parts.length === 3 && parts[2] === "providers")
+                    return this.json(res, 200, history.providers());
+                if (method === "GET" && parts.length === 3 && parts[2] === "config")
+                    return this.json(res, 200, await history.config());
+                if (method === "PATCH" && parts.length === 3 && parts[2] === "config") {
+                    await history.saveConfig(await this.body(req, 64 * 1024), actor);
+                    return this.json(res, 200, { ok: true });
+                }
+                if (method === "DELETE" && parts.length === 2) {
+                    await history.clear(actor);
+                    return this.json(res, 200, { ok: true });
+                }
+                if (method === "DELETE" && parts.length === 4 && parts[2] === "sessions") {
+                    await history.deleteSession(decodeURIComponent(parts[3]), actor);
+                    return this.json(res, 200, { ok: true });
+                }
+                if (method === "POST" && parts.length === 3 && parts[2] === "delete-source") {
+                    const body = await this.body(req, 64 * 1024);
+                    if (typeof body.source !== "string")
+                        return this.json(res, 400, { error: "需要有效的完整来源键" });
+                    await history.deleteSource(body.source, actor);
+                    return this.json(res, 200, { ok: true });
+                }
+                return this.json(res, 404, { error: "会话归档接口不存在" });
+            }
             if (parts[0] === "api" && parts[1] === "agents" && parts[2] && parts[3] === "v1") {
                 const id = decodeURIComponent(parts[2]);
                 if (req.headers["x-evolcore-session-id"] !== undefined && !authorized && !isLoopback(req.socket.remoteAddress))
@@ -312,14 +342,25 @@ class ControlServer {
         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 {
-        return JSON.parse(raw);
+    async body(req, maxBytes = Infinity) {
+        const chunks = [];
+        let size = 0;
+        for await (const chunk of req) {
+            const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            size += buffer.length;
+            if (size > maxBytes)
+                throw Object.assign(new Error("请求正文不能超过 64 KiB"), { statusCode: 413 });
+            chunks.push(buffer);
+        }
+        if (!size)
+            return {};
+        try {
+            return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+        }
+        catch {
+            throw new Error("请求正文必须是有效 JSON");
+        }
     }
-    catch {
-        throw new Error("invalid JSON body");
-    } }
     json(res, status, value) { res.statusCode = status; res.setHeader("content-type", "application/json; charset=utf-8"); res.end(JSON.stringify(value)); }
 }
 exports.ControlServer = ControlServer;

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

@@ -2,8 +2,64 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DshAgent = void 0;
 const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
 const agent_1 = require("./agent");
+const attachments_1 = require("./attachments");
 const dsh_paths_1 = require("./dsh-paths");
+const outputMimeTypes = {
+    ".csv": "text/csv", ".html": "text/html", ".json": "application/json", ".md": "text/markdown",
+    ".pdf": "application/pdf", ".txt": "text/plain", ".doc": "application/msword", ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".mp4": "video/mp4", ".mov": "video/quicktime", ".webm": "video/webm", ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".webp": "image/webp",
+};
+function digest(data) { return (0, node_crypto_1.createHash)("sha256").update(data).digest("hex"); }
+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) {
+    if (paths.length > attachments_1.MAX_ATTACHMENTS)
+        throw new Error("单条消息最多包含 8 个附件");
+    const result = [];
+    const root = (0, node_path_1.resolve)(directory);
+    if (await (0, promises_1.realpath)(directory) !== root || !(await (0, promises_1.lstat)(directory)).isDirectory())
+        throw new Error("DSH 输出目录已被替换");
+    let total = 0;
+    for (const value of paths) {
+        const target = (0, node_path_1.resolve)(cwd, value);
+        if ((0, node_path_1.dirname)(target) !== root || (0, node_path_1.dirname)(await (0, promises_1.realpath)(target)) !== root)
+            throw new Error("DSH 回传附件路径超出输出目录");
+        if (!(await (0, promises_1.lstat)(target)).isFile())
+            throw new Error("DSH 回传附件不是普通文件");
+        const handle = await (0, promises_1.open)(target, node_fs_1.constants.O_RDONLY | (node_fs_1.constants.O_NOFOLLOW ?? 0));
+        let data;
+        try {
+            const info = await handle.stat();
+            if (!info.isFile() || info.size < 1 || info.size > attachments_1.MAX_ATTACHMENT_BYTES)
+                throw new Error("DSH 回传附件大小无效，单个附件不能超过 32 MiB");
+            total += info.size;
+            if (total > attachments_1.MAX_TOTAL_ATTACHMENT_BYTES)
+                throw new Error("单条消息附件总大小不能超过 64 MiB");
+            const buffer = Buffer.alloc(info.size + 1);
+            const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+            if (bytesRead !== info.size)
+                throw new Error("DSH 回传附件大小发生变化");
+            data = new Uint8Array(buffer.subarray(0, bytesRead));
+        }
+        finally {
+            await handle.close();
+        }
+        const source = inputs[returnPaths.indexOf(target)];
+        const original = source && digest(source.data) === digest(data) ? source : inputs.find((input) => input.filename === (0, node_path_1.basename)(target) && digest(input.data) === digest(data));
+        const filename = (0, attachments_1.attachmentFilename)(original?.filename ?? (0, node_path_1.basename)(target));
+        const contentType = original?.contentType ?? outputContentType(filename, data);
+        result.push({ kind: contentType.startsWith("image/") ? "image" : "file", data, filename, contentType });
+    }
+    (0, attachments_1.validateAttachments)(result);
+    return result;
+}
 class DshAgent {
     name = "dsh";
     paths;
@@ -17,54 +73,93 @@ class DshAgent {
     async send(request) {
         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)
-            args.push("--session-id", request.sessionId);
-        args.push("-");
-        const child = this.spawnProcess(this.paths.executable, args, {
-            cwd: request.cwd,
-            env: { ...process.env, ELECTRON_RUN_AS_NODE: "1" },
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        child.stdin.end(request.task, "utf8");
-        let output = "";
-        let errors = "";
-        let sessionId = request.sessionId;
-        let finalText = "";
-        child.stdout.setEncoding?.("utf8");
-        child.stderr.setEncoding?.("utf8");
-        child.stdout.on("data", (chunk) => {
-            output += chunk;
-            for (const line of output.split(/\r?\n/).slice(0, -1)) {
-                try {
-                    const event = JSON.parse(line);
-                    if (event.type === "session" && event.sessionId)
-                        sessionId = event.sessionId;
-                    if (event.type === "final" && event.text)
-                        finalText = event.text.trim();
+        (0, attachments_1.validateAttachments)(request.attachments);
+        const workDirectory = await (0, promises_1.mkdtemp)((0, node_path_1.join)((0, node_os_1.tmpdir)(), "agent-bridge-dsh-"));
+        let failed = false;
+        try {
+            const outputDirectory = (0, node_path_1.join)(workDirectory, "output");
+            await (0, promises_1.mkdir)(outputDirectory, { recursive: true });
+            for (const [index, item] of (request.attachments ?? []).entries())
+                await (0, promises_1.writeFile)((0, node_path_1.join)(workDirectory, `${index}-${(0, attachments_1.attachmentFilename)(item.filename)}`), item.data, { mode: 0o600 });
+            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 = `${request.task}\n\n请使用真实文件工具读取输入附件；生成的回传文件必须写入 outputDirectory 的直接子文件，并调用 present 工具声明文件。原附件已准备 returnPath 副本，原样回传时直接 present 此路径，无需 shell 复制。图片或视频无法理解时请明确说明，仍可原样回传。\n附件传输：\n${JSON.stringify({ inputs: inputPaths, outputDirectory })}`;
+            const args = ["--expose-internals", this.paths.cli, "--profile", "headless", "--patch", this.paths.patch, "--json"];
+            if (request.sessionId && !request.newSession)
+                args.push("--session-id", request.sessionId);
+            args.push("-");
+            const child = this.spawnProcess(this.paths.executable, args, {
+                cwd: request.cwd,
+                env: { ...process.env, ELECTRON_RUN_AS_NODE: "1" },
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+            let output = "";
+            let errors = "";
+            let sessionId = request.newSession ? undefined : request.sessionId;
+            let sessionCwd = request.cwd ?? process.cwd();
+            let finalText = "";
+            const presented = new Set();
+            const presentCalls = new Map();
+            child.stdout.setEncoding?.("utf8");
+            child.stderr.setEncoding?.("utf8");
+            child.stdout.on("data", (chunk) => {
+                output += chunk;
+                for (const line of output.split(/\r?\n/).slice(0, -1)) {
+                    try {
+                        const event = JSON.parse(line);
+                        if (event.type === "session" && event.sessionId)
+                            sessionId = event.sessionId;
+                        if (event.type === "session" && event.cwd)
+                            sessionCwd = event.cwd;
+                        if (event.type === "final" && event.text)
+                            finalText = event.text.trim();
+                        if (event.type === "tool_call" && event.tool === "present" && event.callId)
+                            presentCalls.set(event.callId, (event.input?.files ?? []).map((file) => file.path).filter((path) => typeof path === "string"));
+                        if (event.type === "tool_result" && event.status === "completed" && event.callId)
+                            for (const path of presentCalls.get(event.callId) ?? [])
+                                presented.add(path);
+                    }
+                    catch { /* 忽略诊断输出和未完成的 JSON 行。 */ }
                 }
-                catch { /* diagnostics and partial lines are ignored */ }
-            }
-            output = output.split(/\r?\n/).at(-1) ?? "";
-        });
-        child.stderr.on("data", (chunk) => { errors += chunk; });
-        await new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                child.kill();
-                reject(new agent_1.AgentError(`DSH task timed out after ${request.timeoutMs ?? this.defaultTimeoutMs}ms`));
-            }, request.timeoutMs ?? this.defaultTimeoutMs);
-            child.once("error", (error) => { clearTimeout(timer); reject(new agent_1.AgentError("failed to start DSH", { cause: error })); });
-            child.once("close", (code) => {
-                clearTimeout(timer);
-                if (code !== 0 && !finalText)
-                    reject(new agent_1.AgentError(errors.trim() || `DSH exited with code ${code}`));
-                else
-                    resolve();
+                output = output.split(/\r?\n/).at(-1) ?? "";
+            });
+            child.stderr.on("data", (chunk) => { errors += chunk; });
+            await new Promise((resolve, reject) => {
+                const timer = setTimeout(() => {
+                    child.kill();
+                    reject(new agent_1.AgentError(`DSH task timed out after ${request.timeoutMs ?? this.defaultTimeoutMs}ms`));
+                }, request.timeoutMs ?? this.defaultTimeoutMs);
+                child.once("error", (error) => { clearTimeout(timer); reject(new agent_1.AgentError("failed to start DSH", { cause: error })); });
+                child.once("close", (code) => {
+                    clearTimeout(timer);
+                    if (code !== 0 && !finalText)
+                        reject(new agent_1.AgentError(errors.trim() || `DSH exited with code ${code}`));
+                    else
+                        resolve();
+                });
+                child.stdin.end(task, "utf8");
             });
-        });
-        if (!finalText)
-            throw new agent_1.AgentError("DSH returned no final text");
-        return { text: finalText, sessionId };
+            if (request.newSession && !sessionId)
+                throw new agent_1.AgentError("DSH 未返回真实新会话标识，无法确认后续续聊目标");
+            const attachments = await readPresentedFiles(outputDirectory, [...presented], sessionCwd, request.attachments ?? [], inputPaths.map((item) => item.returnPath));
+            if (!finalText && !attachments.length)
+                throw new agent_1.AgentError("DSH 未返回正文或附件");
+            return { text: finalText, sessionId, ...(attachments?.length ? { attachments } : {}) };
+        }
+        catch (error) {
+            failed = true;
+            throw error;
+        }
+        finally {
+            try {
+                await (0, promises_1.rm)(workDirectory, { recursive: true, force: true });
+            }
+            catch (error) {
+                if (!failed)
+                    throw error;
+            }
+        }
     }
 }
 exports.DshAgent = DshAgent;

package/dist/src-ts/headless-account.patch.yml

@@ -1,5 +1,12 @@
-# Select the account-backed model used by the DeepSeek Harness desktop login.
+# 复用 DeepSeek Harness 桌面端登录账号的模型。
 - id: agent-default-model
   config:
     provider: deepseek-account
     model: deepseek-chat
+
+# headless 默认未挂载交付工具，显式启用真实文件交付事件。
+- insert:
+    - id: tool-present
+      name: '@deepseek-ai/dsh-tool-present'
+      config:
+        maxFiles: 8

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

@@ -18,6 +18,7 @@ const version_manager_1 = require("./version-manager");
 const plugin_catalog_1 = require("./plugin-catalog");
 const log_store_1 = require("./log-store");
 const channel_sessions_1 = require("./channel-sessions");
+const session_management_1 = require("./session-management");
 const _2020_1 = __importDefault(require("ajv/dist/2020"));
 const attachments_1 = require("./attachments");
 const logger = { info() { }, warn() { }, error() { } };
@@ -26,9 +27,11 @@ class PluginManager {
     options;
     controlUrl;
     plugins = new Map();
+    upgrades = new Map();
     httpRoutes = new Map();
     root;
     messages = [];
+    activeIngress = new Map();
     trustConfig = defaultPluginTrustConfig();
     trustLoaded = false;
     publisherLookups = new Map();
@@ -36,12 +39,14 @@ class PluginManager {
     versions;
     logs;
     sessions;
+    sessionManagement;
     constructor(options) {
         this.options = options;
         this.root = (0, node_path_1.resolve)(options.pluginsDir);
         this.versions = options.versions ?? new version_manager_1.VersionManager({ stateDir: options.stateDir });
         this.logs = new log_store_1.LogStore((0, node_path_1.join)(options.stateDir, "logs"));
         this.sessions = new channel_sessions_1.ChannelSessions(options.stateDir);
+        this.sessionManagement = new session_management_1.SessionManagement(options.stateDir, (operation, fields) => this.log("info", operation, fields, "会话管理"), { list: () => this.sessions.list(), isBusy: source => this.sessions.isBusy(source) || this.activeIngress.has(source) }, () => [...this.plugins.entries()].flatMap(([pluginId, loaded]) => loaded.instance?.sessionHistory ? [{ pluginId, provider: loaded.instance.sessionHistory, identity: loaded.instance, status: loaded.record.status }] : []));
     }
     log(level, message, fields, source = "mab") { this.logs.append({ time: new Date().toISOString(), level, source, message, ...(fields ? { fields } : {}) }); }
     setControlUrl(url) { this.controlUrl = url; }
@@ -162,6 +167,22 @@ class PluginManager {
             })]);
     }
     async upgradePackage(id, packageName = `agent-bridge-${id}`, version) {
+        const pending = this.upgrades.get(id);
+        if (pending) {
+            if (pending.packageName === packageName && pending.version === version)
+                return pending.task;
+            throw new agent_1.AgentError("插件正在升级，请等待完成后再请求其他版本");
+        }
+        const task = this.performUpgrade(id, packageName, version);
+        this.upgrades.set(id, { packageName, version, task });
+        try {
+            return await task;
+        }
+        finally {
+            this.upgrades.delete(id);
+        }
+    }
+    async performUpgrade(id, packageName, version) {
         if (!/^agent-bridge-[a-z0-9-]+$/.test(packageName))
             throw new agent_1.AgentError("仅支持 agent-bridge-* npm 包名");
         if (version && !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version))
@@ -358,20 +379,41 @@ class PluginManager {
                 pluginStatus: (targetId) => this.plugins.get(targetId)?.record.status,
                 ingress: {
                     publish: async (message) => {
+                        if (message.channel !== id)
+                            throw new agent_1.AgentError("消息来源与通道插件身份不一致");
+                        const trustedChannel = loaded.record.type === "channel" && (id === "aun" || id === "feishu");
+                        if (trustedChannel && (typeof message.peerId !== "string" || !message.peerId.trim() || [message.peerId, message.recipientId, message.chatId, message.threadId].some(value => value !== undefined && (typeof value !== "string" || value.length > 512 || /[\u0000-\u001f*]/.test(value)))))
+                            throw new agent_1.AgentError("通道来源标识无效");
                         const target = message.agentPlugin || "qwenwork";
+                        if (/^\/sessions(?:\s|$)/.test(message.text.trimStart())) {
+                            if (!trustedChannel)
+                                throw new agent_1.AgentError("当前通道不支持会话管理");
+                            const current = await this.sessions.current(message, target);
+                            const result = await this.sessionManagement.command(message.text, { source: current.source, sessionId: current.logicalSessionId });
+                            await message.reply(result);
+                            return;
+                        }
+                        if (trustedChannel)
+                            await this.sessionManagement.ready();
+                        const archiveToken = trustedChannel ? this.sessionManagement.archiveWriteToken((0, channel_sessions_1.channelSourceKey)(message)) : undefined;
                         this.recordMessage(target, "request", message.text, message.peerId);
+                        const source = (0, channel_sessions_1.channelSourceKey)(message);
+                        if (trustedChannel)
+                            this.activeIngress.set(source, (this.activeIngress.get(source) ?? 0) + 1);
                         try {
                             const instance = this.plugins.get(target)?.instance;
-                            const control = instance?.sessionOperations?.includes("new") && instance.controlSession
+                            const control = instance?.sessionOperations?.includes("new")
                                 ? (request) => this.controlSession(target, request)
                                 : undefined;
                             const task = !message.text.trim() && message.attachments?.length ? "请处理收到的附件" : message.text;
                             const forwarded = new Set();
+                            const sent = [];
                             const onMessage = async (text) => {
                                 if (!text.trim() || forwarded.has(text))
                                     return;
                                 await message.reply(text);
                                 forwarded.add(text);
+                                sent.push({ text });
                                 this.recordMessage(target, "reply", text, message.peerId);
                             };
                             const response = await this.sessions.run(message, target, (sessionId, newSession) => this.handle(target, { task, sessionId, onMessage, ...(newSession ? { newSession: true } : {}), ...(message.attachments ? { attachments: message.attachments } : {}) }), control);
@@ -383,15 +425,37 @@ class PluginManager {
                                     throw new agent_1.AgentError("当前通道不支持附件回传");
                                 }
                                 await message.replyAttachments(attachments, response.text);
+                                sent.push({ text: response.text, attachments });
                                 this.recordMessage(target, "reply", response.text, message.peerId);
                             }
                             else
                                 await onMessage(response.text);
+                            if (trustedChannel && response.source && response.logicalSessionId) {
+                                const identity = { sessionId: response.logicalSessionId, source: response.source, principal: response.source, channel: message.channel, agentPlugin: target, completed: true, time: new Date().toISOString() };
+                                const requestId = message.messageId || (0, node_crypto_1.randomUUID)();
+                                const metadata = (items) => items?.map(item => ({ filename: item.filename, contentType: item.contentType, sizeBytes: item.data.byteLength }));
+                                try {
+                                    await this.sessionManagement.recordIngressTurns(source, archiveToken, [
+                                        { ...identity, role: "user", text: message.text, requestId, messageId: message.messageId ? `${message.messageId}:user` : undefined, attachments: metadata(message.attachments) },
+                                        ...sent.map((item, index) => ({ ...identity, role: "assistant", text: item.text, requestId, messageId: message.messageId ? `${message.messageId}:assistant:${index}` : undefined, attachments: metadata(item.attachments) })),
+                                    ]);
+                                }
+                                catch {
+                                    this.log("warn", "会话归档失败", { sessionId: identity.sessionId, status: "failed" }, "会话管理");
+                                }
+                            }
                         }
                         catch (error) {
                             this.recordMessage(target, "error", error instanceof Error ? error.message : String(error), message.peerId);
                             throw error;
                         }
+                        finally {
+                            const remaining = (this.activeIngress.get(source) ?? 1) - 1;
+                            if (remaining)
+                                this.activeIngress.set(source, remaining);
+                            else
+                                this.activeIngress.delete(source);
+                        }
                     },
                 },
                 runtime: { controlUrl: this.controlUrl, ports: {
@@ -557,9 +621,11 @@ class PluginManager {
         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) || !loaded.instance.controlSession)
+        if (!loaded.instance.sessionOperations?.includes(request.operation))
             throw new agent_1.AgentError(`插件 ${id} 不支持新建会话`);
-        const response = await loaded.instance.controlSession(request);
+        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;