evolcore 0.0.3 → 0.0.4

package/dist/core/message/inbound-admission.js

@@ -0,0 +1,124 @@
+import { AccessPolicyError, readAccessPolicy, } from '../../config/access-policy.js';
+import { isAcceptedContact, resolveContactView, resolvePrincipal, } from '../../config/contact-book.js';
+export function evaluateInboundAdmissionPreflight(input) {
+    const selfAid = String(input.selfAid || '').trim();
+    const channelType = String(input.channelType || '').trim().toLowerCase();
+    const actorId = String(input.actorId || '').trim();
+    const context = {
+        selfAid,
+        channelKey: input.channelKey,
+        channelType,
+        chatType: input.chatType,
+        actorId,
+        trustedHandoffEcho: input.trustedHandoffEcho === true,
+        isOwner: false,
+    };
+    if (context.trustedHandoffEcho)
+        return { allow: true, context };
+    if (!selfAid)
+        return { allow: false, reason: 'invalid_identity', context };
+    if (input.chatType === 'private') {
+        const principal = resolvePrincipal(selfAid, channelType, actorId, input.channelKey);
+        context.principal = principal;
+        context.primaryId = principal.principalId;
+        if (principal.principalStatus === 'conflict') {
+            return { allow: false, reason: 'identity_conflict', context };
+        }
+        if (principal.principalStatus === 'error') {
+            return { allow: false, reason: 'identity_resolution_error', context };
+        }
+        if (channelType === 'aun' && principal.principalStatus !== 'native_aid') {
+            return { allow: false, reason: 'invalid_identity', context };
+        }
+        if (principal.principalId) {
+            try {
+                const contact = resolveContactView(selfAid, principal.principalId);
+                context.contactStatus = contact.status;
+                context.contactSource = contact.source;
+                context.isOwner = contact.isOwner;
+                if (contact.blocked)
+                    return { allow: false, reason: 'blocked', context };
+            }
+            catch {
+                return { allow: false, reason: 'identity_resolution_error', context };
+            }
+        }
+    }
+    try {
+        context.policy = readAccessPolicy(selfAid);
+    }
+    catch (error) {
+        if (error instanceof AccessPolicyError && error.code === 'restricted_mode_without_owner') {
+            return { allow: false, reason: 'restricted_mode_without_owner', context };
+        }
+        return { allow: false, reason: 'invalid_access_policy', context };
+    }
+    return { allow: true, context };
+}
+export function evaluateOrdinaryInboundAdmission(context) {
+    if (context.trustedHandoffEcho)
+        return { allow: true, reason: 'trusted_handoff', context };
+    const policy = context.policy;
+    if (!policy)
+        return { allow: false, reason: 'invalid_access_policy', context };
+    if (context.chatType === 'group') {
+        if (policy.policyMode === 'owners-only') {
+            return { allow: false, reason: 'owners_only', context };
+        }
+        // `open` is genuinely open: group traffic is not gated by the optional
+        // channel allow-list. In `contacts`, AUN groups are currently open once
+        // the agent is receiving that group; non-AUN channels remain explicit.
+        if (policy.policyMode === 'open'
+            || (policy.policyMode === 'contacts' && context.channelType === 'aun')) {
+            return { allow: true, reason: 'group_channel_allowed', context };
+        }
+        return policy.allowedGroupChannels.includes(context.channelKey)
+            ? { allow: true, reason: 'group_channel_allowed', context }
+            : { allow: false, reason: 'group_channel_denied', context };
+    }
+    if (context.isOwner)
+        return { allow: true, reason: 'owner', context };
+    if (policy.policyMode === 'open')
+        return { allow: true, reason: 'open', context };
+    if (policy.policyMode === 'owners-only')
+        return { allow: false, reason: 'owners_only', context };
+    if (context.primaryId && isAcceptedContact(context.selfAid, context.primaryId)) {
+        return { allow: true, reason: 'contact', context };
+    }
+    return { allow: false, reason: 'contact_required', context };
+}
+const principalReplyBuckets = new Map();
+const channelReplyBuckets = new Map();
+const PRINCIPAL_REPLY_MAX = 3;
+const PRINCIPAL_REPLY_WINDOW_MS = 60 * 60 * 1000;
+/** Atomically consume both admission-control reply budgets. */
+export function consumeAdmissionReplyBudget(context, now = Date.now()) {
+    const principalKey = `${context.selfAid}\0${context.primaryId || context.actorId || '<unknown>'}`;
+    const channelKey = `${context.selfAid}\0${context.channelKey}`;
+    const policy = context.policy;
+    const maxTimes = policy?.requestLimit.maxTimes ?? 600;
+    const coolDownMs = (policy?.requestLimit.coolDown ?? 60 * 60) * 1000;
+    if (!canConsume(principalReplyBuckets.get(principalKey), PRINCIPAL_REPLY_MAX, PRINCIPAL_REPLY_WINDOW_MS, now)) {
+        return false;
+    }
+    if (!canConsume(channelReplyBuckets.get(channelKey), maxTimes, coolDownMs, now))
+        return false;
+    consume(principalReplyBuckets, principalKey, PRINCIPAL_REPLY_WINDOW_MS, now);
+    consume(channelReplyBuckets, channelKey, coolDownMs, now);
+    return true;
+}
+export function clearAdmissionReplyBudgets() {
+    principalReplyBuckets.clear();
+    channelReplyBuckets.clear();
+}
+function canConsume(bucket, limit, windowMs, now) {
+    return !bucket || now - bucket.windowStart >= windowMs || bucket.count < limit;
+}
+function consume(buckets, key, windowMs, now) {
+    const bucket = buckets.get(key);
+    if (!bucket || now - bucket.windowStart >= windowMs) {
+        buckets.set(key, { count: 1, windowStart: now });
+        return;
+    }
+    bucket.count += 1;
+}