agent-bridge-aun 1.0.49 → 1.0.58

package/README.md

@@ -23,7 +23,7 @@ mab aun repair-old-aids --json
 
 安装后在 ABWeb 的插件管理中启动 AUN 通道。收到的 AID 消息仅投递给用户在 AUN 身份页中明确关联的 Agent；未关联的 AID 消息会被忽略。旧配置中的 `agent_plugin` 字段不再作为默认路由。配置字段 `owner_aid` 是可选字符串，用作默认 Owner。AID 创建接口为 `POST /api/plugins/aun/aid`，请求内容为 `{"aid":"新AID.agentid.cn","owner_aid":"所有者AID.agentid.cn"}`。
 
-创建调用 SDK 0.5.31 的 `register(aid, { type: "agent", owner })`。注册、连接成功与 Owner 双边共识是不同状态；Owner 声明仍可能为 `single_sided/pending`，不能把“已创建”解释为归属已激活。创建后尝试把新 AID 加入 Owner 名录，默认 `allow_pa_use: true`；只有本地拥有 Owner 私钥且 Storage 可用时才能同步，失败通过 `directorySync` 单独返回。Gateway 信任根使用随插件提供并校验指纹的 AUN 根证书，不从 Gateway 下载未经验证的 CA 链。
+创建调用 SDK 0.5.31 的 `register(aid, { type: "agent", owner })`。注册、连接成功与 Owner 双边共识是不同状态；Owner 声明仍可能为 `single_sided/pending`，不能把“已创建”解释为归属已激活。创建后先读取新鲜签名归属；关联请求已送达但 Owner 尚未确认时，接口返回 `202`、`status: "等待 Owner 确认"`，页面和 CLI 仅给普通提醒，日志为 `info`，不重复注册或发送邀请，也不尝试用 Owner 公钥登录。仅共识成立后尝试把新 AID 加入 Owner 名录，默认 `allow_pa_use: true`；只有本地拥有 Owner 私钥且 Storage 可用时才能同步，失败通过 `directorySync` 单独返回。Gateway 信任根使用随插件提供并校验指纹的 AUN 根证书，不从 Gateway 下载未经验证的 CA 链。
 
 核心支持插件命令后，可运行 `mab aun status`、`mab aun list`、`mab aun agents`、`mab aun default-owner`、`mab aun default-owner set <owner-aid>`、`mab aun create <aid> [--owner <owner-aid>] [--agent <plugin-id>]`、`mab aun bind <aid> <plugin-id>` 和 `mab aun unbind <aid>`。关联或解绑只修改指定 AID，不会影响同一 Agent 下的其它 AID，也不会写入 Agent 全局 AID 配置。`default-owner` 不带参数显示当前配置，`default-owner set <owner-aid>` 校验格式并持久化新的默认值。`create` 明确传入 `--owner` 时优先使用该值；省略时回退到同一配置中的 `owner_aid`，两者都没有时返回错误，不会创建 AID。创建新身份时，实际使用的 Owner 会保存为下次默认值。ABWeb 从同一插件配置读取 `owner_aid` 并预填创建表单，因此 CLI 和 ABWeb 共用默认 Owner。Agent 从当前已就绪的插件动态发现。创建后连接或关联失败时，响应会标明 AID 已创建；先用 `mab aun list` 检查，不要重试创建。运行日志不记录原始参数或 Owner AID；默认 Owner 查询会在终端显示当前值。
 
@@ -72,3 +72,10 @@ AUN 独立包支持核心后台每五分钟检测更新；可信提供者在自
 ## Ability Owner 确认
 
 能力发布和远程调用审批由配置的 `ability_owners[providerAid]` 对应 Owner 在 AUN 加密私聊中管理。发送 `/ability help` 查看命令；`/ability list` 查看能力，`/ability publish <路径...>` 发布，`/ability revoke` 撤销，`/ability pending` 查看待审批清单。逐项处理使用通知中的 `/ability approve <操作键> <确认指纹>` 或 `/ability reject <操作键> <确认指纹>`。只有一项已送达申请时可直接回复“确认”或“拒绝”；多项需先送达固定清单，再用这两个词批量处理。新申请不会加入已展示清单，插件重载后需重新发送 `/ability pending`。Owner 首次发送有效管理命令时，AUN 验证其已配置 AID 并持久保存验证记录；远端消息不能设置或认领 Owner。能力的网页发布、Owner 验证和待审批区域已从 ABWeb 移除；已认证的本机管理 API 保留用于兼容旧管理客户端。
