@aalis/plugin-authority 0.4.0 → 0.5.1

package/dist/index.js

@@ -2,7 +2,9 @@ import { useCommandService } from '@aalis/plugin-commands-api';
 import { getPlatformNames } from '@aalis/plugin-platform-api';
 import { createStorageGateway } from '@aalis/plugin-storage-api';
 import { useWebuiService } from '@aalis/plugin-webui-api';
+import { setNetworkPolicy } from '@aalis/util-network-guard';
 import { AuthorityManager } from './authority-manager.js';
+import { autoConfirmActive, DEFAULT_AUTHORITY, shouldSkipConfirm } from './authority-model.js';
 export { AuthorityManager } from './authority-manager.js';
 // ===== 插件元数据 =====
 export const name = '@aalis/plugin-authority';
@@ -12,36 +14,9 @@ export const provides = ['authority'];
 export const inject = {
     optional: ['commands', 'tools'],
 };
-// 权限管理页（自定义 renderer 在 webui-client）+ 委托关系图（声明式 graph 组件，
-// 复用通用 cytoscape 渲染器）：能力委托模型下"上层分发下层"天然是一张图，比扁平列表直观。
+// 权限管理页（自定义 renderer 在 webui-client）。单 owner 终态无委托树，故无委托关系图。
 const webuiPages = [
     { key: 'authority', label: '权限管理', icon: 'authority', order: 50, renderer: 'authority' },
-    {
-        key: 'authority-graph',
-        label: '委托关系图',
-        icon: 'authority',
-        order: 51,
-        content: [
-            {
-                type: 'graph',
-                label: '委托关系图：owner → 子 → 孙 委托链 + 授予/拒绝能力 + 跨平台绑定（点节点看详情）',
-                source: 'getDelegationGraph',
-                detailSource: 'getDelegationNode',
-                defaultMaxDepth: 2,
-                nodeKinds: [
-                    { kind: 'owner', label: 'Owner（*）', shape: 'diamond', color: '#fbbf24' },
-                    { kind: 'user', label: '用户', shape: 'circle', color: '#60a5fa' },
-                    { kind: 'cap', label: '能力', shape: 'round-rect', color: '#9ca3af' },
-                ],
-                edgeKinds: [
-                    { kind: 'delegate', label: '委托', color: '#34d399' },
-                    { kind: 'grant', label: '授予', color: '#60a5fa' },
-                    { kind: 'deny', label: '拒绝', color: '#ef4444', dashed: true },
-                    { kind: 'bind', label: '绑定', color: '#a78bfa', dashed: true },
-                ],
-            },
-        ],
-    },
 ];
 // ===== 插件入口 =====
 export async function apply(ctx, _config) {
@@ -51,32 +26,67 @@ export async function apply(ctx, _config) {
     const cmds = useCommandService(ctx);
     const storage = createStorageGateway(ctx);
     const authority = new AuthorityManager(ctx.config, ctx.logger, storage);
-    await authority.init();
     ctx.provide('authority', authority);
-    // ===== 执行守卫：能力统一闸 + 受限能力的临时委托确认 =====
+    // 用户等级存于 data:/users.json，读取依赖 storage 服务。storage provider 可能晚于本插件
+    // 上线（曾因此在 init 阶段 readFile 失败被静默吞 → 重启后等级不回载）；改为 storage 就绪时再
+    // load，规避初始化时序竞态。whenService 对「已在线」的服务也会立即触发，故任意加载序都成立。
+    ctx.whenService('storage', () => {
+        void authority.init().then(() => ctx.logger.debug('授权用户等级已加载'), err => ctx.logger.warn(`授权用户等级加载失败: ${err}`));
+    });
+    // 网络出口闸（SSRF）：把 core 配置 network 注入进程级 safeFetch 策略（启动一次）。
+    // 安全归属在权限域；本地固定服务走裸 fetch、不过 safeFetch，故不受影响。
+    setNetworkPolicy(ctx.config.get('network') ?? {});
+    // ===== 执行守卫：两轴正交闸 —— 轴 A 授权（authorize）+ 轴 B 确认（confirm，owner 也吃）=====
     const guard = async (g) => {
         const capability = `${g.type}:${g.name}`;
-        const overrides = (ctx.config.get('visibilityOverrides') ?? {});
-        const visibility = overrides[g.name] ?? g.visibility;
+        // 确认覆盖：'off' 强制关确认；否则覆盖值优先，回退插件声明。
+        const confOv = (ctx.config.get('confirmOverrides') ?? {});
+        const cOv = confOv[capability];
+        const confirm = cOv === 'off' ? undefined : (cOv ?? g.confirm);
         const identity = { platform: g.platform, userId: g.userId };
-        // authorize 永远先评估（含系统源）——防"桥接/系统调用"绕过能力检查提权
-        const denied = authority.authorize(identity, { capability, visibility, resourceCapabilities: g.permissions });
-        if (!denied)
-            return null;
-        // 受限被拒：系统/受信源无人确认，直接返回拒绝；否则走交互确认（白名单/会话授予/回调）
-        if (g.skipConfirm)
-            return denied;
-        const granted = await authority.requestAccess({
+        const accessBase = {
             name: g.name,
             type: g.type,
             capability,
-            resourceCapabilities: g.permissions,
             args: g.args,
             sessionId: g.sessionId,
             platform: g.platform,
             userId: g.userId,
+        };
+        // ── 轴 A · 授权：数字等级裁决（minLevel 由 risk/visibility/authorityOverrides 在 manager 内派生）——系统源也评估，防绕过提权 ──
+        const denied = authority.authorize(identity, {
+            capability,
+            visibility: g.visibility,
+            risk: g.risk,
         });
-        return granted ? null : denied;
+        if (denied) {
+            // 未授权（等级不够 / 硬禁 / 资源受限）：**绝不**让发起者本人弹确认自我提权。
+            // 仅 owner 预先配置的放行（restrictedPolicy 白名单 / 该用户在本会话已有的授予）可救；否则硬拒。
+            // 注意：这里**不**调 requestAccess（那会询问发起者）——只查 isPreApproved（不问人）。
+            if (g.skipConfirm)
+                return denied;
+            return authority.isPreApproved(accessBase) ? null : denied;
+        }
+        // ── 轴 B · 确认：授权已过（含 owner / public / 已授予），但操作声明了 confirm 仍需「意图确认」 ──
+        // 仅对**已授权**操作做意图确认（owner 也吃，防注入借权）；不再是提权入口。
+        // 跳过判定见 shouldSkipConfirm：always 永不跳（cron 无人确认即拒）；非 always 可被
+        // skipConfirm(系统/受信源) 或 owner 本人 auto 模式 跳过。修 #6：旧实现用 `!g.skipConfirm`
+        // 门控整块 → skipConfirm 会连 always 一起绕过。
+        if (confirm) {
+            const skip = shouldSkipConfirm({
+                confirm,
+                skipConfirm: !!g.skipConfirm,
+                isOwner: authority.isOwner(g.platform, g.userId),
+                autoConfirmUntil: ctx.config.get('autoConfirmUntil') ?? 0,
+                now: Date.now(),
+            });
+            if (!skip) {
+                const ok = await authority.requestAccess({ ...accessBase, confirm });
+                if (!ok)
+                    return `操作已取消：${capability} 需确认后执行`;
+            }
+        }
+        return null;
     };
     // 注入到 commands / tools（whenService 在 provider 上线/重启时各调一次）
     ctx.whenService('commands', svc => {
@@ -93,28 +103,17 @@ export async function apply(ctx, _config) {
     });
     ctx.on('app:stopping', () => authority.save());
     // ===== 权限指令 =====
-    // /authority [target] — 查看自己或指定用户的能力
-    cmds.command('authority [target:string]', '查看自己或指定用户的能力授予').action(async (argv, target) => {
+    // /authority [target] — 查看自己或指定用户的权限等级
+    cmds.command('authority [target:string]', '查看自己或指定用户的权限等级').action(async (argv, target) => {
         const describe = (platform, userId, self) => {
             const isOwner = authority.isOwner(platform, userId);
             const who = self ? '您' : `${platform}:${userId}`;
-            const lines = [`${who}${isOwner ? '（owner，拥有全部能力）' : ''}`];
+            if (isOwner)
+                return `${who}（owner，等级 ∞，拥有全部权限）`;
             const entry = userId
                 ? authority.listUsers().find(u => u.platform === platform && u.userId === userId)
                 : undefined;
-            if (entry?.linkedTo)
-                lines.push(`已绑定到主账户 ${entry.linkedTo}（能力以账户为准）`);
-            if (entry?.links?.length)
-                lines.push(`已绑定身份: ${entry.links.join(', ')}`);
-            if (entry?.grant?.length)
-                lines.push(`授予能力: ${entry.grant.join(', ')}`);
-            if (entry?.deny?.length)
-                lines.push(`禁用能力: ${entry.deny.join(', ')}`);
-            if (entry?.grantedBy)
-                lines.push(`委托自: ${entry.grantedBy}`);
-            if (!isOwner && !entry?.grant?.length)
-                lines.push('（默认拥有全部 public 能力）');
-            return lines.join('\n');
+            return `${who} 等级: ${entry?.level ?? DEFAULT_AUTHORITY}`;
         };
         const t = target;
         if (t) {
@@ -125,65 +124,65 @@ export async function apply(ctx, _config) {
         }
         return describe(argv.session.platform, argv.session.userId, true);
     });
-    // /grant <target> <capability> — 委托一个能力（子集约束在 manager 内校验）
+    // /level <target> <整数> — owner 给外部身份设等级（越大越高，0=默认，负数=封禁）。权限管理仅 owner 可达（防自授）。
     cmds
-        .command('grant <target:string> <capability:string>', '授予用户一个能力', { visibility: 'restricted' })
-        .example('/grant onebot:12345 tool:weather')
-        .action(async (argv, target, capability) => editCaps(argv, target, capability, 'grant'));
-    // /deny <target> <capability> — 禁用一个能力
-    cmds
-        .command('deny <target:string> <capability:string>', '禁用用户一个能力', { visibility: 'restricted' })
-        .example('/deny onebot:12345 tool:shell.exec')
-        .action(async (argv, target, capability) => editCaps(argv, target, capability, 'deny'));
-    /** /grant、/deny 共用：往目标用户的 grant/deny 集追加一条能力（委托子集校验在 setUserCapabilities） */
-    function editCaps(argv, target, capability, field) {
+        .command('level <target:string> <level:number>', '设置用户权限等级（整数，越大越高；0 默认，负数封禁）', {
+        visibility: 'restricted',
+    })
+        .example('/level onebot:12345 5')
+        .action(async (argv, target, level) => {
+        if (!authority.isOwner(argv.session.platform, argv.session.userId))
+            return '只有 owner 可管理权限';
         const t = String(target);
-        const cap = String(capability).trim();
         const sep = t.indexOf(':');
         if (sep < 1)
             return '目标格式: <platform:userId>';
-        if (!cap)
-            return '能力不能为空';
-        const granter = { platform: argv.session.platform, userId: argv.session.userId ?? '' };
-        const targetId = { platform: t.slice(0, sep), userId: t.slice(sep + 1) };
-        const cur = authority.listUsers().find(u => u.platform === targetId.platform && u.userId === targetId.userId);
-        const next = [...new Set([...(cur?.[field] ?? []), cap])];
-        try {
-            authority.setUserCapabilities(granter, targetId, {
-                grant: field === 'grant' ? next : cur?.grant,
-                deny: field === 'deny' ? next : cur?.deny,
-            });
-            authority.save();
-            return `已${field === 'grant' ? '授予' : '禁用'} ${t}: ${cap}`;
-        }
-        catch (err) {
-            return err instanceof Error ? err.message : String(err);
-        }
-    }
-    // /bind <code> — 把当前平台账号绑定到 WebUI 主账户（码在 WebUI 权限页生成）。
-    // 仅限私聊：群聊发码会暴露给旁观者。
+        const lv = Number(level);
+        if (!Number.isInteger(lv))
+            return '等级必须是整数';
+        authority.setUserLevel({ platform: t.slice(0, sep), userId: t.slice(sep + 1) }, lv);
+        authority.save();
+        return `已设 ${t} 等级: ${lv}`;
+    });
+    // /auto [分钟|off|on] — owner 临时免 dangerous 二次确认（批处理便利）。on=一直, off=关, 数字=分钟。
     cmds
-        .command('bind <code:string>', '将当前平台账号绑定到 WebUI 账户', { visibility: 'public' })
-        .example('/bind AB12CD34')
-        .action(async (argv, code) => {
-        const { platform, userId, sessionType } = argv.session;
-        if (!userId)
-            return '无法识别您的身份，无法绑定。';
-        if (platform === 'webui' || platform === 'cli')
-            return '请在外部平台（如 QQ）私聊中向机器人发送本指令。';
-        if (sessionType !== 'private')
-            return '为防止绑定码泄露，请在私聊中使用本指令。';
-        try {
-            const account = authority.consumeBindCode(String(code).trim().toUpperCase(), { platform, userId });
-            authority.save();
-            return `绑定成功：${platform}:${userId} ↔ ${account.platform}:${account.userId}。可在 WebUI 权限页解绑。`;
+        .command('auto [arg:string]', '自动确认模式：临时免 dangerous 二次确认（仅 owner 本人）', {
+        visibility: 'restricted',
+    })
+        .example('/auto 30')
+        .example('/auto off')
+        .action(async (argv, arg) => {
+        if (!authority.isOwner(argv.session.platform, argv.session.userId))
+            return '只有 owner 可管理权限';
+        const a = arg === undefined ? undefined : String(arg).trim().toLowerCase();
+        const setUntil = (u) => {
+            ctx.config.set('autoConfirmUntil', u);
+            ctx.getService('app')?.saveConfig();
+        };
+        if (a === undefined) {
+            const u = ctx.config.get('autoConfirmUntil') ?? 0;
+            if (u === -1)
+                return '自动确认：一直开启';
+            if (autoConfirmActive(u, Date.now()))
+                return `自动确认：开启中，剩 ${Math.ceil((u - Date.now()) / 60000)} 分钟`;
+            return '自动确认：关闭';
+        }
+        if (a === 'off' || a === '0') {
+            setUntil(0);
+            return '已关闭自动确认';
         }
-        catch (err) {
-            return err instanceof Error ? err.message : String(err);
+        if (a === 'on') {
+            setUntil(-1);
+            return '已开启自动确认（一直，直到手动关闭）';
         }
+        const m = Number(a);
+        if (!Number.isInteger(m) || m <= 0)
+            return '用法：/auto <分钟> | off | on';
+        setUntil(Date.now() + m * 60000);
+        return `已开启自动确认 ${m} 分钟`;
     });
 }
-// ===== WebUI 操作处理器（最小新模型集；委托树/图 Phase 4 充实）=====
+// ===== WebUI 操作处理器（数字等级单轴：用户等级 + 操作门槛 + owner 列表 + 高级）=====
 function asStringList(v, label) {
     if (v === undefined || v === null)
         return undefined;
@@ -192,7 +191,7 @@ function asStringList(v, label) {
     return v;
 }
 export const actions = {
-    /** 权限概览：用户能力委托 + owner + 操作可见性 + 临时委托 + 受限/禁用清单 */
+    /** 权限概览：用户等级 + owner + 操作门槛/确认 + 临时放行 + 受限/禁用清单 */
     async getOverview(ctx) {
         const auth = ctx.getService('authority');
         const users = auth?.listUsers() ?? [];
@@ -212,242 +211,52 @@ export const actions = {
             users,
             owners,
             platforms,
-            restrictedCapabilities: ctx.config.get('restrictedCapabilities') ?? [],
             deniedCapabilities: ctx.config.get('deniedCapabilities') ?? [],
-            visibilityOverrides: ctx.config.get('visibilityOverrides') ?? {},
+            authorityOverrides: ctx.config.get('authorityOverrides') ?? {},
+            defaultAuthority: DEFAULT_AUTHORITY,
+            confirmOverrides: ctx.config.get('confirmOverrides') ?? {},
+            autoConfirmUntil: ctx.config.get('autoConfirmUntil') ?? 0,
             restrictedPolicy: ctx.config.get('restrictedPolicy') ?? {},
             temporaryGrants: auth?.listTemporaryGrants() ?? [],
             commandPrefix,
+            // 操作清单：指令 + 工具统一带 pluginName/type/confirm，供前端「操作」视图按插件分组、显示两轴默认。
             commands: cmdNodes.map(n => ({
                 key: n.name,
                 name: n.name,
+                type: 'command',
                 displayName: `${commandPrefix}${n.name.split('.').join(' ')}`,
+                pluginName: n.pluginName,
                 visibility: n.visibility ?? 'public',
+                confirm: n.confirm,
+                risk: n.risk,
+            })),
+            tools: tools.map(t => ({
+                key: t.name,
+                name: t.name,
+                type: 'tool',
+                displayName: t.name,
+                pluginName: t.pluginName,
+                visibility: t.visibility ?? 'public',
+                confirm: t.confirm,
+                risk: t.risk,
             })),
-            tools: tools.map(t => ({ key: t.name, name: t.name, visibility: t.visibility ?? 'public' })),
-        };
-    },
-    /**
-     * 委托关系图数据（喂通用 cytoscape graph 组件，协议与 user-relation getRelationGraph 对齐）：
-     * 用户节点（owner/user）+ 能力节点，边 = 委托(父→子) / 授予 / 拒绝 / 绑定(被绑身份→主账户)。
-     * 保证每条边两端节点都存在；支持焦点子图导航（args.focusId 为节点或边 id + maxDepth/maxBreadth），
-     * 点边时回 focusEdge（详情卡片用）。无 focusId 返回全图。
-     */
-    async getDelegationGraph(ctx, args) {
-        const auth = ctx.getService('authority');
-        const users = auth?.listUsers() ?? [];
-        const owners = ctx.config.get('owners') ?? [];
-        const nodes = new Map();
-        const edges = [];
-        const ensureUser = (key) => {
-            const id = `user:${key}`;
-            if (nodes.has(id))
-                return id;
-            const i = key.indexOf(':');
-            const isOwner = i > 0 ? (auth?.isOwner(key.slice(0, i), key.slice(i + 1)) ?? false) : false;
-            nodes.set(id, { data: { id, label: key, kind: isOwner ? 'owner' : 'user', pageRankScale: isOwner ? 0.7 : 0.5 } });
-            return id;
-        };
-        const ensureCap = (pat) => {
-            const id = `cap:${pat}`;
-            if (!nodes.has(id))
-                nodes.set(id, { data: { id, label: pat, kind: 'cap', pageRankScale: 0.3 } });
-            return id;
-        };
-        for (const o of owners)
-            ensureUser(`${o.platform}:${o.userId}`);
-        for (const u of users) {
-            const key = `${u.platform}:${u.userId}`;
-            const src = ensureUser(key);
-            for (const g of u.grant ?? [])
-                edges.push({
-                    data: { id: `grant:${key}:${g}`, source: src, target: ensureCap(g), label: '授予', kind: 'grant' },
-                });
-            for (const d of u.deny ?? [])
-                edges.push({
-                    data: { id: `deny:${key}:${d}`, source: src, target: ensureCap(d), label: '拒绝', kind: 'deny' },
-                });
-            if (u.grantedBy)
-                edges.push({
-                    data: {
-                        id: `delegate:${key}`,
-                        source: ensureUser(u.grantedBy),
-                        target: src,
-                        label: '委托',
-                        kind: 'delegate',
-                        directed: true,
-                    },
-                });
-            if (u.linkedTo)
-                edges.push({
-                    data: {
-                        id: `bind:${key}`,
-                        source: src,
-                        target: ensureUser(u.linkedTo),
-                        label: '绑定',
-                        kind: 'bind',
-                        directed: true,
-                    },
-                });
-        }
-        // owner → 「* 全部能力」：owner 持有 `*`，不逐条 grant，否则会是孤立节点。连一个
-        // `*` 能力节点直观表达"拥有一切"，也让焦点/邻域有内容可展开。
-        const ownerIds = [...nodes.values()].filter(n => n.data.kind === 'owner').map(n => String(n.data.id));
-        if (ownerIds.length > 0) {
-            const allCap = 'cap:*';
-            if (!nodes.has(allCap))
-                nodes.set(allCap, { data: { id: allCap, label: '★ 全部能力 (*)', kind: 'cap', pageRankScale: 0.6 } });
-            for (const id of ownerIds)
-                edges.push({
-                    data: { id: `own:${id}`, source: id, target: allCap, label: '拥有全部', kind: 'grant', directed: true },
-                });
-        }
-        const stats = {
-            用户: users.length,
-            owner: owners.length,
-            能力节点: [...nodes.keys()].filter(k => k.startsWith('cap:')).length,
-        };
-        // 焦点子图导航：无 focusId → 全图；有则从焦点（节点或边两端）BFS maxDepth/maxBreadth。
-        const focusId = typeof args?.focusId === 'string' && args.focusId.trim() ? args.focusId.trim() : undefined;
-        if (!focusId)
-            return { nodes: [...nodes.values()], edges, stats };
-        const maxDepth = Number.isFinite(Number(args?.maxDepth)) ? Number(args?.maxDepth) : 2;
-        const maxBreadth = Number.isFinite(Number(args?.maxBreadth)) ? Number(args?.maxBreadth) : 10;
-        const edgeMatch = edges.find(e => e.data.id === focusId);
-        const starts = edgeMatch
-            ? [String(edgeMatch.data.source), String(edgeMatch.data.target)]
-            : nodes.has(focusId)
-                ? [focusId]
-                : [];
-        const focusEdge = edgeMatch
-            ? {
-                id: String(edgeMatch.data.id),
-                kind: String(edgeMatch.data.kind ?? ''),
-                description: String(edgeMatch.data.label ?? ''),
-                endpoints: [String(edgeMatch.data.source), String(edgeMatch.data.target)],
-                directed: edgeMatch.data.directed === true,
-            }
-            : undefined;
-        // 无向邻接：节点 id → [{edgeId, other}]
-        const adj = new Map();
-        for (const e of edges) {
-            const s = String(e.data.source);
-            const t = String(e.data.target);
-            const id = String(e.data.id);
-            (adj.get(s) ?? adj.set(s, []).get(s))?.push({ edgeId: id, other: t });
-            (adj.get(t) ?? adj.set(t, []).get(t))?.push({ edgeId: id, other: s });
-        }
-        const keptNodes = new Set(starts.filter(id => nodes.has(id)));
-        const keptEdges = new Set(edgeMatch ? [focusId] : []);
-        let frontier = [...keptNodes];
-        for (let d = 0; d < maxDepth && frontier.length > 0; d++) {
-            const next = [];
-            for (const id of frontier) {
-                for (const { edgeId, other } of (adj.get(id) ?? []).slice(0, maxBreadth)) {
-                    keptEdges.add(edgeId);
-                    if (!keptNodes.has(other)) {
-                        keptNodes.add(other);
-                        next.push(other);
-                    }
-                }
-            }
-            frontier = next;
-        }
-        return {
-            focusId,
-            focusEdge,
-            nodes: [...nodes.values()].filter(n => keptNodes.has(String(n.data.id))),
-            edges: edges.filter(e => keptEdges.has(String(e.data.id)) &&
-                keptNodes.has(String(e.data.source)) &&
-                keptNodes.has(String(e.data.target))),
-            stats,
         };
     },
-    /** 委托关系图节点详情（detailSource；点节点时调用） */
-    async getDelegationNode(ctx, args) {
-        const nodeId = String(args.nodeId ?? '');
-        const auth = ctx.getService('authority');
-        const users = auth?.listUsers() ?? [];
-        if (nodeId.startsWith('user:')) {
-            const key = nodeId.slice(5);
-            const i = key.indexOf(':');
-            const isOwner = i > 0 ? (auth?.isOwner(key.slice(0, i), key.slice(i + 1)) ?? false) : false;
-            const u = users.find(x => `${x.platform}:${x.userId}` === key);
-            return {
-                身份: key,
-                类型: isOwner ? 'owner（拥有一切能力）' : '用户',
-                授予: u?.grant?.join('、') || '（无）',
-                拒绝: u?.deny?.join('、') || '（无）',
-                委托自: u?.grantedBy || '（顶层 / owner 直接）',
-                可登录账户: u?.hasPassword ? '是' : '否',
-                绑定: u?.links?.join('、') || (u?.linkedTo ? `→ ${u.linkedTo}` : '（无）'),
-            };
-        }
-        if (nodeId.startsWith('cap:')) {
-            const pat = nodeId.slice(4);
-            const granters = users.filter(u => (u.grant ?? []).some(g => g === pat)).map(u => `${u.platform}:${u.userId}`);
-            const deniers = users.filter(u => (u.deny ?? []).some(d => d === pat)).map(u => `${u.platform}:${u.userId}`);
-            return { 能力: pat, 授予给: granters.join('、') || '（无）', 拒绝于: deniers.join('、') || '（无）' };
-        }
-        return { id: nodeId };
-    },
-    /** 委托：设置用户能力 grant/deny（caller 为授予方，非 owner 时子集校验在 manager 内） */
-    async setUserCapabilities(ctx, args, caller) {
-        const { platform, userId, grant, deny } = args;
+    /** 设置外部身份等级（覆盖式整数）。权限管理仅 owner 可达（防自我提权）。 */
+    async setUserLevel(ctx, args, caller) {
+        const { platform, userId, level } = args;
         if (!platform || !userId)
             throw new Error('platform, userId 必填');
+        if (typeof level !== 'number' || !Number.isInteger(level))
+            throw new Error('level 必须是整数');
         const auth = ctx.getService('authority');
         if (!auth)
             throw new Error('Authority 服务不可用');
-        auth.setUserCapabilities(caller ?? null, { platform: platform, userId: userId }, { grant: asStringList(grant, 'grant'), deny: asStringList(deny, 'deny') });
+        if (caller && !auth.isOwner(caller.platform, caller.userId))
+            throw new Error('只有 owner 可管理权限');
+        auth.setUserLevel({ platform: platform, userId: userId }, level);
         auth.save();
-        return { message: `${platform}:${userId} 的能力委托已更新` };
-    },
-    /** 设置/重置账户密码（owner 或本人） */
-    async setPassword(ctx, args, caller) {
-        const { platform, userId, password } = args;
-        if (!platform || !userId || typeof password !== 'string')
-            throw new Error('platform, userId, password 必填');
-        if (password.length < 6)
-            throw new Error('密码长度至少 6 位');
-        const auth = ctx.getService('authority');
-        if (!auth)
-            throw new Error('Authority 服务不可用');
-        const isSelf = caller && caller.platform === platform && caller.userId === userId;
-        if (caller && !isSelf && !auth.isOwner(caller.platform, caller.userId)) {
-            throw new Error('只有 owner 或本人可设置密码');
-        }
-        await auth.setPassword(platform, userId, password);
-        auth.save();
-        return { message: `${platform}:${userId} 密码已更新` };
-    },
-    async createBindCode(ctx, _args, caller) {
-        if (!caller)
-            throw new Error('无法识别调用者身份');
-        const auth = ctx.getService('authority');
-        if (!auth)
-            throw new Error('Authority 服务不可用');
-        const { code, expiresAt } = auth.createBindCode(caller.platform, caller.userId);
-        const prefix = ctx.getService('commands')?.prefix ?? '/';
-        return { code, expiresAt, hint: `请在 5 分钟内用要绑定的平台账号私聊机器人发送：${prefix}bind ${code}` };
-    },
-    async unlinkIdentity(ctx, args, caller) {
-        const { platform, userId } = args;
-        if (!platform || !userId)
-            throw new Error('platform, userId 必填');
-        const auth = ctx.getService('authority');
-        if (!auth)
-            throw new Error('Authority 服务不可用');
-        if (caller) {
-            const owning = auth.listUsers().find(u => u.links?.includes(`${platform}:${userId}`));
-            const isSelf = owning && owning.platform === caller.platform && owning.userId === caller.userId;
-            if (!isSelf && !auth.isOwner(caller.platform, caller.userId)) {
-                throw new Error('只有绑定所属账户本人或 owner 可以解绑');
-            }
-        }
-        const ok = auth.unlinkIdentity(platform, userId);
-        auth.save();
-        return { ok, message: ok ? `${platform}:${userId} 已解绑` : '该身份没有绑定记录' };
+        return { message: `${platform}:${userId} 等级已更新为 ${level}` };
     },
     /** 删除用户记录 */
     async deleteUser(ctx, args) {
@@ -459,11 +268,14 @@ export const actions = {
         auth?.save();
         return { message: `${platform}:${userId} 记录已删除` };
     },
-    /** 更新 owner 列表 */
-    async setOwners(ctx, args) {
+    /** 更新 owner 列表（仅 owner 可达：防非 owner 把自己加成 owner 提权） */
+    async setOwners(ctx, args, caller) {
         const owners = args.owners;
         if (!Array.isArray(owners))
             throw new Error('owners 必须是数组');
+        const auth = ctx.getService('authority');
+        if (caller && !auth?.isOwner(caller.platform, caller.userId))
+            throw new Error('只有 owner 可管理 owner 列表');
         const app = ctx.getService('app');
         if (!app)
             throw new Error('App 不可用');
@@ -497,42 +309,72 @@ export const actions = {
         const ok = auth.revokeTemporaryGrant(id);
         return { ok, message: ok ? '临时委托已撤销' : '不存在或已过期' };
     },
-    /** owner 覆盖单条操作的可见性（public ↔ restricted），无需改插件声明 */
-    async setVisibilityOverride(ctx, args) {
-        const { name, visibility } = args;
+    /** owner 覆盖单条操作的最低等级（任意整数），无需改插件声明。key=能力键 `type:name`；传非整数则清除该条（回退默认派生）。 */
+    async setAuthorityOverride(ctx, args, caller) {
+        const { name, level } = args;
         if (!name || typeof name !== 'string')
             throw new Error('name 必填');
+        const auth = ctx.getService('authority');
+        if (caller && !auth?.isOwner(caller.platform, caller.userId))
+            throw new Error('只有 owner 可管理权限');
+        const app = ctx.getService('app');
+        if (!app)
+            throw new Error('App 不可用');
+        const overrides = { ...(ctx.config.get('authorityOverrides') ?? {}) };
+        if (typeof level === 'number' && Number.isInteger(level))
+            overrides[name] = level;
+        else
+            delete overrides[name];
+        ctx.config.set('authorityOverrides', overrides);
+        app.saveConfig();
+        return { message: `操作 ${name} 最低等级已更新` };
+    },
+    /** owner 覆盖单条操作的确认要求（session/always/off）。key=能力键 `type:name`；非法值清除该条。 */
+    async setConfirmOverride(ctx, args, caller) {
+        const { name, confirm } = args;
+        if (!name || typeof name !== 'string')
+            throw new Error('name 必填');
+        const auth = ctx.getService('authority');
+        if (caller && !auth?.isOwner(caller.platform, caller.userId))
+            throw new Error('只有 owner 可管理权限');
         const app = ctx.getService('app');
         if (!app)
             throw new Error('App 不可用');
-        const overrides = { ...(ctx.config.get('visibilityOverrides') ?? {}) };
-        if (visibility === 'public' || visibility === 'restricted')
-            overrides[name] = visibility;
+        const overrides = { ...(ctx.config.get('confirmOverrides') ?? {}) };
+        if (confirm === 'session' || confirm === 'always' || confirm === 'off')
+            overrides[name] = confirm;
         else
             delete overrides[name];
-        ctx.config.set('visibilityOverrides', overrides);
+        ctx.config.set('confirmOverrides', overrides);
         app.saveConfig();
-        return { message: `操作 ${name} 可见性已更新` };
+        return { message: `操作 ${name} 确认要求已更新` };
     },
-    /** 更新受限/禁用能力清单 */
+    /** owner 切换 auto 确认模式。minutes: -1=一直 / 0=关 / N=N 分钟。仅 owner 可达。 */
+    async setAutoConfirm(ctx, args, caller) {
+        const auth = ctx.getService('authority');
+        if (caller && !auth?.isOwner(caller.platform, caller.userId))
+            throw new Error('只有 owner 可管理权限');
+        const app = ctx.getService('app');
+        if (!app)
+            throw new Error('App 不可用');
+        const m = args.minutes;
+        if (typeof m !== 'number' || !Number.isInteger(m))
+            throw new Error('minutes 必须是整数（-1 一直 / 0 关 / N 分钟）');
+        const until = m === -1 ? -1 : m <= 0 ? 0 : Date.now() + m * 60000;
+        ctx.config.set('autoConfirmUntil', until);
+        app.saveConfig();
+        return { message: until === -1 ? '自动确认：一直' : until === 0 ? '自动确认：关' : `自动确认：${m} 分钟`, until };
+    },
+    /** 更新禁用能力清单 */
     async setConfig(ctx, args) {
         const app = ctx.getService('app');
         if (!app)
             throw new Error('App 不可用');
-        const restricted = asStringList(args.restrictedCapabilities, 'restrictedCapabilities');
         const denied = asStringList(args.deniedCapabilities, 'deniedCapabilities');
-        if (restricted)
-            ctx.config.set('restrictedCapabilities', restricted);
         if (denied)
             ctx.config.set('deniedCapabilities', denied);
         app.saveConfig();
         return { message: '权限配置已更新' };
     },
 };
-// createBindCode / unlinkIdentity 对任何登录账户开放（绑码只能绑自己；解绑有 handler 内本人/owner 检查）；
-// 其余 action 不声明 → 默认 restricted（仅 owner / 被委托）。
-export const actionsMeta = {
-    createBindCode: { visibility: 'public' },
-    unlinkIdentity: { visibility: 'public' },
-};
 //# sourceMappingURL=index.js.map