@atolis-hq/wake 0.2.97 → 0.3.0

package/dist/src/bootstrap/surface-api-execution-applications.js

@@ -0,0 +1,95 @@
+import { ControlStreamKind, ineligibleRunners, } from '../control-plane/index.js';
+import { ApiCommandStatus, presentRun } from '../surfaces/index.js';
+import { projectionMeta, sampledMeta } from './surface-api-metadata.js';
+import { projectionPage } from './surface-api-projection-pages.js';
+import { withWorkflowContext } from './surface-api-run-context.js';
+import { readWorkTranscript } from './surface-api-transcripts.js';
+export function createExecutionApplications(root, now) {
+    return {
+        async pauseRunner(runnerId, command) {
+            await root.runnerControls.pause(runnerId, command.idempotencyKey);
+            return commandAccepted(command, now());
+        },
+        async unpauseRunner(runnerId, command) {
+            await root.runnerControls.unpause(runnerId, command.idempotencyKey);
+            return commandAccepted(command, now());
+        },
+        async list(query) {
+            const stored = (await root.projections.list('execution')).flatMap((entry) => entry.value.view === null ? [] : [{ ...entry, value: entry.value.view }]);
+            const filtered = stored.filter((entry) => query.state === undefined || entry.value.status === query.state);
+            const page = await projectionPage(root.journal, filtered, query, presentRun, {
+                emptyAsOf: now(),
+                provenance: stored,
+            });
+            return {
+                ...page,
+                items: await Promise.all(page.items.map((item) => withWorkflowContext(root, item))),
+            };
+        },
+        async get(runId) {
+            const stored = await root.projections.read('execution', runId);
+            if (stored?.value.view == null)
+                return undefined;
+            return {
+                data: await withWorkflowContext(root, presentRun(stored.value.view)),
+                meta: await projectionMeta(root.journal, [stored], now()),
+            };
+        },
+        async transcript(runId) {
+            const stored = await root.projections.read('execution', runId);
+            const run = stored?.value.view;
+            if (run === null || run === undefined)
+                return undefined;
+            const workflow = await root.projections.read('orchestration', run.workflowInstanceId);
+            const workItemId = workflow?.value.view?.workItemId;
+            if (workItemId === undefined)
+                return { data: { runId, available: false, entries: [] }, meta: sampledMeta(now()) };
+            const groupId = await root.transcriptStore?.groupForRun(workItemId, runId);
+            if (groupId === undefined)
+                return { data: { runId, available: false, entries: [] }, meta: sampledMeta(now()) };
+            const runs = (await root.projections.list('execution')).flatMap((entry) => (entry.value.view === null ? [] : [entry.value.view]));
+            const workflowIds = [...new Set(runs.map((candidate) => candidate.workflowInstanceId))];
+            const workflows = await Promise.all(workflowIds.map(async (workflowInstanceId) => root.projections.read('orchestration', workflowInstanceId)));
+            const workItemIdsByWorkflow = new Map(workflowIds.map((workflowInstanceId, index) => [
+                workflowInstanceId,
+                workflows[index]?.value.view?.workItemId,
+            ]));
+            const groupRuns = runs.filter((candidate) => workItemIdsByWorkflow.get(candidate.workflowInstanceId) === workItemId);
+            const group = await readWorkTranscript(root.transcriptStore, workItemId, groupId, groupRuns);
+            return {
+                data: { runId, groupId, available: group.available, entries: group.entries },
+                meta: sampledMeta(now()),
+            };
+        },
+        async runners(query) {
+            const sampledAt = now();
+            const stored = await root.projections.read(ControlStreamKind.Global, 'global');
+            const paused = stored === null ? new Set() : ineligibleRunners(stored.value, sampledAt);
+            const all = [...new Set(Object.values(root.config.execution.runnerPools).flat())].map((runnerId) => paused.has(runnerId)
+                ? {
+                    runnerId,
+                    status: 'paused',
+                    available: false,
+                    detail: 'runner is paused',
+                    updatedAt: sampledAt,
+                }
+                : { runnerId, status: 'available', available: true, updatedAt: sampledAt });
+            const offset = query.cursor?.position ?? 0;
+            const items = all.slice(offset, offset + query.limit);
+            return {
+                items,
+                total: all.length,
+                meta: sampledMeta(sampledAt),
+                ...(offset + items.length < all.length ? { nextPosition: offset + items.length } : {}),
+            };
+        },
+    };
+}
+function commandAccepted(command, acceptedAt) {
+    return {
+        commandId: `runner:${command.idempotencyKey}`,
+        idempotencyKey: command.idempotencyKey,
+        acceptedAt,
+        status: ApiCommandStatus.Completed,
+    };
+}

