cloving 1.2.0 → 1.4.0

package/dist/src/service/command-waits.js

@@ -0,0 +1,86 @@
+import { commandWaitViews, } from "../authority/command-wait-view.js";
+import { commandWaitKey, } from "../authority/command-waits.js";
+import { documentDigest } from "../broker/decision-restore.js";
+import { effectInputDigest } from "../broker/effect-restore.js";
+import { operationDigest } from "../broker/operation-digest.js";
+export async function expireCommandWaits(parts) {
+    for (const wait of Object.values(parts.waits)) {
+        if (wait.state !== "waiting" || Date.parse(parts.now) < wait.deadline)
+            continue;
+        await parts.gateway.execute({
+            principal: "controller",
+            command: {
+                kind: "expire-command-wait",
+                commandId: `expire-wait:${operationDigest(commandWaitKey(wait.runId, wait.name))}`,
+                runId: wait.runId,
+                waitName: wait.name,
+            },
+        });
+    }
+}
+export function commandWaitPort(parts) {
+    const { authority, gateway } = parts;
+    const read = async (wait) => (await authority.state()).commandWaits?.[commandWaitKey(wait.runId, wait.name)];
+    return {
+        read,
+        open: async (wait) => {
+            const declarations = (await authority.queries.manifest(wait.runId))?.commandWaits ?? {};
+            const permission = Object.hasOwn(declarations, wait.name)
+                ? declarations[wait.name]
+                : undefined;
+            if (permission === undefined)
+                return { kind: "rejected", reason: "command-wait-not-declared" };
+            return gateway.execute({
+                principal: "worker",
+                command: {
+                    kind: "open-command-wait",
+                    runId: wait.runId,
+                    commandId: wait.commandId,
+                    waitName: wait.name,
+                    target: permission.command,
+                    maximumWaitSeconds: permission.maximumWaitSeconds,
+                    pollEverySeconds: permission.pollEverySeconds,
+                    payload: documentDigest(wait.input),
+                },
+                documents: [wait.input],
+            });
+        },
+        check: async (call) => {
+            const wait = await read(call);
+            if (wait === undefined)
+                return { kind: "rejected", reason: "unknown-command-wait" };
+            return gateway.execute({
+                principal: "worker",
+                command: {
+                    kind: "check-command-wait",
+                    runId: call.runId,
+                    commandId: call.commandId,
+                    waitName: call.name,
+                    inputDigest: effectInputDigest({
+                        capability: "command",
+                        method: `run:${wait.command}`,
+                        target: wait.command,
+                        payload: wait.inputDigest,
+                    }),
+                },
+            });
+        },
+    };
+}
+function displayTime(time) {
+    return time === null ? null : new Date(time).toISOString();
+}
+export async function commandWaitDisplay(input) {
+    const manifest = await input.authority.queries.manifest(input.runId);
+    return commandWaitViews({
+        ...input,
+        declarations: manifest?.commandWaits ?? {},
+        waits: input.waits ?? {},
+        now: Date.parse(input.now),
+    }).map((wait) => ({
+        ...wait,
+        startedAt: displayTime(wait.startedAt),
+        deadline: displayTime(wait.deadline),
+        nextCheckAt: displayTime(wait.nextCheckAt),
+    }));
+}

package/dist/src/service/decision-handler.d.ts

@@ -5,5 +5,9 @@ export declare function feedbackOf(context: ServiceContext, scope: {
     readonly state: StoredState;
     readonly runId: string;
 }): Promise<readonly Fields[]>;
+export declare function decidedOf(context: ServiceContext, scope: {
+    readonly state: StoredState;
+    readonly runId: string;
+}): Promise<readonly Fields[]>;
 export declare function questions(context: ServiceContext, parameters: Fields): Promise<Reply>;
 export declare function decision(context: ServiceContext, parameters: Fields): Promise<Reply>;

package/dist/src/service/decision-handler.js

@@ -1,5 +1,6 @@
-import { continues, gateKey } from "../authority/gates.js";
-import { gateContinuation } from "../authority/reduction.js";
+import { delivers, gateKey } from "../authority/gates.js";
+import { isDeviceActor } from "../authority/commands.js";
+import { gateDelivery } from "../authority/reduction.js";
 import { documentDigest } from "../broker/decision-restore.js";
 import { committed, failed, invalidRequest, isIdentifier, publicReceipt, rejection, result, wholeNumber, } from "./replies.js";
 const decisions = {
@@ -43,6 +44,25 @@ export async function feedbackOf(context, scope) {
     }
     return shown;
 }