+
+
+### 按 Peer 持续授权
+
+Owner 在完整调用申请通知下回复“允许12小时”，或使用 `/ability approve <操作键> <确认指纹> 12h`，可允许所示 Peer 对此 Provider 的此项能力连续调用12小时，覆盖该契约的所有合法参数。另可回复“永久允许”或 `/ability approve <操作键> <确认指纹> permanent`，授权同一范围直到撤销或配置改变。普通“确认”仍只批准本次。多项时先 `/ability pending` 核对固定清单。通知里的完整授权标签也可直接回复；缺少完整清单时会重新展示，核对后再回复，不会将审批标签交给桌面执行。
+
+`/ability grants` 查看到期及撤销命令，`/ability revoke-grant <授权ID>` 随时撤销。重载不会续期，其他 Peer 或能力不能复用；取消发布、解绑或更换 Owner 会撤销。已过 TTL 的旧调用不会因授权恢复执行。详见本工程 `docs/aun-ability-call-flow.md`。

package/dist/src-ts/plugins/aun/ability-control.js

@@ -1,17 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAbilitySelectionText = isAbilitySelectionText;
 exports.parseAbilityControl = parseAbilityControl;
 exports.parseAbilityControlMessage = parseAbilityControlMessage;
 const aidPattern = /^[a-z0-9][a-z0-9_-]{2,63}\.[a-z0-9-]+(?:\.[a-z0-9-]+)+$/;
 const pathPattern = /^(?!protocol\/|definitions\/)[a-z0-9]+(?:[a-z0-9._-]*[a-z0-9])?(?:\/[a-z0-9]+(?:[a-z0-9._-]*[a-z0-9])?)+$/;
 const fingerprintPattern = /^[0-9a-f]{64}$/;
 const maxControlTextLength = 4096;