package/dist/src/bootstrap/surface-api-metadata.js

@@ -0,0 +1,12 @@
+export function sampledMeta(asOf) {
+    return { asOf };
+}
+export async function projectionMeta(journal, projections, emptyAsOf) {
+    const position = projections.reduce((latest, projection) => Math.max(latest, projection.lastGlobalPosition), 0);
+    if (position === 0)
+        return sampledMeta(emptyAsOf);
+    const event = (await journal.readAll(position - 1, 1))[0];
+    if (event === undefined || event.globalPosition !== position)
+        throw new Error(`Journal fact unavailable for projection position ${position}`);
+    return { asOf: event.occurredAt, position };
+}

package/dist/src/bootstrap/surface-api-projection-pages.js

@@ -0,0 +1,22 @@
+import { projectionMeta } from './surface-api-metadata.js';
+export async function projectionPage(journal, values, query, present, options) {
+    const provenance = options.provenance ?? values;
+    const after = query.cursor?.position ?? Number.POSITIVE_INFINITY;
+    const candidates = [...values]
+        .filter((entry) => entry.lastGlobalPosition < after)
+        .sort((left, right) => right.lastGlobalPosition - left.lastGlobalPosition);
+    const visible = candidates.slice(0, query.limit);
+    const last = visible.at(-1);
+    const metaSources = provenance.length === 0 && query.cursor !== undefined
+        ? [{ lastGlobalPosition: query.cursor.position }]
+        : provenance;
+    const meta = await projectionMeta(journal, metaSources, options.emptyAsOf);
+    return {
+        items: visible.map((entry) => present(entry.value)),
+        meta,
+        total: values.length,
+        ...(candidates.length > query.limit && last !== undefined
+            ? { nextPosition: last.lastGlobalPosition }
+            : {}),
+    };
+}

package/dist/src/bootstrap/surface-api-run-context.js

@@ -0,0 +1,5 @@
+import { workflowInstanceId } from '../orchestration/index.js';
+export async function withWorkflowContext(root, run) {
+    const instance = await root.orchestration.get(workflowInstanceId(run.workflowInstanceId));
+    return instance === null ? run : { ...run, workflowName: instance.workflowName };
+}

package/dist/src/bootstrap/surface-api-transcripts.js

@@ -0,0 +1,57 @@
+import { TranscriptChannel } from '../execution/index.js';
+export async function transcriptGroups(store, workItemId, runs) {
+    if (store === undefined)
+        return [];
+    const owned = new Set(runs.map((run) => run.runId));
+    const visible = await Promise.all((await store.listGroups(workItemId)).map(async (group) => {
+        const messages = (await store.readGroup(workItemId, group.id)).filter((message) => owned.has(message.runId));
+        const latest = messages.at(-1);
+        if (latest === undefined)
+            return undefined;
+        return {
+            groupId: group.id,
+            kind: group.kind,
+            ...(group.cli === undefined ? {} : { cli: group.cli }),
+            latestAt: latest.timestamp,
+            runIds: [...new Set(messages.map((message) => message.runId))],
+        };
+    }));
+    return visible.filter((group) => group !== undefined);
+}
+export async function readWorkTranscript(store, workItemId, groupId, runs) {
+    if (store === undefined)
+        return unavailable(groupId);
+    const group = (await store.listGroups(workItemId)).find((item) => item.id === groupId);
+    if (group === undefined)
+        return unavailable(groupId);
+    const included = new Set(group.runIds);
+    const metadata = new Map(runs.filter((run) => included.has(run.runId)).map((run) => [run.runId, run]));
+    if (metadata.size === 0)
+        return unavailable(groupId);
+    return {
+        groupId,
+        available: true,
+        entries: (await store.readGroup(workItemId, groupId))
+            .filter((message) => metadata.has(message.runId))
+            .map((message) => presentEntry(message, groupId, metadata.get(message.runId))),
+    };
+}
+function unavailable(groupId) {
+    return { groupId, available: false, entries: [] };
+}
+export function presentEntry(message, groupId, run) {
+    const durationMs = runDuration(run);
+    return {
+        occurredAt: message.timestamp,
+        channel: message.kind === 'prompt' ? TranscriptChannel.Input : TranscriptChannel.Agent,
+        text: message.text,
+        runId: message.runId,
+        groupId,
+        ...(durationMs === undefined ? {} : { durationMs }),
+    };
+}
+function runDuration(run) {
+    if (run?.finishedAt === undefined)
+        return undefined;
+    return Date.parse(run.finishedAt) - Date.parse(run.startedAt);
+}

package/dist/src/bootstrap/surface-api-work-applications.js

