evolcore 0.0.2 → 0.0.4

package/dist/config/contact-operation-service.js

@@ -0,0 +1,116 @@
+import fs from 'fs';
+import { isValidAid } from '../aun/aid/validation.js';
+import { isExplicitGroupId } from '../aun/group-identity.js';
+import { agentConfig } from '../paths.js';
+import { getContactSnapshot, resolveContactView } from './contact-book.js';
+import { ContactMutationError } from './contact-book-store.js';
+import { mutateContactWithOperation } from './contact-request-service.js';
+export function resolveContactCommand(argv) {
+    const args = argv[0] === 'contact' ? argv.slice(1) : [...argv];
+    const selfAid = String(argValue(args, '--self') || '').trim();
+    if (!isValidAid(selfAid))
+        return invalid('INVALID_SELF', '--self must be a valid Agent AID');
+    const positional = stripOptions(args);
+    const [command, subcommand, ...extra] = positional;
+    if (extra.length > 0)
+        return invalid('INVALID_ARGUMENT', `Unexpected contact arguments: ${extra.join(' ')}`);
+    if (command === 'list') {
+        if (subcommand !== undefined || !args.includes('--blocked')) {
+            return invalid('INVALID_ARGUMENT', 'Only ec contact list --blocked is currently supported');
+        }
+        return {
+            ok: true,
+            command: { kind: 'list-blocked', operationId: 'contact.read', selfAid, canonicalArgv: canonicalArgv(argv) },
+        };
+    }
+    if (command === 'block' || command === 'unblock') {
+        if (!isValidAid(subcommand || '') || isExplicitGroupId(subcommand || '')) {
+            return invalid('INVALID_AID', 'primaryId must be a valid individual AID');
+        }
+        return {
+            ok: true,
+            command: {
+                kind: 'set-blocked',
+                operationId: 'contact.block',
+                selfAid,
+                primaryId: subcommand,
+                blocked: command === 'block',
+                canonicalArgv: canonicalArgv(argv),
+            },
+        };
+    }
+    return invalid('UNKNOWN_COMMAND', `Unknown contact command: ${positional.join(' ')}`);
+}
+export async function executeResolvedContactCommand(command, actor = 'local-cli') {
+    if (!fs.existsSync(agentConfig(command.selfAid))) {
+        return { ok: false, code: 'AGENT_NOT_FOUND', error: `Agent does not exist: ${command.selfAid}` };
+    }
+    try {
+        if (command.kind === 'list-blocked') {
+            const snapshot = getContactSnapshot(command.selfAid);
+            return {
+                ok: true,
+                operation: 'list-blocked',
+                selfAid: command.selfAid,
+                contactRevision: snapshot.contactRevision,
+                items: [...snapshot.blockedIndex].sort().map(id => resolveContactView(command.selfAid, id)),
+            };
+        }
+        if (command.kind === 'set-blocked') {
+            if (!getContactSnapshot(command.selfAid).contacts.has(command.primaryId)) {
+                return { ok: false, code: 'NOT_FOUND', error: `Contact was not found: ${command.primaryId}` };
+            }
+            const result = await mutateContactWithOperation({
+                selfAid: command.selfAid,
+                actorId: actor,
+                operation: command.blocked ? 'block' : 'unblock',
+                primaryId: command.primaryId,
+                mutation: {
+                    type: 'set-status',
+                    primaryId: command.primaryId,
+                    status: command.blocked ? 'blocked' : 'active',
+                },
+            });
+            return {
+                ok: true,
+                operation: 'set-blocked',
+                selfAid: command.selfAid,
+                primaryId: command.primaryId,
+                blocked: command.blocked,
+                changed: result.changed,
+                contactRevision: result.contactRevision,
+            };
+        }
+        return { ok: false, code: 'CONTACT_OPERATION_FAILED', error: 'Unsupported contact operation' };
+    }
+    catch (error) {
+        if (error instanceof ContactMutationError) {
+            return { ok: false, code: error.code, error: error.message, ...(error.data ? { data: error.data } : {}) };
+        }
+        return { ok: false, code: 'CONTACT_OPERATION_FAILED', error: error instanceof Error ? error.message : String(error) };
+    }
+}
+function argValue(args, flag) {
+    const index = args.indexOf(flag);
+    return index >= 0 ? args[index + 1] : undefined;
+}
+function stripOptions(args) {
+    const result = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--self' || arg === '--format') {
+            index += 1;
+            continue;
+        }
+        if (arg === '--blocked')
+            continue;
+        result.push(arg);
+    }
+    return result;
+}
+function canonicalArgv(argv) {
+    return argv[0] === 'contact' ? [...argv] : ['contact', ...argv];
+}
+function invalid(code, reason) {
+    return { ok: false, code, reason };
+}