+const selectionPattern = /^\d+(?:[,\s]+\d+)*$/;
+function isAbilitySelectionText(text) {
+    return selectionPattern.test(text.trim());
+}
 function parseAbilityControl(text) {
     if (text === "确认")
         return { action: "confirm-view" };
     if (text === "拒绝")
         return { action: "reject-view" };
+    if (text === "允许12小时" || text === "允许该 Peer 使用此能力12小时")
+        return { action: "grant-view", grantDurationMs: 43_200_000 };
+    if (text === "永久允许" || text === "永久允许该 Peer 使用此能力")
+        return { action: "grant-view", grantDurationMs: null };
     const trimmed = text.replace(/^ +| +$/g, "");
+    if (isAbilitySelectionText(trimmed)) {
+        const indexes = trimmed.replace(/,/g, " ").split(/\s+/).map(value => Number(value));
+        if (indexes.some(value => !Number.isSafeInteger(value) || value < 1))
+            throw new Error("Ability 清单编号格式无效：请使用从 1 开始的编号");
+        if (new Set(indexes).size !== indexes.length)
+            throw new Error("Ability 清单编号不能重复");
+        return { action: "select-view", indexes };
+    }
     if (!/^\/ability(?:\s|$)/.test(trimmed))
         return undefined;
     if (text.length > maxControlTextLength)
@@ -19,7 +36,7 @@ function parseAbilityControl(text) {
     if (!/^[a-z0-9./ _-]+$/.test(trimmed))
         throw new Error("Ability 管理命令格式无效：请发送单行完整命令，仅使用空格分隔参数");
     const [, action, ...args] = trimmed.split(/ +/);
-    if (["help", "list", "revoke", "pending"].includes(action) && args.length === 0)
+    if (["help", "list", "revoke", "pending", "grants"].includes(action) && args.length === 0)
         return { action: action };
     if (action === "publish") {
         if (!args.length)
@@ -30,10 +47,15 @@ function parseAbilityControl(text) {
             throw new Error("Ability 发布路径不能重复");
         return { action, paths: args };
     }
-    if ((action === "approve" || action === "reject") && args.length === 2) {
-        if (!args.every(value => fingerprintPattern.test(value)))
+    if ((action === "approve" || action === "reject") && (args.length === 2 || args.length === 3)) {
+        if (!args.slice(0, 2).every(value => fingerprintPattern.test(value)))
             throw new Error("Ability 操作键与确认指纹格式无效：必须是完整的 64 位小写十六进制摘要");
-        return { action, key: args[0], confirmationFingerprint: args[1] };
+        if (args.length === 3 && (action !== "approve" || !["12h", "permanent"].includes(args[2])))
+            throw new Error("持续授权只支持批准命令的 12h 或 permanent 选项");
+        return { action, key: args[0], confirmationFingerprint: args[1], ...(args.length === 3 ? { grantDurationMs: args[2] === "permanent" ? null : 43_200_000 } : {}) };
+    }
+    if (action === "revoke-grant" && args.length === 1 && /^[0-9a-f-]{16,128}$/.test(args[0])) {
+        return { action, grantId: args[0] };
     }
     throw new Error("Ability 管理命令或参数数量不正确，请发送 /ability help 查看用法");
 }

package/dist/src-ts/plugins/aun/ability-operation-store.js

@@ -90,10 +90,22 @@ function validEntry(value) {
         return false;
     }
 }
+function validGrant(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const grant = value;
+    return [grant.id, grant.providerAid, grant.authenticatedCaller, grant.path, grant.definitionId, grant.issuedByAid].every(value => typeof value === "string" && value.length > 0 && value.length <= 512)
+        && Array.isArray(grant.effects) && grant.effects.length > 0 && grant.effects.every(value => typeof value === "string")
+        && !!grant.executionTarget && typeof grant.executionTarget === "object" && !Array.isArray(grant.executionTarget) && grant.executionTarget.ownerAid === grant.issuedByAid
+        && Number.isSafeInteger(grant.createdAt) && grant.createdAt >= 0
+        && (grant.expiresAt === null || Number.isSafeInteger(grant.expiresAt) && grant.expiresAt - grant.createdAt === 43_200_000)
+        && (grant.revokedAt === undefined || Number.isSafeInteger(grant.revokedAt) && grant.revokedAt >= grant.createdAt);
+}
 class AbilityOperationStore {
     file;
     now;
     entries = new Map();
+    grants = new Map();
     writes = Promise.resolve();
     constructor(file, now) {
         this.file = file;
@@ -117,7 +129,9 @@ class AbilityOperationStore {
         catch {
             throw failure("operation_store_corrupt", "操作账本损坏，已停止新的执行");
         }
-        if (!snapshot || snapshot.version !== 1 || !Array.isArray(snapshot.entries) || !snapshot.entries.every(validEntry))
+        if (!snapshot || ![1, 2].includes(snapshot.version) || !Array.isArray(snapshot.entries) || !snapshot.entries.every(validEntry)
+            || (snapshot.version === 2 && !Array.isArray(snapshot.grants))
+            || (snapshot.grants !== undefined && (!Array.isArray(snapshot.grants) || !snapshot.grants.every(validGrant))))
             throw failure("operation_store_corrupt", "操作账本格式无效，已停止新的执行");
         let migrated = false;
         for (const saved of snapshot.entries) {
@@ -137,6 +151,12 @@ class AbilityOperationStore {
                 store.entries.set(entry.key, entry);
             migrated ||= legacy;
         }
+        for (const saved of (snapshot.grants ?? [])) {
+            if (store.grants.has(saved.id))
+                throw failure("operation_store_corrupt", "授权账本含重复授权 ID");
+            store.grants.set(saved.id, saved);
+        }
+        migrated ||= snapshot.version === 1;
         if (migrated)
             await store.persist(new Map(store.entries));
         await store.interruptExecuting();
@@ -147,11 +167,11 @@ class AbilityOperationStore {
         this.writes = next;
         return next;
     }
-    async persist(next) {
+    async persist(next, grants = this.grants) {
         const directory = (0, node_path_1.dirname)(this.file);
         await (0, promises_1.mkdir)(directory, { recursive: true, mode: 0o700 });
         const temp = `${this.file}.${(0, node_crypto_1.randomUUID)()}.tmp`;
-        const data = `${JSON.stringify({ version: 1, entries: [...next.values()] })}\n`;
+        const data = `${JSON.stringify({ version: 2, entries: [...next.values()], grants: [...grants.values()] })}\n`;
         try {
             const handle = await (0, promises_1.open)(temp, "wx", 0o600);
             try {
@@ -163,6 +183,7 @@ class AbilityOperationStore {
             }
             await (0, promises_1.rename)(temp, this.file);
             this.entries = next;
+            this.grants = grants;
         }
         finally {
             await (0, promises_1.rm)(temp, { force: true });
@@ -209,14 +230,16 @@ class AbilityOperationStore {
             return { created: true, entry: structuredClone(entry) };
         });
     }
-    approve(key, fingerprint) {
-        return this.confirm(key, fingerprint, true);
+    approve(key, fingerprint, options = {}) {
+        return this.confirm(key, fingerprint, true, options.grantDurationMs, options.grantId);
     }
     reject(key, fingerprint) {
         return this.confirm(key, fingerprint, false);
     }
-    confirm(key, fingerprint, approve) {
+    confirm(key, fingerprint, approve, grantDurationMs, grantId) {
         return this.serial(async () => {
+            if (grantDurationMs !== undefined && (!approve || grantDurationMs !== null && grantDurationMs !== 43_200_000))
+                throw failure("grant_invalid", "持续授权只支持批准 12 小时或永久");
             const expired = this.expirePending(this.entries, this.now());
             if (expired.changed)
                 await this.persist(expired.entries);
@@ -227,6 +250,8 @@ class AbilityOperationStore {
                 throw failure("confirmation_mismatch", "确认内容与原请求不一致");
             if (existing.state !== "pending_confirmation")
                 return { started: false, entry: structuredClone(existing) };
+            if (grantId && !this.grantActive(grantId, existing))
+                throw failure("grant_unavailable", "持续授权已到期、撤销或范围不匹配");
             const now = this.now();
             const confirmationExpired = now >= existing.confirmationExpiresAt;
             const messageExpired = now >= existing.expiresAt;
@@ -236,8 +261,56 @@ class AbilityOperationStore {
                 ...(!started ? { result: confirmationExpired ? response(existing, "confirmation_expired", "Owner 确认申请已过期，不会执行") : approve && messageExpired ? response(existing, "message_expired", "调用已超过最晚启动时间") : response(existing, "user_denied", "Owner 已拒绝本次调用") } : {}) };
             const next = new Map(this.entries);
             next.set(key, entry);
-            await this.persist(next);
-            return { started, entry: structuredClone(entry) };
+            let grant = grantId ? this.grants.get(grantId) : undefined;
+            const ownerAid = typeof existing.executionTarget.ownerAid === "string" ? existing.executionTarget.ownerAid : "";
+            if (grantDurationMs !== undefined && !ownerAid)
+                throw failure("grant_invalid", "持续授权缺少明确 Owner");
+            if (grantDurationMs !== undefined && ownerAid && !existing.result) {
+                grant = { id: (0, node_crypto_1.randomUUID)(), providerAid: existing.providerAid, authenticatedCaller: existing.authenticatedCaller,
+                    path: existing.path, definitionId: existing.definitionId, effects: [...existing.effects], executionTarget: structuredClone(existing.executionTarget),
+                    issuedByAid: ownerAid, createdAt: now, expiresAt: grantDurationMs === null ? null : now + grantDurationMs };
+                const grants = new Map(this.grants);
+                grants.set(grant.id, grant);
+                await this.persist(next, grants);
+            }
+            else
+                await this.persist(next);
+            return { started, entry: structuredClone(entry), ...(grant ? { grant: structuredClone(grant) } : {}) };
+        });
+    }
+    grantActive(id, input) {
+        const grant = this.grants.get(id);
+        return Boolean(grant && grant.revokedAt === undefined && (grant.expiresAt === null || grant.expiresAt > this.now())
+            && grant.providerAid === input.providerAid && grant.authenticatedCaller === input.authenticatedCaller
+            && grant.path === input.path && grant.definitionId === input.definitionId
+            && grant.executionTarget.pluginId === input.executionTarget.pluginId
+            && grant.executionTarget.pluginVersion === input.executionTarget.pluginVersion
+            && grant.executionTarget.ownerAid === input.executionTarget.ownerAid);
+    }
+    activeGrant(input) {
+        return this.serial(async () => {
+            const grant = [...this.grants.values()].find(item => this.grantActive(item.id, input));
+            return grant ? structuredClone(grant) : undefined;
+        });
+    }
+    listGrants(providerAid) {
+        return this.serial(async () => [...this.grants.values()]
+            .filter(grant => providerAid === undefined || grant.providerAid === providerAid)
+            .map(grant => structuredClone(grant)));
+    }
+    revokeGrant(providerAid, grantId) {
+        return this.serial(async () => {
+            const grant = this.grants.get(grantId);
+            if (!grant || grant.providerAid !== providerAid)
+                throw failure("grant_not_found", "授权不存在");
+            if (grant.revokedAt === undefined) {
+                const next = new Map(this.grants);
+                const revoked = { ...grant, revokedAt: this.now() };
+                next.set(grantId, revoked);
+                await this.persist(this.entries, next);
+                return structuredClone(revoked);
+            }
+            return structuredClone(grant);
         });
     }
     finish(key, state, result) {
@@ -313,6 +386,13 @@ class AbilityOperationStore {
             const now = this.now();
             const expired = this.expirePending(this.entries, now);
             const next = expired.entries;
+            const grants = new Map(this.grants);
+            let grantsChanged = false;
+            for (const [id, grant] of grants)
+                if (grant.providerAid === providerAid && grant.revokedAt === undefined) {
+                    grants.set(id, { ...grant, revokedAt: now });
+                    grantsChanged = true;
+                }
             let invalidated = 0;
             for (const entry of next.values()) {
                 if (entry.providerAid !== providerAid || entry.state !== "pending_confirmation")
@@ -322,8 +402,8 @@ class AbilityOperationStore {
                     result: response(entry, code, message) });
                 invalidated++;
             }
-            if (invalidated || expired.changed)
-                await this.persist(next);
+            if (invalidated || expired.changed || grantsChanged)
+                await this.persist(next, grants);
             return invalidated;
         });
     }

package/dist/src-ts/plugins/aun/agentmd-command.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAgentMdCommand = parseAgentMdCommand;
+/** 只识别整条名片命令；引号用于分隔参数，文本从不交给 shell。 */
+function parseAgentMdCommand(text) {
+    const prefix = text.match(/^(?:ec[ \t]+aid|mab[ \t]+aun)[ \t]+agentmd(?:[ \t]+|$)/);
+    if (!prefix)
+        return undefined;
+    const input = text.slice(prefix[0].length);
+    const args = [];
+    let position = 0;
+    while (position < input.length) {
+        while (/\s/.test(input[position] ?? "") && position < input.length)
+            position++;
+        if (position === input.length)
+            break;
+        const quote = input[position];
+        if (quote === "'" || quote === '"') {
+            const start = position++;
+            if (quote === '"') {
+                while (position < input.length) {
+                    if (input[position] === "\\") {
+                        position += 2;
+                        continue;
+                    }
+                    if (input[position++] === '"')
+                        break;
+                }
+                try {
+                    args.push(JSON.parse(input.slice(start, position)));
+                }
+                catch {
+                    throw new Error("双引号参数必须是完整的 JSON 字符串；普通正文可使用单引号");
+                }
+            }
+            else {
+                const end = input.indexOf("'", position);
+                if (end < 0)
+                    throw new Error("名片命令的单引号未闭合");
+                args.push(input.slice(position, end));
+                position = end + 1;
+            }
+            if (position < input.length && !/\s/.test(input[position]))
+                throw new Error("引号参数后需要空格或换行");
+        }
+        else {
+            const end = input.slice(position).search(/\s/);
+            const length = end < 0 ? input.length - position : end;
+            args.push(input.slice(position, position + length));
+            position += length;
+        }
+    }
+    let json = false;
+    // 格式选项只允许出现在尾部，正文中的选项字样保持原样。
+    if (args.at(-1) === "--json") {
+        json = true;
+        args.pop();
+    }
+    else if (args.at(-2) === "--format" && args.at(-1) === "json") {
+        json = true;
+        args.splice(-2);
+    }
+    const [verb = "", aid = "", ...values] = args;
+    if (!["get", "set", "put"].includes(verb) || !aid)
+        throw new Error("用法：ec aid agentmd get <当前AID> | set <当前AID> <字段> <值> | put <当前AID> <完整Markdown>");
+    return { verb, aid, values, json };
+}

package/dist/src-ts/plugins/aun/agentmd-menu.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentMdMenu = exports.AGENTMD_PROTECTED_FIELDS = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_util_1 = require("node:util");
+const yaml_1 = require("yaml");
+exports.AGENTMD_PROTECTED_FIELDS = ["aid", "type", "owner", "ownership", "ownership_proof", "ownership_release", "entity_cert_fingerprint"];
+const object = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+const idleTimeout = 30 * 24 * 60 * 60;
+/** 仅实现 App 名片编辑器所需的 Menu 子集，不把控制消息交给模型。 */
+class AgentMdMenu {
+    tokens = new Map();
+    queues = new Map();
+    clear() { this.tokens.clear(); }
+    /** 本机入口由宿主管理认证保护，与远端 Menu 共用写锁和发布校验。 */
+    async local(aid, verb, values, port) {
+        return this.command(aid, verb, values, port);
+    }
+    /** 手机文本入口保留原始认证信封，不伪造本机调用者或 Menu token。 */
+    async text(event, aid, verb, values, port, transportAid = aid) {
+        return this.command(aid, verb, values, port, event, transportAid);
+    }
+    async command(aid, verb, values, port, event, transportAid = aid) {
+        const previous = this.queues.get(aid) ?? Promise.resolve();
+        const pending = previous.catch(() => undefined).then(async () => {
+            const execute = (payload) => this.execute({ ...event, payload }, aid, port, event ? "text" : "local", transportAid);
+            if (verb === "get" && !values.length)
+                return execute({ type: "menu.query", name: "aid", args: { view: "agentmd" } });
+            // 先核验调用者，再读取用于字段更新的基线。
+            await execute({ type: "menu.query", name: "aid", args: { view: "agentmd" } });
+            const base = await port.read();
+            let content;
+            if (verb === "put" && values.length === 1)
+                content = values[0];
+            else if (verb === "set" && values.length === 2) {
+                const [field, value] = values;
+                if (!["name", "description", "version", "tags", "exttype", "body"].includes(field))
+                    reject("INVALID_ARGUMENT", "仅支持 name/description/version/tags/exttype/body");
+                const parsed = port.parse(base.content);
+                const match = parsed.payload.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+                if (!match)
+                    reject("INVALID_ARGUMENT", "名片头部格式无效");
+                if (field === "body")
+                    content = `${match[0].trimEnd()}\n${value}\n`;
+                else {
+                    const document = (0, yaml_1.parseDocument)(match[1]);
+                    let next = value;
+                    if (field === "tags") {
+                        try {
+                            next = JSON.parse(value);
+                        }
+                        catch {
+                            reject("INVALID_ARGUMENT", "tags 必须是 JSON 字符串数组");
+                        }
+                        if (!Array.isArray(next) || next.some(item => typeof item !== "string"))
+                            reject("INVALID_ARGUMENT", "tags 必须是 JSON 字符串数组");
+                    }
+                    document.set(field, next);
+                    content = `---\n${document.toString()}---\n${parsed.payload.slice(match[0].length)}`;
+                }
+            }
+            else
+                reject("INVALID_ARGUMENT", "用法：mab aun agentmd get <aid> | set <aid> <字段> <值> | put <aid> <完整Markdown>");
+            return execute({ type: "menu.action", name: "aid", action: "agentmd.publish", args: { content, expectedEtag: base.etag, expectedRelationVersion: base.ownership.relation_version } });
+        });
+        this.queues.set(aid, pending);
+        try {
+            return await pending;
+        }
+        finally {
+            if (this.queues.get(aid) === pending)
+                this.queues.delete(aid);
+        }
+    }
+    async handle(event, aid, port, authorized = false) {
+        if (!object(event) || !object(event.payload) || typeof event.payload.type !== "string" || !event.payload.type.startsWith("menu."))
+            return undefined;
+        const request = event.payload;
+        // 响应及事件也在此消费，避免其中的 text 被误当作桌面任务。
+        if (["menu.response", "menu.event"].includes(String(request.type)))
+            return undefined;
+        if (typeof request.id !== "string" || !request.id.trim() || request.id.length > 256)
+            return undefined;
+        const header = { type: "menu.response", id: request.id, ...(typeof request.name === "string" ? { name: request.name } : {}) };
+        const run = async () => {
+            try {
+                return { ...header, data: await this.execute(event, aid, port, authorized ? "text" : "menu") };
+            }
+            catch (error) {
+                const code = typeof error.code === "string" ? String(error.code) : "REQUEST_FAILED";
+                // SDK 异常可能带服务端或存储细节，不原样返回。
+                return { ...header, error: { code, message: error instanceof MenuError ? error.message : "名片操作未完成，请刷新后核对远端状态" } };
+            }
+        };
+        const previous = this.queues.get(aid) ?? Promise.resolve();
+        const pending = previous.catch(() => undefined).then(run);
+        this.queues.set(aid, pending);
+        try {
+            return await pending;
+        }
+        finally {
+            if (this.queues.get(aid) === pending)
+                this.queues.delete(aid);
+        }
+    }
+    async execute(event, aid, port, mode = "menu", transportAid = aid) {
+        const local = mode === "local";
+        const request = event.payload;
+        const envelope = object(event.envelope) ? event.envelope : {};
+        const peer = local ? (await port.read()).ownership.owner_aid : typeof event.from === "string" ? event.from : envelope.from;
+        if (!local && (typeof peer !== "string" || !peer || peer === aid || event.encrypted !== true
+            || (envelope.from !== undefined && envelope.from !== peer) || (envelope.to !== undefined && envelope.to !== transportAid)
+            || (event.to !== undefined && event.to !== transportAid) || event.group_id || envelope.group_id
+            || event.chat_type === "group" || envelope.chat_type === "group"))
+            reject("FORBIDDEN", "名片管理仅支持经过认证的加密私聊");
+        const device = typeof event.sender_device_id === "string" ? event.sender_device_id : "";
+        const slot = typeof event.sender_slot_id === "string" ? event.sender_slot_id : "";
+        const key = JSON.stringify([aid, peer, device, slot]);
+        const read = async () => {
+            if (!port.current())
+                reject("FORBIDDEN", "通道或关联已改变，请重新打开编辑器");
+            const card = await port.read();
+            if (!port.current())
+                reject("FORBIDDEN", "通道或关联已改变，请重新打开编辑器");
+            const owner = card.ownership;
+            if (owner.status !== "consensus" || owner.sub_aid !== aid || owner.owner_aid !== peer || owner.cached !== false || owner.lock !== "locked")
+                reject("FORBIDDEN", "仅当前协议 Owner 可编辑名片");
+            if (!Number.isSafeInteger(owner.relation_version) || Number(owner.relation_version) < 1 || !card.etag || owner.agent_md_etag !== card.etag)
+                reject("OWNERSHIP_CONFLICT", "名片与归属版本不一致，请刷新");
+            const parsed = port.parse(card.content);
+            if (["human", "group", "org", "host"].includes(String(parsed.frontmatter.type).trim().toLowerCase()))
+                reject("NOT_SUPPORTED", "此入口仅编辑普通 Agent 名片");
+            if (parsed.frontmatter.aid !== aid || parsed.frontmatter.owner !== peer)
+                reject("OWNERSHIP_CONFLICT", "名片身份与归属不一致");
+            return { ...card, ...parsed };
+        };
+        const base = await read();
+        const now = Date.now();
+        for (const [tokenKey, record] of this.tokens)
+            if (now - record.usedAt >= idleTimeout * 1000)
+                this.tokens.delete(tokenKey);
+        if (request.type === "menu.token.request") {
+            if (!this.tokens.has(key) && this.tokens.size >= 1000)
+                reject("MENU_TOKEN_REJECTED", "Menu 授权数量已达上限");
+            const token = `mt_${(0, node_crypto_1.randomBytes)(32).toString("base64url")}`;
+            this.tokens.set(key, { token, usedAt: now });
+            return { menu_token: token, idle_timeout: idleTimeout };
+        }
+        const token = this.tokens.get(key);
+        if (mode === "menu" && (!token || token.token !== request.menu_token))
+            reject("MENU_TOKEN_REQUIRED", "Menu token 已失效，请重新申请");
+        if (token)
+            token.usedAt = now;
+        const args = object(request.args) ? request.args : {};
+        if (request.type === "menu.list" && request.name === "menu" && args.view === "catalog") {
+            if (!object(args.context) || args.context.kind !== "agent" || Object.keys(args.context).some(key => key !== "kind"))
+                reject("INVALID_CONTEXT", "名片目录需要 Agent 上下文");
+            if (Object.keys(args).some(key => !["view", "context", "acceptSchemaVersions"].includes(key)))
+                reject("INVALID_ARGUMENT", "目录参数不受支持");
+            if (args.acceptSchemaVersions !== undefined && !(Array.isArray(args.acceptSchemaVersions) ? args.acceptSchemaVersions : [args.acceptSchemaVersions]).includes(1))
+                reject("SCHEMA_VERSION_UNSUPPORTED", "仅支持目录版本 1");
+            return { kind: "menu.catalog", $schema_version: 1, context: { kind: "agent", self: aid, actor: peer, requesterRole: "owner" }, entries: [{
+                        id: "aid.agentmd", name: "aid", type: "setting", label: "能力介绍与名片", section: "agent", order: 71,
+                        control: "markdown-editor", operations: {
+                            query: { supported: true, allowed: true, cmd: "/aid", args: { view: "agentmd", protocolVersion: 1 } },
+                            action: { supported: true, allowed: true, cmd: "/aid", action: "agentmd.publish", args: { protocolVersion: 1 } },
+                        },
+                    }] };
+        }
+        if (request.name !== "aid" && request.cmd !== "/aid")
+            reject("NOT_SUPPORTED", "当前仅支持名片编辑 Menu");
+        const publish = request.type === "menu.action" && request.action === "agentmd.publish";
+        const query = request.type === "menu.query" && args.view === "agentmd";
+        if (!publish && !query)
+            reject("NOT_SUPPORTED", "名片操作不受支持");
+        const allowed = query ? ["view", "protocolVersion", "aid", "self", "scope"] : ["content", "expectedEtag", "expectedRelationVersion", "protocolVersion", "aid", "self", "scope"];
+        if (Object.keys(args).some(key => !allowed.includes(key)) || (args.aid !== undefined && args.aid !== aid) || (args.self !== undefined && args.self !== aid) || (args.scope !== undefined && args.scope !== "agent"))
+            reject("INVALID_ARGUMENT", "名片参数或目标不受支持");
+        if (args.protocolVersion !== undefined && args.protocolVersion !== 1)
+            reject("SCHEMA_VERSION_UNSUPPORTED", "仅支持名片协议版本 1");
+        const data = (card) => ({
+            protocol: "evol.agentmd", protocolVersion: 1, aid, content: card.payload, etag: card.etag,
+            relationVersion: card.ownership.relation_version, verification: "verified", atomicVersionCheck: false,
+        });
+        if (query)
+            return { ...data(base), protectedFields: exports.AGENTMD_PROTECTED_FIELDS, limits: { maxPayloadBytes: 4096, maxDescriptionCharacters: 100 } };
+        if (typeof args.content !== "string" || Buffer.byteLength(args.content) > 6144 || typeof args.expectedEtag !== "string" || !args.expectedEtag.trim() || args.expectedEtag.length > 512 || /[\r\n]/.test(args.expectedEtag) || !Number.isSafeInteger(args.expectedRelationVersion) || Number(args.expectedRelationVersion) < 1)
+            reject("INVALID_ARGUMENT", "发布需要正文、ETag 和归属版本");
+        if (base.etag !== args.expectedEtag)
+            reject("REMOTE_VERSION_CONFLICT", "名片已改变，请重新读取后发布");
+        if (base.ownership.relation_version !== args.expectedRelationVersion)
+            reject("OWNERSHIP_CONFLICT", "归属已改变，请重新读取");
+        const candidate = port.parse(args.content);
+        for (const field of exports.AGENTMD_PROTECTED_FIELDS)
+            if (Object.hasOwn(base.frontmatter, field) !== Object.hasOwn(candidate.frontmatter, field) || !(0, node_util_1.isDeepStrictEqual)(base.frontmatter[field], candidate.frontmatter[field]))
+                reject("PROTECTED_FIELD", `不能修改身份字段：${field}`);
+        // SDK 不暴露条件上传，串行写入并在上传前重读，明确返回非原子版本检查。
+        const latest = await read();
+        if (latest.etag !== base.etag)
+            reject("REMOTE_VERSION_CONFLICT", "名片已改变，请重新读取");
+        if (latest.ownership.relation_version !== base.ownership.relation_version)
+            reject("OWNERSHIP_CONFLICT", "归属已改变，请重新读取");
+        const guard = () => { if (!port.current())
+            reject("FORBIDDEN", "通道或关联已失效"); };
+        guard();
+        await port.upload(candidate.payload, guard);
+        const accepted = await read();
+        const body = (payload) => payload.replace(/\r\n/g, "\n").replace(/^---\n[\s\S]*?\n---(?:\n|$)/, "").trim();
+        if (accepted.ownership.relation_version !== base.ownership.relation_version || !(0, node_util_1.isDeepStrictEqual)(accepted.frontmatter, candidate.frontmatter) || body(accepted.payload) !== body(candidate.payload))
+            reject("PUBLISH_NOT_CONFIRMED", "远端尚未确认本次发布，请刷新核对");
+        return { ...data(accepted), published: true, versionChecked: true, nameChanged: base.frontmatter.name !== accepted.frontmatter.name };
+    }
+}
+exports.AgentMdMenu = AgentMdMenu;
+class MenuError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+function reject(code, message) { throw new MenuError(code, message); }

package/dist/src-ts/plugins/aun/agentmd-natural.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNaturalProfileCommand = parseNaturalProfileCommand;
+/** 确定性的中文名片指令；不从模糊措辞推断新内容或授权。 */
+function parseNaturalProfileCommand(text) {
+    const target = "([a-z0-9][a-z0-9_-]*(?:\\.[a-z0-9-]+)*)";
+    const change = new RegExp(`^(?:请)?(?:帮我)?(?:把|将)\\s*${target}\\s*的(?:名片)?(描述|简介|能力介绍|介绍正文|显示名称|名称)\\s*(?:修改为|设置为|改成|改为|设为)\\s*[：:]?\\s*([\\s\\S]+)$`, "i").exec(text.trim());
+    if (change) {
+        let value = change[3].trim();
+        if ((value.startsWith("“") && value.endsWith("”")) || (value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'")))
+            value = value.slice(1, -1);
+        const field = ["描述", "简介"].includes(change[2]) ? "description" : ["显示名称", "名称"].includes(change[2]) ? "name" : "body";
+        return { target: change[1].toLowerCase(), verb: "set", values: [field, value] };
+    }
+    const read = new RegExp(`^(?:请)?(?:帮我)?(?:查看|看一下|读取)\\s*${target}\\s*的(?:名片|描述|简介|能力介绍)[。！!]?\\s*$`, "i").exec(text.trim());
+    return read ? { target: read[1].toLowerCase(), verb: "get", values: [] } : undefined;
+}

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

@@ -134,7 +134,8 @@ async function readAunFsBytes(storage, path, options) {
         throw new AunFsError("OUTPUT_LIMIT", "FS 文件超过读取预算");
     if (expectedSize !== undefined && expectedSize !== size)
         throw new AunFsError("INVALID_RESPONSE", "FS 文件大小已变化");
-    const limits = storage.lowlevel?.getLimits ? record(await storage.lowlevel.getLimits(readOptions)) : {};
+    // 分块上限查询当前连接，不能要求读取者拥有目标 AID 的配额管理权限。
+    const limits = storage.lowlevel?.getLimits ? record(await storage.lowlevel.getLimits()) : {};
     const inline = limits.max_inline_bytes ?? 64 * 1024;
     if (!Number.isSafeInteger(inline) || Number(inline) < 1)
         unsupported("Storage 内联读取上限无效");