agent-bridge-aun 1.0.36 → 1.0.40

package/README.md

@@ -10,7 +10,7 @@
 
 该插件依赖 `@agentunion/fastaun`，要求 Node.js 22.16 或更高版本。
 
-附件回复按图片、视频和普通文件分组发送。MIME 类型为 `video/*` 的附件使用 EvolCore 标准 `type: "video"` 消息，使支持视频预览的 Peer 客户端显示播放器；保留原话题和请求引用。视频沿用 EvolCore 标准上传流程：通过 SDK 上传可公开读取的对象，发送不带分享 URL 的标准对象引用，便于接收端取得下载票据及播放器分段读取；持有对象地址者可读取视频。图片和普通文件继续使用仅原 Peer 可访问的限时分享。该流程由插件独立实现，不调用 `ec` 命令，也不改变各 Agent 插件的产物回传策略。
+附件回复按图片、视频和普通文件分组发送，并保留原话题和请求引用。图片使用不带普通说明正文的 `type: "image"` 消息，说明和下载链接另发加密文本，兼容 AUN 网页的图片卡片显示规则；MIME 类型为 `video/*` 的附件使用 `type: "video"`，普通文件使用 `type: "file"`，二者正文均附下载链接。三类附件参考 EvolCore 的标准附件格式，由插件直接通过 AUN SDK 上传可公开读取的对象，发送不带受限分享 URL 的标准对象引用，便于接收端取得下载票据及播放器分段读取。持有对象地址者可读取附件；旧版本已发送的私有分享不会自动改为公开。发送失败或状态未确认时仍向原 Peer 提供下载链接，不自动重发附件。图片已发送而说明失败时明确报告说明发送阶段，不误报 FS 上传失败。附件链路不调用 `ec` 命令，也不依赖 EvolCore 运行。
 
 ABWeb 的 AUN 设置只展示已连接 AID，并按来源分组。成功注册并记录在插件 `created_aids` 中的 AID 属于本工程；共享密钥库中其余 AID 属于 EvolCore。旧版 `created-aids.json` 记录继续兼容。来源只用于展示，连接和关联由 AUN 插件直接管理。列表先显示已关联 Agent 的身份，各组按最近成功关联的时间倒序排列，时间相同或旧记录没有时间时按 AID 名称排序。关联时间保存在插件配置的 `binding_times` 中，刷新或重启后保留；旧记录不补造时间，再次关联成功后开始记录。
 

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

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

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