+export async function decidedOf(context, scope) {
+    const decided = typed(scope.state).filter((gate) => gate.runId === scope.runId &&
+        gate.outcome !== null &&
+        gate.outcome.decision !== null);
+    const shown = [];
+    for (const gate of decided) {
+        const page = await context.authority.queries.eventsAfter({
+            after: (gate.outcome?.sequence ?? 1) - 1,
+            limit: 1,
+        });
+        const actor = page.events[0]?.payload["actor"];
+        shown.push({
+            decisionId: decisionId(gate),
+            decision: gate.outcome?.decision ?? null,
+            actor: typeof actor === "string" ? actor : "local",
+        });
+    }
+    return shown;
+}
 async function described(context, shown) {
     const { state, gate } = shown;
     const { queries } = context.authority;
@@ -120,7 +140,20 @@ function textLimit(context, command) {
         ? { bytes: feedbackBytes, name: "A feedback text" }
         : { bytes: context.textBytes, name: "An answer" };
 }
+function actorOf(parameters) {
+    const actor = parameters["actor"] ?? null;
+    if (actor === null)
+        return null;
+    return isDeviceActor(actor) ? actor : undefined;
+}
 function decisionRequest(parameters) {
+    const actor = actorOf(parameters);
+    const fields = decisionFields(parameters);
+    if (actor === undefined || fields === undefined)
+        return undefined;
+    return { ...fields, actor };
+}
+function decisionFields(parameters) {
     const { command, reference, expectedRevision, generation } = parameters;
     const { subjectDigest, commandId } = parameters;
     const text = parameters["text"] ?? null;
@@ -183,6 +216,7 @@ export async function decision(context, parameters) {
             generation: request.generation,
             subject: request.subjectDigest,
             ...(text === null ? {} : { answer: documentDigest(text) }),
+            ...(request.actor === null ? {} : { actor: request.actor }),
         },
         documents: text === null ? [] : [text],
     });
