agent-bridge-aun 1.0.41 → 1.0.45-sdk0531.3

package/README.md

@@ -6,12 +6,35 @@
 
 安装后在 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 的兼容注册流程；Owner AID 只保存为本地归属配置，不代表 AUN 协议 Owner 关系已签名或激活。Gateway 信任根使用随插件提供并校验指纹的 AUN 根证书，不从 Gateway 下载未经验证的 CA 链。
+创建调用 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 链。
 
 核心支持插件命令后，可运行 `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 查询会在终端显示当前值。
 
 该插件依赖 `@agentunion/fastaun`，要求 Node.js 22.16 或更高版本。
 
+## 原生文件命令
+
+`mab fs` 与 `mab aun fs` 共用 AUN 插件当前连接，不要求安装或运行 EvolCore。`--as` 只能选择后台已连接的身份；只有一个连接时可省略，多连接时必须指定。远端后端根据经过验证的名片类型选择，不依赖 Owner 名录同步。
+
+```bash
+mab fs stat 209530905.agentid.cn:/.well-known/ability/index.json --as devproj.agentid.cn --json
+mab fs cat 209530905.agentid.cn:/.well-known/ability/index.json --as devproj.agentid.cn --authoritative --json
+mab fs cp ./说明.txt devproj.agentid.cn:/docs/说明.txt --as devproj.agentid.cn
+mab fs cp devproj.agentid.cn:/docs/说明.txt ./下载.txt --as devproj.agentid.cn
+```
+
+命令包括 `ls`、`stat`、`lstat`、`cat`、`cp`、`mv`、`rm`、`mkdir`、`ln -s`、`chmod`、`setfacl`、`getfacl`、`token`、`find`、`df`、`link`、`mount`、`approve`、`reject` 和 `umount`（也接受 `unmount`）。SDK 后端没有对应能力时返回 `UNSUPPORTED`。群空间当前不支持正文读取、软链、可见性修改、令牌、分享链接或挂载审批；个人空间不支持跨 AID 移动，跨 personal/group 的复制或移动也会拒绝。`stat` 默认不跟随末级软链，`-L` 才跟随。
+
+文本读取最多 256 KiB，二进制摘要输入最多 64 KiB，列表最多 512 项；超限明确失败。普通 Storage 读取按服务内联上限分块，并在读取前后核对大小、版本和已有哈希。本机文件上传和下载使用独立的管理身份校验及二进制传输接口，单文件最多 32 MiB、传输最多 60 秒，不把本机路径交给后台读写。下载先在目标目录暂存，校验大小和 SHA-256 后提交；覆盖已有文件必须显式加 `--overwrite`。`--authoritative` 使用个人 Storage 的权威对象读取，不以缓存参数替代，也不适用于群空间。本机认证管理入口可取得新签发的 token 和分享链接，插件不把这些值写入运行日志。
+
+## AUN 私聊中的兼容入口
+
+私聊可以发送一条完整、单行的 `ec fs cat <AID:/路径>` （可选 `--format json`）。插件直接解析参数，不执行 shell，不安装或替换本机 `ec`。普通聊天提及、引用、代码块和多条命令不会触发执行；消息里的 `--as` 不能选择宿主身份。
+
+兼容入口只读取能够匿名公开访问的文件，不借用宿主对私有对象的权限。公开正文走有大小限制的匿名 HTTPS 读取；`stat`、`lstat`、目录、配额和 ACL 没有可证明的匿名视图，当前返回 `UNSUPPORTED`。私聊兼容入口不接受 `--token` 或 `--authoritative`。文件写入、删除、权限、令牌及挂载变更会提示需要 Owner 在本机明确操作，不接受远端文本自报授权。回复保留原私聊话题。
+
+文件可读只证明 FS 发布可访问。还需核对 L1 的 `publisher`、`capabilities` 和每个精确 `detail_ref` 对应的 L3；在线发现及真实 Ability 调用分别验收，不能以索引可读代替执行成功。
+
 附件回复按图片、视频和普通文件分组发送，并保留原话题和请求引用。图片使用不带普通说明正文的 `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/config.schema.json

