evolcore 0.0.10 → 0.0.12

package/dist/core/auth/operation-authorizer.js

@@ -5,68 +5,6 @@ import { isResolvedConfigMutation, } from '../../config/resolved-config-op.js';
 import { normalizePeer } from '../model/config-scope.js';
 import { getOperationMeta } from './operation-catalog.js';
 import { formatPeerKey, parsePeerKey } from '../relation/peer-identity.js';
-export const USER_PLANE_CAPABILITY_CEILING = {
-    allowOperations: new Set([
-        'model.list',
-        'model.current',
-        'model.use',
-        'model.effort',
-        'model.reset',
-        'permission.current',
-        'permission.answer',
-        'chatmode.current',
-        'chatmode.update',
-        'mentionmode.current',
-        'mentionmode.update',
-        'group.mentionmode.current',
-        'group.rulespolicy.current',
-        'session.list',
-        'session.create',
-        'session.rename',
-        'trigger.list',
-        'trigger.show',
-        'trigger.history',
-        'trigger.eventCatalog',
-        'trigger.create',
-        'trigger.update',
-        'trigger.setEnabled',
-        'trigger.cancel',
-        'trigger.delete',
-        'trigger.run',
-        'stats.summary',
-        'stats.session',
-        'stats.context',
-        'file.list',
-        'file.fetch',
-        'ec.msg.send',
-        'ec.msg.file',
-        'ec.group.send',
-        'ec.group.file',
-        'config.get',
-        'config.set',
-        'config.unset',
-    ]),
-    denyOperations: new Set([
-        'role.assign',
-        'role.revoke',
-        'config.write',
-        'gateway.write',
-        'cli.exec.raw',
-        'shell.exec',
-        'rce.exec',
-    ]),
-    denyNamespaces: new Set([
-        'role',
-        'connect',
-        'contact',
-        'agent',
-        'system',
-        'storage',
-        'aid',
-    ]),
-    allowCategories: new Set(['read', 'write-own']),
-    denyCategories: new Set(['write-agent', 'process', 'dangerous']),
-};
 export function authorizeCommand(ctx) {
     return authorizeCommandInternal(ctx);
 }
