evolcore 0.0.1 → 0.0.3

package/dist/core/auth/auth-gateway.js

@@ -0,0 +1,166 @@
+import { checkRoleAccess, resolvePeerRoleDetail, roleToSessionIdentity } from '../../config/peer-role-resolver.js';
+import { isValidAid } from '../../aun/aid/validation.js';
+import { formatPeerKey } from '../relation/peer-identity.js';
+import { authorizeCommand, authorizeResolvedConfigCommand } from './operation-authorizer.js';
+import { auditCommandAuthorization } from './authorization-audit.js';
+import { hasTrustedPrincipal } from './authenticated-actor.js';
+export function buildAuthSubject(input) {
+    const chatType = input.chatType === 'group' ? 'group' : 'private';
+    const actorId = input.actorId;
+    const conversationId = input.conversationId || (chatType === 'group' ? input.channelId : actorId || input.channelId);
+    const roleDetail = input.roleDetail ?? resolveRoleDetail({
+        selfAid: input.selfAid,
+        channelKey: input.channel,
+        channelType: input.channelType,
+        chatType,
+        actorId,
+        conversationId,
+        peerType: input.peerType,
+    });
+    const processOwners = input.processOwners ?? [];
+    const isDaemonOwner = isProcessOwner({
+        actor: roleDetail.actor,
+        processOwners,
+    });
+    const suppliedRole = input.identity?.role && input.identity.role !== 'none' ? input.identity.role : undefined;
+    const role = suppliedRole ?? (isDaemonOwner ? 'owner' : roleDetail.effectiveRole ?? 'none');
+    return {
+        selfAid: input.selfAid,
+        actorId,
+        channel: input.channel,
+        channelType: input.channelType,
+        channelId: input.channelId,
+        chatType,
+        conversationId,
+        peerKey: input.channelType && conversationId ? formatPeerKey(input.channelType, conversationId) : undefined,
+        role,
+        roleSource: isDaemonOwner && !roleDetail.effectiveRole ? 'fallback' : roleDetail.source,
+        identity: input.identity ?? roleToSessionIdentity(role === 'none' ? null : role),
+        isDaemonOwner,
+        fromControlChannel: !!input.fromControlChannel,
+        allowAccess: isDaemonOwner || (suppliedRole
+            ? checkRoleAccess(suppliedRole, input.selfAid)
+            : roleDetail.allowAccess && checkRoleAccess(role, input.selfAid)),
+    };
+}
+function isProcessOwner(input) {
+    if (!hasTrustedPrincipal(input.actor))
+        return false;
+    const owners = new Set((input.processOwners ?? []).map(value => String(value || '').trim()).filter(Boolean));
+    return owners.has(input.actor.principalId);
+}
+export function authorizeAccess(subject) {
+    if (subject.allowAccess)
+        return { allow: true, subject };
+    return {
+        allow: false,
+        code: 'ROLE_ACCESS_DENIED',
+        reason: `Role ${subject.role} is not allowed to access this agent`,
+        subject,
+    };
+}
+export function authorizeOperation(params) {
+    const access = authorizeAccess(params.subject);
+    if (!access.allow) {
+        if (params.audit !== false) {
+            auditDecision(params, {
+                allow: false,
+                code: 'ROLE_ACCESS_DENIED',
+                reason: access.reason,
+                operation: params.intent.operation,
+                scope: params.intent.scope,
+                role: params.subject.role,
+                dangerous: params.intent.dangerous,
+            });
+        }
+        return access;
+    }
+    const ctx = {
+        intent: params.intent,
+        actorId: params.subject.actorId,
+        channel: params.subject.channel,
+        channelId: params.subject.channelId,
+        chatType: params.subject.chatType,
+        selfAid: params.subject.selfAid,
+        peerKey: params.subject.peerKey,
+        role: params.subject.role,
+        isDaemonOwner: params.subject.isDaemonOwner,
+        fromControlChannel: params.subject.fromControlChannel,
+        allowExplicitRelationTarget: params.allowExplicitRelationTarget,
+        source: params.source,
+    };
+    const decision = params.resolvedConfigCommand
+        ? authorizeResolvedConfigCommand(params.resolvedConfigCommand, operationContext(ctx))
+        : authorizeCommand(ctx);
+    if (params.audit !== false && (!decision.allow || params.auditAllowed !== false)) {
+        auditDecision(params, decision);
+    }
+    if (!decision.allow) {
+        return {
+            allow: false,
+            code: decision.code,
+            reason: decision.reason,
+            subject: params.subject,
+            command: decision,
+        };
+    }
+    return { allow: true, subject: params.subject, command: decision };
+}
+function operationContext(context) {
+    const { intent: _intent, ...rest } = context;
+    return rest;
+}
+function resolveRoleDetail(input) {
+    if (!input.selfAid || !input.actorId || !input.conversationId) {
+        const operatorId = String(input.actorId || '').trim();
+        const operatorChannelType = String(input.channelType || '').trim().toLowerCase();
+        const nativeAid = operatorChannelType === 'aun' && isValidAid(operatorId);
+        return {
+            effectiveRole: null,
+            source: 'none',
+            isAuthenticated: false,
+            allowAccess: false,
+            roleExists: false,
+            actor: {
+                operatorId,
+                operatorChannelKey: input.channelKey,
+                operatorChannelType,
+                ...(nativeAid
+                    ? { principalId: operatorId, principalStatus: 'native_aid' }
+                    : { principalStatus: 'error' }),
+            },
+        };
+    }
+    return resolvePeerRoleDetail({
+        selfAid: input.selfAid,
+        channelKey: input.channelKey,
+        channelType: input.channelType,
+        chatType: input.chatType,
+        actorId: input.actorId,
+        conversationId: input.conversationId,
+        peerType: input.peerType,
+    });
+}
+function auditDecision(params, decision) {
+    auditCommandAuthorization({
+        ts: Date.now(),
+        source: params.source,
+        operation: params.intent.operation,
+        scope: params.intent.scope,
+        dangerous: decision.dangerous ?? params.intent.dangerous ?? false,
+        actorId: params.subject.actorId,
+        selfAid: params.subject.selfAid,
+        peerKey: params.subject.peerKey,
+        channel: params.subject.channel,
+        channelId: params.subject.channelId,
+        role: params.subject.role,
+        isDaemonOwner: params.subject.isDaemonOwner,
+        fromControlChannel: params.subject.fromControlChannel,
+        decision: decision.allow ? 'allow' : 'deny',
+        code: decision.allow ? undefined : decision.code,
+        reason: decision.allow ? undefined : decision.reason,
+        matchedRule: decision.matchedRule,
+        argsSummary: params.intent.args,
+        ...params.auditMetadata,
+    });
+}