@@ -0,0 +1,199 @@
+import { correlationId, EventActorKind } from '../kernel/index.js';
+import { isOperatorRetryEligible, OperatorRetryIneligibleError, } from '../orchestration/index.js';
+import { ResourceEventType, selectResourceEvent } from '../resources/index.js';
+import { ApiCommandStatus, fromWorkItemKey, presentResource, presentRun, presentWorkflowInstance, presentWorkItem, } from '../surfaces/index.js';
+import { workItemId, WorkStatus } from '../work/index.js';
+import { primaryExternalRef } from './external-ref.js';
+import { projectionMeta } from './surface-api-metadata.js';
+import { projectionPage } from './surface-api-projection-pages.js';
+import { withWorkflowContext } from './surface-api-run-context.js';
+import { readWorkTranscript, transcriptGroups } from './surface-api-transcripts.js';
+export function createSurfaceWorkApplications(root, now) {
+    return {
+        async list(query) {
+            const stored = (await root.projections.list('work')).flatMap((entry) => entry.value === null ? [] : [{ ...entry, value: entry.value }]);
+            const filtered = stored
+                .filter((entry) => query.search === undefined ||
+                `${entry.value.workItemId} ${entry.value.objective}`
+                    .toLocaleLowerCase()
+                    .includes(query.search.toLocaleLowerCase()))
+                .filter((entry) => query.state === undefined || entry.value.state === query.state);
+            return projectionPage(root.journal, filtered, query, presentWorkItem, {
+                emptyAsOf: now(),
+                provenance: stored,
+            });
+        },
+        detail: (key) => workDetail(root, key, now),
+        async transcript(key, groupId) {
+            const id = decodeWorkItemId(key);
+            if (id === undefined)
+                return undefined;
+            const work = await root.projections.read('work', id);
+            if (work === null || work.value === null)
+                return undefined;
+            return readWorkTranscript(root.transcriptStore, id, groupId, await runsForWorkItem(root, id)).then(async (data) => ({ data, meta: await projectionMeta(root.journal, [], now()) }));
+        },
+        async freeze(key, command) {
+            const id = decodeWorkItemId(key);
+            if (id === undefined)
+                throw new Error('Work item not found');
+            await root.work.freeze(id, commandContext(command.idempotencyKey, now));
+            return accepted(command.idempotencyKey, now());
+        },
+        async unfreeze(key, command) {
+            const id = decodeWorkItemId(key);
+            if (id === undefined)
+                throw new Error('Work item not found');
+            await root.work.unfreeze(id, commandContext(command.idempotencyKey, now));
+            return accepted(command.idempotencyKey, now());
+        },
+        async delete(key, command) {
+            const id = decodeWorkItemId(key);
+            if (id === undefined)
+                throw new Error('Work item not found');
+            const context = commandContext(command.idempotencyKey, now);
+            const correlations = await root.resources.correlationsForWork(id);
+            await root.work.delete(id, context);
+            await Promise.all(correlations.map((entry) => root.resources.retract(entry.resourceId, id, context)));
+            return accepted(command.idempotencyKey, now());
+        },
+        async retry(key, command) {
+            const id = decodeWorkItemId(key);
+            if (id === undefined)
+                return retryIneligible('Work item was not found');
+            const work = await root.work.get(id);
+            if (work === null)
+                return retryIneligible('Work item was not found');
+            if (work.deleted === true)
+                return retryIneligible('Work item is deleted');
+            if (work.state !== WorkStatus.Open)
+                return retryIneligible('Work item is not open');
+            const primary = (await root.orchestration.listAll()).find((value) => value.workItemId === id && value.parentWorkflowInstanceId === undefined);
+            if (primary === undefined)
+                return retryIneligible('Work item has no primary workflow');
+            if (!isOperatorRetryEligible(primary))
+                return retryIneligible('Workflow is not retry eligible');
+            try {
+                await root.orchestration.retryBlockedFailedStage(primary.workflowInstanceId, commandContext(command.idempotencyKey, now));
+            }
+            catch (error) {
+                if (error instanceof OperatorRetryIneligibleError)
+                    return retryIneligible(error.message);
+                throw error;
+            }
+            return accepted(command.idempotencyKey, now());
+        },
+    };
+}
+async function workDetail(root, key, now) {
+    const id = decodeWorkItemId(key);
+    if (id === undefined)
+        return undefined;
+    const work = await root.work.get(id);
+    if (work === null)
+        return undefined;
+    const correlations = await root.resources.correlationsForWork(id);
+    const resources = (await Promise.all(correlations.map((item) => root.resources.get(item.resourceId)))).filter((value) => value !== null);
+    const workflows = (await root.orchestration.listAll()).filter((value) => value.workItemId === id);
+    const runs = await runsForWorkItem(root, id, workflows);
+    const pullRequests = await root.projections.list('activities-pr');
+    const pullRequest = pullRequests.find((entry) => resources.some((resource) => resource.resourceId === entry.key));
+    const primary = workflows.find((value) => value.parentWorkflowInstanceId === undefined) ?? null;
+    const externalRef = await primaryExternalRef(root, work.workItemId);
+    const data = {
+        work: { ...presentWorkItem(work), ...(externalRef === undefined ? {} : { externalRef }) },
+        resources: resources.map(presentResource(root.resolveResourceLink)),
+        orchestration: {
+            primary: primary === null ? null : presentWorkflowInstance(primary),
+            children: workflows
+                .filter((value) => value.parentWorkflowInstanceId !== undefined)
+                .map(presentWorkflowInstance),
+        },
+        execution: {
+            runs: await Promise.all(runs.map((run) => withWorkflowContext(root, presentRun(run)))),
+            transcriptGroups: await transcriptGroups(root.transcriptStore, id, runs),
+        },
+        activities: presentPullRequest(pullRequest?.value),
+    };
+    const [projections, correlationFacts] = await Promise.all([
+        contributingProjections(root, id, resources, workflows, runs),
+        contributingResourceCorrelationFacts(root, id),
+    ]);
+    return {
+        data,
+        meta: await projectionMeta(root.journal, [...projections, ...correlationFacts, ...(pullRequest === undefined ? [] : [pullRequest])], now()),
+    };
+}
+async function runsForWorkItem(root, id, workflows) {
+    const matching = workflows ??
+        (await root.projections.list('orchestration'))
+            .flatMap((entry) => (entry.value.view === null ? [] : [entry.value.view]))
+            .filter((workflow) => workflow.workItemId === id);
+    return (await root.projections.list('execution'))
+        .flatMap((entry) => (entry.value.view === null ? [] : [entry.value.view]))
+        .filter((run) => matching.some((workflow) => workflow.workflowInstanceId === run.workflowInstanceId))
+        .sort((left, right) => right.startedAt.localeCompare(left.startedAt));
+}
+function decodeWorkItemId(key) {
+    try {
+        return workItemId(fromWorkItemKey(key));
+    }
+    catch {
+        return undefined;
+    }
+}
+function presentPullRequest(value) {
+    return value == null
+        ? {}
+        : {
+            pullRequest: {
+                resourceId: value.resourceId,
+                state: value.state,
+                headRevision: value.headRevision,
+                baseRevision: value.baseRevision,
+                checks: value.checks,
+            },
+        };
+}
+async function contributingProjections(root, id, resources, workflows, runs) {
+    const records = await Promise.all([
+        root.projections.read('work', id),
+        ...resources.map((value) => root.projections.read('resources', value.resourceId)),
+        ...workflows.map((value) => root.projections.read('orchestration', value.workflowInstanceId)),
+        ...runs.map((value) => root.projections.read('execution', value.runId)),
+    ]);
+    return records.filter((value) => value !== null);
+}
+async function contributingResourceCorrelationFacts(root, id) {
+    const events = await root.journal.readAll(0);
+    return events.flatMap((event) => {
+        const owned = selectResourceEvent(event);
+        if (owned === null)
+            return [];
+        if (owned.eventType !== ResourceEventType.WorkCorrelationEstablished &&
+            owned.eventType !== ResourceEventType.WorkCorrelationRetracted &&
+            owned.eventType !== ResourceEventType.WorkCorrelationConflicted)
+            return [];
+        return owned.payload.workItemId === id ? [{ lastGlobalPosition: owned.globalPosition }] : [];
+    });
+}
+function commandContext(idempotencyKey, now) {
+    const occurredAt = now();
+    return {
+        commandId: `work:${idempotencyKey}`,
+        correlationId: correlationId(`work:${idempotencyKey}`),
+        occurredAt,
+        actor: { kind: EventActorKind.Operator, id: 'web' },
+    };
+}
+function accepted(idempotencyKey, acceptedAt) {
+    return {
+        commandId: `work:${idempotencyKey}`,
+        idempotencyKey,
+        acceptedAt,
+        status: ApiCommandStatus.Accepted,
+    };
+}
+function retryIneligible(detail) {
+    return { conflict: true, code: 'retry-ineligible', detail };
+}

package/dist/src/bootstrap/surface-applications.js

@@ -0,0 +1,7 @@
+import { createSurfaceApiApplications } from './surface-api-applications.js';
+import { createSurfaceCliApplications } from './surface-cli-applications.js';
+export function createSurfaceApplications(root, options = {}) {
+    const now = options.now ?? (() => new Date().toISOString());
+    const api = createSurfaceApiApplications(root, now);
+    return { api, cli: createSurfaceCliApplications(root, api, now) };
+}