@@ -84,68 +22,33 @@ export function authorizeResolvedConfigCommand(command, context) {
  * enforced here.
  */
 export function evaluateRoleOperationCapability(params) {
-    const opMeta = getOperationMeta(params.operation);
-    if (!opMeta) {
-        return {
-            allow: false,
-            operation: params.operation,
-            reason: `Unknown operation: ${params.operation}`,
-        };
-    }
-    const roleDef = getRoleDefinition(params.role, params.selfAid);
-    if (!roleDef || roleDef.allowAccess === false) {
-        return {
-            allow: false,
-            operation: params.operation,
-            reason: `Role ${params.role} cannot access commands`,
-        };
-    }
-    const matched = matchCommandPermission(params.operation, opMeta.category, roleDef.commandPermissions || {}, opMeta.dangerous);
-    if (!matched) {
-        return {
-            allow: false,
-            operation: params.operation,
-            reason: `Role ${params.role} has no permission for ${params.operation}`,
-        };
-    }
-    const { permission, matchedRule } = matched;
-    if (!permission.allow) {
-        return {
-            allow: false,
-            operation: params.operation,
-            reason: permission.reason || `Role ${params.role} explicitly denies ${params.operation}`,
-            matchedRule,
-        };
-    }
-    const scopes = permission.scopes || opMeta.defaultScopes;
-    if (!scopes.includes(params.scope)) {
-        return {
-            allow: false,
+    // Capability discovery has no concrete relation target. Use a synthetic
+    // self relation so target/current-relation constraints are evaluated as
+    // role capabilities without weakening the real authorization path.
+    const capabilitySelf = params.selfAid ?? 'capability.agentid.pub';
+    const capabilityPeer = formatPeerKey('aun', capabilitySelf);
+    const decision = authorizeCommand({
+        intent: {
             operation: params.operation,
-            reason: `Scope ${params.scope} is not allowed for ${params.operation}`,
-            matchedRule,
-        };
-    }
-    const constraints = permission.constraints;
-    if (constraints?.privateOnly && params.chatType !== 'private') {
-        return { allow: false, operation: params.operation, reason: 'Operation is private-chat only', matchedRule };
-    }
-    if (constraints?.groupOnly && params.chatType !== 'group') {
-        return { allow: false, operation: params.operation, reason: 'Operation is group-chat only', matchedRule };
-    }
-    if (constraints?.requireAgentOwner && params.role !== 'owner') {
-        return { allow: false, operation: params.operation, reason: 'Operation requires Agent owner', matchedRule };
-    }
-    if (constraints?.requireAgentAdmin && params.role !== 'owner' && params.role !== 'admin') {
-        return { allow: false, operation: params.operation, reason: 'Operation requires Agent admin', matchedRule };
-    }
-    if (constraints?.requireControlChannel && !params.fromControlChannel) {
-        return { allow: false, operation: params.operation, reason: 'Operation requires the control channel', matchedRule };
-    }
-    if (opMeta.dangerous && !isExplicitDangerousGrant(matchedRule, permission)) {
-        return { allow: false, operation: params.operation, reason: 'Dangerous operation is not explicitly granted', matchedRule };
-    }
-    return { allow: true, operation: params.operation, matchedRule };
+            scope: params.scope,
+            source: 'menu',
+            args: {
+                self: capabilitySelf,
+                peer: capabilityPeer,
+                peerKey: capabilityPeer,
+            },
+        },
+        selfAid: capabilitySelf,
+        peerKey: capabilityPeer,
+        role: params.role,
+        chatType: params.chatType,
+        isDaemonOwner: params.fromControlChannel && params.role === 'owner',
+        fromControlChannel: params.fromControlChannel,
+        source: 'menu',
+    });
+    return decision.allow
+        ? { allow: true, operation: params.operation, matchedRule: decision.matchedRule }
+        : { allow: false, operation: params.operation, reason: decision.reason, matchedRule: decision.matchedRule };
 }
 function authorizeCommandInternal(ctx, resolvedConfigCommand) {
     const { intent, role } = ctx;
@@ -208,11 +111,6 @@ function authorizeCommandInternal(ctx, resolvedConfigCommand) {
     if (roleDef.allowAccess === false) {
         return denyDecision(ctx, 'ROLE_ACCESS_DENIED', `Role ${role} is not allowed to access commands`, operation, intent.scope, opMeta.dangerous);
     }
-    if (!isManagementRole(role)
-        && !resolvedConfigCommand
-        && !isUserPlaneOperationAllowed(operation, opMeta.category, opMeta.dangerous)) {
-        return denyDecision(ctx, 'NOT_ALLOWED', `Operation ${operation} is outside the user permission plane`, operation, intent.scope, opMeta.dangerous);
-    }
     const matchResult = matchCommandPermission(operation, opMeta.category, roleDef.commandPermissions || {}, opMeta.dangerous);
     if (!matchResult) {
         return denyDecision(ctx, 'NO_PERMISSION', `Role ${role} has no permission for ${operation}`, operation, intent.scope, opMeta.dangerous);
@@ -261,7 +159,7 @@ function authorizeCommandInternal(ctx, resolvedConfigCommand) {
     if (permission.constraints) {
         const constraintCheck = checkConstraints(ctx, permission.constraints, resolvedConfigCommand);
         if (!constraintCheck.ok) {
-            return denyDecision(ctx, 'ARGUMENT_MISMATCH', constraintCheck.reason || 'Command arguments do not satisfy permission constraints', operation, intent.scope, opMeta.dangerous, matchedRule);
+            return denyDecision(ctx, constraintCheck.code ?? 'ARGUMENT_MISMATCH', constraintCheck.reason || 'Command arguments do not satisfy permission constraints', operation, intent.scope, opMeta.dangerous, matchedRule);
         }
     }
     return {
@@ -275,10 +173,9 @@ function authorizeCommandInternal(ctx, resolvedConfigCommand) {
     };
 }
 function matchCommandPermission(operation, category, commandPerms, isDangerous) {
-    const namespace = operation.split('.')[0];
     const matches = [];
     for (const [rule, permission] of Object.entries(commandPerms)) {
-        const rank = getRuleRank(rule, permission, operation, namespace, category, isDangerous);
+        const rank = getRuleRank(rule, permission, operation, category, isDangerous);
         if (rank > 0) {
             matches.push({ permission, matchedRule: rule, rank });
         }
@@ -288,12 +185,17 @@ function matchCommandPermission(operation, category, commandPerms, isDangerous)
     matches.sort((a, b) => b.rank - a.rank);
     return matches[0];
 }
-function getRuleRank(rule, permission, operation, namespace, category, isDangerous) {
+function getRuleRank(rule, permission, operation, category, isDangerous) {
     const denyOffset = permission.allow ? 0 : 1;
     if (rule === operation)
         return 1000 + denyOffset;
-    if (rule === `${namespace}.*`)
-        return 800 + denyOffset;
+    if (rule.endsWith('.*')) {
+        const prefix = rule.slice(0, -1);
+        if (operation.startsWith(prefix)) {
+            const depth = rule.slice(0, -2).split('.').length;
+            return 800 + Math.min((depth - 1) * 20, 180) + denyOffset;
+        }
+    }
     if (rule.startsWith('category:') && rule.slice('category:'.length) === category)
         return 600 + denyOffset;
     if (rule === 'dangerous:*' && isDangerous)
@@ -305,20 +207,6 @@ function getRuleRank(rule, permission, operation, namespace, category, isDangero
 function isExplicitDangerousGrant(rule, permission) {
     return permission.allow === true && permission.dangerous === true && (rule === 'dangerous:*' || !rule.includes('*') && !rule.startsWith('category:'));
 }
-function isUserPlaneOperationAllowed(operation, category, dangerous) {
-    const namespace = operation.split('.')[0];
-    if (dangerous)
-        return false;
-    if (USER_PLANE_CAPABILITY_CEILING.denyCategories.has(category))
-        return false;
-    if (!USER_PLANE_CAPABILITY_CEILING.allowCategories.has(category))
-        return false;
-    if (USER_PLANE_CAPABILITY_CEILING.denyOperations.has(operation))
-        return false;
-    if (USER_PLANE_CAPABILITY_CEILING.denyNamespaces.has(namespace))
-        return false;
-    return USER_PLANE_CAPABILITY_CEILING.allowOperations.has(operation);
-}
 function checkConstraints(ctx, constraints, resolvedConfigCommand) {
     if (constraints.ownPeerOnly) {
         const peerCheck = checkOwnPeer(ctx);
@@ -326,16 +214,17 @@ function checkConstraints(ctx, constraints, resolvedConfigCommand) {
             return peerCheck;
     }
     if (constraints.ownAgentOnly || constraints.targetCurrentAgentOnly) {
-        const argSelf = stringArg(ctx.intent.args.self);
-        if (argSelf && argSelf !== ctx.selfAid) {
+        const controlOwnerOverride = ctx.fromControlChannel && ctx.isDaemonOwner;
+        const targetAid = stringArg(ctx.intent.args.self) ?? stringArg(ctx.intent.args.aid);
+        if (!controlOwnerOverride && (!ctx.selfAid || !targetAid || targetAid !== ctx.selfAid)) {
             return { ok: false, reason: 'Only the current agent can be targeted' };
         }
     }
     if (constraints.requireAgentOwner && ctx.role !== 'owner') {
-        return { ok: false, reason: 'This command requires agent owner permission' };
+        return { ok: false, code: 'NO_PERMISSION', reason: 'This command requires agent owner permission' };
     }
     if (constraints.requireAgentAdmin && ctx.role !== 'owner' && ctx.role !== 'admin') {
-        return { ok: false, reason: 'This command requires agent admin permission' };
+        return { ok: false, code: 'NO_PERMISSION', reason: 'This command requires agent admin permission' };
     }
     if (constraints.privateOnly && ctx.chatType !== 'private') {
         return { ok: false, reason: 'This command is only allowed in private chats' };
@@ -345,7 +234,7 @@ function checkConstraints(ctx, constraints, resolvedConfigCommand) {
         const sameGroup = constraints.currentRelationOnly ? ' and may only target that same group' : '';
         return {
             ok: false,
-            reason: `Denied ${ctx.intent.operation}: role=${ctx.role}, source_chat=${ctx.chatType ?? 'unknown'}, target_group=${target}. This role may send group messages only from a group-chat task${sameGroup}; the target being a group is not sufficient.`,
+            reason: `Denied ${ctx.intent.operation}: role=${ctx.role}, source_chat=${ctx.chatType ?? 'unknown'}, target_group=${target}. This role may access group operations only from a group-chat task${sameGroup}; the target being a group is not sufficient.`,
         };
     }
     if (constraints.requireDaemonOwner && !ctx.isDaemonOwner) {
@@ -516,7 +405,7 @@ function checkCurrentRelation(ctx, resolvedConfigCommand) {
                 const targetGroup = stringArg(ctx.intent.args.targetId) ?? peerIdFromArg(requestedPeer);
                 return {
                     ok: false,
-                    reason: `Denied ${ctx.intent.operation}: role=${ctx.role}, current_group=${currentGroup}, target_group=${targetGroup}. This role may send only to the current group; cross-group sends require admin or owner permission.`,
+                    reason: `Denied ${ctx.intent.operation}: role=${ctx.role}, current_group=${currentGroup}, target_group=${targetGroup}. This role may access only the current group; cross-group access requires admin or owner permission.`,
                 };
             }
             return { ok: false, reason: 'Only the current relation can be targeted' };
@@ -613,6 +502,25 @@ function checkOwnPeer(ctx) {
         return { ok: true };
     const requestedPeerId = argPeer ? peerIdFromArg(argPeer) : undefined;
     const requestedPeerKeyId = argPeerKey ? peerIdFromArg(argPeerKey) : undefined;
+    if (ctx.chatType === 'group') {
+        if (!expectedPeerKey)
+            return { ok: false, reason: 'Cannot verify peer ownership' };
+        const candidateKeys = new Set();
+        if (argPeerKey)
+            candidateKeys.add(argPeerKey);
+        if (argPeer) {
+            candidateKeys.add(argPeer);
+            const channelType = parseChannelType(expectedPeerKey);
+            if (channelType)
+                candidateKeys.add(formatPeerKey(channelType, argPeer));
+            const legacyChannelType = parseLegacyChannelType(expectedPeerKey);
+            if (legacyChannelType)
+                candidateKeys.add(`${legacyChannelType}::${argPeer}`);
+        }
+        return candidateKeys.has(expectedPeerKey)
+            ? { ok: true }
+            : { ok: false, reason: 'Only the current group relation can be targeted' };
+    }
     if (ctx.actorId) {
         if (requestedPeerId && requestedPeerId !== ctx.actorId) {
             return { ok: false, reason: 'Only the actor peer can be targeted' };