agent-bridge-aun 1.0.46 → 1.0.49

package/README.md

@@ -69,3 +69,6 @@ ABWeb 的 AUN 设置只展示已连接 AID，并按来源分组。成功注册
 AUN 独立包支持核心后台每五分钟检测更新；可信提供者在自动安装策略下会下载新副本并重载通道。
 
 显式关联已有 EvolCore Agent 的 AID 时，先执行 `ec agent disable <aid>`，再配置 `ecagent` 路由并重载。`ec` 不存在或命令失败时，只将所选 AID 的 JSON 配置更新为 `enabled=false`、`active_baseagent=ecagent` 和对应路由；其它 AID 保持原值。仍有 EvolCore 运行实例时，必须确认重载成功才完成关联，避免原 Claude 与桌面 Agent 同时回复。纯密钥库身份不调用 `ec`，解绑不自动启用原 Agent。
+## 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 保留用于兼容旧管理客户端。

package/config.schema.json

@@ -127,6 +127,18 @@
         "type": "string",
         "pattern": "^[a-z0-9][a-z0-9_-]{2,63}\\.[a-z0-9-]+(?:\\.[a-z0-9-]+)+$"
       }
+    },
+    "ability_owner_verifications": {
+      "type": "object",
+      "default": {},
+      "description": "由 AUN 插件维护的 Owner 确认结果；仅当值与当前 ability_owners 相同时有效。",
+      "propertyNames": {
+        "pattern": "^[a-z0-9][a-z0-9_-]{2,63}\\.[a-z0-9-]+(?:\\.[a-z0-9-]+)+$"
+      },
+      "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-control.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+function parseAbilityControl(text) {
+    if (text === "确认")
+        return { action: "confirm-view" };
+    if (text === "拒绝")
+        return { action: "reject-view" };
+    const trimmed = text.replace(/^ +| +$/g, "");
+    if (!/^\/ability(?:\s|$)/.test(trimmed))
+        return undefined;
+    if (text.length > maxControlTextLength)
+        throw new Error("Ability 管理命令过长，最多允许 4096 个字符");
+    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)
+        return { action: action };
+    if (action === "publish") {
+        if (!args.length)
+            throw new Error("Ability 发布命令缺少路径参数");
+        if (args.some(path => path.length > 512 || !pathPattern.test(path)))
+            throw new Error("Ability 路径格式无效：必须符合插件 Ability path 规则且不能使用协议保留命名空间");
+        if (new Set(args).size !== args.length)
+            throw new Error("Ability 发布路径不能重复");
+        return { action, paths: args };
+    }
+    if ((action === "approve" || action === "reject") && args.length === 2) {
+        if (!args.every(value => fingerprintPattern.test(value)))
+            throw new Error("Ability 操作键与确认指纹格式无效：必须是完整的 64 位小写十六进制摘要");
+        return { action, key: args[0], confirmationFingerprint: args[1] };
+    }
+    throw new Error("Ability 管理命令或参数数量不正确，请发送 /ability help 查看用法");
+}
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function parseAbilityControlMessage(value, providerAid, ownerAid) {
+    const raw = record(value);
+    if (!raw)
+        return undefined;
+    const body = record(raw.payload);
+    const text = typeof raw.payload === "string" ? raw.payload : typeof body?.text === "string" ? body.text : "";
+    const command = parseAbilityControl(text);
+    if (!command)
+        return undefined;
+    const envelope = record(raw.envelope);
+    if (raw.envelope !== undefined && !envelope)
+        throw new Error("Ability 管理消息的认证信封格式无效");
+    const peerId = typeof raw.from === "string" ? raw.from : typeof envelope?.from === "string" ? envelope.from : "";
+    if (!aidPattern.test(peerId) || peerId === providerAid || !aidPattern.test(providerAid))
+        throw new Error("Ability 管理消息来源必须是该 Provider 配置的 Owner 身份");
+    for (const fields of [raw, body, envelope]) {
+        if (!fields)
+            continue;
+        if ([fields.from, fields.sender_aid].some(sender => sender !== undefined && sender !== peerId))
+            throw new Error("Ability 管理消息来源与认证信封身份不一致");
+        if (fields.to !== undefined && fields.to !== providerAid)
+            throw new Error("Ability 管理消息收件者与当前 Provider 不一致");
+    }
+    const privateMessage = [raw, body, envelope].every(fields => !fields || (fields.group_id === undefined && fields.group_aid === undefined
+        && (fields.chat_type === undefined || ["private", "direct", "p2p", "dm"].includes(String(fields.chat_type)))));
+    if (raw.encrypted !== true || !privateMessage)
+        throw new Error("Ability 管理命令仅接受 Owner 的加密私聊消息");
+    if ((raw.type !== undefined && !["text", "message"].includes(String(raw.type))) || (body?.type !== undefined && body.type !== "text")
+        || raw.attachments !== undefined || body?.attachments !== undefined)
+        throw new Error("Ability 管理命令必须是无附件的纯文本消息，通知和错误不能作为命令");
+    if (!ownerAid || !aidPattern.test(ownerAid))
+        throw Object.assign(new Error("尚未配置有效的 Ability Owner，请先在本机配置该 Provider 的 Owner AID"), { code: "ability_owner_unconfigured" });
+    if (peerId !== ownerAid)
+        throw new Error("Ability 管理消息来源必须是该 Provider 配置的 Owner 身份");
+    return { command, peerId,
+        ...(typeof raw.message_id === "string" ? { messageId: raw.message_id } : {}),
+        ...(typeof body?.thread_id === "string" ? { threadId: body.thread_id } : {}),
+    };
+}

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