package/dist/config/contact-request-service.js

@@ -0,0 +1,331 @@
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
+import { isValidAid } from '../aun/aid/validation.js';
+import { agentContactOperations } from '../paths.js';
+import { listStaticAgentAdmins, listStaticAgentOwners } from './peer-role-resolver.js';
+import { listAgentOwners } from './access-policy.js';
+import { ContactMutationError, mutateContactBookPrepared, } from './contact-book-store.js';
+export const CONTACT_REQUEST_TTL_MS = 20 * 60 * 1000;
+export const CONTACT_REQUEST_WINDOW_MS = 60 * 60 * 1000;
+export const CONTACT_REQUEST_MAX_PER_WINDOW = 3;
+export const CONTACT_REQUEST_MAX_PENDING = 100;
+export const CONTACT_REQUEST_MAX_RETAINED = 1000;
+export const CONTACT_REQUEST_NOTE_MAX_LENGTH = 500;
+export async function mutateContactWithOperation(input) {
+    const at = new Date(input.now ?? Date.now()).toISOString();
+    const logFile = agentContactOperations(input.selfAid);
+    const result = await mutateContactBookPrepared(input.selfAid, ({ contactRevision }) => {
+        if (input.expectedContactRevision !== undefined && input.expectedContactRevision !== contactRevision) {
+            throw new ContactMutationError('CONFLICT', 'Contact book changed since it was read', {
+                expectedContactRevision: input.expectedContactRevision,
+                contactRevision,
+            });
+        }
+        return {
+            mutation: input.mutation,
+            actor: input.actorId,
+            value: undefined,
+            beforeCommit: ({ contactRevision: nextRevision }) => appendOperationRecords(logFile, [operationRecord({
+                    at,
+                    op: input.operation,
+                    primaryId: input.primaryId,
+                    actorId: input.actorId,
+                    contactRevision: nextRevision,
+                })]),
+        };
+    });
+    const { value: _value, ...mutationResult } = result;
+    return mutationResult;
+}
+export async function submitContactRequest(input) {
+    const applicantAid = String(input.applicantAid || '').trim();
+    const owners = listAgentOwners(input.selfAid);
+    if (!isValidAid(applicantAid)) {
+        return { code: 'invalid-applicant', contactRevision: '' };
+    }
+    if (owners.includes(applicantAid)) {
+        return { code: 'owner', contactRevision: '' };
+    }
+    if (owners.length === 0) {
+        return { code: 'no-owner', contactRevision: '' };
+    }
+    const note = normalizeNote(input.note);
+    if (note === null) {
+        return { code: 'invalid-note', contactRevision: '' };
+    }
+    const nowMs = input.now ?? Date.now();
+    const nowIso = new Date(nowMs).toISOString();
+    const logFile = agentContactOperations(input.selfAid);
+    const result = await mutateContactBookPrepared(input.selfAid, ({ contact }) => {
+        const expiration = collectExpiredMutations(contact, nowMs);
+        const effectiveEntry = effectiveEntryAfterExpirations(contact.contacts[applicantAid], nowMs);
+        if (effectiveEntry?.status === 'blocked') {
+            return preparedWithExpirations(expiration, { code: 'blocked', contactRevision: '' }, logFile);
+        }
+        if (effectiveEntry && (effectiveEntry.status === undefined || effectiveEntry.status === 'active')) {
+            return preparedWithExpirations(expiration, { code: 'already-contact', contactRevision: '' }, logFile);
+        }
+        const operations = readOperationLog(logFile);
+        const windowStart = nowMs - CONTACT_REQUEST_WINDOW_MS;
+        const recentCount = operations.filter(record => (record.primaryId === applicantAid
+            && (record.op === 'request' || record.op === 'resubmit')
+            && Date.parse(record.at) > windowStart
+            && Date.parse(record.at) <= nowMs)).length;
+        if (recentCount >= CONTACT_REQUEST_MAX_PER_WINDOW) {
+            return preparedWithExpirations(expiration, { code: 'rate-limited', contactRevision: '' }, logFile);
+        }
+        const counts = countRequestRecordsAfterExpirations(contact, nowMs);
+        const isExistingPending = effectiveEntry?.status === 'pending';
+        if (!isExistingPending && (counts.pending >= CONTACT_REQUEST_MAX_PENDING
+            || counts.retained >= CONTACT_REQUEST_MAX_RETAINED)) {
+            return preparedWithExpirations(expiration, { code: 'capacity', contactRevision: '' }, logFile);
+        }
+        const requestId = `creq_${crypto.randomUUID().replace(/-/g, '')}`;
+        const expiresAt = new Date(nowMs + CONTACT_REQUEST_TTL_MS).toISOString();
+        const op = isExistingPending ? 'resubmit' : 'request';
+        const value = {
+            code: isExistingPending ? 'resubmitted' : 'submitted',
+            requestId,
+            submittedAt: nowIso,
+            expiresAt,
+            contactRevision: '',
+        };
+        const mutations = [
+            ...expiration.mutations,
+            {
+                type: 'set-request',
+                primaryId: applicantAid,
+                request: { id: requestId, submittedAt: nowIso, expiresAt },
+            },
+        ];
+        return {
+            mutation: { type: 'batch', mutations },
+            actor: applicantAid,
+            value,
+            beforeCommit: ({ contactRevision }) => appendOperationRecords(logFile, [
+                ...expiration.events.map(event => ({ ...event, contactRevision })),
+                operationRecord({
+                    at: nowIso,
+                    op,
+                    primaryId: applicantAid,
+                    requestId,
+                    sourceChannelKey: input.sourceChannelKey,
+                    ...(note ? { note } : {}),
+                    contactRevision,
+                }),
+            ]),
+        };
+    });
+    return { ...result.value, contactRevision: result.contactRevision };
+}
+export async function reviewContactRequest(input) {
+    const nowMs = input.now ?? Date.now();
+    const nowIso = new Date(nowMs).toISOString();
+    const logFile = agentContactOperations(input.selfAid);
+    try {
+        const result = await mutateContactBookPrepared(input.selfAid, ({ contact, contactRevision }) => {
+            const owners = listStaticAgentOwners(input.selfAid, { fresh: true });
+            const admins = listStaticAgentAdmins(input.selfAid, { fresh: true });
+            const selectedManager = input.reviewerRole === undefined
+                && input.actorId === input.approverId
+                && (owners.includes(input.approverId) || admins.includes(input.approverId));
+            const managementReviewer = input.actorId === input.approverId
+                && ((input.reviewerRole === 'admin' && admins.includes(input.actorId))
+                    || (input.reviewerRole === 'owner' && owners.includes(input.actorId)));
+            if (!selectedManager && !managementReviewer) {
+                return preparedNoop({ code: 'forbidden', contactRevision });
+            }
+            if (contactRevision !== input.expectedContactRevision) {
+                return preparedNoop({ code: 'revision-conflict', contactRevision });
+            }
+            const entry = contact.contacts[input.primaryId];
+            if (!entry || entry.status !== 'pending' || entry.pendingRequest?.id !== input.requestId) {
+                return preparedNoop({ code: 'request-stale', contactRevision });
+            }
+            if (Date.parse(entry.pendingRequest.expiresAt) <= nowMs) {
+                const mutation = {
+                    type: 'expire-request',
+                    primaryId: input.primaryId,
+                    requestId: input.requestId,
+                    now: nowIso,
+                };
+                return {
+                    mutation,
+                    actor: input.actorId,
+                    value: { code: 'request-expired', contactRevision },
+                    beforeCommit: ({ contactRevision: nextRevision }) => appendOperationRecords(logFile, [operationRecord({
+                            at: nowIso,
+                            op: 'expire',
+                            primaryId: input.primaryId,
+                            requestId: input.requestId,
+                            contactRevision: nextRevision,
+                        })]),
+                };
+            }
+            const code = input.decision === 'approve'
+                ? 'approved'
+                : input.decision === 'reject'
+                    ? 'rejected'
+                    : 'blocked';
+            return {
+                mutation: {
+                    type: 'review-request',
+                    primaryId: input.primaryId,
+                    requestId: input.requestId,
+                    decision: input.decision,
+                    now: nowIso,
+                },
+                actor: input.actorId,
+                value: { code, contactRevision },
+                beforeCommit: ({ contactRevision: nextRevision }) => appendOperationRecords(logFile, [operationRecord({
+                        at: nowIso,
+                        op: input.decision === 'approve' ? 'approve' : input.decision === 'reject' ? 'reject' : 'block',
+                        primaryId: input.primaryId,
+                        requestId: input.requestId,
+                        actorId: input.actorId,
+                        contactRevision: nextRevision,
+                    })]),
+            };
+        });
+        return { ...result.value, contactRevision: result.contactRevision };
+    }
+    catch (error) {
+        if (error instanceof ContactMutationError && error.code === 'REQUEST_EXPIRED') {
+            return { code: 'request-expired', contactRevision: input.expectedContactRevision };
+        }
+        throw error;
+    }
+}
+export async function expirePendingContactRequests(selfAid, now = Date.now()) {
+    const nowIso = new Date(now).toISOString();
+    const logFile = agentContactOperations(selfAid);
+    const result = await mutateContactBookPrepared(selfAid, ({ contact }) => {
+        const expiration = collectExpiredMutations(contact, now);
+        if (expiration.mutations.length === 0)
+            return preparedNoop(0);
+        return {
+            mutation: { type: 'batch', mutations: expiration.mutations },
+            actor: 'contact-request-expiry',
+            value: expiration.mutations.length,
+            beforeCommit: ({ contactRevision }) => appendOperationRecords(logFile, expiration.events.map(event => ({ ...event, contactRevision }))),
+        };
+    });
+    return result.value;
+}
+export async function listPendingContactRequests(selfAid, now = Date.now()) {
+    await expirePendingContactRequests(selfAid, now);
+    const result = await mutateContactBookPrepared(selfAid, ({ contact, contactRevision }) => preparedNoop(Object.entries(contact.contacts)
+        .filter(([, entry]) => entry.status === 'pending' && entry.pendingRequest)
+        .map(([primaryId, entry]) => ({
+        primaryId,
+        requestId: entry.pendingRequest.id,
+        submittedAt: entry.pendingRequest.submittedAt,
+        expiresAt: entry.pendingRequest.expiresAt,
+        contactRevision,
+    }))));
+    return result.value;
+}
+export function findContactRequestNote(selfAid, requestId) {
+    const records = readOperationLog(agentContactOperations(selfAid));
+    return [...records].reverse().find(record => (record.requestId === requestId
+        && (record.op === 'request' || record.op === 'resubmit')))?.note;
+}
+function normalizeNote(value) {
+    const note = String(value ?? '').trim();
+    if (note.length > CONTACT_REQUEST_NOTE_MAX_LENGTH)
+        return null;
+    return note;
+}
+function collectExpiredMutations(book, now) {
+    const mutations = [];
+    const events = [];
+    for (const [primaryId, entry] of Object.entries(book.contacts)) {
+        if (entry.status !== 'pending' || !entry.pendingRequest)
+            continue;
+        if (Date.parse(entry.pendingRequest.expiresAt) > now)
+            continue;
+        mutations.push({
+            type: 'expire-request',
+            primaryId,
+            requestId: entry.pendingRequest.id,
+            now: new Date(now).toISOString(),
+        });
+        events.push(operationRecord({
+            at: new Date(now).toISOString(),
+            op: 'expire',
+            primaryId,
+            requestId: entry.pendingRequest.id,
+            contactRevision: '',
+        }));
+    }
+    return { mutations, events };
+}
+function effectiveEntryAfterExpirations(entry, now) {
+    if (entry?.status === 'pending' && entry.pendingRequest && Date.parse(entry.pendingRequest.expiresAt) <= now) {
+        return { ...entry, status: 'declined', pendingRequest: undefined, declinedAt: entry.pendingRequest.expiresAt };
+    }
+    return entry;
+}
+function countRequestRecordsAfterExpirations(book, now) {
+    let pending = 0;
+    let declined = 0;
+    for (const entry of Object.values(book.contacts)) {
+        const effective = effectiveEntryAfterExpirations(entry, now);
+        if (effective?.status === 'pending')
+            pending += 1;
+        else if (effective?.status === 'declined')
+            declined += 1;
+    }
+    return { pending, retained: pending + declined };
+}
+function preparedWithExpirations(expiration, value, logFile) {
+    if (expiration.mutations.length === 0)
+        return preparedNoop(value);
+    return {
+        mutation: { type: 'batch', mutations: expiration.mutations },
+        actor: 'contact-request-expiry',
+        value,
+        beforeCommit: ({ contactRevision }) => appendOperationRecords(logFile, expiration.events.map(event => ({ ...event, contactRevision }))),
+    };
+}
+function preparedNoop(value) {
+    return { value };
+}
+function readOperationLog(file) {
+    let raw;
+    try {
+        raw = fs.readFileSync(file, 'utf8');
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            return [];
+        throw new ContactMutationError('CONTACT_OPERATION_LOG_INVALID', `Cannot read contact operation log: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const records = [];
+    for (const [index, line] of raw.split('\n').entries()) {
+        if (!line.trim())
+            continue;
+        try {
+            const record = JSON.parse(line);
+            if (!record || typeof record !== 'object' || typeof record.at !== 'string'
+                || !Number.isFinite(Date.parse(record.at)) || typeof record.op !== 'string'
+                || typeof record.primaryId !== 'string')
+                throw new Error('invalid record');
+            records.push(record);
+        }
+        catch (error) {
+            throw new ContactMutationError('CONTACT_OPERATION_LOG_INVALID', `Invalid contact operation log record at line ${index + 1}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return records;
+}
+function appendOperationRecords(file, records) {
+    if (records.length === 0)
+        return;
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.appendFileSync(file, `${records.map(record => JSON.stringify(record)).join('\n')}\n`, 'utf8');
+}
+function operationRecord(input) {
+    return { id: `evt_${crypto.randomUUID().replace(/-/g, '')}`, ...input };
+}