@aalis/plugin-authority 0.1.2 → 0.4.0

package/dist/index.js

@@ -1,527 +1,9 @@
-import { Buffer } from 'node:buffer';
 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';
-const BIND_CODE_TTL_MS = 5 * 60 * 1000;
-// 8 位、去易混淆字符（0O1IL）的码空间 ≈ 31^8 ≈ 8.5e11，无需额外限流
-const BIND_CODE_ALPHABET = '23456789ABCDEFGHJKMNPQRSTUVWXYZ';
-function generateBindCode() {
-    const bytes = crypto.getRandomValues(new Uint8Array(8));
-    let code = '';
-    for (const b of bytes)
-        code += BIND_CODE_ALPHABET[b % BIND_CODE_ALPHABET.length];
-    return code;
-}
-// 密码哈希：Web Crypto PBKDF2-SHA256（迭代数随凭据存储，便于将来上调不破坏旧凭据）
-const PBKDF2_ITERATIONS = 310_000;
-async function deriveHash(password, saltHex, iterations) {
-    const key = await crypto.subtle.importKey('raw', new TextEncoder().encode(password), 'PBKDF2', false, ['deriveBits']);
-    const bits = await crypto.subtle.deriveBits({ name: 'PBKDF2', hash: 'SHA-256', salt: Buffer.from(saltHex, 'hex'), iterations }, key, 256);
-    return Buffer.from(bits).toString('hex');
-}
-/** 恒定时间字符串比较（长度不同直接 false；不早退） */
-function timingSafeEqualStr(a, b) {
-    if (a.length !== b.length)
-        return false;
-    let diff = 0;
-    for (let i = 0; i < a.length; i++)
-        diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
-    return diff === 0;
-}
-export class AuthorityManager {
-    users = new Map();
-    /** 反向绑定索引：被绑平台身份键 → 主账户键（从 users[].links 重建） */
-    linkIndex = new Map();
-    /** 待消费绑定码（内存态） */
-    bindCodes = new Map();
-    config;
-    logger;
-    storage;
-    fileUri;
-    dirty = false;
-    saveChain = Promise.resolve();
-    confirmHandlers = new Map();
-    dangerousGrants = new Map();
-    grantSeq = 0;
-    /**
-     * dangerous 策略的开启时间（运行时状态，不序列化到 config）。
-     * 进程重启后重置为 null，对限时策略而言等同于「重启即失效」。
-     */
-    dangerousEnabledAt = null;
-    constructor(config, logger, storage) {
-        this.config = config;
-        this.logger = logger.child('authority');
-        this.storage = storage;
-        this.fileUri = 'data:/users.json';
-    }
-    getAuthority(platform, userId) {
-        if (!userId)
-            return this.config.get('defaultAuthority') ?? 1;
-        if ((platform === 'webui' || platform === 'cli') && userId === 'console') {
-            return this.config.get('ownerAuthority') ?? 5;
-        }
-        const owners = this.config.get('owners') ?? [];
-        if (owners.some((o) => o.platform === platform && o.userId === userId)) {
-            return this.config.get('ownerAuthority') ?? 5;
-        }
-        // 被绑身份解析到主账户（零合并单一真源）。递归至多一层：linkIndex 的
-        // 键只会是外部平台身份（consumeBindCode 拒绝 webui/cli），值是 webui 账户。
-        const linked = this.linkIndex.get(`${platform}:${userId}`);
-        if (linked) {
-            const idx = linked.indexOf(':');
-            return this.getAuthority(linked.slice(0, idx), linked.slice(idx + 1));
-        }
-        return this.users.get(`${platform}:${userId}`)?.level ?? this.config.get('defaultAuthority') ?? 1;
-    }
-    setAuthority(platform, userId, level) {
-        const key = `${platform}:${userId}`;
-        this.users.set(key, { ...this.users.get(key), level });
-        this.dirty = true;
-        this.logger.debug(`设置用户权限: ${key} → ${level}`);
-    }
-    removeUser(platform, userId) {
-        if (this.users.delete(`${platform}:${userId}`)) {
-            this.dirty = true;
-            this.rebuildLinkIndex();
-            this.logger.debug(`删除用户权限记录: ${platform}:${userId}`);
-        }
-    }
-    // ── 跨平台身份绑定 ──────────────────────────────────────
-    /** 从 users[].links 重建反向索引（表很小，全量重建即可） */
-    rebuildLinkIndex() {
-        this.linkIndex.clear();
-        for (const [key, record] of this.users) {
-            for (const linked of record.links ?? [])
-                this.linkIndex.set(linked, key);
-        }
-    }
-    createBindCode(platform, userId) {
-        if (platform !== 'webui')
-            throw new Error('绑定码只能由 WebUI 主账户发起');
-        const account = `${platform}:${userId}`;
-        // 同账户重新生成作废旧码；顺手清理过期码
-        const now = Date.now();
-        for (const [code, pending] of this.bindCodes) {
-            if (pending.account === account || pending.expiresAt <= now)
-                this.bindCodes.delete(code);
-        }
-        const code = generateBindCode();
-        const expiresAt = now + BIND_CODE_TTL_MS;
-        this.bindCodes.set(code, { account, expiresAt });
-        this.logger.info(`生成绑定码: 账户 ${account}（5 分钟有效）`);
-        return { code, expiresAt };
-    }
-    consumeBindCode(code, identity) {
-        if (identity.platform === 'webui' || identity.platform === 'cli') {
-            throw new Error('请在外部平台（如 QQ）私聊中向机器人发送绑定码');
-        }
-        const pending = this.bindCodes.get(code);
-        if (!pending || pending.expiresAt <= Date.now()) {
-            this.bindCodes.delete(code);
-            throw new Error('绑定码无效或已过期，请在 WebUI 重新生成');
-        }
-        const identityKey = `${identity.platform}:${identity.userId}`;
-        const existing = this.linkIndex.get(identityKey);
-        if (existing)
-            throw new Error(`该平台身份已绑定到 ${existing}，请先解绑`);
-        this.bindCodes.delete(code); // 一次性
-        const accountRecord = { ...this.users.get(pending.account) };
-        // 绑时一次性合并（运行时零合并的前提）：等级取 max、grants/denies 并集
-        // 写入账户；平台身份原记录原样留底，解绑即还原。
-        const identityRecord = this.users.get(identityKey);
-        if (identityRecord) {
-            if (identityRecord.level !== undefined && identityRecord.level > (accountRecord.level ?? 0)) {
-                accountRecord.level = identityRecord.level;
-            }
-            const union = (a, b) => {
-                const merged = [...new Set([...(a ?? []), ...(b ?? [])])];
-                return merged.length > 0 ? merged : undefined;
-            };
-            accountRecord.grants = union(accountRecord.grants, identityRecord.grants);
-            accountRecord.denies = union(accountRecord.denies, identityRecord.denies);
-        }
-        accountRecord.links = [...new Set([...(accountRecord.links ?? []), identityKey])];
-        this.users.set(pending.account, accountRecord);
-        this.dirty = true;
-        this.rebuildLinkIndex();
-        const idx = pending.account.indexOf(':');
-        this.logger.info(`身份绑定成功: ${identityKey} → ${pending.account}`);
-        return { platform: pending.account.slice(0, idx), userId: pending.account.slice(idx + 1) };
-    }
-    unlinkIdentity(platform, userId) {
-        const identityKey = `${platform}:${userId}`;
-        const accountKey = this.linkIndex.get(identityKey);
-        if (!accountKey)
-            return false;
-        const record = this.users.get(accountKey);
-        if (record?.links) {
-            const links = record.links.filter(k => k !== identityKey);
-            this.users.set(accountKey, { ...record, links: links.length > 0 ? links : undefined });
-        }
-        this.dirty = true;
-        this.rebuildLinkIndex();
-        this.logger.info(`身份解绑: ${identityKey} ↮ ${accountKey}`);
-        return true;
-    }
-    async setPassword(platform, userId, password) {
-        if (!password)
-            throw new Error('密码不能为空');
-        const key = `${platform}:${userId}`;
-        const salt = Buffer.from(crypto.getRandomValues(new Uint8Array(16))).toString('hex');
-        const hash = await deriveHash(password, salt, PBKDF2_ITERATIONS);
-        this.users.set(key, { ...this.users.get(key), secret: `pbkdf2:${PBKDF2_ITERATIONS}:${salt}:${hash}` });
-        this.dirty = true;
-        this.logger.info(`账户密码已更新: ${key}`);
-    }
-    async verifyPassword(platform, userId, password) {
-        const secret = this.users.get(`${platform}:${userId}`)?.secret;
-        if (!secret || !password)
-            return false;
-        const [scheme, iterStr, salt, hash] = secret.split(':');
-        const iterations = Number(iterStr);
-        if (scheme !== 'pbkdf2' || !Number.isFinite(iterations) || iterations < 1 || !salt || !hash)
-            return false;
-        const actual = await deriveHash(password, salt, iterations);
-        return timingSafeEqualStr(actual, hash);
-    }
-    hasPassword(platform, userId) {
-        return !!this.users.get(`${platform}:${userId}`)?.secret;
-    }
-    setUserCapabilities(platform, userId, overrides) {
-        const key = `${platform}:${userId}`;
-        const normalize = (list) => {
-            const cleaned = [...new Set((list ?? []).map(p => p.trim()).filter(Boolean))];
-            return cleaned.length > 0 ? cleaned : undefined;
-        };
-        const next = {
-            ...this.users.get(key),
-            grants: normalize(overrides.grants),
-            denies: normalize(overrides.denies),
-        };
-        if (next.level === undefined && !next.grants && !next.denies && !next.secret && !next.links) {
-            this.users.delete(key);
-        }
-        else {
-            this.users.set(key, next);
-        }
-        this.dirty = true;
-        this.logger.debug(`设置用户 capability 覆盖: ${key} grants=${next.grants?.length ?? 0} denies=${next.denies?.length ?? 0}`);
-    }
-    /**
-     * capability 中心统一闸。裁决优先级（per-capability）：
-     * 全局 permissionPolicy > 用户 deny > 用户 grant > 角色链等级门槛。
-     *
-     * 等级门槛 = max(declaredAuthority, requiredAuthorityFor([cap]))——
-     * 即"操作声明的基础等级"与"capability 归属角色包"取较高者，只升不降。
-     */
-    authorize(identity, request) {
-        const level = this.getAuthority(identity.platform, identity.userId);
-        const declared = request.declaredAuthority ?? 0;
-        if (request.capabilities.length === 0) {
-            if (level < declared)
-                return `权限不足: 需要权限等级 ${declared}，当前用户等级 ${level}`;
-            return null;
-        }
-        const policyDenied = this.checkPermissionPolicy(request.capabilities);
-        if (policyDenied)
-            return policyDenied;
-        // 被绑身份零合并解析：grants 以主账户为唯一真源；denies 取自身∪账户并集
-        // （自身记录的 deny 在绑定后仍生效——防"绑定洗白封禁"）。
-        const ownKey = identity.userId ? `${identity.platform}:${identity.userId}` : undefined;
-        const ownRecord = ownKey ? this.users.get(ownKey) : undefined;
-        const accountKey = ownKey ? this.linkIndex.get(ownKey) : undefined;
-        const accountRecord = accountKey ? this.users.get(accountKey) : undefined;
-        const grants = accountKey ? accountRecord?.grants : ownRecord?.grants;
-        const denies = [...(ownRecord?.denies ?? []), ...(accountRecord?.denies ?? [])];
-        for (const cap of request.capabilities) {
-            if (denies.length > 0 && this.matchAny(denies, [cap])) {
-                return `已被禁止: ${cap}`;
-            }
-            if (grants && this.matchAny(grants, [cap]))
-                continue;
-            const required = Math.max(declared, this.requiredAuthorityFor([cap]));
-            if (level < required) {
-                return `权限不足: "${cap}" 需要权限等级 ${required}，当前用户等级 ${level}`;
-            }
-        }
-        return null;
-    }
-    isDangerousAllowed(name, permissions = []) {
-        const policy = this.config.get('dangerousPolicy');
-        if (!policy?.allow || policy.allow.length === 0)
-            return false;
-        // 有限时策略时检查过期；未记录 enabledAt 视为未启用（重启后自动失效）
-        if (policy.duration && policy.duration > 0) {
-            if (!this.dangerousEnabledAt)
-                return false;
-            const elapsed = (Date.now() - this.dangerousEnabledAt) / 1000;
-            if (elapsed > policy.duration) {
-                this.logger.info('dangerous 白名单已过期');
-                return false;
-            }
-        }
-        return this.matchAny(policy.allow, [name, ...permissions]);
-    }
-    /** 刷新 dangerous 策略启动时间戳（运行时状态） */
-    markDangerousEnabled() {
-        this.dangerousEnabledAt = Date.now();
-    }
-    /** 清除 dangerous 策略启动时间戳 */
-    clearDangerousEnabled() {
-        this.dangerousEnabledAt = null;
-    }
-    setConfirmHandler(platform, handler) {
-        this.confirmHandlers.set(platform, handler);
-    }
-    async confirmDangerous(request) {
-        if (this.isDangerousAllowed(request.name, request.permissions))
-            return true;
-        const grant = this.consumeDangerousGrant(request);
-        if (grant) {
-            this.logger.info(`命中高危会话授权: ${request.type}:${request.name} session=${request.sessionId} grant=${grant.id} used=${grant.used}${grant.maxUses ? `/${grant.maxUses}` : ''}`);
-            return true;
-        }
-        const handler = this.confirmHandlers.get(request.platform);
-        if (handler) {
-            try {
-                const result = await handler(request);
-                const normalized = this.normalizeConfirmResult(result);
-                if (normalized.allowed && normalized.grant?.scope === 'session') {
-                    this.createDangerousGrant(request, normalized);
-                }
-                return normalized.allowed;
-            }
-            catch (err) {
-                this.logger.warn(`高危确认回调异常: ${err}`);
-                return false;
-            }
-        }
-        return false;
-    }
-    /**
-     * 计算一组细粒度权限所要求的最低权限等级（参数级动态提权）。
-     *
-     * 例如 file_write 写普通文件只需声明的 authority:3，但写 data:/users.json
-     * （用户权限表）或 data:/scheduler-jobs.json（计划任务，可注入 owner 身份的
-     * actor）这类敏感文件、或写 aalis:/ 源码根（重启后即任意代码执行）时要求
-     * owner 等级，防止低权限用户借文件写入自我提权。
-     *
-     * 默认保护清单可被 config.permissionAuthority 覆盖/扩展（同模式取配置值，
-     * 新模式叠加；命中多个模式时取最大要求）。只提高门槛，不降低声明值。
-     */
-    /** 参数级提权完整清单（内置保护 + config.permissionAuthority 合并后；展示与裁决共用同一真源） */
-    getEscalationMap() {
-        const ownerLevel = this.config.get('ownerAuthority') ?? 5;
-        return {
-            'storage:path:data:/users.json:write': ownerLevel,
-            'storage:path:data:/users.json:delete': ownerLevel,
-            'storage:path:data:/scheduler-jobs.json:write': ownerLevel,
-            'storage:path:data:/scheduler-jobs.json:delete': ownerLevel,
-            'storage:aalis:write': ownerLevel,
-            'storage:aalis:delete': ownerLevel,
-            ...(this.config.get('permissionAuthority') ?? {}),
-        };
-    }
-    requiredAuthorityFor(permissions) {
-        if (permissions.length === 0)
-            return 0;
-        let required = 0;
-        for (const [pattern, level] of Object.entries(this.getEscalationMap())) {
-            if (level > required && this.matchAny([pattern], permissions))
-                required = level;
-        }
-        return required;
-    }
-    checkPermissionPolicy(permissions) {
-        const policy = this.config.get('permissionPolicy');
-        if (!policy)
-            return null;
-        const deny = policy.deny ?? [];
-        if (deny.length > 0 && this.matchAny(deny, permissions)) {
-            return `权限策略拒绝: ${permissions.join(', ')}`;
-        }
-        const allow = policy.allow ?? [];
-        if (allow.length > 0 && !this.matchAny(allow, permissions)) {
-            return `权限策略未允许: ${permissions.join(', ')}`;
-        }
-        return null;
-    }
-    matchAny(patterns, values) {
-        return patterns.some(pattern => values.some(value => this.matchPattern(pattern, value)));
-    }
-    matchPattern(pattern, value) {
-        if (pattern === '*' || pattern === value)
-            return true;
-        const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/\\\*/g, '.*');
-        return new RegExp(`^${escaped}$`).test(value);
-    }
-    listDangerousGrants() {
-        this.pruneDangerousGrants();
-        return [...this.dangerousGrants.values()].map(grant => ({ ...grant }));
-    }
-    revokeDangerousGrant(id) {
-        const ok = this.dangerousGrants.delete(id);
-        if (ok)
-            this.logger.info(`已撤销高危会话授权: ${id}`);
-        return ok;
-    }
-    normalizeConfirmResult(result) {
-        return typeof result === 'boolean' ? { allowed: result } : result;
-    }
-    consumeDangerousGrant(request) {
-        this.pruneDangerousGrants();
-        for (const grant of this.dangerousGrants.values()) {
-            if (grant.type !== request.type)
-                continue;
-            if (grant.name !== request.name)
-                continue;
-            if (grant.sessionId !== request.sessionId)
-                continue;
-            if (grant.platform !== request.platform)
-                continue;
-            if (grant.userId && request.userId && grant.userId !== request.userId)
-                continue;
-            if (!this.samePermissions(grant.permissions, request.permissions))
-                continue;
-            grant.used++;
-            if (grant.maxUses && grant.used >= grant.maxUses) {
-                this.dangerousGrants.delete(grant.id);
-            }
-            return grant;
-        }
-        return undefined;
-    }
-    createDangerousGrant(request, result) {
-        const grantRequest = result.grant;
-        if (!grantRequest || grantRequest.scope !== 'session')
-            return;
-        // 创建新授权时顺带清扫过期/用尽的（对称 bindCodes 的发码即清扫——审计 MEDIUM #11）
-        this.pruneDangerousGrants();
-        const durationSeconds = Math.max(1, Math.min(grantRequest.durationSeconds ?? 600, 3600));
-        const grant = {
-            id: `grant_${Date.now()}_${++this.grantSeq}`,
-            name: request.name,
-            type: request.type,
-            permissions: request.permissions,
-            sessionId: request.sessionId,
-            platform: request.platform,
-            userId: request.userId,
-            expiresAt: Date.now() + durationSeconds * 1000,
-            maxUses: grantRequest.maxUses,
-            used: 0,
-            createdAt: Date.now(),
-        };
-        this.dangerousGrants.set(grant.id, grant);
-        this.logger.info(`创建高危会话授权: ${request.type}:${request.name} session=${request.sessionId} duration=${durationSeconds}s maxUses=${grant.maxUses ?? 'unlimited'} grant=${grant.id}`);
-    }
-    pruneDangerousGrants() {
-        const now = Date.now();
-        for (const [id, grant] of this.dangerousGrants) {
-            if (grant.expiresAt <= now || (grant.maxUses && grant.used >= grant.maxUses)) {
-                this.dangerousGrants.delete(id);
-                this.logger.debug(`高危会话授权已过期: ${id}`);
-            }
-        }
-    }
-    samePermissions(a, b) {
-        const left = [...new Set(a ?? [])].sort();
-        const right = [...new Set(b ?? [])].sort();
-        if (left.length !== right.length)
-            return false;
-        return left.every((value, index) => value === right[index]);
-    }
-    isOwner(platform, userId) {
-        if (!userId)
-            return false;
-        if ((platform === 'webui' || platform === 'cli') && userId === 'console')
-            return true;
-        const owners = this.config.get('owners') ?? [];
-        return owners.some((o) => o.platform === platform && o.userId === userId);
-    }
-    listUsers() {
-        const result = [];
-        const defaultLevel = this.config.get('defaultAuthority') ?? 1;
-        for (const [key, record] of this.users) {
-            const idx = key.indexOf(':');
-            const platform = key.slice(0, idx);
-            const userId = key.slice(idx + 1);
-            const linkedTo = this.linkIndex.get(key);
-            result.push({
-                platform,
-                userId,
-                // 被绑身份显示运行时有效等级（解析到主账户）；自身记录被遮蔽留底
-                authority: linkedTo ? this.getAuthority(platform, userId) : (record.level ?? defaultLevel),
-                grants: record.grants,
-                denies: record.denies,
-                hasPassword: record.secret ? true : undefined,
-                links: record.links,
-                linkedTo,
-            });
-        }
-        // 无自身记录的被绑身份也要可见（绑定关系本身就是一条用户事实）
-        for (const [identityKey, accountKey] of this.linkIndex) {
-            if (this.users.has(identityKey))
-                continue;
-            const idx = identityKey.indexOf(':');
-            const platform = identityKey.slice(0, idx);
-            const userId = identityKey.slice(idx + 1);
-            result.push({ platform, userId, authority: this.getAuthority(platform, userId), linkedTo: accountKey });
-        }
-        return result;
-    }
-    save() {
-        if (!this.dirty)
-            return;
-        const users = {};
-        for (const [key, record] of this.users)
-            users[key] = record;
-        const payload = JSON.stringify({ version: 2, users }, null, 2);
-        this.dirty = false;
-        this.saveChain = this.saveChain
-            .then(() => this.storage.writeFile(this.fileUri, payload))
-            .then(() => {
-            this.logger.debug('用户权限数据已保存');
-        }, err => {
-            this.logger.warn(`保存用户权限数据失败: ${err}`);
-            this.dirty = true;
-        });
-    }
-    async init() {
-        try {
-            let raw;
-            try {
-                raw = (await this.storage.readFile(this.fileUri, 'utf-8'));
-            }
-            catch {
-                return;
-            }
-            const data = JSON.parse(raw);
-            if (data.version === 2 && typeof data.users === 'object' && data.users !== null) {
-                for (const [key, record] of Object.entries(data.users)) {
-                    if (record && typeof record === 'object')
-                        this.users.set(key, record);
-                }
-            }
-            else {
-                // v1 平面格式（{"platform:userId": level}）：就地迁移，下次 save 写 v2
-                for (const [key, level] of Object.entries(data)) {
-                    if (typeof level === 'number')
-                        this.users.set(key, { level });
-                }
-                if (this.users.size > 0) {
-                    this.dirty = true;
-                    this.logger.info(`users.json v1 → v2 迁移：${this.users.size} 条记录`);
-                }
-            }
-            this.rebuildLinkIndex();
-            this.logger.debug(`加载了 ${this.users.size} 条用户权限记录（绑定 ${this.linkIndex.size} 条）`);
-        }
-        catch (err) {
-            this.logger.warn(`加载用户权限数据失败: ${err}`);
-        }
-    }
-}
+import { AuthorityManager } from './authority-manager.js';
+export { AuthorityManager } from './authority-manager.js';
 // ===== 插件元数据 =====
 export const name = '@aalis/plugin-authority';
 export const displayName = '权限管理';
