mu-agent-bridge 1.0.32 → 1.0.33

package/README.md

@@ -142,19 +142,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)。
-
-### 飞书凭据与办公 Agent 关联
-
-在 ABWeb 的“飞书通道 → 手动配置凭据”中填写 App ID、App Secret，并选择“关联办公 Agent”。Secret 使用密码框显示；已保存的密钥保持掩码，不通过状态接口返回。WorkBuddy、千问办公、豆包根据运行后台的机器上是否存在可执行文件检测，文件缺失或插件未就绪的选项置灰。自定义安装位置请在对应插件配置中填写 `executablePath`。
-
-也可以使用 CLI，Secret 在命令执行后隐藏输入，不写在命令参数中：
-
-```bash
-mab feishu configure cli_你的应用ID --agent workbuddy
-mab feishu agents
-mab feishu list
-mab feishu bind cli_你的应用ID workbuddy
-mab feishu unbind cli_你的应用ID
-```
-
-`configure` 保存凭据及可选关联后，需要在 ABWeb 重载飞书插件以连接机器人。非交互终端请使用网页密码框；不要把 Secret 写进命令行、脚本或仓库。

package/dist/src-ts/attachments.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_TOTAL_ATTACHMENT_BYTES = exports.MAX_ATTACHMENTS = exports.MAX_ATTACHMENT_BYTES = void 0;
+exports.detectImageContentType = detectImageContentType;
+exports.attachmentFilename = attachmentFilename;
+exports.validateAttachment = validateAttachment;
+exports.validateAttachments = validateAttachments;
+exports.asAttachments = asAttachments;
+exports.MAX_ATTACHMENT_BYTES = 32 * 1024 * 1024;
+exports.MAX_ATTACHMENTS = 8;
+exports.MAX_TOTAL_ATTACHMENT_BYTES = 64 * 1024 * 1024;
+function detectImageContentType(data) {
+    if (data.length >= 8 && data.slice(0, 8).every((value, index) => value === [137, 80, 78, 71, 13, 10, 26, 10][index]))
+        return "image/png";
+    if (data.length >= 3 && data[0] === 0xff && data[1] === 0xd8 && data[2] === 0xff)
+        return "image/jpeg";
+    if (data.length >= 12 && String.fromCharCode(...data.slice(0, 4)) === "RIFF" && String.fromCharCode(...data.slice(8, 12)) === "WEBP")
+        return "image/webp";
+    return undefined;
+}
+function attachmentFilename(filename) {
+    if (typeof filename !== "string" || /[\u0000-\u001f\u007f]/.test(filename))
+        throw new Error("附件文件名无效");
+    const name = filename.split(/[\\/]/).pop() ?? "";
+    if (!name.trim() || name === "." || name === "..")
+        throw new Error("附件文件名无效");
+    return name;
+}
+function validateAttachment(item) {
+    if (!item || !(item.data instanceof Uint8Array) || item.data.byteLength === 0)
+        throw new Error("附件内容不能为空");
+    if (item.data.byteLength > exports.MAX_ATTACHMENT_BYTES)
+        throw new Error("单个附件不能超过 32 MiB");
+    attachmentFilename(item.filename);
+    if (item.kind !== "image" && item.kind !== "file")
+        throw new Error("附件类型无效");
+    if (typeof item.contentType !== "string" || !/^[A-Za-z0-9!#$&^_.+-]+\/[A-Za-z0-9!#$&^_.+-]+$/.test(item.contentType))
+        throw new Error("附件 MIME 类型无效");
+    if (item.kind === "image") {
+        const detected = detectImageContentType(item.data);
+        if (!detected || detected !== item.contentType.toLowerCase())
+            throw new Error("图片内容与 MIME 类型不一致");
+    }
+}
+function validateAttachments(items) {
+    if (!items)
+        return;
+    if (!Array.isArray(items))
+        throw new Error("附件列表无效");
+    if (items.length > exports.MAX_ATTACHMENTS)
+        throw new Error("单条消息最多包含 8 个附件");
+    let total = 0;
+    for (const item of items) {
+        validateAttachment(item);
+        total += item.data.byteLength;
+    }
+    if (total > exports.MAX_TOTAL_ATTACHMENT_BYTES)
+        throw new Error("单条消息附件总大小不能超过 64 MiB");
+}
+function asAttachments(images) {
+    return (images ?? []).map((image) => ({ ...image, kind: "image" }));
+}

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

@@ -22,7 +22,7 @@ class ChannelSessions {
                     throw new Error("通道会话文件格式无效");
                 for (const [key, value] of Object.entries(data)) {
                     const entry = value;
-                    if (!entry || typeof entry.sessionId !== "string" || typeof entry.source !== "string" || typeof entry.agentPlugin !== "string" || typeof entry.updatedAt !== "string" || (entry.newSession !== undefined && typeof entry.newSession !== "boolean"))
+                    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;
                 }
@@ -37,13 +37,14 @@ class ChannelSessions {
     async list() { await this.load(); return Object.values(this.sessions).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)); }
     async run(message, agentPlugin, call, control) {
         const source = JSON.stringify([message.channel, message.recipientId || "", message.chatId || "", message.peerId, message.threadId || ""]);
-        const command = message.text?.trim().match(/^\/new(?:[ \t]+([^\r\n]+))?$/);
-        const unsupported = message.text?.trim().match(unsupportedCommands);
+        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);
         if (unsupported)
             return { text: `会话命令 ${unsupported[0].split(/[ \t]/, 1)[0]} 本期暂不支持` };
-        if (/^\/clear(?:[ \t]+[^\r\n]*)?$/.test(message.text?.trim() ?? ""))
+        if (!hasAttachments && /^\/clear(?:[ \t]+[^\r\n]*)?$/.test(message.text?.trim() ?? ""))
             return { text: "/clear 已移除，请使用 /new 新建会话" };
-        if (message.text?.trim() === "/help")
+        if (!hasAttachments && message.text?.trim() === "/help")
             return { text: [
                     control ? "/new [名称]：新建并切换会话" : "/new [名称]：当前 Agent 插件不支持新建会话",
                     "话题中不支持 /new；/renew 及其他会话命令当前暂不支持",
@@ -62,10 +63,10 @@ class ChannelSessions {
             const sessionId = !command && entry?.agentPlugin === agentPlugin ? entry.sessionId : (0, node_crypto_1.randomUUID)();
             const response = command
                 ? await control({ operation: "new", sessionId, ...(command[1]?.trim() ? { name: command[1].trim() } : {}) })
-                : await call(sessionId, !entry || entry.agentPlugin !== agentPlugin || entry.newSession === true);
+                : await call(sessionId);
             if (command && (typeof response.sessionId !== "string" || !response.sessionId.trim()))
                 throw new Error("插件未返回有效的新会话标识，原会话绑定保持不变");
-            const next = { source, agentPlugin, sessionId: response.sessionId || sessionId, updatedAt: new Date().toISOString(), ...(command ? { newSession: true } : {}) };
+            const 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 });

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

@@ -5,7 +5,6 @@ exports.resolveLocalControlHost = resolveLocalControlHost;
 exports.controlUrl = controlUrl;
 exports.runPluginCommand = runPluginCommand;
 exports.runCoreHelp = runCoreHelp;
-const secret_input_1 = require("./secret-input");
 const node_http_1 = require("node:http");
 const MAX_BODY_BYTES = 1024 * 1024;
 const PLUGIN_ID = /^[a-z][a-z0-9-]{1,63}$/;
@@ -109,7 +108,6 @@ function commandManifest(value, plugin) {
         || !Array.isArray(value.commands) || value.commands.some((command) => !object(command)
         || typeof command.name !== "string" || !/^[a-z][a-z0-9-]*$/.test(command.name)
         || typeof command.summary !== "string" || !command.summary.trim() || typeof command.usage !== "string" || !command.usage.trim()
-        || (command.secretPrompt !== undefined && (typeof command.secretPrompt !== "string" || !command.secretPrompt.trim()))
         || (command.examples !== undefined && (!Array.isArray(command.examples) || command.examples.some((example) => typeof example !== "string"))))) {
         throw new CliError("插件命令清单协议无效（需要 protocolVersion: 1）");
     }
@@ -128,7 +126,7 @@ async function runPluginCommand(id, args, port, options = {}) {
             throw new CliError(`插件“${id}”未安装；请先到 ABWeb 安装插件`, 2);
         if (!plugin.capabilities.includes("cli"))
             throw new CliError(`插件“${plugin.displayName}”未提供 CLI 命令；请升级对应插件`, 2);
-        if (!["ready", "degraded"].includes(plugin.status))
+        if (plugin.status !== "ready")
             throw new CliError(`插件“${plugin.displayName}”未就绪（${plugin.status}）`, 2);
         const path = `/api/plugins/${id}/commands`;
         const response = await requestJson(port, path, options);
@@ -148,9 +146,7 @@ async function runPluginCommand(id, args, port, options = {}) {
                 ])].join("\n");
             return output({ ok: true, message, data: { ...manifest, commands: selected } }, 0, json);
         }
-        const prompt = manifest.commands.find((command) => command.name === argv[0])?.secretPrompt;
-        const secret = prompt ? await (options.readSecret ?? secret_input_1.readSecret)(prompt) : undefined;
-        const executed = await requestJson(port, path, options, { protocolVersion: 1, argv, ...(secret === undefined ? {} : { secret }) });
+        const executed = await requestJson(port, path, options, { protocolVersion: 1, argv });
         const result = executed.value;
         if (!object(result) || typeof result.ok !== "boolean" || typeof result.message !== "string"
             || (executed.status >= 200 && executed.status < 300 ? !result.ok : result.ok)

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

@@ -221,8 +221,6 @@ class ControlServer {
                 const result = await identity.create(body.aid, body.ownerAid);
                 return this.json(res, result.status === "等待 Owner 确认" ? 202 : result.status === "existing" ? 200 : 201, result);
             }
-            if (method === "GET" && url.pathname === "/api/agents/availability")
-                return this.json(res, 200, { agents: await this.options.manager.availableAgents() });
             if (method === "GET" && url.pathname === "/api/plugins")
                 return this.json(res, 200, { ok: true, plugins: this.options.manager.list() });
             if (method === "GET" && url.pathname === "/api/plugins/catalog")

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

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

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

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

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

@@ -19,13 +19,13 @@ const plugin_catalog_1 = require("./plugin-catalog");
 const log_store_1 = require("./log-store");
 const channel_sessions_1 = require("./channel-sessions");
 const _2020_1 = __importDefault(require("ajv/dist/2020"));
+const attachments_1 = require("./attachments");
 const logger = { info() { }, warn() { }, error() { } };
 const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
 class PluginManager {
     options;
     controlUrl;
     plugins = new Map();
-    upgrades = new Map();
     httpRoutes = new Map();
     root;
     messages = [];
@@ -162,22 +162,6 @@ 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))
@@ -378,11 +362,22 @@ class PluginManager {
                         this.recordMessage(target, "request", message.text, message.peerId);
                         try {
                             const instance = this.plugins.get(target)?.instance;
-                            const control = instance?.sessionOperations?.includes("new")
+                            const control = instance?.sessionOperations?.includes("new") && instance.controlSession
                                 ? (request) => this.controlSession(target, request)
                                 : undefined;
-                            const response = await this.sessions.run(message, target, (sessionId, newSession) => this.handle(target, { task: message.text, sessionId, ...(newSession ? { newSession: true } : {}) }), control);
-                            await message.reply(response.text);
+                            const task = !message.text.trim() && message.attachments?.length ? "请处理收到的附件" : message.text;
+                            const response = await this.sessions.run(message, target, (sessionId) => this.handle(target, { task, sessionId, ...(message.attachments ? { attachments: message.attachments } : {}) }), control);
+                            const attachments = response.attachments?.length ? response.attachments : (0, attachments_1.asAttachments)(response.images);
+                            (0, attachments_1.validateAttachments)(attachments);
+                            if (attachments.length) {
+                                if (!message.replyAttachments) {
+                                    await message.reply("当前通道不支持附件回传");
+                                    throw new agent_1.AgentError("当前通道不支持附件回传");
+                                }
+                                await message.replyAttachments(attachments, response.text);
+                            }
+                            else
+                                await message.reply(response.text);
                             this.recordMessage(target, "reply", response.text, message.peerId);
                         }
                         catch (error) {
@@ -545,17 +540,18 @@ class PluginManager {
             const reason = loaded?.record.error ? `启动错误：${loaded.record.error}` : `当前状态：${loaded?.record.status ?? "未发现"}`;
             throw new agent_1.AgentError(`插件“${name}”无法调用，插件未就绪：${processText}${reason}`);
         }
+        (0, attachments_1.validateAttachments)(request.attachments);
+        if (request.attachments?.length && !loaded.instance.attachmentInput)
+            throw new agent_1.AgentError(`插件 ${id} 不支持接收附件`);
         return loaded.instance.handle(request);
     }
     async controlSession(id, request) {
         const loaded = this.plugins.get(id);
         if (!loaded?.instance || loaded.record.status !== "ready")
             throw new agent_1.AgentError(`插件 ${id} 未就绪，无法控制会话`);
-        if (!loaded.instance.sessionOperations?.includes(request.operation))
+        if (!loaded.instance.sessionOperations?.includes(request.operation) || !loaded.instance.controlSession)
             throw new agent_1.AgentError(`插件 ${id} 不支持新建会话`);
-        const response = loaded.instance.controlSession
-            ? await loaded.instance.controlSession(request)
-            : { text: `${loaded.record.displayName} 已创建新会话`, sessionId: request.sessionId };
+        const response = await loaded.instance.controlSession(request);
         if (typeof response.sessionId !== "string" || !response.sessionId.trim())
             throw new agent_1.AgentError("插件未返回有效的新会话标识，原会话绑定保持不变");
         return response;
@@ -630,13 +626,10 @@ class PluginManager {
         const packagedFile = (0, node_path_1.join)(record.path, record.manifest.entry);
         const developmentFile = (0, node_path_1.resolve)(__dirname, "plugins", record.id, (0, node_path_1.basename)(record.manifest.entry));
         const file = (0, node_fs_1.existsSync)(packagedFile) ? packagedFile : developmentFile;
-        // 同时刷新插件内部依赖，避免升级后仍运行旧版 CDP 客户端。
+        // CommonJS is the platform's compiled format; evict the module cache for reload.
         const req = (0, node_module_1.createRequire)(file);
         const resolved = req.resolve(file);
-        const moduleRoot = (0, node_fs_1.existsSync)(packagedFile) ? (0, node_path_1.resolve)(record.path) : (0, node_path_1.dirname)(file);
-        for (const cached of Object.keys(req.cache))
-            if (cached === resolved || cached.startsWith(`${moduleRoot}${node_path_1.sep}`))
-                delete req.cache[cached];
+        delete req.cache[resolved];
         const mod = req(resolved);
         let value = mod.default ?? mod.plugin ?? mod;
         // Entries may export a ready instance, a factory, or a class. Supporting all

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

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAunAttachment = parseAunAttachment;
+exports.downloadAunAttachments = downloadAunAttachments;
+exports.downloadAunAttachment = downloadAunAttachment;
+exports.uploadAunAttachments = uploadAunAttachments;
+const node_crypto_1 = require("node:crypto");
+const attachments_1 = require("../../attachments");
+const aidPattern = /^[a-z0-9][a-z0-9_-]{2,63}\.[a-z0-9-]+(?:\.[a-z0-9-]+)+$/;
+const mimePattern = /^[A-Za-z0-9!#$&^_.+-]+\/[A-Za-z0-9!#$&^_.+-]+$/;
+const imageTypes = new Set(["image/png", "image/jpeg", "image/webp"]);
+function digest(data) { return (0, node_crypto_1.createHash)("sha256").update(data).digest("hex"); }
+function validKey(key) { return /^[A-Za-z0-9._-]+(?:\/[A-Za-z0-9._-]+)*$/.test(key) && !key.split("/").some((part) => part === "." || part === ".."); }
+function validHash(value) { return /^[a-f0-9]{64}$/i.test(value); }
+function validateReference(ref) {
+    if (!aidPattern.test(ref.ownerAid) || !/^[A-Za-z0-9_-][A-Za-z0-9._-]{0,63}$/.test(ref.bucket) || !validKey(ref.objectKey))
+        throw new Error("AUN 附件引用路径无效");
+    (0, attachments_1.attachmentFilename)(ref.filename);
+    if (ref.contentType !== undefined && !mimePattern.test(ref.contentType))
+        throw new Error("AUN 附件 MIME 类型无效");
+    if (ref.sizeBytes !== undefined && (!Number.isSafeInteger(ref.sizeBytes) || ref.sizeBytes < 1 || ref.sizeBytes > attachments_1.MAX_ATTACHMENT_BYTES))
+        throw new Error("AUN 附件大小无效，单个附件不能超过 32 MiB");
+    if (ref.sha256 !== undefined && !validHash(ref.sha256))
+        throw new Error("AUN 附件哈希无效");
+    if (ref.token !== undefined && !/^[A-Za-z0-9._~-]{1,4096}$/.test(ref.token))
+        throw new Error("AUN 附件分享令牌无效");
+}
+function pathToken(value, ownerAid, objectKey) {
+    const url = new URL(value);
+    if (url.protocol !== "https:" || url.username || url.password || url.port || url.hash || url.hostname !== ownerAid || url.pathname !== `/${objectKey}`)
+        throw new Error("AUN 附件链接与对象引用不一致");
+    const tokens = url.searchParams.getAll("t");
+    if (tokens.length > 1 || tokens.length === 1 && !tokens[0])
+        throw new Error("AUN 附件分享令牌无效");
+    return tokens[0];
+}
+function parseAunAttachment(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("AUN 附件引用无效");
+    const item = value;
+    const ownerAid = typeof item.owner_aid === "string" ? item.owner_aid : "";
+    const objectKey = typeof item.object_key === "string" ? item.object_key : "";
+    const bucket = item.bucket === undefined ? "default" : typeof item.bucket === "string" ? item.bucket : "";
+    const filename = (0, attachments_1.attachmentFilename)(typeof item.filename === "string" ? item.filename : objectKey);
+    const ref = { ownerAid, bucket, objectKey, filename };
+    if (item.content_type !== undefined) {
+        if (typeof item.content_type !== "string")
+            throw new Error("AUN 附件 MIME 类型无效");
+        ref.contentType = item.content_type.toLowerCase();
+    }
+    if (item.size_bytes !== undefined) {
+        if (typeof item.size_bytes !== "number")
+            throw new Error("AUN 附件大小无效");
+        ref.sizeBytes = item.size_bytes;
+    }
+    if (item.sha256 !== undefined) {
+        if (typeof item.sha256 !== "string")
+            throw new Error("AUN 附件哈希无效");
+        ref.sha256 = item.sha256.toLowerCase();
+    }
+    validateReference(ref);
+    if (item.url !== undefined) {
+        if (typeof item.url !== "string")
+            throw new Error("AUN 附件链接无效");
+        const token = pathToken(item.url, ownerAid, objectKey);
+        if (token)
+            ref.token = token;
+    }
+    validateReference(ref);
+    return ref;
+}
+function metadataValue(meta, field, alias) { return meta[field] ?? (alias ? meta[alias] : undefined); }
+function checkedMetadata(meta, ref) {
+    const size = metadataValue(meta, "size", "size_bytes");
+    if (typeof size !== "number" || !Number.isSafeInteger(size) || size < 1 || size > attachments_1.MAX_ATTACHMENT_BYTES)
+        throw new Error("AUN 附件元数据大小无效");
+    if (ref.sizeBytes !== undefined && ref.sizeBytes !== size)
+        throw new Error("AUN 附件大小校验失败");
+    if (meta.type && meta.type !== "file")
+        throw new Error("AUN 附件对象不是文件");
+    if ([meta.owner, meta.owner_aid].some((owner) => owner && owner !== ref.ownerAid) || meta.bucket && meta.bucket !== ref.bucket
+        || [meta.path, meta.object_key].some((path) => path && path !== `/${ref.objectKey}` && path !== ref.objectKey))
+        throw new Error("AUN 附件元数据引用不一致");
+    const rawType = metadataValue(meta, "contentType", "content_type");
+    if (rawType && (typeof rawType !== "string" || !mimePattern.test(rawType)))
+        throw new Error("AUN 附件元数据 MIME 类型无效");
+    const contentType = typeof rawType === "string" && rawType ? rawType.toLowerCase() : ref.contentType ?? "application/octet-stream";
+    if (ref.contentType && rawType && ref.contentType.toLowerCase() !== contentType)
+        throw new Error("AUN 附件 MIME 类型校验失败");
+    const sha256 = typeof meta.sha256 === "string" && meta.sha256 ? meta.sha256.toLowerCase() : undefined;
+    if (sha256 && !validHash(sha256))
+        throw new Error("AUN 附件元数据哈希无效");
+    if (sha256 && ref.sha256 && sha256 !== ref.sha256.toLowerCase())
+        throw new Error("AUN 附件哈希校验失败");
+    return { size, contentType, ...(sha256 ? { sha256 } : {}) };
+}
+async function downloadAunAttachments(client, refs) {
+    if (refs.length > attachments_1.MAX_ATTACHMENTS)
+        throw new Error("单条消息最多包含 8 个附件");
+    const entries = [];
+    let total = 0;
+    for (const ref of refs) {
+        validateReference(ref);
+        const options = { owner: ref.ownerAid, bucket: ref.bucket, ...(ref.token ? { token: ref.token } : {}) };
+        let inlineContent;
+        let downloadUrl;
+        let rawMetadata;
+        if (ref.token) {
+            if (!client.storage.lowlevel?.getByShare)
+                throw new Error("AUN SDK 不支持受限分享附件");
+            rawMetadata = await client.storage.lowlevel.getByShare({ shareId: ref.token });
+            if (!rawMetadata.object_key && !rawMetadata.path)
+                throw new Error("AUN 分享附件缺少对象引用");
+            if (typeof rawMetadata.content === "string")
+                inlineContent = rawMetadata.content;
+            else if (typeof rawMetadata.download_url === "string")
+                downloadUrl = rawMetadata.download_url;
+            else
+                throw new Error("AUN 分享附件缺少内容或下载票据");
+        }
+        else
+            rawMetadata = await client.storage.stat(`/${ref.objectKey}`, options);
+        const metadata = checkedMetadata(rawMetadata, ref);
+        total += metadata.size;
+        if (total > attachments_1.MAX_TOTAL_ATTACHMENT_BYTES)
+            throw new Error("单条消息附件总大小不能超过 64 MiB");
+        entries.push({ ref, options, inlineContent, downloadUrl, ...metadata });
+    }
+    const result = [];
+    for (const { ref, options, inlineContent, downloadUrl, size, contentType, sha256 } of entries) {
+        if (inlineContent !== undefined && (inlineContent.length > Math.ceil(attachments_1.MAX_ATTACHMENT_BYTES / 3) * 4 || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(inlineContent)))
+            throw new Error("AUN 分享附件 Base64 无效");
+        let data;
+        if (inlineContent !== undefined)
+            data = new Uint8Array(Buffer.from(inlineContent, "base64"));
+        else if (downloadUrl !== undefined)
+            data = await readDownloadTicket(downloadUrl, size);
+        else {
+            try {
+                data = await client.storage.readBytes(`/${ref.objectKey}`, { ...options, limit: attachments_1.MAX_ATTACHMENT_BYTES + 1 });
+            }
+            catch (error) {
+                const failure = error;
+                const inlineLimit = ["EINLINE", "EINLINE_LIMIT", "ERR_INLINE_LIMIT", "INLINE_LIMIT", "-32033"].includes(String(failure.code)) || failure.code === -32602 && /inline/i.test(failure.message ?? "");
+                if (!inlineLimit || !client.storage.lowlevel?.createDownloadTicket)
+                    throw error;
+                const ticket = await client.storage.lowlevel.createDownloadTicket({ owner: ref.ownerAid, bucket: ref.bucket, objectKey: ref.objectKey });
+                if (typeof ticket.download_url !== "string")
+                    throw new Error("AUN 附件缺少下载票据");
+                if (ticket.sha256 && ticket.sha256 !== sha256 && ticket.sha256 !== ref.sha256)
+                    throw new Error("AUN 附件下载票据哈希不一致");
+                data = await readDownloadTicket(ticket.download_url, size);
+            }
+        }
+        if (!(data instanceof Uint8Array) || data.byteLength !== size)
+            throw new Error("AUN 附件大小校验失败");
+        const actualHash = digest(data);
+        if (ref.sha256 && actualHash !== ref.sha256.toLowerCase() || sha256 && actualHash !== sha256)
+            throw new Error("AUN 附件哈希校验失败");
+        result.push({ kind: imageTypes.has(contentType) ? "image" : "file", data, filename: (0, attachments_1.attachmentFilename)(ref.filename), contentType });
+    }
+    (0, attachments_1.validateAttachments)(result);
+    return result;
+}
+function checkedDownloadUrl(url) {
+    if (url.protocol !== "https:" || url.username || url.password || url.port || url.hash || !url.hostname.includes(".") || /^(?:localhost|127\.|0\.|10\.|192\.168\.|169\.254\.|172\.(?:1[6-9]|2\d|3[01])\.)/.test(url.hostname) || url.hostname.includes(":"))
+        throw new Error("AUN 下载地址无效");
+    return url;
+}
+async function readDownloadTicket(value, expectedSize) {
+    let url = checkedDownloadUrl(new URL(value));
+    const signal = AbortSignal.timeout(60_000);
+    let response;
+    // 票据和每跳地址都需校验；共用超时，不携带 AID 凭据或向跳转地址补充查询参数。
+    for (let redirects = 0;; redirects++) {
+        response = await fetch(url.href, { redirect: "manual", signal });
+        if (![301, 302, 303, 307, 308].includes(response.status))
+            break;
+        const location = response.headers.get("location");
+        await response.body?.cancel();
+        if (!location)
+            throw new Error("AUN 附件下载重定向缺少地址");
+        if (redirects >= 3)
+            throw new Error("AUN 附件下载重定向次数过多");
+        url = checkedDownloadUrl(new URL(location, url));
+    }
+    if (!response.ok || !response.body) {
+        await response.body?.cancel();
+        throw new Error(`AUN 附件下载失败：HTTP ${response.status}`);
+    }
+    const length = response.headers.get("content-length");
+    if (length !== null && Number(length) !== expectedSize) {
+        await response.body.cancel();
+        throw new Error("AUN 附件大小校验失败");
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let size = 0;
+    try {
+        while (true) {
+            const item = await reader.read();
+            if (item.done)
+                break;
+            size += item.value.byteLength;
+            if (size > expectedSize)
+                throw new Error("AUN 附件大小校验失败");
+            chunks.push(item.value);
+        }
+    }
+    finally {
+        await reader.cancel();
+    }
+    if (size !== expectedSize)
+        throw new Error("AUN 附件大小校验失败");
+    return new Uint8Array(Buffer.concat(chunks));
+}
+async function downloadAunAttachment(client, ref) { return (await downloadAunAttachments(client, [ref]))[0]; }
+async function uploadAunAttachments(client, ownerAid, peerAid, items) {
+    (0, attachments_1.validateAttachments)(items);
+    if (!aidPattern.test(ownerAid) || !aidPattern.test(peerAid))
+        throw new Error("AUN 附件分享 AID 无效");
+    const result = [];
+    for (const item of items) {
+        const filename = (0, attachments_1.attachmentFilename)(item.filename);
+        const objectKey = `shared/${(0, node_crypto_1.randomUUID)()}/${filename.replace(/[^A-Za-z0-9._-]/g, "_")}`;
+        const sha256 = digest(item.data);
+        const ref = { ownerAid, bucket: "default", objectKey, filename, contentType: item.contentType.toLowerCase(), sizeBytes: item.data.byteLength, sha256 };
+        const uploaded = await client.storage.writeBytes(`/${objectKey}`, item.data, { contentType: item.contentType, public: false, overwrite: false });
+        checkedMetadata({ ...uploaded, size: uploaded.size ?? uploaded.size_bytes ?? item.data.byteLength }, ref);
+        const share = await client.storage.lowlevel.createShareLink({ owner: ownerAid, bucket: "default", objectKey, allowedAids: [peerAid], expireInSeconds: 86400 });
+        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 });
+    }
+    return result;
+}