@@ -1,19 +1,126 @@
 {
   "type": "object",
   "properties": {
-    "identities": { "type": "array", "items": { "type": "string" } },
-    "created_aids": { "type": "array", "items": { "type": "string" } },
-    "bindings": { "type": "object", "additionalProperties": { "type": "string" } },
-    "binding_times": { "type": "object", "additionalProperties": { "type": "string" } },
-    "aid": { "type": "string", "minLength": 1 },
-    "owner_aid": { "type": "string", "minLength": 1 },
-    "agent_plugin": { "type": "string", "description": "兼容旧配置；消息只按 AID 的显式关联路由。" },
-    "aun_path": { "type": "string", "minLength": 1 },
-    "encryption_seed": { "type": "string" },
-    "verify_ssl": { "type": "boolean", "default": true },
-    "root_ca_path": { "type": "string" },
-    "allow_from": { "type": "string", "default": "", "description": "留空接受所有 AUN Peer；填写 AID 后限制来源，可用英文逗号分隔。" },
-    "delivery_mode": { "enum": ["fanout", "queue"] }
+    "identities": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "created_aids": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "bindings": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "string"
+      }
+    },
+    "binding_times": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "string"
+      }
+    },
+    "aid": {
+      "type": "string",
+      "minLength": 1
+    },
+    "owner_aid": {
+      "type": "string",
+      "minLength": 1
+    },
+    "agent_plugin": {
+      "type": "string",
+      "description": "兼容旧配置；消息只按 AID 的显式关联路由。"
+    },
+    "aun_path": {
+      "type": "string",
+      "minLength": 1
+    },
+    "encryption_seed": {
+      "type": "string"
+    },
+    "verify_ssl": {
+      "type": "boolean",
+      "default": true
+    },
+    "root_ca_path": {
+      "type": "string"
+    },
+    "allow_from": {
+      "type": "string",
+      "default": "",
+      "description": "留空接受所有 AUN Peer；填写 AID 后限制来源，可用英文逗号分隔。"
+    },
+    "delivery_mode": {
+      "enum": [
+        "fanout",
+        "queue"
+      ]
+    },
+    "ability_selections": {
+      "type": "object",
+      "default": {},
+      "description": "按 Provider AID 保存明确批准的能力发布路径；默认为不发布。",
+      "additionalProperties": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        },
+        "uniqueItems": true
+      }
+    },
+    "ability_ledgers": {
+      "type": "object",
+      "default": {},
+      "description": "AUN 能力发布归属与中断恢复账本，由通道维护。",
+      "additionalProperties": {
+        "type": "object",
+        "additionalProperties": {
+          "type": "object",
+          "required": [
+            "definition_id",
+            "release_id",
+            "plugin_id",
+            "plugin_version"
+          ],
+          "properties": {
+            "definition_id": {
+              "type": "string"
+            },
+            "release_id": {
+              "type": "string"
+            },
+            "plugin_id": {
+              "type": "string"
+            },
+            "plugin_version": {
+              "type": "string"
+            },
+            "previous_definition_ids": {
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            }
+          },
+          "additionalProperties": false
+        }
+      }
+    },
+    "ability_owners": {
+      "type": "object",
+      "default": {},
+      "description": "宿主管理员为每个 Provider AID 明确委托的能力确认 Owner；不等于 AUN 协议 Ownership，需验证该 AID 的控制权。",
+      "additionalProperties": {
+        "type": "string",
+        "pattern": "^[a-z0-9][a-z0-9_-]{2,63}\\.[a-z0-9-]+(?:\\.[a-z0-9-]+)+$"
+      }
+    }
   },
   "additionalProperties": false
 }

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

