ec-web 0.0.19 → 0.0.21

package/dist/sources/relation-roles.js

@@ -3,25 +3,6 @@ import path from 'path';
 import { resolvePaths } from '../paths.js';
 import { getSessionsAunDir, listPeers, readJsonFile, readMessages, } from '../fs-utils.js';
 import { resolveParentDistModule, toFileUrl } from './parent-package.js';
-import { ipcQuery } from '../ipc-client.js';
-async function execRoleMenu(aid, payload, auth) {
-    const response = await ipcQuery(resolvePaths().socket, {
-        type: 'menu.exec',
-        payload: { ...payload, name: 'role', agent: aid, args: { self: aid, ...(payload.args ?? {}) } },
-        auth: { source: 'ecweb', actorAid: auth.actorAid ?? null, localDirect: !!auth.localDirect },
-    }, 10_000);
-    if (!response?.ok || !response.response)
-        throw new Error(response?.error || 'Role Menu is unavailable');
-    return response.response;
-}
-function sendRoleMenuError(res, response) {
-    const error = response?.error ?? { code: 'INTERNAL_ERROR', message: 'Role Menu request failed' };
-    const status = error.code === 'NOT_FOUND' ? 404
-        : error.code === 'CONFLICT' ? 409
-            : error.code === 'PERMISSION_DENIED' || error.code === 'NOT_ALLOWED' ? 403
-                : error.code === 'TEMPORARILY_UNAVAILABLE' ? 503 : 400;
-    sendJson(res, status, { error: error.message, code: error.code, data: error.data });
-}
 async function getParentModules() {
     const configPath = resolveParentDistModule('config', 'config-manager.js');
     const rolesPath = resolveParentDistModule('config', 'roles.js');
@@ -32,8 +13,8 @@ async function getParentModules() {
     return { config, roles, resolver };
 }
 async function getCommandModules() {
-    const permissionPath = resolveParentDistModule('core', 'command', 'command-permission.js');
-    const auditPath = resolveParentDistModule('core', 'command', 'command-audit.js');
+    const permissionPath = resolveParentDistModule('core', 'auth', 'operation-authorizer.js');
+    const auditPath = resolveParentDistModule('core', 'auth', 'authorization-audit.js');
     const permission = await import(toFileUrl(permissionPath));
     const audit = await import(toFileUrl(auditPath));
     return { permission, audit };
@@ -77,9 +58,15 @@ async function getAgentsFromIpc() {
         return [];
     }
 }
-async function authorizeRoleAssignmentWrite(modules, aid, auth, operation, targetRole, args) {
-    const { permission, audit } = await getCommandModules();
-    const actorRole = auth.localDirect
+function resolveEcwebActor(modules, aid, auth) {
+    const processConfig = modules.config?.read && modules.config?.ConfigTarget
+        ? modules.config.read(modules.config.ConfigTarget.Process)
+        : undefined;
+    const processOwners = Array.isArray(processConfig?.owners)
+        ? processConfig.owners.map((value) => String(value || '').trim()).filter(Boolean)
+        : [];
+    const daemonOwner = !!auth.localDirect || (!!auth.actorAid && processOwners.includes(auth.actorAid));
+    const actorRole = daemonOwner
         ? 'owner'
         : auth.actorAid
             ? (modules.resolver.resolvePeerRoleDetail({
@@ -90,6 +77,61 @@ async function authorizeRoleAssignmentWrite(modules, aid, auth, operation, targe
                 conversationId: auth.actorAid,
             }).effectiveRole || 'none')
             : 'none';
+    return {
+        daemonOwner,
+        actorRole,
+        actorId: auth.localDirect ? 'local-direct' : auth.actorAid || undefined,
+    };
+}
+async function authorizeRoleAssignmentRead(modules, aid, auth) {
+    const { permission, audit } = await getCommandModules();
+    const actor = resolveEcwebActor(modules, aid, auth);
+    const decision = permission.authorizeCommand({
+        intent: {
+            operation: 'role.relation.read',
+            scope: 'agent',
+            source: 'ecweb',
+            args: { self: aid },
+        },
+        actorId: actor.actorId,
+        selfAid: aid,
+        role: actor.actorRole,
+        processRole: actor.daemonOwner ? 'daemon-owner' : 'none',
+        isDaemonOwner: actor.daemonOwner,
+        source: 'ecweb',
+    });
+    await audit.auditCommandAuthorization({
+        ts: Date.now(),
+        source: 'ecweb',
+        operation: 'role.relation.read',
+        scope: 'agent',
+        dangerous: false,
+        actorId: actor.actorId,
+        selfAid: aid,
+        role: actor.actorRole,
+        processRole: actor.daemonOwner ? 'daemon-owner' : 'none',
+        isDaemonOwner: actor.daemonOwner,
+        decision: decision.allow ? 'allow' : 'deny',
+        code: decision.allow ? undefined : decision.code,
+        reason: decision.allow ? undefined : decision.reason,
+        matchedRule: decision.matchedRule,
+        argsSummary: { self: aid },
+    });
+    if (decision.allow)
+        return { allow: true, actorRole: actor.actorRole };
+    return {
+        allow: false,
+        status: 403,
+        error: 'forbidden: role assignment read not allowed',
+        code: decision.code,
+        reason: decision.reason,
+        actorRole: actor.actorRole,
+    };
+}
+async function authorizeRoleAssignmentWrite(modules, aid, auth, operation, targetRole, args) {
+    const { permission, audit } = await getCommandModules();
+    const actor = resolveEcwebActor(modules, aid, auth);
+    const { daemonOwner, actorRole } = actor;
     const targetPeerId = typeof args.peerId === 'string' ? args.peerId : undefined;
     if (targetPeerId && modules.resolver.isStaticAgentOwner?.(aid, targetPeerId)) {
         const reason = `Static owner ${targetPeerId} is defined in agents/${aid}/config.json and cannot be changed by relation role assignments`;
@@ -99,9 +141,11 @@ async function authorizeRoleAssignmentWrite(modules, aid, auth, operation, targe
             operation,
             scope: 'agent',
             dangerous: false,
-            actorId: auth.localDirect ? 'local-direct' : auth.actorAid || undefined,
+            actorId: actor.actorId,
             selfAid: aid,
             role: actorRole,
+            processRole: daemonOwner ? 'daemon-owner' : 'none',
+            isDaemonOwner: daemonOwner,
             decision: 'deny',
             code: 'IMMUTABLE_STATIC_OWNER',
             reason,
@@ -126,9 +170,11 @@ async function authorizeRoleAssignmentWrite(modules, aid, auth, operation, targe
                 targetRole,
             },
         },
-        actorId: auth.localDirect ? 'local-direct' : auth.actorAid || undefined,
+        actorId: actor.actorId,
         selfAid: aid,
         role: actorRole,
+        processRole: daemonOwner ? 'daemon-owner' : 'none',
+        isDaemonOwner: daemonOwner,
         source: 'ecweb',
     });
     if (!decision.allow) {
@@ -138,9 +184,11 @@ async function authorizeRoleAssignmentWrite(modules, aid, auth, operation, targe
             operation,
             scope: 'agent',
             dangerous: false,
-            actorId: auth.localDirect ? 'local-direct' : auth.actorAid || undefined,
+            actorId: actor.actorId,
             selfAid: aid,
             role: actorRole,
+            processRole: daemonOwner ? 'daemon-owner' : 'none',
+            isDaemonOwner: daemonOwner,
             decision: 'deny',
             code: decision.code,
             reason: decision.reason,
@@ -156,9 +204,9 @@ async function authorizeRoleAssignmentWrite(modules, aid, auth, operation, targe
             actorRole,
         };
     }
-    const policyAllowed = operation === 'role.assign'
+    const policyAllowed = daemonOwner || (operation === 'role.assign'
         ? !!targetRole && canAssignRole(actorRole, targetRole)
-        : canRevokeRole(actorRole, targetRole);
+        : canRevokeRole(actorRole, targetRole));
     if (!policyAllowed) {
         const reason = operation === 'role.assign'
             ? `Role ${actorRole} cannot assign target role ${targetRole || '(missing)'}`
@@ -169,9 +217,11 @@ async function authorizeRoleAssignmentWrite(modules, aid, auth, operation, targe
             operation,
             scope: 'agent',
             dangerous: false,
-            actorId: auth.localDirect ? 'local-direct' : auth.actorAid || undefined,
+            actorId: actor.actorId,
             selfAid: aid,
             role: actorRole,
+            processRole: daemonOwner ? 'daemon-owner' : 'none',
+            isDaemonOwner: daemonOwner,
             decision: 'deny',
             code: 'NOT_ALLOWED',
             reason,
@@ -193,9 +243,11 @@ async function authorizeRoleAssignmentWrite(modules, aid, auth, operation, targe
         operation,
         scope: 'agent',
         dangerous: false,
-        actorId: auth.localDirect ? 'local-direct' : auth.actorAid || undefined,
+        actorId: actor.actorId,
         selfAid: aid,
         role: actorRole,
+        processRole: daemonOwner ? 'daemon-owner' : 'none',
+        isDaemonOwner: daemonOwner,
         decision: 'allow',
         matchedRule: decision.matchedRule,
         argsSummary: { ...args, targetRole },
@@ -492,8 +544,8 @@ function explicitAssignment(scope, peerKey, role, ids) {
 function resolveGroupRoleDetail(modules, aid, groupId) {
     const target = relationTargetFromId(groupId);
     const relation = readRelationConfig(modules.config, aid, target.peerKey);
-    const assigned = typeof relation.roles?.assigned === 'string' && roleExists(modules.roles, aid, relation.roles.assigned)
-        ? relation.roles.assigned
+    const assigned = typeof relation.role === 'string' && roleExists(modules.roles, aid, relation.role)
+        ? relation.role
         : null;
     if (assigned) {
         return {
@@ -519,7 +571,7 @@ function assignmentForDetail(detail, modules, seed, member) {
     if (member && detail.source === 'group-member') {
         return explicitAssignment('group-member', groupTarget.peerKey, role, { groupId: groupTarget.channelId, peerId: member.peerId });
     }
-    if (member && detail.source === 'private-inherited') {
+    if (member && (detail.source === 'private-inherited' || detail.source === 'relation-actor')) {
         const privateTarget = relationTargetFromId(member.peerId);
         return explicitAssignment('private', privateTarget.peerKey, role, { peerId: member.peerId });
     }
@@ -584,34 +636,14 @@ function listRelationRoleAssignments(config, aid) {
             continue;
         const peerKey = entry.name;
         const relation = readRelationConfig(config, aid, peerKey);
-        const roles = relation.roles;
-        if (!roles || typeof roles !== 'object')
-            continue;
         const parsed = parsePeerKey(peerKey);
-        const hasMembers = roles.members && typeof roles.members === 'object' && Object.keys(roles.members).length > 0;
-        if (typeof roles.assigned === 'string') {
-            out.push({
-                scope: hasMembers ? 'group' : 'private',
-                peerKey,
-                role: roles.assigned,
-                ...(hasMembers ? { groupId: parsed.channelId } : { peerId: parsed.channelId }),
-                source: 'relation-config',
-            });
-        }
-        if (roles.members && typeof roles.members === 'object') {
-            for (const [peerId, role] of Object.entries(roles.members)) {
-                if (typeof role !== 'string')
-                    continue;
-                out.push({
-                    scope: 'group-member',
-                    peerKey,
-                    groupId: parsed.channelId,
-                    peerId,
-                    role,
-                    source: 'relation-config',
-                });
-            }
-        }
+        if (typeof relation.role !== 'string')
+            continue;
+        const isGroup = relation.targetKind === 'group'
+            || /^group\.agentid\.pub\//i.test(parsed.channelId);
+        out.push(isGroup
+            ? { scope: 'group', groupId: parsed.channelId, peerKey, role: relation.role, source: 'relation-config' }
+            : { scope: 'private', peerId: parsed.channelId, peerKey, role: relation.role, source: 'relation-config' });
     }
     return out;
 }
@@ -624,26 +656,17 @@ async function buildSnapshot(auth = {}) {
         const aid = agent.aid;
         if (!aid)
             continue;
-        const [roleOptions, defaults, assignmentResult] = await Promise.all([
-            execRoleMenu(aid, {
-                type: 'menu.options', id: `ecweb-relation-role-options-${Date.now()}`,
-                args: { option: 'roles' },
-            }, auth),
-            execRoleMenu(aid, {
-                type: 'menu.query', id: `ecweb-relation-role-defaults-${Date.now()}`,
-                args: { view: 'defaults' },
-            }, auth),
-            listAssignmentsThroughMenu(aid, auth),
-        ]);
-        if (roleOptions.error || defaults.error || assignmentResult.error)
+        const readDecision = await authorizeRoleAssignmentRead(modules, aid, auth);
+        if (!readDecision.allow)
             continue;
+        const roleConfig = modules.roles.readRolesConfig(aid);
         snapshotAgents.push({
             aid,
             displayName: agent.displayName ?? agent.personalName,
             name: agent.name,
-            roles: roleOptions.data.filter((item) => item.assignable).map((item) => item.value),
-            defaultRoles: defaults.data.defaultRoles,
-            assignments: assignmentResult.data.assignments,
+            roles: Object.keys(roleConfig.roles || {}).filter(role => isAssignableUserRole(role)),
+            defaultRoles: roleConfig.defaultRoles ?? { private: null, group: null },
+            assignments: listRelationRoleAssignments(modules.config, aid),
         });
         for (const seed of loadConversationSeeds(aid)) {
             conversations.push(withResolvedRoles(seed, modules));
@@ -691,80 +714,12 @@ function scopedAssignmentArgs(body, fallbackTargetId) {
     const peerId = body.peerId || fallbackTargetId;
     if (!groupRaw || !peerId)
         throw new Error('groupId and peerId are required');
-    const target = relationTargetFromId(groupRaw);
-    return { scope, groupId: target.channelId, peerId, peerKey: target.peerKey };
-}
-function toMenuTarget(target) {
-    if (target.scope === 'private')
-        return { kind: 'private', peerAid: target.peerId };
-    if (target.scope === 'group')
-        return { kind: 'group', groupId: target.groupId };
-    return { kind: 'group-member', groupId: target.groupId, memberAid: target.peerId };
-}
-function toLegacyAssignment(target, role) {
-    if (target.scope === 'private')
-        return { scope: 'private', peerId: target.peerId, peerKey: target.peerKey, role, source: 'relation-config' };
-    if (target.scope === 'group')
-        return { scope: 'group', groupId: target.groupId, peerKey: target.peerKey, role, source: 'relation-config' };
-    return { scope: 'group-member', groupId: target.groupId, peerId: target.peerId, peerKey: target.peerKey, role, source: 'relation-config' };
-}
-async function updateAssignmentThroughMenu(aid, body, fallbackTargetId, role, auth) {
-    const target = scopedAssignmentArgs(body, fallbackTargetId);
-    const menuTarget = toMenuTarget(target);
-    const snapshot = await execRoleMenu(aid, {
-        type: 'menu.query', id: `ecweb-assignment-target-${Date.now()}`,
-        args: { view: 'target', target: menuTarget },
-    }, auth);
-    if (snapshot.error)
-        return { response: snapshot, target };
-    const response = await execRoleMenu(aid, {
-        type: 'menu.update', id: `ecweb-assignment-update-${Date.now()}`,
-        args: {
-            resource: 'assignment',
-            target: menuTarget,
-            expectedPolicyRevision: snapshot.data.policyRevision,
-            expectedRelationRevision: snapshot.data.relationRevision,
-        },
-        value: JSON.stringify(role),
-    }, auth);
-    return { response, target };
-}
-async function listAssignmentsThroughMenu(aid, auth) {
-    const items = [];
-    let cursor = null;
-    do {
-        const response = await execRoleMenu(aid, {
-            type: 'menu.query', id: `ecweb-assignment-list-${Date.now()}-${items.length}`,
-            args: { view: 'assignments', limit: 200, cursor },
-        }, auth);
-        if (response.error)
-            return response;
-        items.push(...response.data.items);
-        cursor = response.data.nextCursor;
-    } while (cursor);
-    const assignments = items
-        .filter((item) => item.target?.kind !== 'default' && item.target?.kind !== 'unknown')
-        .map((item) => {
-        const target = item.target;
-        if (target.kind === 'private')
-            return { scope: 'private', peerId: target.peerAid, peerKey: target.peerKey, role: item.roleId, source: 'relation-config' };
-        if (target.kind === 'group')
-            return { scope: 'group', groupId: target.groupId, peerKey: target.peerKey, role: item.roleId, source: 'relation-config' };
-        return { scope: 'group-member', groupId: target.groupId, peerId: target.memberAid, peerKey: target.peerKey, role: item.roleId, source: 'relation-config' };
-    });
-    return { data: { $schema_version: 1, assignments } };
-}
-function pruneEmptyRoles(config) {
-    const roles = config.roles;
-    if (!roles || typeof roles !== 'object')
-        return config;
-    if (roles.members && typeof roles.members === 'object' && Object.keys(roles.members).length === 0) {
-        delete roles.members;
-    }
-    if (!Object.prototype.hasOwnProperty.call(roles, 'assigned') && !roles.members) {
-        delete config.roles;
-    }
-    return config;
+    const groupTarget = relationTargetFromId(groupRaw);
+    // The canonical relation schema has one role per relation. A member override
+    // is therefore stored on that member's private relation; groupId is retained
+    // only for the ECWeb presentation layer.
+    const memberTarget = relationTargetFromId(peerId);
+    return { scope, groupId: groupTarget.channelId, peerId, peerKey: memberTarget.peerKey };
 }
 function setScopedAssignment(configMod, aid, body, fallbackTargetId) {
     const target = scopedAssignmentArgs(body, fallbackTargetId);
@@ -772,15 +727,12 @@ function setScopedAssignment(configMod, aid, body, fallbackTargetId) {
     if (!role)
         throw new Error('role is required');
     const config = readRelationConfig(configMod, aid, target.peerKey);
-    const roles = config.roles && typeof config.roles === 'object' ? { ...config.roles } : {};
-    if (target.scope === 'group-member') {
-        roles.members = roles.members && typeof roles.members === 'object' ? { ...roles.members } : {};
-        roles.members[target.peerId] = role;
-    }
-    else {
-        roles.assigned = role;
-    }
-    writeRelationConfig(configMod, aid, target.peerKey, { ...config, roles });
+    const next = { ...config };
+    delete next.roles;
+    next.$schema_version = 8;
+    next.targetKind = target.scope === 'group' ? 'group' : 'private';
+    next.role = role;
+    writeRelationConfig(configMod, aid, target.peerKey, next);
     if (target.scope === 'private')
         return { scope: 'private', peerId: target.peerId, peerKey: target.peerKey, role, source: 'relation-config' };
     if (target.scope === 'group')
@@ -790,11 +742,10 @@ function setScopedAssignment(configMod, aid, body, fallbackTargetId) {
 function getScopedAssignment(configMod, aid, body, fallbackTargetId) {
     const target = scopedAssignmentArgs(body, fallbackTargetId);
     const config = readRelationConfig(configMod, aid, target.peerKey);
+    const role = config.role;
     if (target.scope === 'group-member') {
-        const role = config.roles?.members?.[target.peerId];
         return explicitAssignment('group-member', target.peerKey, role, { groupId: target.groupId, peerId: target.peerId });
     }
-    const role = config.roles?.assigned;
     if (target.scope === 'private')
         return explicitAssignment('private', target.peerKey, role, { peerId: target.peerId });
     return explicitAssignment('group', target.peerKey, role, { groupId: target.groupId });
@@ -802,34 +753,27 @@ function getScopedAssignment(configMod, aid, body, fallbackTargetId) {
 function deleteScopedAssignment(configMod, aid, body, fallbackTargetId) {
     const target = scopedAssignmentArgs(body, fallbackTargetId);
     const config = readRelationConfig(configMod, aid, target.peerKey);
-    if (!config.roles || typeof config.roles !== 'object')
+    const deleted = typeof config.role === 'string';
+    if (!deleted)
         return false;
-    const roles = { ...config.roles };
-    let deleted = false;
-    if (target.scope === 'group-member') {
-        const members = roles.members && typeof roles.members === 'object' ? { ...roles.members } : {};
-        deleted = Object.prototype.hasOwnProperty.call(members, target.peerId);
-        delete members[target.peerId];
-        roles.members = members;
-    }
-    else {
-        deleted = Object.prototype.hasOwnProperty.call(roles, 'assigned');
-        delete roles.assigned;
-    }
-    writeRelationConfig(configMod, aid, target.peerKey, pruneEmptyRoles({ ...config, roles }));
+    const next = { ...config };
+    delete next.role;
+    delete next.roles;
+    writeRelationConfig(configMod, aid, target.peerKey, next);
     return deleted;
 }
 export async function handleRelationRolesApi(req, res, auth = {}) {
     try {
         const urlPath = (req.url || '').split('?')[0];
+        const modules = await getParentModules();
         if (req.method === 'GET' && urlPath.startsWith('/api/roles/agent/')) {
             const aid = decodeURIComponent(urlPath.split('/').filter(Boolean).pop() || '');
             if (!aid)
                 return sendJson(res, 400, { error: 'missing aid' });
-            const result = await listAssignmentsThroughMenu(aid, auth);
-            if (result.error)
-                return sendRoleMenuError(res, result);
-            return sendJson(res, 200, result.data);
+            const decision = await authorizeRoleAssignmentRead(modules, aid, auth);
+            if (!decision.allow)
+                return sendAuthorizationDenied(res, decision);
+            return sendJson(res, 200, { $schema_version: 1, assignments: listRelationRoleAssignments(modules.config, aid) });
         }
         if ((req.method === 'POST' || req.method === 'PUT') && urlPath.startsWith('/api/roles/agent/')) {
             const aid = decodeURIComponent(urlPath.split('/').filter(Boolean).pop() || '');
@@ -839,10 +783,15 @@ export async function handleRelationRolesApi(req, res, auth = {}) {
             if (typeof body.role !== 'string' || !body.role) {
                 return sendJson(res, 400, { error: 'role is required' });
             }
-            const result = await updateAssignmentThroughMenu(aid, body, undefined, body.role, auth);
-            if (result.response.error)
-                return sendRoleMenuError(res, result.response);
-            return sendJson(res, 200, { ok: true, assignment: toLegacyAssignment(result.target, body.role) });
+            if (!roleExists(modules.roles, aid, body.role))
+                return sendJson(res, 404, { error: 'role not found' });
+            const target = scopedAssignmentArgs(body);
+            const decision = await authorizeRoleAssignmentWrite(modules, aid, auth, 'role.assign', body.role, {
+                scope: body.scope, peerId: target.peerId, groupId: target.groupId, peerKey: target.peerKey,
+            });
+            if (!decision.allow)
+                return sendAuthorizationDenied(res, decision);
+            return sendJson(res, 200, { ok: true, assignment: setScopedAssignment(modules.config, aid, body) });
         }
         return sendJson(res, 404, { error: 'not found' });
     }
@@ -856,22 +805,32 @@ export async function handlePeerRoleApi(req, res, auth = {}) {
         const target = assignmentFromPath(urlPath);
         if (!target)
             return sendJson(res, 400, { error: 'missing aid or target id' });
+        const modules = await getParentModules();
         if (req.method === 'DELETE') {
             const body = await parseBody(req);
-            const result = await updateAssignmentThroughMenu(target.aid, body, target.targetId, null, auth);
-            if (result.response.error)
-                return sendRoleMenuError(res, result.response);
-            return sendJson(res, 200, { ok: true, deleted: result.response.data.changed });
+            const scoped = scopedAssignmentArgs(body, target.targetId);
+            const current = getScopedAssignment(modules.config, target.aid, body, target.targetId);
+            const decision = await authorizeRoleAssignmentWrite(modules, target.aid, auth, 'role.revoke', current?.role, {
+                scope: body.scope, peerId: scoped.peerId, groupId: scoped.groupId, peerKey: scoped.peerKey,
+            });
+            if (!decision.allow)
+                return sendAuthorizationDenied(res, decision);
+            return sendJson(res, 200, { ok: true, deleted: deleteScopedAssignment(modules.config, target.aid, body, target.targetId) });
         }
         if (req.method === 'PUT') {
             const body = await parseBody(req);
             if (typeof body.role !== 'string' || !body.role) {
                 return sendJson(res, 400, { error: 'role is required' });
             }
-            const result = await updateAssignmentThroughMenu(target.aid, body, target.targetId, body.role, auth);
-            if (result.response.error)
-                return sendRoleMenuError(res, result.response);
-            return sendJson(res, 200, { ok: true, assignment: toLegacyAssignment(result.target, body.role) });
+            if (!roleExists(modules.roles, target.aid, body.role))
+                return sendJson(res, 404, { error: 'role not found' });
+            const scoped = scopedAssignmentArgs(body, target.targetId);
+            const decision = await authorizeRoleAssignmentWrite(modules, target.aid, auth, 'role.assign', body.role, {
+                scope: body.scope, peerId: scoped.peerId, groupId: scoped.groupId, peerKey: scoped.peerKey,
+            });
+            if (!decision.allow)
+                return sendAuthorizationDenied(res, decision);
+            return sendJson(res, 200, { ok: true, assignment: setScopedAssignment(modules.config, target.aid, body, target.targetId) });
         }
         return sendJson(res, 404, { error: 'not found' });
     }