package/dist/core/auth/authenticated-actor.js

@@ -0,0 +1,6 @@
+export function isTrustedPrincipalStatus(status) {
+    return status === 'native_aid' || status === 'mapped';
+}
+export function hasTrustedPrincipal(actor) {
+    return !!actor?.principalId && isTrustedPrincipalStatus(actor.principalStatus);
+}

package/dist/core/auth/authorization-audit.js

@@ -0,0 +1,119 @@
+import { logger } from '../../utils/logger.js';
+import { LogWriter } from '../../utils/log-writer.js';
+import { resolvePaths } from '../../paths.js';
+import crypto from 'node:crypto';
+export function auditCommandAuthorization(event) {
+    const shouldAudit = event.source === 'menu.cli' ||
+        event.decision === 'deny' ||
+        (event.decision === 'allow' && event.dangerous) ||
+        (event.source === 'agent-tool' && event.operation.startsWith('config.')) ||
+        event.operation.startsWith('role.') ||
+        event.operation === 'cli.exec.raw';
+    if (!shouldAudit)
+        return;
+    const auditRecord = buildAuditRecord(event);
+    logAuditEvent(auditRecord);
+}
+function buildAuditRecord(event) {
+    return {
+        ts: event.ts,
+        source: event.source,
+        operation: event.operation,
+        scope: event.scope,
+        dangerous: event.dangerous,
+        actorId: redactIdentifier(event.actorId),
+        selfAid: redactIdentifier(event.selfAid),
+        peerKey: redactIdentifier(event.peerKey),
+        channel: event.channel,
+        channelId: redactIdentifier(event.channelId),
+        role: event.role,
+        isDaemonOwner: event.isDaemonOwner,
+        fromControlChannel: event.fromControlChannel,
+        taskId: event.taskId,
+        messageId: event.messageId,
+        decision: event.decision,
+        code: event.code,
+        reason: event.reason,
+        matchedRule: event.matchedRule,
+        argvHash: event.argvHash,
+        argsSummary: event.argsSummary,
+        durationMs: event.durationMs,
+        exitCode: event.exitCode,
+    };
+}
+function redactIdentifier(value) {
+    if (!value)
+        return undefined;
+    return crypto.createHash('sha256').update(value).digest('hex').slice(0, 12);
+}
+function logAuditEvent(record) {
+    // A role-management snapshot fans out into several successful read checks.
+    // Keep those available for verbose ECWeb diagnostics without flooding INFO.
+    const routineEcwebRoleRead = record.source === 'ecweb'
+        && !record.dangerous
+        && (record.operation === 'role.policy.read' || record.operation === 'role.relation.read');
+    const level = record.decision === 'deny'
+        ? 'warn'
+        : routineEcwebRoleRead
+            ? 'debug'
+            : 'info';
+    const marker = record.decision === 'deny' ? 'DENY' : record.dangerous ? 'DANGEROUS_ALLOW' : 'ALLOW';
+    const message = [
+        `[CommandAudit:${marker}]`,
+        `operation=${record.operation}`,
+        `role=${record.role}`,
+        `actor=${record.actorId || 'unknown'}`,
+        record.taskId ? `task=${record.taskId}` : null,
+        record.messageId ? `message=${record.messageId}` : null,
+        record.code ? `code=${record.code}` : null,
+        record.matchedRule ? `rule=${record.matchedRule}` : null,
+        record.dangerous ? 'dangerous=true' : null,
+    ]
+        .filter(Boolean)
+        .join(' ');
+    logger[level](message);
+    if (record.reason)
+        logger[level](`  reason: ${record.reason}`);
+    if (record.argvHash)
+        logger[level](`  argvHash: ${record.argvHash}`);
+}
+export function hashArgv(argv) {
+    const joined = argv.join(' ');
+    return crypto.createHash('sha256').update(joined).digest('hex').slice(0, 16);
+}
+export function auditRoleMutation(record) {
+    const payload = {
+        type: 'role-mutation',
+        ts: record.ts ?? Date.now(),
+        operation: record.operation,
+        actor: record.actor ?? 'unknown',
+        selfAid: record.selfAid,
+        roleId: record.roleId,
+        relation: record.relation,
+        oldValue: record.oldValue,
+        newValue: record.newValue,
+        files: record.files,
+    };
+    writeRoleMutationAudit(payload);
+    logger.info(`[RoleMutationAudit] ${JSON.stringify(payload)}`);
+}
+let roleMutationWriter;
+function writeRoleMutationAudit(payload) {
+    try {
+        const logDir = resolvePaths().logs;
+        if (roleMutationWriter?.logDir !== logDir) {
+            roleMutationWriter?.writer.close();
+            roleMutationWriter = {
+                logDir,
+                writer: new LogWriter({
+                    baseName: 'role-mutations',
+                    logDir,
+                    rotation: 'daily',
+                    retention: { days: 30 },
+                }),
+            };
+        }
+        roleMutationWriter.writer.write(JSON.stringify(payload));
+    }
+    catch { }
+}