@@ -0,0 +1,318 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbilityOperationStore = void 0;
+exports.abilityOperationKey = abilityOperationKey;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+function failure(code, message) {
+    return Object.assign(new Error(`${code}: ${message}`), { code });
+}
+function canonical(value, parents = new Set()) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return JSON.stringify(value);
+    if (typeof value === "number" && Number.isFinite(value))
+        return JSON.stringify(value);
+    if (!value || typeof value !== "object" || parents.has(value))
+        throw failure("params_invalid", "操作数据必须是有效 JSON");
+    parents.add(value);
+    try {
+        if (Array.isArray(value))
+            return `[${Array.from(value, item => canonical(item, parents)).join(",")}]`;
+        if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)
+            throw failure("params_invalid", "操作数据必须是普通 JSON 对象");
+        return `{${Object.keys(value).sort().map(key => `${JSON.stringify(key)}:${canonical(value[key], parents)}`).join(",")}}`;
+    }
+    finally {
+        parents.delete(value);
+    }
+}
+function digest(value) { return (0, node_crypto_1.createHash)("sha256").update(canonical(value)).digest("hex"); }
+function abilityOperationKey(input) {
+    return digest([input.providerAid, input.authenticatedCaller, input.operationId]);
+}
+function operationFingerprint(input) {
+    return digest({ providerAid: input.providerAid, authenticatedCaller: input.authenticatedCaller, operationId: input.operationId,
+        path: input.path, definitionId: input.definitionId, params: input.params, effects: input.effects, executionTarget: input.executionTarget, async: input.async ?? false });
+}
+function confirmationFingerprint(input, fingerprint) {
+    return digest({ key: abilityOperationKey(input), fingerprint, expiresAt: input.expiresAt });
+}
+function validateInput(input) {
+    for (const field of ["providerAid", "authenticatedCaller", "operationId", "callId", "path", "definitionId"]) {
+        if (typeof input[field] !== "string" || !input[field] || input[field].length > 512 || /[\u0000-\u001f\u007f]/.test(input[field]))
+            throw failure("params_invalid", `操作字段 ${field} 无效`);
+    }
+    if (!input.params || typeof input.params !== "object" || Array.isArray(input.params)
+        || !input.executionTarget || typeof input.executionTarget !== "object" || Array.isArray(input.executionTarget)
+        || !Array.isArray(input.effects) || !input.effects.length || !input.effects.every(item => typeof item === "string" && item.length > 0)
+        || !Number.isSafeInteger(input.expiresAt) || input.expiresAt <= 0
+        || !Number.isSafeInteger(input.dedupeRetentionSeconds) || input.dedupeRetentionSeconds <= 0
+        || !Number.isSafeInteger(input.dedupeRetentionSeconds * 1000)
+        || (input.async !== undefined && typeof input.async !== "boolean"))
+        throw failure("params_invalid", "操作契约、参数或过期时间无效");
+    if (Buffer.byteLength(canonical(input.params)) > 256 * 1024)
+        throw failure("params_invalid", "操作参数超过 256 KiB");
+    canonical(input.executionTarget);
+}
+function response(entry, code, message, executionState = "not_executed") {
+    return { type: "ability", role: "result", call_id: entry.callId, operation_id: entry.operationId, ability_path: entry.path, definition_id: entry.definitionId,
+        ok: false, execution_state: executionState, error: { code, message } };
+}
+function validEntry(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const entry = value;
+    try {
+        validateInput(entry);
+        if (entry.key !== abilityOperationKey(entry) || entry.fingerprint !== operationFingerprint(entry)
+            || entry.confirmationFingerprint !== confirmationFingerprint(entry, entry.fingerprint)
+            || !["pending_confirmation", "executing", "succeeded", "failed", "unknown"].includes(entry.state)
+            || ![entry.createdAt, entry.updatedAt, entry.retainUntil].every(Number.isSafeInteger)
+            || entry.createdAt < 0 || entry.updatedAt < entry.createdAt || entry.retainUntil < entry.createdAt + entry.dedupeRetentionSeconds * 1000)
+            return false;
+        if (["succeeded", "failed", "unknown"].includes(entry.state) && (!entry.result || typeof entry.result !== "object" || Array.isArray(entry.result)))
+            return false;
+        if (["pending_confirmation", "executing"].includes(entry.state) && entry.result !== undefined)
+            return false;
+        if (entry.result !== undefined)
+            canonical(entry.result);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+class AbilityOperationStore {
+    file;
+    now;
+    entries = new Map();
+    writes = Promise.resolve();
+    constructor(file, now) {
+        this.file = file;
+        this.now = now;
+    }
+    static async open(file, options = {}) {
+        const store = new AbilityOperationStore(file, options.now ?? Date.now);
+        let raw;
+        try {
+            raw = await (0, promises_1.readFile)(file, "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return store;
+            throw error;
+        }
+        let snapshot;
+        try {
+            snapshot = JSON.parse(raw);
+        }
+        catch {
+            throw failure("operation_store_corrupt", "操作账本损坏，已停止新的执行");
+        }
+        if (!snapshot || snapshot.version !== 1 || !Array.isArray(snapshot.entries) || !snapshot.entries.every(validEntry))
+            throw failure("operation_store_corrupt", "操作账本格式无效，已停止新的执行");
+        let migrated = false;
+        for (const entry of snapshot.entries) {
+            if (store.entries.has(entry.key))
+                throw failure("operation_store_corrupt", "操作账本含重复幂等键");
+            const legacyExpired = entry.result?.error?.code === "expired";
+            if (legacyExpired) {
+                const result = structuredClone(entry.result);
+                result.error = { ...result.error, code: "message_expired" };
+                store.entries.set(entry.key, { ...entry, result });
+                migrated = true;
+            }
+            else
+                store.entries.set(entry.key, entry);
+        }
+        if (migrated)
+            await store.persist(new Map(store.entries));
+        await store.interruptExecuting();
+        return store;
+    }
+    serial(run) {
+        const next = this.writes.catch(() => undefined).then(run);
+        this.writes = next;
+        return next;
+    }
+    async persist(next) {
+        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`;
+        try {
+            const handle = await (0, promises_1.open)(temp, "wx", 0o600);
+            try {
+                await handle.writeFile(data, "utf8");
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+            await (0, promises_1.rename)(temp, this.file);
+            this.entries = next;
+        }
+        finally {
+            await (0, promises_1.rm)(temp, { force: true });
+        }
+    }
+    expirePending(entries, now) {
+        const next = new Map(entries);
+        let changed = false;
+        for (const entry of entries.values()) {
+            if (entry.state !== "pending_confirmation" || now < entry.expiresAt)
+                continue;
+            next.set(entry.key, { ...entry, state: "failed", updatedAt: Math.max(entry.updatedAt, now),
+                retainUntil: Math.max(entry.retainUntil, now + entry.dedupeRetentionSeconds * 1000),
+                result: response(entry, "message_expired", "调用消息已过期，不会执行") });
+            changed = true;
+        }
+        return { entries: next, changed };
+    }
+    draft(input) {
+        return this.serial(async () => {
+            validateInput(input);
+            const copied = JSON.parse(canonical(input));
+            const key = abilityOperationKey(copied);
+            const fingerprint = operationFingerprint(copied);
+            const now = this.now();
+            const expired = this.expirePending(this.entries, now);
+            const next = new Map([...expired.entries].filter(([, item]) => !["succeeded", "failed"].includes(item.state) || item.retainUntil > now));
+            const existing = next.get(key);
+            if (existing) {
+                if (expired.changed)
+                    await this.persist(next);
+                if (existing.fingerprint !== fingerprint)
+                    throw failure("idempotency_conflict", "相同 operation_id 的请求内容已改变");
+                return { created: false, entry: structuredClone(existing) };
+            }
+            const retainUntil = now + copied.dedupeRetentionSeconds * 1000;
+            if (!Number.isSafeInteger(retainUntil))
+                throw failure("params_invalid", "操作保留期无效");
+            const entry = { ...copied, key, fingerprint, confirmationFingerprint: confirmationFingerprint(copied, fingerprint),
+                state: "pending_confirmation", createdAt: now, updatedAt: now, retainUntil };
+            next.set(key, entry);
+            await this.persist(next);
+            return { created: true, entry: structuredClone(entry) };
+        });
+    }
+    approve(key, fingerprint) {
+        return this.confirm(key, fingerprint, true);
+    }
+    reject(key, fingerprint) {
+        return this.confirm(key, fingerprint, false);
+    }
+    confirm(key, fingerprint, approve) {
+        return this.serial(async () => {
+            const expired = this.expirePending(this.entries, this.now());
+            if (expired.changed)
+                await this.persist(expired.entries);
+            const existing = this.entries.get(key);
+            if (!existing)
+                throw failure("operation_not_found", "操作记录不存在");
+            if (existing.confirmationFingerprint !== fingerprint)
+                throw failure("confirmation_mismatch", "确认内容与原请求不一致");
+            if (existing.state !== "pending_confirmation")
+                return { started: false, entry: structuredClone(existing) };
+            const now = this.now();
+            const messageExpired = now >= existing.expiresAt;
+            const started = approve && !messageExpired;
+            const entry = { ...existing, state: started ? "executing" : "failed", updatedAt: Math.max(existing.updatedAt, now),
+                retainUntil: Math.max(existing.retainUntil, now + existing.dedupeRetentionSeconds * 1000),
+                ...(!started ? { result: 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) };
+        });
+    }
+    finish(key, state, result) {
+        return this.serial(async () => {
+            const existing = this.entries.get(key);
+            if (!existing)
+                throw failure("operation_not_found", "操作记录不存在");
+            if (existing.state !== "executing")
+                throw failure("operation_not_executing", "只有本次已批准执行的操作可以保存结果");
+            if (!result || typeof result !== "object" || Array.isArray(result))
+                throw failure("result_invalid", "操作结果必须是 JSON 对象");
+            const saved = JSON.parse(canonical(result));
+            if (Buffer.byteLength(canonical(saved)) > 512 * 1024)
+                throw failure("result_invalid", "操作结果超过 512 KiB");
+            const now = this.now();
+            const entry = { ...existing, state, updatedAt: Math.max(existing.updatedAt, now), retainUntil: Math.max(existing.retainUntil, now + existing.dedupeRetentionSeconds * 1000),
+                result: { ...saved, type: "ability", role: "result", call_id: existing.callId, operation_id: existing.operationId, ability_path: existing.path, definition_id: existing.definitionId } };
+            const next = new Map(this.entries);
+            next.set(key, entry);
+            await this.persist(next);
+            return structuredClone(entry);
+        });
+    }
+    replay(key, callId) {
+        return this.serial(async () => {
+            if (typeof callId !== "string" || !callId || callId.length > 512 || /[\u0000-\u001f\u007f]/.test(callId))
+                throw failure("params_invalid", "调用关联标识无效");
+            const expired = this.expirePending(this.entries, this.now());
+            if (expired.changed)
+                await this.persist(expired.entries);
+            const existing = this.entries.get(key);
+            if (!existing)
+                return undefined;
+            const entry = structuredClone(existing);
+            entry.callId = callId;
+            if (entry.result)
+                entry.result.call_id = callId;
+            return entry;
+        });
+    }
+    get(key) {
+        return this.serial(async () => {
+            const expired = this.expirePending(this.entries, this.now());
+            if (expired.changed)
+                await this.persist(expired.entries);
+            const entry = this.entries.get(key);
+            return entry ? structuredClone(entry) : undefined;
+        });
+    }
+    interruptExecuting() {
+        return this.serial(async () => {
+            const executing = [...this.entries.values()].filter(entry => entry.state === "executing");
+            if (!executing.length)
+                return;
+            const next = new Map(this.entries);
+            for (const entry of executing)
+                next.set(entry.key, { ...entry, state: "unknown", updatedAt: Math.max(entry.updatedAt, this.now()), result: response(entry, "execution_unknown", "执行曾被中断，必须先核对结果，不会自动重试", "unknown") });
+            await this.persist(next);
+        });
+    }
+    pending() {
+        return this.serial(async () => {
+            const expired = this.expirePending(this.entries, this.now());
+            if (expired.changed)
+                await this.persist(expired.entries);
+            return [...this.entries.values()].filter(entry => entry.state === "pending_confirmation").map(entry => structuredClone(entry));
+        });
+    }
+    invalidateProvider(providerAid, code = "provider_invalidated", message = "Provider 发布或 Owner policy 已改变，本次调用不会执行") {
+        return this.serial(async () => {
+            if (typeof providerAid !== "string" || !providerAid || typeof code !== "string" || !code || typeof message !== "string" || !message)
+                throw failure("params_invalid", "Provider 失效参数无效");
+            const now = this.now();
+            const expired = this.expirePending(this.entries, now);
+            const next = expired.entries;
+            let invalidated = 0;
+            for (const entry of next.values()) {
+                if (entry.providerAid !== providerAid || entry.state !== "pending_confirmation")
+                    continue;
+                next.set(entry.key, { ...entry, state: "failed", updatedAt: Math.max(entry.updatedAt, now),
+                    retainUntil: Math.max(entry.retainUntil, now + entry.dedupeRetentionSeconds * 1000),
+                    result: response(entry, code, message) });
+                invalidated++;
+            }
+            if (invalidated || expired.changed)
+                await this.persist(next);
+            return invalidated;
+        });
+    }
+}
+exports.AbilityOperationStore = AbilityOperationStore;

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAbilityMessage = isAbilityMessage;
+exports.parseAbilityEnvelope = parseAbilityEnvelope;
+exports.abilityFailureResult = abilityFailureResult;
+const aidPattern = /^[a-z0-9][a-z0-9_-]{2,63}\.[a-z0-9-]+(?:\.[a-z0-9-]+)+$/;
+function isAbilityMessage(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const body = value.payload;
+    return !!body && typeof body === "object" && !Array.isArray(body) && body.type === "ability";
+}
+function parseAbilityEnvelope(value) {
+    if (!isAbilityMessage(value))
+        return undefined;
+    const event = value;
+    const envelope = event.envelope && typeof event.envelope === "object" ? event.envelope : undefined;
+    // fastaun 解密事件的顶层 from 来自认证信封，不能读取业务 payload 自报身份。
+    const callerAid = typeof event.from === "string" ? event.from : typeof envelope?.from === "string" ? envelope.from : "";
+    if (envelope?.from !== undefined && envelope.from !== callerAid)
+        return undefined;
+    const payload = event.payload;
+    if (!aidPattern.test(callerAid) || event.encrypted !== true || payload.role !== "call")
+        return undefined;
+    if (typeof payload.call_id !== "string" || !payload.call_id || typeof payload.operation_id !== "string" || !payload.operation_id || typeof payload.ability_path !== "string")
+        return undefined;
+    if (payload.ability_path !== "protocol/discover" && typeof payload.definition_id !== "string")
+        return undefined;
+    if (payload.params !== undefined && (!payload.params || typeof payload.params !== "object" || Array.isArray(payload.params)))
+        return undefined;
+    return { callerAid, encrypted: true, payload };
+}
+function abilityFailureResult(payload, code, message) {
+    return {
+        type: "ability", role: "result",
+        call_id: payload.call_id,
+        operation_id: payload.operation_id,
+        ...(typeof payload.ability_path === "string" ? { ability_path: payload.ability_path } : {}),
+        ...(typeof payload.definition_id === "string" ? { definition_id: payload.definition_id } : {}),
+        ok: false, execution_state: "not_executed", error: { code, message },
+    };
+}

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwnerProof = void 0;
+const node_crypto_1 = require("node:crypto");
+const lifetime = 10 * 60_000;
+const limit = 1024;
+const aidPattern = /^[a-z0-9][a-z0-9_-]{2,63}\.[a-z0-9-]+(?:\.[a-z0-9-]+)+$/;
+function key(session, providerAid, ownerAid) {
+    return JSON.stringify([session.id, providerAid, ownerAid]);
+}
+function validSession(session, now) {
+    return typeof session.id === "string" && session.id.length > 0 && session.id.length <= 512
+        && !/[\u0000-\u001f\u007f]/.test(session.id) && Number.isSafeInteger(session.expiresAt) && session.expiresAt > now;
+}
+class OwnerProof {
+    entries = new Map();
+    now;
+    constructor(options = {}) { this.now = options.now ?? Date.now; }
+    prune(now) {
+        for (const [recordKey, entry] of this.entries)
+            if (entry.expiresAt <= now)
+                this.entries.delete(recordKey);
+    }
+    start(session, providerAid, ownerAid) {
+        const now = this.now();
+        if (!validSession(session, now))
+            throw new Error("管理会话无效或已过期");
+        if (typeof providerAid !== "string" || !aidPattern.test(providerAid) || typeof ownerAid !== "string" || !aidPattern.test(ownerAid))
+            throw new Error("Provider 或 Owner AID 无效");
+        this.prune(now);
+        const recordKey = key(session, providerAid, ownerAid);
+        if (!this.entries.has(recordKey) && this.entries.size >= limit)
+            throw new Error("Owner 证明记录已达上限，请稍后重试");
+        const nonce = (0, node_crypto_1.randomBytes)(32).toString("hex");
+        const expiresAt = Math.min(session.expiresAt, now + lifetime);
+        this.entries.set(recordKey, { providerAid, ownerAid, sessionExpiresAt: session.expiresAt, expiresAt, nonceHash: (0, node_crypto_1.createHash)("sha256").update(nonce).digest("hex") });
+        return { nonce, expiresAt };
+    }
+    accept(providerAid, authenticatedSenderAid, nonce, encrypted) {
+        const now = this.now();
+        this.prune(now);
+        if (encrypted !== true || !authenticatedSenderAid || typeof nonce !== "string" || !/^[0-9a-f]{64}$/.test(nonce))
+            return false;
+        const nonceHash = (0, node_crypto_1.createHash)("sha256").update(nonce).digest("hex");
+        for (const entry of this.entries.values()) {
+            if (entry.providerAid !== providerAid || entry.ownerAid !== authenticatedSenderAid || entry.nonceHash !== nonceHash)
+                continue;
+            delete entry.nonceHash;
+            entry.expiresAt = Math.min(entry.sessionExpiresAt, now + lifetime);
+            return true;
+        }
+        return false;
+    }
+    verified(session, providerAid, ownerAid) {
+        const now = this.now();
+        this.prune(now);
+        if (!validSession(session, now))
+            return false;
+        const entry = this.entries.get(key(session, providerAid, ownerAid));
+        return entry !== undefined && entry.nonceHash === undefined;
+    }
+    clear(providerAid) {
+        if (providerAid === undefined)
+            this.entries.clear();
+        else
+            for (const [recordKey, entry] of this.entries)
+                if (entry.providerAid === providerAid)
+                    this.entries.delete(recordKey);
+    }
+}
+exports.OwnerProof = OwnerProof;