@agentshouse/mdruntime 0.1.0-c8f3163f32f93 → 0.1.0-c90a12b59fe09

package/dist/actions.js

@@ -0,0 +1,261 @@
+import { roomTarget, target } from '@agentshouse/mdmodel';
+import { CATCHING_UP, resendConversations } from './conversation.js';
+import { listingNow } from './listing.js';
+import { locked, lockedRooms } from './locks.js';
+import { scoped } from './models.js';
+import { ABSENT_TARGET, failure, historyAnswer, LOCKED_UNREADABLE, lockedRoom, handedOutcome, UNANSWERED, undeclared, UNCERTAIN, UNREADABLE, } from './outcome.js';
+import { refuse } from './refusal.js';
+function operationOf(input) {
+    const operation = input?.operation_id;
+    return typeof operation === 'string' ? operation : null;
+}
+export async function readHistory(runtime, locator, path, query = {}) {
+    const { store, socket, presence, journal } = runtime;
+    const { session } = socket;
+    if (socket.closed() || session.now().refusal !== null)
+        return UNCERTAIN;
+    await socket.firstDiscovery;
+    if (!session.now().roomsNamed)
+        return UNCERTAIN;
+    try {
+        await socket.authorize();
+    }
+    catch {
+        return UNCERTAIN;
+    }
+    const { closed, authorization, refusal } = session.now();
+    if (closed || authorization === undefined || refusal !== null)
+        return UNCERTAIN;
+    const since = presence.losses();
+    const transfer = ['transfer', 'history', locator, path];
+    if (query.revision !== undefined)
+        transfer.push(query.revision);
+    if (query.pageToken !== undefined)
+        transfer.push(query.pageToken);
+    journal.record(transfer.join(' '));
+    try {
+        const result = await socket.history(authorization, {
+            locator,
+            path,
+            ...(query.revision === undefined ? {} : { revision: query.revision }),
+            ...(query.pageToken === undefined ? {} : { pageToken: query.pageToken }),
+        });
+        journal.record(`outcome history ${result.kind}`);
+        if (presence.lostSince(locator, since))
+            return failure({ kind: 'room-not-readable', locator });
+        if (result.kind === 'scoped-refusal') {
+            const room = await store.record(result.locator);
+            if (room !== undefined)
+                await scoped(runtime, result, room.locator, room.declaration);
+        }
+        if (result.kind === 'revoked-authorization')
+            await refuse(runtime, 'revoked-authorization');
+        return historyAnswer(result);
+    }
+    catch {
+        journal.record('outcome history transport-uncertainty');
+        return UNCERTAIN;
+    }
+}
+export async function located(runtime, room, path, destination) {
+    const crossing = roomTarget(destination);
+    const listing = await listingNow(runtime);
+    if (crossing === null) {
+        const named = target(path, destination);
+        return named === null || !listing.has(room) ? null : { room, path: named };
+    }
+    const held = [...listing.values()].find((listed) => listed.handle === crossing.handle);
+    return held === undefined ? null : { room: held.locator, path: crossing.path };
+}
+export async function resolveReference(runtime, room, path, destination) {
+    const { store } = runtime;
+    if (roomTarget(destination) === null && target(path, destination) === null) {
+        return ABSENT_TARGET;
+    }
+    const at = await located(runtime, room, path, destination);
+    if (at === null)
+        return UNREADABLE;
+    if (await locked(runtime, at.room))
+        return LOCKED_UNREADABLE;
+    const held = await store.record(at.room);
+    if (held !== undefined &&
+        (await (await store.open()).entries(held.key, 'visible', [at.path])).length > 0) {
+        return { kind: 'document', ...at };
+    }
+    const history = await readHistory(runtime, at.room, at.path);
+    if (history.kind === 'no-history' || history.kind === 'revision')
+        return ABSENT_TARGET;
+    if (history.kind !== 'history')
+        return history;
+    const [last] = history.revisions;
+    if (last === undefined)
+        return ABSENT_TARGET;
+    return history.deleted === true
+        ? { kind: 'deleted', ...at, revision: last }
+        : { kind: 'document', ...at };
+}
+async function declaredAction({ store }, name) {
+    for (const capability of (await (await store.open()).facts()).capabilities) {
+        for (const action of capability.actions ?? []) {
+            if (action.name === name)
+                return action;
+        }
+    }
+    return undefined;
+}
+async function calledRooms(runtime, name, input) {
+    const member = (await declaredAction(runtime, name))?.room;
+    if (member === undefined || input === null || typeof input !== 'object')
+        return [];
+    const named = input[member];
+    return (Array.isArray(named) ? named : [named]).filter((room) => typeof room === 'string');
+}
+export async function invokeAction(runtime, name, input, { dispatching, attempt } = {}) {
+    const { store, socket, journal, retries } = runtime;
+    const { session } = socket;
+    await socket.ready;
+    if (socket.closed() || session.now().refusal !== null) {
+        return handedOutcome(retries, attempt, UNANSWERED);
+    }
+    if ((await declaredAction(runtime, name)) === undefined)
+        return undeclared(name);
+    try {
+        await socket.authorize();
+    }
+    catch {
+        return handedOutcome(retries, attempt, UNANSWERED);
+    }
+    const { closed, authorization, refusal } = session.now();
+    if (closed || authorization === undefined || refusal !== null) {
+        return handedOutcome(retries, attempt, UNANSWERED);
+    }
+    await dispatching?.();
+    journal.record(`transfer action ${name}`);
+    try {
+        const result = await socket.action(authorization, { name, input });
+        if (result.kind === 'scoped-refusal') {
+            const room = await store.record(result.locator);
+            if (room !== undefined)
+                await scoped(runtime, result, room.locator, room.declaration);
+        }
+        if (result.kind === 'revoked-authorization')
+            await refuse(runtime, 'revoked-authorization');
+        journal.record(`outcome action ${result.kind}`);
+        if (result.kind === 'rejected')
+            journal.record(`refusal rejected ${result.code}`);
+        return handedOutcome(retries, attempt, result);
+    }
+    catch (error) {
+        journal.record('outcome action transport-uncertainty');
+        return handedOutcome(retries, attempt, { kind: 'transport-uncertainty', failure: error });
+    }
+}
+export async function readConversationHistory(runtime, request) {
+    const { socket, journal, retries } = runtime;
+    const caught = { step: 'conversations', instance: CATCHING_UP };
+    await socket.ready;
+    const stream = socket.conversations();
+    if (socket.closed() || socket.session.now().refusal !== null || stream?.history === undefined) {
+        return handedOutcome(retries, caught, UNANSWERED);
+    }
+    journal.record('transfer conversation history');
+    try {
+        const result = await stream.history(request);
+        if (result.kind === 'revoked-authorization')
+            await refuse(runtime, 'revoked-authorization');
+        journal.record(`outcome conversation history ${result.kind}`);
+        return handedOutcome(retries, caught, result);
+    }
+    catch (error) {
+        journal.record('outcome conversation history transport-uncertainty');
+        return handedOutcome(retries, caught, { kind: 'transport-uncertainty', failure: error });
+    }
+}
+function unsettled(result) {
+    if (result.kind === 'action')
+        return false;
+    return result.retryable && (result.kind !== 'rejected' || result.reset === undefined);
+}
+function numberedCall(runtime, name, input, operation, dispatching) {
+    return invokeAction(runtime, name, input, {
+        dispatching,
+        attempt: { step: 'sending', instance: `action ${operation}` },
+    });
+}
+async function recoveredAction(runtime, name, input, attempt) {
+    const { store, socket, recovery } = runtime;
+    const { lanes } = socket;
+    const operation = operationOf(input);
+    if (operation === null)
+        return invokeAction(runtime, name, input, { attempt });
+    const dispatching = async () => (await store.open()).keepCall({ operation, name, input });
+    lanes.call(operation);
+    try {
+        let result = await numberedCall(runtime, name, input, operation, dispatching);
+        if (unsettled(result)) {
+            await recovery.attempt(`action ${operation}`, async () => {
+                if (socket.closed() || socket.session.now().refusal !== null)
+                    return 'done';
+                if (!socket.isOpen())
+                    return 'again';
+                result = await numberedCall(runtime, name, input, operation, dispatching);
+                return unsettled(result) ? 'again' : 'done';
+            }, { again: true });
+        }
+        if (!unsettled(result))
+            await (await store.open()).dropCall(operation);
+        return result;
+    }
+    finally {
+        lanes.called(operation);
+    }
+}
+export async function called(runtime, name, input, attempt) {
+    await runtime.socket.ready;
+    const lockedNow = await lockedRooms(runtime);
+    const room = (await calledRooms(runtime, name, input)).find((one) => lockedNow.includes(one));
+    return room === undefined ? recoveredAction(runtime, name, input, attempt) : lockedRoom(room);
+}
+export async function resendCalls(runtime, signal) {
+    const { store, socket } = runtime;
+    const { lanes } = socket;
+    if (!socket.isOpen() || socket.closed() || socket.stopping())
+        return 'done';
+    const local = await store.open();
+    for (const held of await local.calls()) {
+        if (lanes.calling(held.operation))
+            continue;
+        if (socket.closed() || signal.aborted)
+            return 'done';
+        lanes.call(held.operation);
+        try {
+            if (unsettled(await numberedCall(runtime, held.name, held.input, held.operation))) {
+                return 'again';
+            }
+            await local.dropCall(held.operation);
+        }
+        finally {
+            lanes.called(held.operation);
+        }
+    }
+    return 'done';
+}
+async function resendPass({ socket, conversations }, signal) {
+    if (!socket.continuing() || !socket.isOpen() || socket.stopping())
+        return 'done';
+    const reading = { complete: true, reachable: true };
+    try {
+        await resendConversations(conversations, reading);
+    }
+    catch {
+        reading.reachable = false;
+    }
+    if (signal.aborted)
+        return 'done';
+    return reading.reachable && reading.complete ? 'done' : 'again';
+}
+export function resendLater(runtime) {
+    if (!runtime.socket.isOpen())
+        return;
+    void runtime.recovery.attempt('resend', (signal) => resendPass(runtime, signal), { again: true });
+}