agent-bridge-aun 1.0.41 → 1.0.44

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;