evolcore 0.0.1 → 0.0.3

package/dist/config/contact-book.js

@@ -0,0 +1,224 @@
+import { agentContactConfig } from '../paths.js';
+import { isValidAid } from '../aun/aid/validation.js';
+import { isExplicitGroupId } from '../aun/group-identity.js';
+import { ConfigTarget, read, validateConfig } from './config-manager.js';
+import { ContactMutationError, contactRevision, mutateContactBookSync } from './contact-book-store.js';
+import { formatContactAlias, normalizeContactChannelKey, parseContactAlias, } from './contact-alias.js';
+export class ContactBookError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'ContactBookError';
+    }
+}
+let aliasMapCache = new WeakMap();
+let snapshotByBook = new WeakMap();
+const EMPTY_ALIAS_MAP = {
+    aliasToPrimary: new Map(),
+    conflictingAliases: new Set(),
+};
+export function agentContactConfigPath(aid) {
+    return agentContactConfig(aid);
+}
+export function readContactBook(selfAid, opts = {}) {
+    if (!selfAid)
+        return null;
+    return read(ConfigTarget.Contact, { self: selfAid }, { cache: opts.cache ?? true });
+}
+export function resolvePrincipal(selfAid, channelType, actorId, channelKey) {
+    const actor = String(actorId || '').trim();
+    const type = String(channelType || '').trim().toLowerCase();
+    if (type === 'aun') {
+        return isValidAid(actor)
+            ? { principalId: actor, principalStatus: 'native_aid' }
+            : { principalStatus: actor ? 'unmapped' : 'error' };
+    }
+    const canonicalChannelKey = normalizeContactChannelKey(selfAid, type, channelKey);
+    if (!isValidAid(String(selfAid || '').trim()) || !actor || !canonicalChannelKey) {
+        return { principalStatus: 'error' };
+    }
+    try {
+        const aliases = loadAliasMap(selfAid);
+        const exact = formatContactAlias(canonicalChannelKey, actor);
+        if (aliases.conflictingAliases.has(exact))
+            return { principalStatus: 'conflict' };
+        const mapped = aliases.aliasToPrimary.get(exact);
+        if (mapped)
+            return { principalId: mapped, principalStatus: 'mapped' };
+        return { principalStatus: 'unmapped' };
+    }
+    catch {
+        return { principalStatus: 'error' };
+    }
+}
+export function resolvePrimaryId(selfAid, channelType, actorId, channelKey) {
+    const actor = String(actorId || '').trim();
+    return resolvePrincipal(selfAid, channelType, actor, channelKey).principalId ?? actor;
+}
+export function bindContactAlias(selfAid, primaryId, channelType, actorId, channelKey) {
+    const primary = normalizePrimaryId(primaryId);
+    const type = String(channelType || '').trim().toLowerCase();
+    const actor = String(actorId || '').trim();
+    if (type === 'aun') {
+        if (!isValidAid(actor) || actor !== primary) {
+            throw new ContactBookError('NATIVE_AID_REMAP_FORBIDDEN', `Native AID "${actor}" cannot be remapped to "${primary}"`);
+        }
+        return false;
+    }
+    const canonicalChannelKey = normalizeContactChannelKey(selfAid, type, channelKey);
+    if (!canonicalChannelKey || !actor) {
+        throw new ContactBookError('INVALID_ALIAS', `Invalid contact alias: ${String(channelKey)}:${String(actorId)}`);
+    }
+    const alias = formatContactAlias(canonicalChannelKey, actor);
+    try {
+        return mutateContactBookSync({
+            selfAid,
+            mutation: { type: 'bind-alias', primaryId: primary, alias },
+        }).changed;
+    }
+    catch (error) {
+        if (error instanceof ContactMutationError)
+            throw new ContactBookError(error.code, error.message);
+        throw error;
+    }
+}
+export function unbindContactAlias(selfAid, primaryId, channelType, actorId, channelKey) {
+    const primary = normalizePrimaryId(primaryId);
+    const type = String(channelType || '').trim().toLowerCase();
+    const actor = String(actorId || '').trim();
+    const canonicalChannelKey = normalizeContactChannelKey(selfAid, type, channelKey);
+    if (!canonicalChannelKey || type === 'aun' || !actor) {
+        throw new ContactBookError('INVALID_ALIAS', `Invalid contact alias: ${String(channelKey)}:${String(actorId)}`);
+    }
+    const alias = formatContactAlias(canonicalChannelKey, actor);
+    try {
+        return mutateContactBookSync({
+            selfAid,
+            mutation: { type: 'unbind-alias', primaryId: primary, alias },
+        }).changed;
+    }
+    catch (error) {
+        if (error instanceof ContactMutationError)
+            throw new ContactBookError(error.code, error.message);
+        throw error;
+    }
+}
+export function clearContactBookCache() {
+    aliasMapCache = new WeakMap();
+    snapshotByBook = new WeakMap();
+}
+export function getContactSnapshot(selfAid) {
+    const book = readContactBook(selfAid, { cache: true }) ?? { $schema_version: 2, contacts: {} };
+    const cached = snapshotByBook.get(book);
+    if (cached)
+        return cached;
+    const errors = validateConfig(ConfigTarget.Contact, book);
+    if (errors.length) {
+        throw new ContactBookError('INVALID_CONTACT_BOOK', `Invalid contact book for ${selfAid}: ${errors.join('; ')}`);
+    }
+    const aliases = buildAliasMap(book, selfAid);
+    if (aliases.conflictingAliases.size) {
+        throw new ContactBookError('ALIAS_CONFLICT', `Conflicting contact aliases: ${[...aliases.conflictingAliases].join(', ')}`);
+    }
+    const snapshot = buildSnapshot(book, selfAid, aliases);
+    snapshotByBook.set(book, snapshot);
+    return snapshot;
+}
+export function resolveContactView(selfAid, primaryId) {
+    const id = String(primaryId || '').trim();
+    const owner = listAgentOwners(selfAid).includes(id);
+    const entry = getContactSnapshot(selfAid).contacts.get(id);
+    const status = owner ? 'active' : entry?.status ?? 'active';
+    return {
+        primaryId: id,
+        ...(entry?.displayName ? { displayName: entry.displayName } : {}),
+        aliases: entry?.aliases ?? [],
+        status,
+        blocked: status === 'blocked',
+        isOwner: owner,
+        source: owner ? 'owner' : entry ? 'contact' : 'none',
+    };
+}
+export function isBlockedContact(selfAid, primaryId) {
+    return resolveContactView(selfAid, primaryId).blocked;
+}
+function buildSnapshot(book, selfAid, aliases) {
+    const contacts = new Map();
+    const blockedIndex = new Set();
+    const owners = new Set(listAgentOwners(selfAid));
+    for (const [primaryId, rawEntry] of Object.entries(book.contacts)) {
+        if (!isValidAid(primaryId) || isExplicitGroupId(primaryId)) {
+            throw new ContactBookError('INVALID_CONTACT_BOOK', `Invalid contact AID: ${primaryId}`);
+        }
+        if (rawEntry.status === 'blocked' && owners.has(primaryId)) {
+            throw new ContactBookError('INVALID_CONTACT_BOOK', `Owner contact ${primaryId} cannot be blocked`);
+        }
+        const entry = Object.freeze({
+            ...rawEntry,
+            ...(rawEntry.aliases ? { aliases: Object.freeze([...rawEntry.aliases]) } : {}),
+        });
+        contacts.set(primaryId, entry);
+        if (entry.status === 'blocked')
+            blockedIndex.add(primaryId);
+    }
+    return Object.freeze({
+        contacts,
+        aliasIndex: aliases.aliasToPrimary,
+        conflictingAliases: aliases.conflictingAliases,
+        blockedIndex,
+        contactRevision: contactRevision(book),
+    });
+}
+function loadAliasMap(selfAid) {
+    const book = readContactBook(selfAid, { cache: true });
+    if (!book)
+        return EMPTY_ALIAS_MAP;
+    const cached = aliasMapCache.get(book);
+    if (cached)
+        return cached;
+    const errors = validateConfig(ConfigTarget.Contact, book);
+    if (errors.length) {
+        throw new ContactBookError('INVALID_CONTACT_BOOK', `Invalid contact book for ${selfAid}: ${errors.join('; ')}`);
+    }
+    const built = buildAliasMap(book, selfAid);
+    aliasMapCache.set(book, built);
+    return built;
+}
+function buildAliasMap(book, selfAid) {
+    const aliasToPrimary = new Map();
+    const conflictingAliases = new Set();
+    for (const [primaryId, entry] of Object.entries(book?.contacts ?? {})) {
+        if (!isValidAid(primaryId) || isExplicitGroupId(primaryId) || !entry || typeof entry !== 'object')
+            continue;
+        for (const rawAlias of entry.aliases ?? []) {
+            const parsed = parseContactAlias(rawAlias, selfAid);
+            if (!parsed) {
+                throw new ContactBookError('INVALID_CONTACT_BOOK', `Invalid contact alias for ${selfAid}: ${String(rawAlias)}`);
+            }
+            const alias = parsed.alias;
+            if (conflictingAliases.has(alias))
+                continue;
+            const existing = aliasToPrimary.get(alias);
+            if (existing && existing !== primaryId) {
+                aliasToPrimary.delete(alias);
+                conflictingAliases.add(alias);
+            }
+            else {
+                aliasToPrimary.set(alias, primaryId);
+            }
+        }
+    }
+    return { aliasToPrimary, conflictingAliases };
+}
+function normalizePrimaryId(value) {
+    const id = String(value || '').trim();
+    if (!isValidAid(id) || isExplicitGroupId(id)) {
+        throw new ContactBookError('INVALID_PRIMARY_ID', `Invalid individual contact AID: ${String(value)}`);
+    }
+    return id;
+}
+function listAgentOwners(selfAid) {
+    const agent = read(ConfigTarget.Agent, { self: selfAid }, { cache: true });
+    return [...new Set((agent?.owners ?? []).map(value => String(value || '').trim()).filter(Boolean))];
+}

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

@@ -0,0 +1,110 @@
+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, mutateContactBook } from './contact-book-store.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') {
+            const result = await mutateContactBook({
+                selfAid: command.selfAid,
+                actor,
+                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 };
+}