@@ -203,9 +237,9 @@ export async function decision(context, parameters) {
 }
 async function continuationState(context, decided) {
     const { gate, run } = decided;
-    if (!continues(gate))
+    if (!delivers(gate))
         return "held";
-    const { operationId } = gateContinuation(gate);
+    const { operationId } = gateDelivery(gate);
     const operation = (await context.authority.operations()).find((item) => item.operationId === operationId);
     if (operation?.deliveries.some((delivery) => delivery.outcome === "sent"))
         return "admitted";
@@ -224,6 +258,7 @@ async function recorded(context, outcome) {
         decisionId: decisionId(gate),
         runId,
         decision: gate.outcome?.decision ?? null,
+        actor: stored.command.actor ?? null,
         commandId,
         replayed: outcome.replayed,
         receipt: publicReceipt(stored),

package/dist/src/service/expiry.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { setTimeout as delay } from "node:timers/promises";
 import { notBefore } from "../authority/instants.js";
 import { operationDigest } from "../broker/operation-digest.js";
+import { expireCommandWaits } from "./command-waits.js";
 function expiryIdentity(runId, gateId) {
     return `expire:${createHash("sha256").update(`${runId} ${gateId}`).digest("hex").slice(0, 32)}`;
 }
@@ -9,6 +10,7 @@ async function scanned(parts) {
     const { authority, gateway, clock } = parts;
     const state = await authority.state();
     const now = clock();
+    await expireCommandWaits({ waits: state.commandWaits ?? {}, gateway, now });
     const due = Object.values(state.gates).filter((gate) => gate.outcome === null &&
         gate.expiresAt !== null &&
         notBefore(now, gate.expiresAt) &&

package/dist/src/service/gateway.js

@@ -1,5 +1,6 @@
 import { invalidCommand, serializable, textList, unserializable, } from "../broker/actor/authority-receipts.js";
 import { record } from "../protocol.js";
+import { commandLimits } from "../command-settings.js";
 export const workerCommandBound = 1_000;
 const permitted = {
     operator: [
@@ -10,6 +11,9 @@ const permitted = {
         "cancel-run",
     ],
     worker: [
+        "open-command-wait",
+        "check-command-wait",
+        "record-schedule-skip",
         "mark-started",
         "open-gate",
         "register-wait",
@@ -19,7 +23,7 @@ const permitted = {
         "request-effect",
         "report-effect",
     ],
-    controller: ["expire-gate", "expire-lease"],
+    controller: ["expire-gate", "expire-lease", "expire-command-wait"],
 };
 const pinned = ["decide-gate", "resume-run"];
 function denied(principal, subject) {
@@ -64,8 +68,17 @@ function refusal(submission, textBytes) {
         };
     return undefined;
 }
+async function reportLimit(parts, submission) {
+    if (submission.command["kind"] !== "report-effect" ||
+        !submission.documents.some((text) => Buffer.byteLength(text) > parts.textBytes))
+        return parts.textBytes;
+    const operation = await parts.authority.effects.operation(String(submission.command["operationId"]));
+    return operation?.capability === "command"
+        ? commandLimits.resultBytes
+        : parts.textBytes;
+}
 export function commandGateway(parts) {
-    const { authority, registry, clock, textBytes } = parts;
+    const { authority, registry, clock } = parts;
     const bound = parts.pendingWorkerCommands ?? workerCommandBound;
     let pending = 0;
     async function manifest(command) {
@@ -74,7 +87,11 @@ export function commandGateway(parts) {
             return registry.byPin(String(command["workflow"]))?.manifest;
         if (!pinned.includes(kind))
             return undefined;
-        const run = (await authority.state()).runs[String(command["runId"])];
+        const runId = String(command["runId"]);
+        const stored = await authority.queries.manifest(runId);
+        if (stored?.bundleDigest !== undefined)
+            return stored;
+        const run = (await authority.state()).runs[runId];
         return registry.byPin(run?.workflow ?? "")?.manifest;
     }
     async function forwarded(submission) {
@@ -109,7 +126,7 @@ export function commandGateway(parts) {
             const submission = checked(given.principal, copy);
             if (submission === undefined)
                 return invalidCommand;
-            const refused = refusal(submission, textBytes);
+            const refused = refusal(submission, await reportLimit(parts, submission));
             if (refused !== undefined)
                 return refused;
             return submission.principal === "worker"

package/dist/src/service/queue-spend.d.ts

@@ -0,0 +1,6 @@
+import type { Fields } from "../protocol.ts";
+import type { ServiceContext } from "./replies.ts";
+type SpendContext = Pick<ServiceContext, "authority" | "clock" | "queueDailySpendLimitUsd">;
+export declare function queueRun(context: Pick<ServiceContext, "authority">, runId: string): Promise<boolean>;
+export declare function queueSpend(context: SpendContext): Promise<Fields>;
+export {};

package/dist/src/service/queue-spend.js

@@ -0,0 +1,68 @@
+import { queueSpending } from "../queue-spend.js";
+import { priceOf } from "../worker-usage.js";
+import { reportFields } from "./worker-totals.js";
+export async function queueRun(context, runId) {
+    const { queries } = context.authority;
+    if ((await queries.manifest(runId))?.queue === true)
+        return true;
+    if ((await queries.workflowIds([runId]))[runId] !== "develop-issue")
+        return false;
+    const { events } = await queries.eventsAfter({ runId, after: 0, limit: 1 });
+    return (events[0]?.type === "run.created" &&
+        events[0].payload["resolver"] === "issue-command:1");
+}
+export async function queueSpend(context) {
+    const limitUsd = context.queueDailySpendLimitUsd;
+    if (limitUsd === undefined)
+        return {};
+    const now = Date.parse(context.clock());
+    const operations = await context.authority.effects.workerTurns({
+        after: new Date(now - 24 * 3_600_000).toISOString(),
+        through: new Date(now).toISOString(),
+    });
+    const runIds = [...new Set(operations.map((operation) => operation.runId))];
+    const costs = [];
+    const totals = {
+        costs,
+        unknownTurns: 0,
+        turnsInWork: 0,
+    };
+    const queued = new Set();
+    for (const runId of runIds) {
+        if (await queueRun(context, runId))
+            queued.add(runId);
+    }
+    for (const operation of operations) {
+        if (queued.has(operation.runId))
+            await countTurn(context, { operation, totals });
+    }
+    const spending = queueSpending(totals.costs, limitUsd);
+    const spentUsd = totals.costs.length === 0 && totals.unknownTurns > 0
+        ? null
+        : spending.spentUsd;
+    return {
+        spend: {
+            limitUsd,
+            spentUsd,
+            unknownTurns: totals.unknownTurns,
+            turnsInWork: totals.turnsInWork,
+            windowHours: 24,
+            holding: spentUsd !== null && spending.holding,
+        },
+    };
+}
+async function countTurn(context, turn) {
+    const { operation, totals } = turn;
+    if (operation.settledSequence === null) {
+        totals.turnsInWork += 1;
+        return;
+    }
+    const report = reportFields(operation.result === null
+        ? undefined
+        : await context.authority.queries.document(operation.result));
+    const cost = priceOf(report["costUsd"]) ?? priceOf(report["estimatedCostUsd"]);
+    if (cost === null)
+        totals.unknownTurns += 1;
+    else
+        totals.costs.push(cost);
+}

package/dist/src/service/registry.d.ts

@@ -1,6 +1,11 @@
-import type { WorkflowStage, WorkflowStages } from "../workflow-declaration.ts";
+import type { CommandWaits, WorkflowStage, WorkflowStages } from "../workflow-declaration.ts";
 import type { SubmissionContract } from "../submission.ts";
 import type { ExecutionManifest } from "../workflow-admission.ts";
+import type { AvailableManifest } from "../broker/actor/delivery-intents.ts";
+export interface WorkflowBundleStore {
+    readonly directory: string;
+    readonly repository: string;
+}
 export type Resolution = {
     readonly kind: "resolved";
     readonly input: unknown;
@@ -23,6 +28,7 @@ export interface Resolver {
     readonly skippedTickets?: () => readonly Readonly<Record<string, unknown>>[];
 }
 export interface WorkflowRegistration {
+    readonly queue?: boolean;
     readonly workflowId: string;
     readonly manifest: ExecutionManifest;
     readonly availability: "available" | "unavailable";
@@ -31,6 +37,8 @@ export interface WorkflowRegistration {
     readonly effectLimit?: number;
     readonly stages?: readonly WorkflowStage[];
     readonly handoffs?: readonly string[];
+    readonly commands?: readonly string[];
+    readonly commandWaits?: CommandWaits;
     readonly admission?: "when-idle" | number;
 }
 export interface Registered extends WorkflowRegistration {
@@ -41,6 +49,11 @@ export interface Registry {
     readonly workflowStages: WorkflowStages;
     readonly byId: (workflowId: string) => Registered | undefined;
     readonly byPin: (pin: string) => Registered | undefined;
-    readonly available: (pinned: ExecutionManifest) => ExecutionManifest | undefined;
+    readonly bundle: (pinned: ExecutionManifest) => Promise<string | undefined>;
+    readonly available: AvailableManifest;
 }
-export declare function workflowRegistry(workflows: readonly WorkflowRegistration[], retainedWorkflows?: readonly WorkflowRegistration[]): Registry;
+export declare function workflowRegistry(workflows: readonly WorkflowRegistration[], options?: {
+    readonly retainedWorkflows?: readonly WorkflowRegistration[];
+    readonly workflowBundles?: WorkflowBundleStore;
+    readonly retainedWorkflow?: AvailableManifest;
+}): Registry;

package/dist/src/service/registry.js

@@ -1,5 +1,6 @@
 import { workflowPin } from "../broker/workflow-pin.js";
 import { declaredManifest } from "../execution-pin.js";
+import { readRetainedWorkflowBundle } from "../../tools/workflow-bundles.js";
 function registered(workflow) {
     const manifest = declaredManifest(workflow.manifest, workflow);
     return {
@@ -9,10 +10,32 @@ function registered(workflow) {
         pin: workflowPin(manifest),
     };
 }
-export function workflowRegistry(workflows, retainedWorkflows = []) {
+function availableVersions(workflow) {
+    if (workflow.availability !== "available")
+        return [];
+    if (workflow.manifest.bundleDigest === undefined)
+        return [workflow];
+    const manifest = { ...workflow.manifest };
+    delete manifest.bundleDigest;
+    return [workflow, { ...workflow, manifest, pin: workflowPin(manifest) }];
+}
+export function workflowRegistry(workflows, options = {}) {
     const current = workflows.map(registered);
-    const available = [...current, ...retainedWorkflows.map(registered)].filter((workflow) => workflow.availability === "available");
+    const available = [
+        ...current,
+        ...(options.retainedWorkflows ?? []).map(registered),
+    ].flatMap(availableVersions);
     const byPin = (pin) => available.find((workflow) => workflow.pin === pin);
+    const bundle = async (pinned) => {
+        if (pinned.bundleDigest === undefined ||
+            options.workflowBundles === undefined)
+            return undefined;
+        const retained = await readRetainedWorkflowBundle({
+            ...options.workflowBundles,
+            id: pinned.bundleDigest,
+        });
+        return retained.kind === "available" ? retained.directory : undefined;
+    };
     return {
         workflowIds: current.map((workflow) => workflow.workflowId),
         workflowStages: Object.fromEntries(current.flatMap((workflow) => workflow.stages === undefined
@@ -20,6 +43,14 @@ export function workflowRegistry(workflows, retainedWorkflows = []) {
             : [[workflow.workflowId, workflow.stages]])),
         byId: (workflowId) => current.find((workflow) => workflow.workflowId === workflowId),
         byPin,
-        available: (pinned) => byPin(workflowPin(pinned))?.manifest,
+        bundle,
+        available: (pinned) => {
+            const manifest = byPin(workflowPin(pinned))?.manifest;
+            if (pinned.bundleDigest === undefined)
+                return manifest;
+            return bundle(pinned).then((directory) => directory !== undefined
+                ? (manifest ?? options.retainedWorkflow?.(pinned))
+                : undefined);
+        },
     };
 }

package/dist/src/service/replies.d.ts

@@ -1,10 +1,16 @@
+import type { SchedulePort } from "../schedule-progress.ts";
 import type { Authority, CommandRecord, StoreReceipt } from "../broker/actor/authority.ts";
 import type { Fields, Reply } from "../protocol.ts";
 import type { ChangeSignal } from "./changes.ts";
 import type { Gateway } from "./gateway.ts";
 import type { Registry } from "./registry.ts";
-import type { WorkflowRefusal } from "../workflow-refusals.ts";
+import { type WorkflowRefusal } from "../workflow-refusals.ts";
+import type { CommandEffects } from "../command-settings.ts";
 export interface ServiceContext {
+    readonly schedule?: SchedulePort;
+    readonly queueDailySpendLimitUsd?: number;
+    readonly workerHarness?: (operationId: string) => Promise<string | undefined>;
+    readonly commandEffects?: CommandEffects;
     readonly authority: Authority;
     readonly registry: Registry;
     readonly workflowRefusals?: readonly WorkflowRefusal[];
@@ -18,6 +24,13 @@ export interface ServiceContext {
     readonly worldReports?: () => readonly unknown[];
     readonly changed?: ChangeSignal["next"];
 }
+export declare function queryMetadata(options: {
+    readonly schedule?: SchedulePort;
+    readonly queueDailySpendLimitUsd?: number;
+    readonly workerHarness?: ServiceContext["workerHarness"];
+    readonly commandEffects?: CommandEffects;
+    readonly workflowRefusals?: readonly WorkflowRefusal[];
+}): Pick<ServiceContext, "schedule" | "workerHarness" | "commandEffects" | "workflowRefusals" | "queueDailySpendLimitUsd">;
 export declare function result(kind: string, fields: Fields): Reply;
 export declare function failed(code: string, extra: Fields): Reply;
 export declare function invalidRequest(detail: string): Reply;
@@ -26,3 +39,5 @@ export declare function committed(receipt: StoreReceipt): boolean;
 export declare function isIdentifier(value: unknown): value is string;
 export declare function wholeNumber(value: unknown, minimum: number): value is number;
 export declare function publicReceipt(record: CommandRecord): Fields;
+export declare function scheduleRequest(context: ServiceContext, parameters: Fields): Promise<Reply>;
+export declare function errorMessage(error: unknown): string;

package/dist/src/service/replies.js

@@ -1,4 +1,20 @@
 import { isRecordKey } from "../authority/commands.js";
+import { workflowRefusals, } from "../workflow-refusals.js";
+export function queryMetadata(options) {
+    return {
+        ...(options.schedule === undefined ? {} : { schedule: options.schedule }),
+        ...(options.queueDailySpendLimitUsd === undefined
+            ? {}
+            : { queueDailySpendLimitUsd: options.queueDailySpendLimitUsd }),
+        ...(options.workerHarness === undefined
+            ? {}
+            : { workerHarness: options.workerHarness }),
+        ...(options.commandEffects === undefined
+            ? {}
+            : { commandEffects: options.commandEffects }),
+        workflowRefusals: workflowRefusals(options.workflowRefusals),
+    };
+}
 const codes = {
     "invalid-command": "invalid-request",
     "request-too-large": "input-too-large",
@@ -54,3 +70,10 @@ export function publicReceipt(record) {
         commandDigest: record.commandDigest,
     };
 }
+export function scheduleRequest(context, parameters) {
+    return (context.schedule?.(parameters) ??
+        Promise.resolve(failed("schedules-unavailable", {})));
+}
+export function errorMessage(error) {
+    return String(Reflect.get(Object(error), "message"));
+}