@@ -5,6 +5,7 @@ exports.abilityOperationKey = abilityOperationKey;
 const node_crypto_1 = require("node:crypto");
 const promises_1 = require("node:fs/promises");
 const node_path_1 = require("node:path");
+const confirmationLifetimeMs = 12 * 60 * 60 * 1000;
 function failure(code, message) {
     return Object.assign(new Error(`${code}: ${message}`), { code });
 }
@@ -35,7 +36,10 @@ 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) {
+function confirmationFingerprint(input, fingerprint, confirmationExpiresAt) {
+    return digest({ key: abilityOperationKey(input), fingerprint, expiresAt: input.expiresAt, confirmationExpiresAt });
+}
+function legacyConfirmationFingerprint(input, fingerprint) {
     return digest({ key: abilityOperationKey(input), fingerprint, expiresAt: input.expiresAt });
 }
 function validateInput(input) {
@@ -62,11 +66,14 @@ function response(entry, code, message, executionState = "not_executed") {
 function validEntry(value) {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return false;
-    const entry = value;
+    const raw = value;
+    const legacy = raw.confirmationExpiresAt === undefined;
+    const entry = legacy ? { ...raw, confirmationExpiresAt: raw.expiresAt } : raw;
     try {
         validateInput(entry);
         if (entry.key !== abilityOperationKey(entry) || entry.fingerprint !== operationFingerprint(entry)
-            || entry.confirmationFingerprint !== confirmationFingerprint(entry, entry.fingerprint)
+            || !Number.isSafeInteger(entry.confirmationExpiresAt) || entry.confirmationExpiresAt <= 0
+            || entry.confirmationFingerprint !== (legacy ? legacyConfirmationFingerprint(entry, entry.fingerprint) : confirmationFingerprint(entry, entry.fingerprint, entry.confirmationExpiresAt))
             || !["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)
@@ -113,7 +120,10 @@ class AbilityOperationStore {
         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) {
+        for (const saved of snapshot.entries) {
+            const legacy = saved.confirmationExpiresAt === undefined;
+            const entry = legacy ? { ...saved, confirmationExpiresAt: saved.expiresAt,
+                confirmationFingerprint: confirmationFingerprint(saved, saved.fingerprint, saved.expiresAt) } : saved;
             if (store.entries.has(entry.key))
                 throw failure("operation_store_corrupt", "操作账本含重复幂等键");
             const legacyExpired = entry.result?.error?.code === "expired";
@@ -125,6 +135,7 @@ class AbilityOperationStore {
             }
             else
                 store.entries.set(entry.key, entry);
+            migrated ||= legacy;
         }
         if (migrated)
             await store.persist(new Map(store.entries));
@@ -161,11 +172,11 @@ class AbilityOperationStore {
         const next = new Map(entries);
         let changed = false;
         for (const entry of entries.values()) {
-            if (entry.state !== "pending_confirmation" || now < entry.expiresAt)
+            if (entry.state !== "pending_confirmation" || now < entry.confirmationExpiresAt)
                 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", "调用消息已过期，不会执行") });
+                result: response(entry, "confirmation_expired", "Owner 确认申请已过期，不会执行") });
             changed = true;
         }
         return { entries: next, changed };
@@ -188,9 +199,10 @@ class AbilityOperationStore {
                 return { created: false, entry: structuredClone(existing) };
             }
             const retainUntil = now + copied.dedupeRetentionSeconds * 1000;
-            if (!Number.isSafeInteger(retainUntil))
+            const confirmationExpiresAt = now + confirmationLifetimeMs;
+            if (!Number.isSafeInteger(retainUntil) || !Number.isSafeInteger(confirmationExpiresAt))
                 throw failure("params_invalid", "操作保留期无效");
-            const entry = { ...copied, key, fingerprint, confirmationFingerprint: confirmationFingerprint(copied, fingerprint),
+            const entry = { ...copied, key, fingerprint, confirmationExpiresAt, confirmationFingerprint: confirmationFingerprint(copied, fingerprint, confirmationExpiresAt),
                 state: "pending_confirmation", createdAt: now, updatedAt: now, retainUntil };
             next.set(key, entry);
             await this.persist(next);
@@ -216,11 +228,12 @@ class AbilityOperationStore {
             if (existing.state !== "pending_confirmation")
                 return { started: false, entry: structuredClone(existing) };
             const now = this.now();
+            const confirmationExpired = now >= existing.confirmationExpiresAt;
             const messageExpired = now >= existing.expiresAt;
-            const started = approve && !messageExpired;
+            const started = approve && !confirmationExpired && !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 已拒绝本次调用") } : {}) };
+                ...(!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);

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OwnerProof = void 0;
 const node_crypto_1 = require("node:crypto");
 const lifetime = 10 * 60_000;
+const confirmationLifetime = 12 * 60 * 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) {
@@ -32,7 +33,7 @@ class OwnerProof {
         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);
+        const expiresAt = Math.min(session.expiresAt, now + confirmationLifetime);
         this.entries.set(recordKey, { providerAid, ownerAid, sessionExpiresAt: session.expiresAt, expiresAt, nonceHash: (0, node_crypto_1.createHash)("sha256").update(nonce).digest("hex") });
         return { nonce, expiresAt };
     }
@@ -51,6 +52,27 @@ class OwnerProof {
         }
         return false;
     }
+    acceptConfirmation(providerAid, authenticatedSenderAid, text, encrypted) {
+        const now = this.now();
+        this.prune(now);
+        if (encrypted !== true || !authenticatedSenderAid || text !== "确认")
+            return false;
+        for (const entry of this.entries.values()) {
+            if (entry.providerAid !== providerAid || entry.ownerAid !== authenticatedSenderAid || entry.nonceHash === undefined)
+                continue;
+            this.clear(providerAid);
+            return true;
+        }
+        return false;
+    }
+    hasPendingConfirmation(providerAid) {
+        const now = this.now();
+        this.prune(now);
+        for (const entry of this.entries.values())
+            if (entry.providerAid === providerAid && entry.nonceHash !== undefined)
+                return true;
+        return false;
+    }
     verified(session, providerAid, ownerAid) {
         const now = this.now();
         this.prune(now);

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

@@ -68,15 +68,14 @@ async function configureAidForPlugin(pluginId, aid, port, run = runEc, home = pr
         throw new Error("插件 ID 格式无效");
     if (!Number.isInteger(port) || port < 1 || port > 65535)
         throw new Error("后台端口无效");
-    const path = pluginId === "dsh" ? "/dsh/v1" : `/api/agents/${pluginId}/v1`;
-    const ecagent = { baseUrl: `http://127.0.0.1:${port}${path}`, apiKey: "mab-local", model: pluginId };
+    const baseagent = { provider: "provider-1", model: pluginId };
     try {
         // MAB 直接接收 AUN 消息，先停用该 AID 的 EvolCore Agent，避免双重回复。
         const disabled = await run(["agent", "disable", aid, "--format", "json"], home);
         if (!disabled?.ok)
             throw new Error(`停用原 Agent 失败：${disabled?.code ?? ""} ${disabled?.error ?? "未知错误"}`);
         for (const [key, value] of [
-            ...Object.entries(ecagent).map(([key, value]) => [`baseagents.ecagent.${key}`, value]),
+            ...Object.entries(baseagent).map(([key, value]) => [`baseagents.ecagent.${key}`, value]),
             ["active_baseagent", "ecagent"],
         ]) {
             const result = await run(["agent", "set", aid, key, value, "--format", "json"], home);
@@ -95,7 +94,10 @@ async function configureAidForPlugin(pluginId, aid, port, run = runEc, home = pr
             throw new Error(`AID ${aid} 原配置格式无效，未覆盖文件`);
         config.enabled = false;
         config.active_baseagent = "ecagent";
-        config.baseagents = { ...config.baseagents, ecagent: { ...config.baseagents?.ecagent, ...ecagent } };
+        const ecagent = config.baseagents?.ecagent ?? {};
+        delete ecagent.baseUrl;
+        delete ecagent.apiKey;
+        config.baseagents = { ...config.baseagents, ecagent: { ...ecagent, ...baseagent } };
         const temporary = `${file}.mab-${(0, node_crypto_1.randomUUID)()}.tmp`;
         try {
             await (0, promises_1.writeFile)(temporary, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });