agent-bridge-aun 1.0.49 → 1.0.58

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

@@ -0,0 +1,333 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AunMenu = void 0;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const runtime_menu_1 = require("./runtime-menu");
+const requestTypes = new Set(["menu.token.request", "menu.list", "menu.query", "menu.options", "menu.update", "menu.action"]);
+const booleanResources = ["allowInternalContacts", "allowExternalContacts", "allowAllContacts"];
+const resources = [...booleanResources, "allowedAids", "deniedAids", "requestLimit"];
+class MenuError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+function object(value) { return !!value && typeof value === "object" && !Array.isArray(value); }
+function hash(value) { return (0, node_crypto_1.createHash)("sha256").update(value).digest("hex"); }
+function allowedFrom(peer, allowFrom) {
+    const rules = (allowFrom ?? "").split(",").map(item => item.trim()).filter(Boolean);
+    return !rules.length || rules.includes("*") || rules.includes(peer);
+}
+function resourceValid(resource, value) {
+    if (resource === "allowedAids" || resource === "deniedAids")
+        return Array.isArray(value)
+            && value.every(item => typeof item === "string" && item.split(".").length >= 3
+                && item.split(".").every(label => /^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$/.test(label))) && new Set(value).size === value.length;
+    if (resource === "requestLimit")
+        return object(value) && Object.keys(value).every(key => key === "maxTimes" || key === "coolDown")
+            && Number.isSafeInteger(value.maxTimes) && value.maxTimes >= 1 && value.maxTimes <= 100_000
+            && Number.isSafeInteger(value.coolDown) && value.coolDown >= 1 && value.coolDown <= 86_400;
+    return typeof value === "boolean";
+}
+function volatileReply(version) {
+    if (typeof version !== "string" || !/^\d+\.\d+\.\d+$/.test(version.trim()))
+        return false;
+    const parts = version.trim().split(".").map(Number);
+    return parts.every(Number.isSafeInteger) && (parts[0] > 0 || parts[1] > 5 || parts[1] === 5 && parts[2] >= 17);
+}
+function logField(value) {
+    return typeof value === "string" ? value.replace(/[\u0000-\u001f\u007f]/g, "").slice(0, 256) : "";
+}
+class AunMenu {
+    dataDir;
+    port;
+    records = {};
+    writes = Promise.resolve();
+    tokens = new Map();
+    responses = new Map();
+    idleSeconds = 30 * 24 * 60 * 60;
+    constructor(dataDir, port) {
+        this.dataDir = dataDir;
+        this.port = port;
+    }
+    async load() {
+        let text;
+        try {
+            text = await (0, promises_1.readFile)((0, node_path_1.join)(this.dataDir, "access-policy.json"), "utf8");
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return;
+            throw error;
+        }
+        const file = JSON.parse(text);
+        if (!object(file) || file.schemaVersion !== 1 || !object(file.records)
+            || Object.values(file.records).some(entry => !object(entry) || typeof entry.ownerAid !== "string"
+                || typeof entry.accessRevision !== "string" || !entry.accessRevision || !object(entry.policy)
+                || resources.some(key => !resourceValid(key, entry.policy[key]))))
+            throw new Error("AUN 访问策略文件无效，未启用通道");
+        this.records = file.records;
+    }
+    snapshot(aid, ownerAid) {
+        const exists = Object.hasOwn(this.records, aid);
+        const saved = exists ? this.records[aid] : undefined;
+        if (saved?.ownerAid === ownerAid)
+            return saved;
+        // 旧身份尚无策略时，查询如实反映既有全开放行为，显式写入后才启用名录准入。
+        const policy = { requestLimit: { maxTimes: 600, coolDown: 3600 }, allowInternalContacts: !exists,
+            allowExternalContacts: !exists, allowAllContacts: !exists, allowedAids: [], deniedAids: [] };
+        return { ownerAid, policy, accessRevision: `legacy-${hash(JSON.stringify([aid, ownerAid, saved?.accessRevision, policy]))}` };
+    }
+    async accept(aid, raw) {
+        const req = raw.payload;
+        if (!object(req) || typeof req.type !== "string" || !req.type.startsWith("menu."))
+            return false;
+        if (req.type === "menu.response" || req.type === "menu.event")
+            return true;
+        const peer = raw.from ?? raw.envelope?.from;
+        if (typeof peer !== "string" || !peer || peer === aid || !allowedFrom(peer, this.port.allowFrom()))
+            return true;
+        if (typeof req.id !== "string" || !req.id.trim() || req.id.length > 256)
+            return true;
+        const started = Date.now();
+        const fields = { aid, peer, type: logField(req.type), id: logField(req.id), name: logField(req.name ?? req.cmd) };
+        this.port.log("AUN 菜单请求已收到", fields);
+        const header = { type: "menu.response", id: req.id, ...(typeof req.name === "string" ? { name: req.name } : {}) };
+        let response;
+        try {
+            if (!requestTypes.has(req.type))
+                throw new MenuError("NOT_SUPPORTED", "当前 AUN 插件不支持此菜单请求");
+            if (raw.encrypted !== true || raw.to !== aid || raw.envelope?.from !== undefined && raw.envelope.from !== peer
+                || raw.envelope?.to !== undefined && raw.envelope.to !== aid || raw.group_id || raw.group_aid || req.agent !== undefined
+                || req.args !== undefined && !object(req.args))
+                throw new MenuError("NOT_ALLOWED", "菜单仅接受当前身份的直接加密私信");
+            const target = this.port.target(aid);
+            if (!target)
+                throw new MenuError("AGENT_UNAVAILABLE", "当前 Agent 关联不可用");
+            const ownerAid = await this.port.owner(aid);
+            if (ownerAid !== peer || this.port.target(aid) !== target)
+                throw new MenuError("NOT_ALLOWED", "需要当前身份的已确认 Owner");
+            if (req.args?.self !== undefined && req.args.self !== aid)
+                throw new MenuError("NOT_ALLOWED", "菜单目标身份不匹配");
+            for (const key of ["sender_device_id", "sender_slot_id"])
+                if (raw[key] !== undefined && (typeof raw[key] !== "string"
+                    || !raw[key].trim() || raw[key].length > 256 || /[\u0000-\u001f\u007f]/.test(raw[key])))
+                    throw new MenuError("NOT_ALLOWED", "菜单发送端身份无效");
+            const subject = JSON.stringify([aid, peer, target, raw.sender_device_id ?? "", raw.sender_slot_id ?? ""]);
+            const now = Date.now();
+            for (const [key, token] of this.tokens)
+                if (now - token.lastUsed >= this.idleSeconds * 1000)
+                    this.tokens.delete(key);
+            if (req.type === "menu.token.request") {
+                if (this.tokens.size >= 1000 && !this.tokens.has(subject))
+                    throw new MenuError("MENU_TOKEN_REJECTED", "菜单授权数量已达上限");
+                const token = `mt_${(0, node_crypto_1.randomBytes)(32).toString("base64url")}`;
+                this.tokens.set(subject, { hash: hash(token), lastUsed: now });
+                response = { ...header, data: { menu_token: token, idle_timeout: this.idleSeconds } };
+            }
+            else {
+                const token = this.tokens.get(subject);
+                if (!token || typeof req.menu_token !== "string" || req.menu_token.length > 256 || token.hash !== hash(req.menu_token))
+                    throw new MenuError("MENU_TOKEN_REQUIRED", "请重新申请菜单授权");
+                token.lastUsed = now;
+                if (req.type === "menu.update") {
+                    const key = JSON.stringify([subject, req.id]), requestHash = hash(JSON.stringify({ ...req, menu_token: undefined }));
+                    for (const [key, item] of this.responses)
+                        if (now - item.at > 10 * 60_000)
+                            this.responses.delete(key);
+                    const cached = this.responses.get(key);
+                    if (cached && cached.hash !== requestHash)
+                        throw new MenuError("INVALID_ARGUMENT", "同一请求 ID 不能用于不同更新");
+                    if (cached)
+                        response = await cached.response;
+                    else {
+                        const pending = this.execute(req, aid, ownerAid, target).then(data => ({ ...header, data }));
+                        this.responses.set(key, { hash: requestHash, at: now, response: pending });
+                        while (this.responses.size > 1000)
+                            this.responses.delete(this.responses.keys().next().value);
+                        try {
+                            response = await pending;
+                        }
+                        catch (error) {
+                            this.responses.delete(key);
+                            throw error;
+                        }
+                    }
+                }
+                else if (this.port.agentmd && (req.name === "aid" || req.cmd === "/aid" || req.type === "menu.list" && req.args?.view === "catalog")) {
+                    response = await this.port.agentmd(aid, raw);
+                }
+                else
+                    response = { ...header, data: await this.execute(req, aid, ownerAid, target) };
+            }
+        }
+        catch (error) {
+            response = { ...header, error: error instanceof MenuError ? { code: error.code, message: error.message }
+                    : { code: "INTERNAL_ERROR", message: "菜单处理失败，请稍后重试" } };
+        }
+        response.processing_ms ??= Date.now() - started;
+        const outcome = { ...fields, processing_ms: response.processing_ms, code: object(response.error) ? response.error.code : "OK" };
+        this.port.log("AUN 菜单请求已处理", outcome);
+        // 旧手机 SDK 不消费短时游标及设备定向回复；只根据已认证头判断版本。
+        const modern = volatileReply(raw.protected_headers?.sdk_version);
+        const device = typeof raw.sender_device_id === "string" && raw.sender_device_id.length <= 256
+            && !/[\u0000-\u001f\u007f]/.test(raw.sender_device_id) ? raw.sender_device_id.trim() : "";
+        if (modern && raw.sender_device_id !== undefined && !device) {
+            this.port.log("AUN 菜单响应发送失败", { ...outcome, code: "INVALID_MENU_REPLY_DEVICE" });
+            return true;
+        }
+        try {
+            await this.port.send(aid, { to: peer, payload: response, encrypt: true, message_class: "control",
+                ...(modern ? { ttl: 60, ...(device ? { to_device_id: device } : {}) } : {}) });
+            this.port.log("AUN 菜单响应已发送", outcome);
+        }
+        catch (error) {
+            this.port.log("AUN 菜单响应发送失败", { ...outcome, code: "SEND_FAILED" });
+            throw error;
+        }
+        return true;
+    }
+    async execute(req, aid, ownerAid, target) {
+        if (req.type === "menu.list") {
+            if (req.args?.view !== undefined)
+                throw new MenuError("NOT_SUPPORTED", "当前不支持此菜单目录视图");
+            return [{ group: "权限管理", commands: [
+                        { cmd: "/agent", label: "身份归属", desc: "读取当前身份及已确认的 Owner" },
+                        { cmd: "/baseagent", label: "关联 Agent", desc: "读取当前关联的本地 Agent" },
+                        { cmd: "/connect", label: "通信准入", desc: "读取及更新联系人准入策略" },
+                        ...(this.port.agentmd ? [{ cmd: "/aid", label: "能力介绍与名片", desc: "读取及发布当前身份的能力介绍" }] : []),
+                        ...(this.port.runtime ? [
+                            { cmd: "/model", label: "模型", desc: "读取当前关联 Agent 的模型信息" },
+                            { cmd: "/effort", label: "推理强度", desc: "读取当前关联 Agent 的推理强度" },
+                            { cmd: "/chatmode", label: "对话模式", desc: "读取当前私聊对话模式" },
+                        ] : []),
+                    ] }];
+        }
+        const name = req.name ?? (typeof req.cmd === "string" ? req.cmd.replace(/^\//, "") : undefined);
+        if (req.name !== undefined && req.cmd !== undefined && req.cmd !== `/${req.name}`)
+            throw new MenuError("INVALID_ARGUMENT", "菜单名称与命令不一致");
+        if (this.port.runtime && ["agent", "model", "effort", "chatmode", "role"].includes(name)) {
+            if (req.args?.aid !== undefined && req.args.aid !== aid)
+                throw new MenuError("NOT_ALLOWED", "只能查询当前身份");
+            if (req.type === "menu.options" && ["model", "effort", "chatmode"].includes(name))
+                return [];
+            if (req.type !== "menu.query")
+                throw new MenuError("NOT_SUPPORTED", "运行信息仅支持读取，请在关联客户端修改设置");
+            const baseagent = this.port.baseagent(aid);
+            if (!baseagent)
+                throw new MenuError("AGENT_UNAVAILABLE", "关联 Agent 不可用");
+            const snapshot = await this.port.runtime(aid);
+            if (this.port.target(aid) !== target || await this.port.owner(aid) !== ownerAid || this.port.target(aid) !== target)
+                throw new MenuError("NOT_ALLOWED", "读取期间身份归属或关联发生变化");
+            try {
+                return (0, runtime_menu_1.runtimeMenuQuery)(name, req.args ?? {}, aid, ownerAid, baseagent, snapshot);
+            }
+            catch (error) {
+                throw new MenuError(error.code ?? "INTERNAL_ERROR", "运行信息请求参数不受支持");
+            }
+        }
+        if (req.type === "menu.query" && (name === "baseagent" || name === "agent")) {
+            if (req.args?.aid !== undefined && req.args.aid !== aid)
+                throw new MenuError("NOT_ALLOWED", "只能查询当前身份");
+            if (name === "agent" && req.args?.aid !== aid)
+                throw new MenuError("INVALID_ARGUMENT", "agent 菜单需要当前 aid");
+            const baseagent = this.port.baseagent(aid);
+            if (!baseagent || this.port.target(aid) !== target)
+                throw new MenuError("AGENT_UNAVAILABLE", "当前 Agent 关联不可用");
+            if (name === "baseagent")
+                return { baseagent, scope: "agent", override: null, source: "agent" };
+            const config = { owner: ownerAid, owners: [ownerAid], active_baseagent: baseagent };
+            return { aid, config, safeConfig: config };
+        }
+        if ((req.name !== "connect" && req.cmd !== "/connect") || req.name !== undefined && req.name !== "connect"
+            || req.cmd !== undefined && req.cmd !== "/connect")
+            throw new MenuError("NOT_SUPPORTED", "当前仅支持 connect/access 菜单");
+        if (req.args?.self !== aid)
+            throw new MenuError("INVALID_ARGUMENT", "connect 菜单需要当前 self AID");
+        if (req.type === "menu.query" && req.args?.view === "access") {
+            const snapshot = this.snapshot(aid, ownerAid);
+            return { $schema_version: 1, self: aid, view: "access", policy: snapshot.policy, accessRevision: snapshot.accessRevision };
+        }
+        if (req.type !== "menu.update")
+            throw new MenuError("NOT_SUPPORTED", "当前不支持此菜单操作");
+        const resource = req.args?.resource;
+        if (!resources.includes(resource))
+            throw new MenuError("NOT_SUPPORTED", "不支持此访问策略资源");
+        if (typeof req.value !== "string" || typeof req.args?.expectedAccessRevision !== "string" || !req.args.expectedAccessRevision)
+            throw new MenuError("INVALID_ARGUMENT", "需要 JSON 字符串和访问策略版本");
+        let value;
+        try {
+            value = JSON.parse(req.value);
+        }
+        catch {
+            throw new MenuError("INVALID_ARGUMENT", "访问策略值必须是有效 JSON 字符串");
+        }
+        if (!resourceValid(resource, value))
+            throw new MenuError("INVALID_ARGUMENT", "访问策略值的类型或范围无效");
+        const mutation = this.writes.then(async () => {
+            const current = this.snapshot(aid, ownerAid);
+            if (current.accessRevision !== req.args.expectedAccessRevision)
+                throw new MenuError("CONFLICT", "访问策略已变更，请重新读取后操作");
+            const changed = resource === "requestLimit"
+                ? current.policy.requestLimit.maxTimes !== value.maxTimes
+                    || current.policy.requestLimit.coolDown !== value.coolDown
+                : JSON.stringify(current.policy[resource]) !== JSON.stringify(value);
+            const saved = this.records[aid];
+            if (!changed && saved?.ownerAid === ownerAid)
+                return { $schema_version: 1, self: aid, resource, policy: current.policy, accessRevision: current.accessRevision, changed };
+            const next = { ownerAid, policy: { ...current.policy, [resource]: value }, accessRevision: (0, node_crypto_1.randomUUID)() };
+            const records = { ...this.records, [aid]: next };
+            const temporary = (0, node_path_1.join)(this.dataDir, `access-policy-${(0, node_crypto_1.randomUUID)()}.tmp`);
+            try {
+                await (0, promises_1.writeFile)(temporary, `${JSON.stringify({ schemaVersion: 1, records }, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+                if (this.port.target(aid) !== target || await this.port.owner(aid) !== ownerAid || this.port.target(aid) !== target)
+                    throw new MenuError("NOT_ALLOWED", "Owner 或 Agent 关联已变更，本次更新未保存");
+                await (0, promises_1.rename)(temporary, (0, node_path_1.join)(this.dataDir, "access-policy.json"));
+                this.records = records;
+            }
+            finally {
+                await (0, promises_1.rm)(temporary, { force: true });
+            }
+            return { $schema_version: 1, self: aid, resource, policy: next.policy, accessRevision: next.accessRevision, changed };
+        });
+        this.writes = mutation.catch(() => undefined);
+        return mutation;
+    }
+    async allowsChat(aid, peer) {
+        const saved = this.records[aid];
+        if (!saved)
+            return true;
+        const target = this.port.target(aid);
+        try {
+            const ownerAid = await this.port.owner(aid);
+            if (saved.ownerAid !== ownerAid || saved.policy.deniedAids.includes(peer))
+                return false;
+            let directory;
+            try {
+                directory = await this.port.directory(aid, ownerAid);
+            }
+            catch { /* 名录不可确认时，仅保留实时 Owner 的修复通道。 */ }
+            if (this.records[aid] !== saved || this.port.target(aid) !== target)
+                return false;
+            if (await this.port.owner(aid) !== ownerAid || this.records[aid] !== saved || this.port.target(aid) !== target)
+                return false;
+            if (!directory)
+                return peer === ownerAid;
+            if (directory.blocked_aids.some((entry) => entry.target_type === "aid" && entry.target_id === peer))
+                return false;
+            if (peer === ownerAid || peer === directory.personal_assistant?.aid)
+                return true;
+            if (saved.policy.allowAllContacts || saved.policy.allowedAids.includes(peer))
+                return true;
+            const contact = directory.entries.find((entry) => entry.aid === peer);
+            return Boolean(contact && (contact.owner_aid === ownerAid ? saved.policy.allowInternalContacts : saved.policy.allowExternalContacts));
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.AunMenu = AunMenu;

package/dist/src-ts/plugins/aun/public/app.js

@@ -36,7 +36,7 @@
       list.replaceChildren();
       const entries = [];
       const seen = new Set();
-      for (const [group, label, values] of [[0, "本工程 · 已连接", identities.groups.muAgentBridge || []], [1, "EvolCore · 已连接", identities.groups.evolcore || []]]) {
+      for (const [group, label, values] of [[0, "本工程 · 已连接", identities.groups.muAgentBridge || []], [1, "EvolCore · 仅展示", identities.groups.evolcore || []]]) {
         for (const aid of values) {
           if (seen.has(aid)) continue;
           seen.add(aid);
@@ -44,10 +44,15 @@
         }
       }
       entries.sort((a, b) => Number(Boolean(b.bound)) - Number(Boolean(a.bound)) || a.group - b.group || b.time - a.time || a.aid.localeCompare(b.aid));
-      for (const { aid, label, bound } of entries) {
+      for (const { aid, label, bound, group } of entries) {
           const row = document.createElement("tr");
           for (const value of [aid, label, bound || "未关联"]) { const cell = document.createElement("td"); cell.textContent = value; row.append(cell); }
-          const cell = document.createElement("td"); const select = document.createElement("select"); select.setAttribute("aria-label", `${aid} 关联 Agent`);
+          const cell = document.createElement("td");
+          if (group === 1) {
+            cell.textContent = "EvolCore 来源身份不能关联";
+            row.append(cell); list.append(row); continue;
+          }
+          const select = document.createElement("select"); select.setAttribute("aria-label", `${aid} 关联 Agent`);
           select.append(new Option("选择 Agent", ""), ...agents.map((agent) => new Option(agent.displayName || agent.id, agent.id)));
           select.value = bound; select.onchange = () => { if (select.value) void bind(aid, select.value); else if (bound) void unbind(aid); };
           cell.append(select); row.append(cell); list.append(row);
@@ -73,14 +78,16 @@
     show("正在创建 AID 并连接，请稍候……");
     void request("/api/plugins/aun/aid", "POST", { aid, ownerAid: owner }).then((result) => {
       const failed = result.connection === "degraded";
-      const directoryFailed = result.directorySync?.status === "not_synced";
+      const pending = result.status === "等待 Owner 确认";
+      const directoryFailed = !pending && result.directorySync?.status === "not_synced";
       const message = [
         failed ? `${aid} 已创建，但连接失败：${result.connectionError || "未提供连接失败原因，请查看运行日志"}\n身份已经保存在本地，请勿重复注册。`
-          : result.status === "等待 Owner 确认" ? `${aid} 等待 Owner 确认` : `${aid} 已创建并连接`,
-        directoryFailed ? `Owner 名录未同步：${result.directorySync.error || "原因未知"}`
+          : `${aid} 已创建并连接`,
+        pending ? "关联请求已发送，等待 Owner 确认；确认前暂不加入通信名录，请勿重复创建 AID。"
+          : directoryFailed ? `Owner 名录未同步：${result.directorySync.error || "原因未知"}`
           : result.directorySync?.status === "synced" ? "已加入 Owner 名录，个人助理可按默认权限使用该联系人。" : "Owner 名录同步状态未知，请查看运行日志。",
       ].join("\n");
-      notify(failed || directoryFailed ? "AID 创建完成，部分步骤失败" : "AID 创建结果", message, failed || directoryFailed);
+      notify(failed || directoryFailed ? "AID 创建完成，部分步骤失败" : pending ? "等待 Owner 确认" : "AID 创建结果", message, failed || directoryFailed);
       return load();
     }).catch((error) => notify("创建 AID 失败", errorMessage(error), true));
   };

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runtimeMenuQuery = runtimeMenuQuery;
+function runtimeMenuQuery(name, args, aid, owner, baseagent, snapshot) {
+    const fail = (code, message) => { throw Object.assign(new Error(message), { code }); };
+    if (args.aid !== undefined && args.aid !== aid || args.self !== undefined && args.self !== aid
+        || args.baseagent !== undefined && args.baseagent !== baseagent)
+        fail("INVALID_ARGUMENT", "只能读取当前身份及其关联 Agent");
+    const scope = args.scope ?? "agent";
+    if (!["agent", "relation"].includes(scope))
+        fail("NOT_SUPPORTED", "仅支持 Agent 或当前私聊关系");
+    const peerKey = `aun#${owner}`;
+    if (args.peerKey !== undefined && ![owner, peerKey].includes(args.peerKey))
+        fail("NOT_ALLOWED", "仅支持当前 Owner 私聊关系");
+    const selected = { model: snapshot.model, effort: snapshot.effort };
+    if (name === "agent") {
+        const config = { owner, owners: [owner], active_baseagent: baseagent, baseagents: { [baseagent]: selected } };
+        return { aid, baseagent, status: snapshot.status, connection: { status: snapshot.connected ? "connected" : "disconnected" },
+            sessions: { active: snapshot.activeSessions, active_peers: snapshot.activePeers }, config, safeConfig: config };
+    }
+    if (name === "model" || name === "effort")
+        return { [name]: snapshot[name], baseagent, source: snapshot.source,
+            scope, self: aid, field: `baseagents.${baseagent}.${name}`, override: null, writable: false,
+            ...(scope === "relation" ? { peerKey } : {}) };
+    if (name === "chatmode") {
+        if (args.field !== undefined && !["private", "chatmode.private"].includes(args.field))
+            fail("NOT_SUPPORTED", "当前只支持私聊交互模式");
+        return { mode: "interactive", source: "agent", scope, self: aid, field: "chatmode.private", override: null, writable: false,
+            ...(scope === "relation" ? { peerKey } : {}) };
+    }
+    if (name === "role") {
+        const common = { $schema_version: 1, self: aid, policyRevision: "aun-runtime-readonly-v1" };
+        if (args.view === "target") {
+            if (args.target?.kind !== "private" || args.target.peerAid !== owner)
+                fail("NOT_ALLOWED", "仅提供当前 Owner 的私聊只读快照");
+            return { ...common, target: args.target, relationRevision: null, explicitRole: null,
+                effectiveRole: { roleId: "owner", source: "ownership", allowAccess: true },
+                relationConfig: { explicit: {}, fields: Object.entries({ "chatmode.private": "interactive", [`baseagents.${baseagent}.model`]: snapshot.model, [`baseagents.${baseagent}.effort`]: snapshot.effort }).map(([field, value]) => ({
+                        field, hasExplicitValue: false, effectiveValue: value, effectiveContext: "private", source: "agent", readable: true, writable: false, writeReason: "由关联客户端管理"
+                    })) } };
+        }
+        if (args.view === "role" && args.roleId === "owner")
+            return { ...common, roleId: "owner",
+                meta: { origin: "builtin", overridden: false, kind: "management", assignable: false, editable: false, deletable: false, resettable: false },
+                definition: { description: "当前协议 Owner 的运行信息只读视图", allowAccess: true, permissions: {}, commandPermissions: {} } };
+        if (args.view === "capabilities")
+            return { ...common, capabilities: Object.fromEntries([
+                    "roleList", "roleRead", "roleWrite", "roleCreate", "roleDelete", "roleReset", "defaultRoleRead", "defaultRoleWrite", "permissionFields", "permissionValues", "operations", "privateTargetsList", "joinedGroupsList", "assignmentInventory", "relationSnapshot", "privateRoleAssign", "groupRoleAssign", "deleteWithReplacement", "jsonStringUpdateValue",
+                ].map(key => [key, key === "roleRead" || key === "relationSnapshot"])) };
+    }
+    return fail("NOT_SUPPORTED", "当前不支持此运行信息查询");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-bridge-aun",
-  "version": "1.0.49",
+  "version": "1.0.58",
   "description": "mu-agent-bridge 的 AUN 通道插件。",
   "keywords": [
     "mu-agent-bridge-plugin",

package/plugin.json

@@ -1,6 +1,6 @@
 {
   "id": "aun",
-  "version": "1.0.49",
+  "version": "1.0.58",
   "type": "channel",
   "displayName": "AUN 通道",
   "entry": "dist/src-ts/plugins/aun/index.js",