@@ -13,7 +13,7 @@ const evolcore_1 = require("./evolcore");
 const messages_1 = require("./messages");
 const attachments_1 = require("./attachments");
 const manifest = {
-    id: "aun", version: "1.0.36", type: "channel", displayName: "AUN 通道",
+    id: "aun", version: "1.0.40", type: "channel", displayName: "AUN 通道",
     entry: "dist/src-ts/plugins/aun/index.js", apiVersion: "1", process: "in-process",
     capabilities: ["channel", "channel.identity.create", "channel.receive", "channel.send", "health", "cli"],
     configSchema: "config.schema.json",
@@ -22,15 +22,14 @@ const manifest = {
 const newSessionCommand = /^\/new(?:[ \t]+[^\r\n]+)?$/;
 const successfulSendStatuses = new Set(["accepted", "sent", "delivered", "duplicate"]);
 function attachmentDownloadLinks(refs) {
-    return refs.flatMap((ref) => typeof ref.url === "string" && ref.url ? [ref.url] : []);
+    return refs.flatMap((ref) => typeof ref.url === "string" && ref.url ? [ref.url]
+        : typeof ref.owner_aid === "string" && typeof ref.object_key === "string" ? [`https://${ref.owner_aid}/${ref.object_key}`] : []);
 }
 function withAttachmentDownloadLinks(text, kind, refs) {
-    if (kind !== "image")
-        return text;
     const links = attachmentDownloadLinks(refs);
     if (!links.length)
         return text;
-    return `${text || "图片已生成。"}\n图片下载链接（预览不可用时）：\n${links.join("\n")}`;
+    return `${text || "附件已生成。"}\n${kind === "file" ? "文件" : "附件"}下载链接：\n${links.join("\n")}`;
 }
 function withFailureDownloadLinks(text, refs) {
     const links = attachmentDownloadLinks(refs);
@@ -960,7 +959,8 @@ class AunPlugin {
             channel: "aun", recipientId: aid, peerId: message.peerId, messageId: message.messageId, text: message.text, threadId: message.threadId,
             ...(attachments.length ? { attachments } : {}),
             agentPlugin,
-            reply: async (text) => {
+            reply: async (text, signal) => {
+                signal?.throwIfAborted();
                 if (!text.trim())
                     return;
                 try {
@@ -972,7 +972,8 @@ class AunPlugin {
                     throw new agent_1.AgentOperationError("AUN_TEXT_SEND_FAILED", "发送 AUN 文本消息（结果未确认，不自动重发）", error);
                 }
             },
-            replyAttachments: async (items, text) => {
+            replyAttachments: async (items, text, signal) => {
+                signal?.throwIfAborted();
                 if (!items.length)
                     return;
                 let sent = 0;
@@ -984,7 +985,8 @@ class AunPlugin {
                     if (!client?.storage)
                         throw new Error("AUN SDK 不支持附件存储接口");
                     const refs = uploadedRefs && uploadedItems === items ? uploadedRefs : await (0, attachments_1.uploadAunAttachments)({ storage: client.storage }, aid, message.peerId, items);
-                    this.context?.logger.info("AUN FS 文件上传与授权完成", { ...trace, stage: "上传并授权附件", files: items.map(item => ({ filename: item.filename, sizeBytes: item.data.byteLength })) });
+                    signal?.throwIfAborted();
+                    this.context?.logger.info("AUN FS 标准附件上传完成", { ...trace, stage: "上传附件", files: items.map(item => ({ filename: item.filename, sizeBytes: item.data.byteLength })) });
                     if (!uploadedRefs || uploadedItems !== items) {
                         uploadedItems = items;
                         uploadedRefs = refs;
@@ -998,8 +1000,10 @@ class AunPlugin {
                     }
                     groupsCount = groups.size;
                     for (const [kind, group] of groups) {
+                        signal?.throwIfAborted();
                         const payloadText = withAttachmentDownloadLinks(text || (kind === "image" ? "图片已生成。" : kind === "video" ? "视频已生成。" : "文件已生成。"), kind, group);
-                        const payload = { type: kind, text: payloadText, attachments: group };
+                        // AUN 网页会隐藏带普通正文的单图卡片，图片说明需另发文本。
+                        const payload = { type: kind, ...(kind === "image" ? {} : { text: payloadText }), attachments: group };
                         if (message.threadId)
                             payload.thread_id = message.threadId;
                         if (message.messageId)
@@ -1008,15 +1012,29 @@ class AunPlugin {
                         fallbackLinks = attachmentDownloadLinks(group);
                         sending = true;
                         // message.send 失败时可能已送达，不自动重试或降级明文，避免重复发送和泄露引用。
-                        const sendResult = await client.call("message.send", { to: message.peerId, payload, encrypt: true });
+                        const sendResult = await this.callAunWithRecovery(aid, { to: message.peerId, payload, encrypt: true });
                         if (typeof sendResult?.status !== "string" || !successfulSendStatuses.has(sendResult.status))
                             throw new Error(`AUN 附件发送状态未确认：${sendResult?.status === undefined ? "未返回状态" : String(sendResult.status)}`);
                         this.context?.logger.info("AUN 附件消息已发送", { ...trace, stage: "发送附件消息", kind, count: group.length });
                         sending = false;
                         sent++;
+                        if (kind === "image" && payloadText) {
+                            try {
+                                signal?.throwIfAborted();
+                                const { attachments: _attachments, ...caption } = payload;
+                                const result = await this.callAunWithRecovery(aid, { to: message.peerId, payload: { ...caption, type: "text", text: payloadText }, encrypt: true });
+                                if (typeof result?.status !== "string" || !successfulSendStatuses.has(result.status))
+                                    throw new Error(`AUN 图片说明发送状态未确认：${result?.status === undefined ? "未返回状态" : String(result.status)}`);
+                                this.context?.logger.info("AUN 图片说明已发送", { ...trace, stage: "发送图片说明" });
+                            }
+                            catch (error) {
+                                throw new agent_1.AgentOperationError("AUN_ATTACHMENT_CAPTION_SEND_FAILED", "图片已发送，发送 AUN 图片说明（结果未确认，不自动重发）", error);
+                            }
+                        }
                     }
                 }
                 catch (error) {
+                    signal?.throwIfAborted();
                     deliveryFailed = true;
                     const failure = sending ? new agent_1.AgentOperationError("AUN_ATTACHMENT_SEND_FAILED", "发送 AUN 附件消息（FS 上传已完成）", error) : error;
                     const progress = sending ? `（已确认发送 ${sent}/${groupsCount} 组，当前组结果未确认，请勿重复发送）` : "";
@@ -1053,12 +1071,38 @@ class AunPlugin {
             payload.thread_id = threadId;
         const params = { to: peerId, payload, encrypt: true };
         try {
-            await this.clients.get(aid).client.call("message.send", params);
+            await this.callAunWithRecovery(aid, params);
         }
         catch (error) {
             if (encryptedOnly || !this.isE2eeError(error))
                 throw error;
-            await this.clients.get(aid).client.call("message.send", { ...params, encrypt: false });
+            await this.callAunWithRecovery(aid, { ...params, encrypt: false });
+        }
+    }
+    async callAunWithRecovery(aid, params) {
+        const connection = this.clients.get(aid);
+        if (!connection)
+            throw new agent_1.AgentOperationError("AUN_CONNECTION_MISSING", "查找 AUN 身份连接", new Error(`AID ${aid} 当前没有已连接的客户端`));
+        try {
+            return await connection.client.call("message.send", params);
+        }
+        catch (error) {
+            if (!isAunWriteNotStarted(error))
+                throw error;
+            this.context?.logger.warn("AUN 发送前连接已断开，正在恢复 AUN 到 Peer 的连接并重试一次", { aid, peer: params.to, stage: "恢复 AUN 连接", error: safeError((0, agent_1.errorDetails)(error)) });
+            try {
+                connection.reconnecting ??= connection.client.connect({ auto_reconnect: true }).finally(() => { connection.reconnecting = undefined; });
+                await connection.reconnecting;
+            }
+            catch (cause) {
+                throw new agent_1.AgentOperationError("AUN_RECONNECT_FAILED", "恢复 AUN 到 Peer 的连接（消息确认未写出）", cause);
+            }
+            try {
+                return await connection.client.call("message.send", params);
+            }
+            catch (cause) {
+                throw new agent_1.AgentOperationError("AUN_SEND_FAILED", "AUN 重连后发送消息（仅重试一次）", cause);
+            }
         }
     }
     isE2eeError(error) {
@@ -1077,6 +1121,14 @@ exports.default = AunPlugin;
 function safeError(error) {
     return redact(error instanceof Error ? error.message : String(error));
 }
+function isAunWriteNotStarted(error) {
+    for (let current = error; current && typeof current === "object"; current = current.cause) {
+        const value = current;
+        if (value.name === "ConnectionError" && typeof value.message === "string" && /^(?:client is not connected|transport not connected|send cancelled before write:|transport closed$)/i.test(value.message))
+            return true;
+    }
+    return false;
+}
 async function readResponse(response, limit) {
     if (!response.body) {
         const raw = await response.text();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-bridge-aun",
-  "version": "1.0.36",
+  "version": "1.0.40",
   "description": "mu-agent-bridge 的 AUN 通道插件。",
   "keywords": [
     "mu-agent-bridge-plugin",

package/plugin.json

@@ -1,6 +1,6 @@
 {
   "id": "aun",
-  "version": "1.0.36",
+  "version": "1.0.40",
   "type": "channel",
   "displayName": "AUN 通道",
   "entry": "dist/src-ts/plugins/aun/index.js",