@@ -530,38 +12,32 @@ export const provides = ['authority'];
 export const inject = {
     optional: ['commands', 'tools'],
 };
+// 权限管理页（自定义 renderer 在 webui-client）+ 委托关系图（声明式 graph 组件，
+// 复用通用 cytoscape 渲染器）：能力委托模型下"上层分发下层"天然是一张图，比扁平列表直观。
 const webuiPages = [
     { key: 'authority', label: '权限管理', icon: 'authority', order: 50, renderer: 'authority' },
     {
         key: 'authority-graph',
-        label: '权限图',
-        icon: '<svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M12 3l8 4v5c0 5-3.5 8-8 9-4.5-1-8-4-8-9V7z"/><circle cx="12" cy="10" r="1.6"/><circle cx="8.5" cy="14.5" r="1.3"/><circle cx="15.5" cy="14.5" r="1.3"/><line x1="12" y1="11.5" x2="8.5" y2="13.3"/><line x1="12" y1="11.5" x2="15.5" y2="13.3"/></svg>',
+        label: '委托关系图',
+        icon: 'authority',
         order: 51,
         content: [
             {
                 type: 'graph',
-                label: '权限依赖图：用户 → 角色链 ← capability / 指令 / 工具（点击节点查看详情）',
-                source: 'getPermissionGraph',
-                detailSource: 'getPermissionNode',
+                label: '委托关系图：owner → 子 → 孙 委托链 + 授予/拒绝能力 + 跨平台绑定（点节点看详情）',
+                source: 'getDelegationGraph',
+                detailSource: 'getDelegationNode',
                 defaultMaxDepth: 2,
-                defaultMaxBreadth: 30,
-                refresh: 0,
-                // 权限图自有图例（声明后组件不再用人物关系图的 person/event/entity 语义）
                 nodeKinds: [
+                    { kind: 'owner', label: 'Owner（*）', shape: 'diamond', color: '#fbbf24' },
                     { kind: 'user', label: '用户', shape: 'circle', color: '#60a5fa' },
-                    { kind: 'role', label: '角色（等级）', shape: 'round-rect', color: '#f59e0b' },
-                    { kind: 'capability', label: 'capability', shape: 'diamond', color: '#34d399' },
-                    { kind: 'command', label: '指令', shape: 'round-rect', color: '#a855f7' },
-                    { kind: 'tool', label: '工具', shape: 'round-rect', color: '#06b6d4' },
+                    { kind: 'cap', label: '能力', shape: 'round-rect', color: '#9ca3af' },
                 ],
                 edgeKinds: [
-                    { kind: 'inherit', label: '继承', color: '#f59e0b' },
-                    { kind: 'level', label: '等级归属', color: '#60a5fa' },
-                    { kind: 'bind', label: '绑定', color: '#f472b6', dashed: true },
-                    { kind: 'grant', label: '授予', color: '#34d399', dashed: true },
-                    { kind: 'deny', label: '拒绝', color: '#ef4444' },
-                    { kind: 'escalation', label: '提权要求', color: '#ef4444', dashed: true },
-                    { kind: 'belongs', label: '归入角色包', color: '#6b7280' },
+                    { kind: 'delegate', label: '委托', color: '#34d399' },
+                    { kind: 'grant', label: '授予', color: '#60a5fa' },
+                    { kind: 'deny', label: '拒绝', color: '#ef4444', dashed: true },
+                    { kind: 'bind', label: '绑定', color: '#a78bfa', dashed: true },
                 ],
             },
         ],
@@ -569,7 +45,6 @@ const webuiPages = [
 ];
 // ===== 插件入口 =====
 export async function apply(ctx, _config) {
-    // 注册 WebUI 页面
     const webui = useWebuiService(ctx);
     for (const page of webuiPages)
         webui.registerPage(page);
@@ -578,33 +53,32 @@ export async function apply(ctx, _config) {
     const authority = new AuthorityManager(ctx.config, ctx.logger, storage);
     await authority.init();
     ctx.provide('authority', authority);
-    // ===== 向 tools/commands 注入执行守卫 =====
-    const guard = async (guardCtx) => {
-        // ExecutionGuard 是 tool/command surface 的适配器：等级门槛、参数级提权、
-        // 全局策略与用户 grant/deny 全部收进 authorize 统一闸；dangerous 确认是
-        // 交互流程（弹窗/会话授权），保留在适配器层。
-        const capabilities = guardCtx.permissions?.length ? guardCtx.permissions : [`${guardCtx.type}:${guardCtx.name}`];
-        const denied = authority.authorize({ platform: guardCtx.platform, userId: guardCtx.userId }, { capabilities, declaredAuthority: guardCtx.authority });
-        if (denied)
+    // ===== 执行守卫：能力统一闸 + 受限能力的临时委托确认 =====
+    const guard = async (g) => {
+        const capability = `${g.type}:${g.name}`;
+        const overrides = (ctx.config.get('visibilityOverrides') ?? {});
+        const visibility = overrides[g.name] ?? g.visibility;
+        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;
-        if (guardCtx.safety === 'dangerous' && !guardCtx.skipSafetyCheck) {
-            const confirmed = await authority.confirmDangerous({
-                name: guardCtx.name,
-                type: guardCtx.type,
-                args: guardCtx.args,
-                permissions: guardCtx.permissions,
-                sessionId: guardCtx.sessionId,
-                platform: guardCtx.platform,
-                userId: guardCtx.userId,
-            });
-            if (!confirmed) {
-                return `已取消执行${guardCtx.type === 'command' ? '指令' : '工具'} ${guardCtx.name}。`;
-            }
-        }
-        return null;
+        const granted = await authority.requestAccess({
+            name: g.name,
+            type: g.type,
+            capability,
+            resourceCapabilities: g.permissions,
+            args: g.args,
+            sessionId: g.sessionId,
+            platform: g.platform,
+            userId: g.userId,
+        });
+        return granted ? null : denied;
     };
-    // 注入到 commands / tools 服务。whenService 会在 provider 上线（含 bounce 后
-    // 重新 provide）时各调一次，自动覆盖"authority 早于 provider"和"provider 重启"两种场景。
+    // 注入到 commands / tools（whenService 在 provider 上线/重启时各调一次）
     ctx.whenService('commands', svc => {
         if (svc.setExecutionGuard) {
             svc.setExecutionGuard(guard);
@@ -616,106 +90,117 @@ export async function apply(ctx, _config) {
             svc.setExecutionGuard(guard);
             ctx.logger.debug('权限守卫已注入: tools');
         }
-        const toolOvr = ctx.config.get('toolOverrides');
-        if (toolOvr && svc.loadOverrides) {
-            svc.loadOverrides(toolOvr);
-        }
-    });
-    // ===== 应用停止时保存 =====
-    ctx.on('app:stopping', () => {
-        authority.save();
     });
+    ctx.on('app:stopping', () => authority.save());
     // ===== 权限指令 =====
-    // /grant — 设置用户权限等级
-    cmds
-        .command('grant <target:string> <level:number>', '设置用户权限等级', { authority: 2 })
-        .example('/grant onebot:12345 2')
-        .action(async (argv, target, level) => {
-        const t = target;
-        const lvl = level;
-        if (Number.isNaN(lvl) || lvl < 0)
-            return '权限等级必须是非负整数。';
-        const callerAuth = authority.getAuthority(argv.session.platform, argv.session.userId);
-        if (lvl >= callerAuth)
-            return `不能将权限设置为 >= 您自身的等级 (${callerAuth})。`;
-        const sep = t.indexOf(':');
-        if (sep < 1)
-            return '目标格式: <platform:userId>，例如 onebot:12345';
-        const platform = t.slice(0, sep);
-        const userId = t.slice(sep + 1);
-        authority.setAuthority(platform, userId, lvl);
-        authority.save();
-        return `已将 ${t} 的权限等级设置为 ${lvl}。`;
-    });
-    // /authority — 查看权限等级 + 个别授予/拒绝 + 绑定关系
-    const describeIdentity = (platform, userId, self) => {
-        const level = authority.getAuthority(platform, userId);
-        const isOwner = authority.isOwner(platform, userId);
-        const lines = [`${self ? '您' : `${platform}:${userId}`}的权限等级: ${level}${isOwner ? ' (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?.grants?.length)
-            lines.push(`个别授予: ${entry.grants.join(', ')}`);
-        if (entry?.denies?.length)
-            lines.push(`个别拒绝: ${entry.denies.join(', ')}`);
-        return lines.join('\n');
-    };
-    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，拥有全部能力）' : ''}`];
+            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');
+        };
         const t = target;
         if (t) {
             const sep = t.indexOf(':');
             if (sep < 1)
                 return '目标格式: <platform:userId>';
-            return describeIdentity(t.slice(0, sep), t.slice(sep + 1), false);
+            return describe(t.slice(0, sep), t.slice(sep + 1), false);
         }
-        return describeIdentity(argv.session.platform, argv.session.userId, true);
+        return describe(argv.session.platform, argv.session.userId, true);
     });
-    // /bind — 把当前平台账号绑定到 WebUI 主账户（码在 WebUI 权限页生成）。
-    // 仅限私聊：群聊发码会把绑定码暴露给旁观者；公开信道（群聊）安全性弱，
-    // 故直接限定私聊信道完成绑定握手。
+    // /grant <target> <capability> — 委托一个能力（子集约束在 manager 内校验）
+    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('bind <code:string>', '将当前平台账号绑定到 WebUI 账户', { authority: 1 })
+        .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) {
+        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 权限页生成）。
+    // 仅限私聊：群聊发码会暴露给旁观者。
+    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') {
+        if (platform === 'webui' || platform === 'cli')
             return '请在外部平台（如 QQ）私聊中向机器人发送本指令。';
-        }
-        if (sessionType !== 'private') {
+        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 权限页解绑。`;
+            return `绑定成功：${platform}:${userId} ↔ ${account.platform}:${account.userId}。可在 WebUI 权限页解绑。`;
         }
         catch (err) {
             return err instanceof Error ? err.message : String(err);
         }
     });
 }
-// ===== WebUI 操作处理器 =====
+// ===== WebUI 操作处理器（最小新模型集；委托树/图 Phase 4 充实）=====
+function asStringList(v, label) {
+    if (v === undefined || v === null)
+        return undefined;
+    if (!Array.isArray(v) || v.some(x => typeof x !== 'string'))
+        throw new Error(`${label} 必须是字符串数组`);
+    return v;
+}
 export const actions = {
-    /** 获取权限概览 */
+    /** 权限概览：用户能力委托 + owner + 操作可见性 + 临时委托 + 受限/禁用清单 */
     async getOverview(ctx) {
         const auth = ctx.getService('authority');
         const users = auth?.listUsers() ?? [];
         const owners = ctx.config.get('owners') ?? [];
-        const overrides = ctx.getService('commands')?.getOverrides() ?? {};
-        // 扁平化所有指令节点，按 dot 名顺序排列，便于 UI 表格渲染
-        const cmdNodes = ctx.getService('commands')?.getAll() ?? [];
-        const commandPrefix = ctx.getService('commands')?.prefix ?? '/';
-        const cmdNames = new Set(cmdNodes.map(n => n.name));
+        const commandsSvc = ctx.getService('commands');
+        const commandPrefix = commandsSvc?.prefix ?? '/';
+        const cmdNodes = commandsSvc?.getAll() ?? [];
         const tools = ctx.getService('tools')?.getAll() ?? [];
-        // 平台候选（WebUI 下拉用）：身份系统的平台名 = 消息上的 platform 字段。
-        // 取 adapter.platform（getPlatformNames）而非服务提供者 contextId——后者是
-        // 插件实例名（如 @aalis/plugin-adapter-onebot），按它设的权限永远不会命中
-        // 任何真实调用者。webui/cli 是内置 surface，无 adapter，显式列入。
         const platforms = Array.from(new Set([
             ...getPlatformNames(ctx),
             'webui',
@@ -727,398 +212,215 @@ export const actions = {
             users,
             owners,
             platforms,
-            defaultAuthority: ctx.config.get('defaultAuthority') ?? 1,
-            ownerAuthority: ctx.config.get('ownerAuthority') ?? 5,
-            dangerousPolicy: ctx.config.get('dangerousPolicy') ?? {},
-            permissionPolicy: ctx.config.get('permissionPolicy') ?? {},
-            // 参数级动态提权清单（glob→等级；内置保护清单见 requiredAuthorityFor 文档）
-            permissionAuthority: ctx.config.get('permissionAuthority') ?? {},
-            dangerousGrants: auth?.listDangerousGrants() ?? [],
+            restrictedCapabilities: ctx.config.get('restrictedCapabilities') ?? [],
+            deniedCapabilities: ctx.config.get('deniedCapabilities') ?? [],
+            visibilityOverrides: ctx.config.get('visibilityOverrides') ?? {},
+            restrictedPolicy: ctx.config.get('restrictedPolicy') ?? {},
+            temporaryGrants: auth?.listTemporaryGrants() ?? [],
             commandPrefix,
-            commands: cmdNodes.map(n => {
-                const path = n.name.split('.');
-                const depth = path.length - 1;
-                const hasSubcommands = cmdNodes.some(other => other.name.startsWith(`${n.name}.`));
-                return {
-                    // key 同时是 override 的查找键与 setCommandOverride 的入参；如 'profile.clear.nuke'
-                    key: n.name,
-                    // 兼容旧前端：以 name 作 React key
-                    name: n.name,
-                    // 用于显示，如 '/profile clear nuke'
-                    displayName: `${commandPrefix}${path.join(' ')}`,
-                    // 叶子段名（'nuke'）用于子行紧凑显示
-                    leafName: path[path.length - 1],
-                    path,
-                    depth,
-                    isRoot: depth === 0,
-                    hasSubcommands,
-                    hasAction: !!n.handler,
-                    description: n.description,
-                    authority: n.authority,
-                    safety: n.safety,
-                    permissions: n.permissions,
-                    baseAuthority: n.baseAuthority,
-                    baseSafety: n.baseSafety,
-                    basePermissions: n.basePermissions,
-                    overridden: n.overridden,
-                    pluginName: n.pluginName,
-                };
-            }),
-            commandOverrides: overrides,
-            orphanCommandOverrides: Object.keys(overrides).filter(k => !cmdNames.has(k)),
-            tools,
-            toolOverrides: ctx.getService('tools')?.getOverrides?.() ?? {},
+            commands: cmdNodes.map(n => ({
+                key: n.name,
+                name: n.name,
+                displayName: `${commandPrefix}${n.name.split('.').join(' ')}`,
+                visibility: n.visibility ?? 'public',
+            })),
+            tools: tools.map(t => ({ key: t.name, name: t.name, visibility: t.visibility ?? 'public' })),
         };
     },
-    /** 设置用户权限等级 */
-    async setUser(ctx, args, caller) {
-        const { platform, userId, authority } = args;
-        if (!platform || !userId || typeof authority !== 'number') {
-            throw new Error('platform, userId, authority(number) 必填');
-        }
-        if (authority < 0)
-            throw new Error('权限等级必须 >= 0');
-        const auth = ctx.getService('authority');
-        // 与 /grant 指令同语义的防越权检查：不能把任何人设到 >= 自身等级
-        // （caller 为登录账户的真实身份；单 token 模式为 webui:console=owner）。
-        if (caller && auth) {
-            const callerLevel = auth.getAuthority(caller.platform, caller.userId);
-            if (authority >= callerLevel) {
-                throw new Error(`不能将权限设置为 >= 您自身的等级 (${callerLevel})`);
-            }
-        }
-        auth?.setAuthority(platform, userId, authority);
-        auth?.save();
-        return { message: `${platform}:${userId} 权限已设为 ${authority}` };
-    },
-    /** 设置用户的 capability 个别授予/拒绝（deny > grant > 角色链） */
-    async setUserCapabilities(ctx, args, caller) {
-        const { platform, userId, grants, denies } = args;
-        if (!platform || !userId)
-            throw new Error('platform, userId 必填');
-        const asList = (v, label) => {
-            if (v === undefined || v === null)
-                return undefined;
-            if (!Array.isArray(v) || v.some(x => typeof x !== 'string'))
-                throw new Error(`${label} 必须是字符串数组`);
-            return v;
-        };
-        const auth = ctx.getService('authority');
-        if (!auth)
-            throw new Error('Authority 服务不可用');
-        // 防越权：不能改动等级 >= 自身的用户（与 setUser 同思路；改授予=改实际权力）
-        if (caller) {
-            const callerLevel = auth.getAuthority(caller.platform, caller.userId);
-            const targetLevel = auth.getAuthority(platform, userId);
-            const isSelf = caller.platform === platform && caller.userId === userId;
-            if (!isSelf && targetLevel >= callerLevel) {
-                throw new Error(`不能修改等级 >= 您自身 (${callerLevel}) 的用户的 capability 授予`);
-            }
-        }
-        auth.setUserCapabilities(platform, userId, {
-            grants: asList(grants, 'grants'),
-            denies: asList(denies, 'denies'),
-        });
-        auth.save();
-        return { message: `${platform}:${userId} 的 capability 授予已更新` };
-    },
-    /** 设置/重置账户密码（webui 登录凭据；仅本人或更高等级者可操作） */
-    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 服务不可用');
-        if (caller) {
-            const callerLevel = auth.getAuthority(caller.platform, caller.userId);
-            const targetLevel = auth.getAuthority(platform, userId);
-            const isSelf = caller.platform === platform && caller.userId === userId;
-            if (!isSelf && targetLevel >= callerLevel) {
-                throw new Error(`不能为等级 >= 您自身 (${callerLevel}) 的用户设置密码`);
-            }
-        }
-        await auth.setPassword(platform, userId, password);
-        auth.save();
-        return { message: `${platform}:${userId} 密码已更新` };
-    },
-    /** 权限依赖图（graph 组件数据源）：用户 → 角色链 ← capability / 指令 / 工具 */
-    async getPermissionGraph(ctx) {
+    /**
+     * 委托关系图数据（喂通用 cytoscape graph 组件，协议与 user-relation getRelationGraph 对齐）：
+     * 用户节点（owner/user）+ 能力节点，边 = 委托(父→子) / 授予 / 拒绝 / 绑定(被绑身份→主账户)。
+     * 保证每条边两端节点都存在；支持焦点子图导航（args.focusId 为节点或边 id + maxDepth/maxBreadth），
+     * 点边时回 focusEdge（详情卡片用）。无 focusId 返回全图。
+     */
+    async getDelegationGraph(ctx, args) {
         const auth = ctx.getService('authority');
-        if (!auth)
-            throw new Error('Authority 服务不可用');
-        const ownerLevel = ctx.config.get('ownerAuthority') ?? 5;
-        const clamp = (n) => Math.max(0, Math.min(ownerLevel, Math.round(n)));
-        const nodes = [];
+        const users = auth?.listUsers() ?? [];
+        const owners = ctx.config.get('owners') ?? [];
+        const nodes = new Map();
         const edges = [];
-        // 角色链（kind=role：圆角矩形；尺寸随等级增大）
-        for (let n = 0; n <= ownerLevel; n++) {
-            nodes.push({
-                data: {
-                    id: `role:${n}`,
-                    label: n === ownerLevel ? `owner (${n})` : `等级 ${n}`,
-                    kind: 'role',
-                    pageRankScale: 0.35 + (0.65 * n) / ownerLevel,
-                },
-            });
-            if (n > 0) {
-                edges.push({
-                    data: {
-                        id: `inherit:${n}`,
-                        source: `role:${n}`,
-                        target: `role:${n - 1}`,
-                        label: '继承',
-                        kind: 'inherit',
-                        directed: true,
-                    },
-                });
-            }
-        }
-        // capability 节点（kind=capability：菱形），按模式去重
-        const capIds = new Set();
-        const capNode = (pattern) => {
-            if (!capIds.has(pattern)) {
-                capIds.add(pattern);
-                nodes.push({ data: { id: `cap:${pattern}`, label: pattern, kind: 'capability', pageRankScale: 0.3 } });
-            }
-            return `cap:${pattern}`;
+        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;
         };
-        // 用户（users.json + owners 配置 + 单 token 模式的 console）
-        const users = auth.listUsers();
-        const owners = ctx.config.get('owners') ?? [];
-        const userIds = new Set();
-        const userNode = (platform, userId) => {
-            const key = `${platform}:${userId}`;
-            if (!userIds.has(key)) {
-                userIds.add(key);
-                nodes.push({ data: { id: `user:${key}`, label: key, kind: 'user', pageRankScale: 0.55 } });
-            }
-            return `user:${key}`;
+        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 id = userNode(u.platform, u.userId);
-            if (u.linkedTo) {
-                // 被绑身份：权限随主账户走，只画绑定边（等级边由账户承担）
-                const idx = u.linkedTo.indexOf(':');
+            const key = `${u.platform}:${u.userId}`;
+            const src = ensureUser(key);
+            for (const g of u.grant ?? [])
                 edges.push({
-                    data: {
-                        id: `bind:${u.platform}:${u.userId}`,
-                        source: id,
-                        target: userNode(u.linkedTo.slice(0, idx), u.linkedTo.slice(idx + 1)),
-                        label: '绑定',
-                        kind: 'bind',
-                        directed: true,
-                    },
+                    data: { id: `grant:${key}:${g}`, source: src, target: ensureCap(g), label: '授予', kind: 'grant' },
                 });
-            }
-            else {
+            for (const d of u.deny ?? [])
                 edges.push({
-                    data: {
-                        id: `lvl:${u.platform}:${u.userId}`,
-                        source: id,
-                        target: `role:${clamp(u.authority)}`,
-                        label: '等级',
-                        kind: 'level',
-                        directed: true,
-                    },
+                    data: { id: `deny:${key}:${d}`, source: src, target: ensureCap(d), label: '拒绝', kind: 'deny' },
                 });
-            }
-            for (const g of u.grants ?? []) {
+            if (u.grantedBy)
                 edges.push({
                     data: {
-                        id: `grant:${u.platform}:${u.userId}:${g}`,
-                        source: id,
-                        target: capNode(g),
-                        label: '授予',
-                        kind: 'grant',
+                        id: `delegate:${key}`,
+                        source: ensureUser(u.grantedBy),
+                        target: src,
+                        label: '委托',
+                        kind: 'delegate',
                         directed: true,
                     },
                 });
-            }
-            for (const d of u.denies ?? []) {
+            if (u.linkedTo)
                 edges.push({
                     data: {
-                        id: `deny:${u.platform}:${u.userId}:${d}`,
-                        source: id,
-                        target: capNode(d),
-                        label: '拒绝',
-                        kind: 'deny',
+                        id: `bind:${key}`,
+                        source: src,
+                        target: ensureUser(u.linkedTo),
+                        label: '绑定',
+                        kind: 'bind',
                         directed: true,
                     },
                 });
-            }
         }
-        for (const o of owners) {
-            edges.push({
-                data: {
-                    id: `owner:${o.platform}:${o.userId}`,
-                    source: userNode(o.platform, o.userId),
-                    target: `role:${ownerLevel}`,
-                    label: 'owner',
-                    kind: 'level',
-                    directed: true,
-                },
-            });
-        }
-        edges.push({
-            data: {
-                id: 'console-owner',
-                source: userNode('webui', 'console'),
-                target: `role:${ownerLevel}`,
-                label: '单 token/本地',
-                kind: 'level',
-                directed: true,
-            },
-        });
-        // 参数级提权清单（内置保护 + 配置，与裁决同源）
-        for (const [pattern, level] of Object.entries(auth.getEscalationMap())) {
-            edges.push({
-                data: {
-                    id: `esc:${pattern}`,
-                    source: capNode(pattern),
-                    target: `role:${clamp(level)}`,
-                    label: '需等级',
-                    kind: 'escalation',
-                    directed: true,
-                },
-            });
-        }
-        // 指令与工具（仅根指令控制规模）
-        const cmds = (ctx.getService('commands')?.getAll() ?? []).filter(c => !c.name.includes('.'));
-        for (const c of cmds) {
-            nodes.push({
-                data: {
-                    id: `cmd:${c.name}`,
-                    label: `/${c.name}${c.safety === 'dangerous' ? ' ⚠' : ''}`,
-                    kind: 'command',
-                    pageRankScale: 0.12,
-                },
-            });
-            edges.push({
-                data: {
-                    id: `cmd-lvl:${c.name}`,
-                    source: `cmd:${c.name}`,
-                    target: `role:${clamp(c.authority ?? 1)}`,
-                    label: '归入',
-                    kind: 'belongs',
-                    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 toolDefs = ctx.getService('tools')?.getAll() ?? [];
-        for (const t of toolDefs) {
-            nodes.push({
-                data: {
-                    id: `tool:${t.name}`,
-                    label: `${t.name}${t.safety === 'dangerous' ? ' ⚠' : ''}`,
-                    kind: 'tool',
-                    pageRankScale: 0.12,
-                },
-            });
-            edges.push({
-                data: {
-                    id: `tool-lvl:${t.name}`,
-                    source: `tool:${t.name}`,
-                    target: `role:${clamp(t.authority ?? 1)}`,
-                    label: '归入',
-                    kind: 'belongs',
-                    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 {
-            nodes,
-            edges,
-            stats: {
-                用户: userIds.size,
-                角色: ownerLevel + 1,
-                指令根: cmds.length,
-                工具: toolDefs.length,
-                capability: capIds.size,
-            },
+            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,
         };
     },
-    /** 权限图节点详情（graph 组件 detailSource） */
-    async getPermissionNode(ctx, args) {
+    /** 委托关系图节点详情（detailSource；点节点时调用） */
+    async getDelegationNode(ctx, args) {
         const nodeId = String(args.nodeId ?? '');
         const auth = ctx.getService('authority');
-        if (!auth)
-            throw new Error('Authority 服务不可用');
-        const ownerLevel = ctx.config.get('ownerAuthority') ?? 5;
+        const users = auth?.listUsers() ?? [];
         if (nodeId.startsWith('user:')) {
             const key = nodeId.slice(5);
-            const idx = key.indexOf(':');
-            const platform = key.slice(0, idx);
-            const userId = key.slice(idx + 1);
-            const entry = auth.listUsers().find(u => u.platform === platform && u.userId === userId);
+            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,
-                有效等级: auth.getAuthority(platform, userId),
-                owner: auth.isOwner(platform, userId) || undefined,
-                可登录账户: entry?.hasPassword || undefined,
-                绑定到: entry?.linkedTo,
-                已绑身份: entry?.links?.join(', '),
-                个别授予: entry?.grants?.join(', '),
-                个别拒绝: entry?.denies?.join(', '),
-            };
-        }
-        if (nodeId.startsWith('role:')) {
-            const n = Number(nodeId.slice(5));
-            const holders = auth.listUsers().filter(u => !u.linkedTo && u.authority === n).length;
-            return {
-                角色: n === ownerLevel ? `owner（等级 ${n}）` : `等级 ${n}`,
-                语义: '内置角色链：高等级继承低等级的全部授予；capability 图为唯一裁决',
-                显式持有用户数: holders,
+                类型: 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 pattern = nodeId.slice(4);
-            const escalation = auth.getEscalationMap()[pattern];
-            return {
-                capability: pattern,
-                提权要求: escalation !== undefined ? `等级 ${escalation}` : undefined,
-                说明: 'glob 模式，按 PermissionId 匹配；裁决优先级 deny > grant > 角色链',
-            };
+            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('、') || '（无）' };
         }
-        if (nodeId.startsWith('cmd:')) {
-            const cmdName = nodeId.slice(4);
-            const c = ctx
-                .getService('commands')
-                ?.getAll()
-                .find(x => x.name === cmdName);
-            if (!c)
-                return { error: `指令 ${cmdName} 不存在` };
-            return {
-                指令: `/${cmdName}`,
-                描述: c.description,
-                所需等级: c.authority,
-                安全等级: c.safety,
-                capability: c.permissions?.join(', '),
-                来源插件: c.pluginName,
-            };
-        }
-        if (nodeId.startsWith('tool:')) {
-            const toolName = nodeId.slice(5);
-            const t = ctx
-                .getService('tools')
-                ?.getAll()
-                .find(x => x.name === toolName);
-            if (!t)
-                return { error: `工具 ${toolName} 不存在` };
-            return {
-                工具: toolName,
-                描述: t.description,
-                所需等级: t.authority ?? 1,
-                安全等级: t.safety ?? 'safe',
-                capability: t.permissions?.join(', '),
-                来源插件: t.pluginName,
-            };
+        return { id: nodeId };
+    },
+    /** 委托：设置用户能力 grant/deny（caller 为授予方，非 owner 时子集校验在 manager 内） */
+    async setUserCapabilities(ctx, args, caller) {
+        const { platform, userId, grant, deny } = args;
+        if (!platform || !userId)
+            throw new Error('platform, userId 必填');
+        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') });
+        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 或本人可设置密码');
         }
-        return { error: `未知节点: ${nodeId}` };
+        await auth.setPassword(platform, userId, password);
+        auth.save();
+        return { message: `${platform}:${userId} 密码已更新` };
     },
-    /** 生成跨平台绑定码（绑定到调用者自己的账户；5 分钟内在外部平台私聊发 /bind <码>） */
     async createBindCode(ctx, _args, caller) {
         if (!caller)
             throw new Error('无法识别调用者身份');
@@ -1127,13 +429,8 @@ export const actions = {
             throw new Error('Authority 服务不可用');
         const { code, expiresAt } = auth.createBindCode(caller.platform, caller.userId);
         const prefix = ctx.getService('commands')?.prefix ?? '/';
-        return {
-            code,
-            expiresAt,
-            hint: `请在 5 分钟内，用要绑定的平台账号（如 QQ）私聊向机器人发送：${prefix}bind ${code}`,
-        };
+        return { code, expiresAt, hint: `请在 5 分钟内用要绑定的平台账号私聊机器人发送：${prefix}bind ${code}` };
     },
-    /** 解绑平台身份（owner 或该绑定所属账户本人） */
     async unlinkIdentity(ctx, args, caller) {
         const { platform, userId } = args;
         if (!platform || !userId)
@@ -1142,12 +439,9 @@ export const actions = {
         if (!auth)
             throw new Error('Authority 服务不可用');
         if (caller) {
-            const identityKey = `${platform}:${userId}`;
-            const ownerLevel = ctx.config.get('ownerAuthority') ?? 5;
-            const callerLevel = auth.getAuthority(caller.platform, caller.userId);
-            const owningAccount = auth.listUsers().find(u => u.links?.includes(identityKey));
-            const isSelf = owningAccount && owningAccount.platform === caller.platform && owningAccount.userId === caller.userId;
-            if (!isSelf && callerLevel < ownerLevel) {
+            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 可以解绑');
             }
         }
@@ -1155,7 +449,7 @@ export const actions = {
         auth.save();
         return { ok, message: ok ? `${platform}:${userId} 已解绑` : '该身份没有绑定记录' };
     },
-    /** 删除用户权限记录（等级回退默认，grants/denies/密码一并清除） */
+    /** 删除用户记录 */
     async deleteUser(ctx, args) {
         const { platform, userId } = args;
         if (!platform || !userId)
@@ -1163,7 +457,7 @@ export const actions = {
         const auth = ctx.getService('authority');
         auth?.removeUser(platform, userId);
         auth?.save();
-        return { message: `${platform}:${userId} 权限已重置` };
+        return { message: `${platform}:${userId} 记录已删除` };
     },
     /** 更新 owner 列表 */
     async setOwners(ctx, args) {
@@ -1177,132 +471,68 @@ export const actions = {
         app.saveConfig();
         return { message: 'Owner 列表已更新' };
     },
-    /** 更新 dangerousPolicy */
-    async setDangerousPolicy(ctx, args) {
+    /** 更新受限能力的临时放行策略（restrictedPolicy） */
+    async setRestrictedPolicy(ctx, args) {
         const policy = args.policy;
         if (!policy || typeof policy !== 'object')
             throw new Error('policy 必须是对象');
         const app = ctx.getService('app');
         if (!app)
             throw new Error('App 不可用');
-        ctx.config.set('dangerousPolicy', policy);
+        ctx.config.set('restrictedPolicy', policy);
         app.saveConfig();
-        // 启用限时策略时，标记运行时启动时间戳（不写入 config）
         if (Array.isArray(policy.allow) && policy.allow.length > 0) {
-            const auth = ctx.getService('authority');
-            auth?.markDangerousEnabled?.();
+            ctx.getService('authority')?.markPolicyEnabled?.();
         }
-        return { message: '高危策略已更新' };
+        return { message: '临时放行策略已更新' };
     },
-    /** 撤销一个高危会话授权 */
-    async revokeDangerousGrant(ctx, args) {
+    /** 撤销一个临时能力委托 */
+    async revokeTemporaryGrant(ctx, args) {
         const id = args.id;
         if (!id)
-            throw new Error('id 必须是字符串');
+            throw new Error('id 必填');
         const auth = ctx.getService('authority');
         if (!auth)
             throw new Error('Authority 服务不可用');
-        const ok = auth.revokeDangerousGrant(id);
-        return { ok, message: ok ? '授权已撤销' : '授权不存在或已过期' };
-    },
-    /** 更新全局权限配置（defaultAuthority, ownerAuthority） */
-    async setConfig(ctx, args) {
-        const { defaultAuthority, ownerAuthority } = args;
-        const app = ctx.getService('app');
-        if (!app)
-            throw new Error('App 不可用');
-        if (typeof defaultAuthority === 'number')
-            ctx.config.set('defaultAuthority', defaultAuthority);
-        if (typeof ownerAuthority === 'number')
-            ctx.config.set('ownerAuthority', ownerAuthority);
-        app.saveConfig();
-        return { message: '权限配置已更新' };
+        const ok = auth.revokeTemporaryGrant(id);
+        return { ok, message: ok ? '临时委托已撤销' : '不存在或已过期' };
     },
-    /** 更新单条指令的权限覆盖 */
-    async setCommandOverride(ctx, args) {
-        const { name, authority, safety } = args;
+    /** owner 覆盖单条操作的可见性（public ↔ restricted），无需改插件声明 */
+    async setVisibilityOverride(ctx, args) {
+        const { name, visibility } = args;
         if (!name || typeof name !== 'string')
             throw new Error('name 必填');
         const app = ctx.getService('app');
         if (!app)
             throw new Error('App 不可用');
-        const override = {};
-        if (typeof authority === 'number')
-            override.authority = authority;
-        if (typeof safety === 'string' && (safety === 'safe' || safety === 'dangerous'))
-            override.safety = safety;
-        if (Object.keys(override).length === 0) {
-            ctx.getService('commands')?.removeOverride(name);
-        }
-        else {
-            ctx.getService('commands')?.setOverride(name, override);
-        }
-        ctx.config.set('commandOverrides', ctx.getService('commands')?.getOverrides() ?? {});
+        const overrides = { ...(ctx.config.get('visibilityOverrides') ?? {}) };
+        if (visibility === 'public' || visibility === 'restricted')
+            overrides[name] = visibility;
+        else
+            delete overrides[name];
+        ctx.config.set('visibilityOverrides', overrides);
         app.saveConfig();
-        return { message: `指令 ${name} 权限已更新` };
+        return { message: `操作 ${name} 可见性已更新` };
     },
-    /** 重置指令覆盖 */
-    async resetCommandOverride(ctx, args) {
-        const { name } = args;
-        if (!name || typeof name !== 'string')
-            throw new Error('name 必填');
-        const app = ctx.getService('app');
-        if (!app)
-            throw new Error('App 不可用');
-        ctx.getService('commands')?.removeOverride(name);
-        ctx.config.set('commandOverrides', ctx.getService('commands')?.getOverrides() ?? {});
-        app.saveConfig();
-        return { message: `指令 ${name} 覆盖已重置` };
-    },
-    /** 更新单个工具的权限覆盖 */
-    async setToolOverride(ctx, args) {
-        const { name, authority, safety } = args;
-        if (!name || typeof name !== 'string')
-            throw new Error('name 必填');
-        const app = ctx.getService('app');
-        const tools = ctx.getService('tools');
-        if (!app)
-            throw new Error('App 不可用');
-        if (!tools?.setOverride)
-            throw new Error('ToolService 未支持 override');
-        const override = {};
-        if (typeof authority === 'number')
-            override.authority = authority;
-        if (typeof safety === 'string' && (safety === 'safe' || safety === 'dangerous'))
-            override.safety = safety;
-        if (Object.keys(override).length === 0) {
-            tools.removeOverride?.(name);
-        }
-        else {
-            tools.setOverride(name, override);
-        }
-        ctx.config.set('toolOverrides', tools.getOverrides?.() ?? {});
-        app.saveConfig();
-        return { message: `工具 ${name} 权限已更新` };
-    },
-    /** 重置工具覆盖 */
-    async resetToolOverride(ctx, args) {
-        const { name } = args;
-        if (!name || typeof name !== 'string')
-            throw new Error('name 必填');
+    /** 更新受限/禁用能力清单 */
+    async setConfig(ctx, args) {
         const app = ctx.getService('app');
-        const tools = ctx.getService('tools');
         if (!app)
             throw new Error('App 不可用');
-        tools?.removeOverride?.(name);
-        ctx.config.set('toolOverrides', tools?.getOverrides?.() ?? {});
+        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: `工具 ${name} 覆盖已重置` };
+        return { message: '权限配置已更新' };
     },
 };
-// actions 权限标注：createBindCode / unlinkIdentity 对任何登录账户开放
-// （绑码只能绑到调用者自己；解绑有 handler 内的本人/owner 业务检查）；
-// 权限图为管理读档（含用户表信息，与 REST 管理读同档=4）。
-// 其余 action 不声明 → 默认要求 owner（默认拒绝）。
+// createBindCode / unlinkIdentity 对任何登录账户开放（绑码只能绑自己；解绑有 handler 内本人/owner 检查）；
+// 其余 action 不声明 → 默认 restricted（仅 owner / 被委托）。
 export const actionsMeta = {
-    createBindCode: { authority: 1 },
-    unlinkIdentity: { authority: 1 },
-    getPermissionGraph: { authority: 4 },
-    getPermissionNode: { authority: 4 },
+    createBindCode: { visibility: 'public' },
+    unlinkIdentity: { visibility: 'public' },
 };
 //# sourceMappingURL=index.js.map