cloving 1.4.0 → 1.5.0

package/dist/src/service/workflow-reload.js

@@ -0,0 +1,52 @@
+import { failed, result } from "./replies.js";
+export function workflowFields(context) {
+    const inventory = context.workflowCatalog?.inventory();
+    const stages = context.registry.workflowStages;
+    return {
+        ...(inventory?.bundleDigest === undefined
+            ? {}
+            : { bundleDigest: inventory.bundleDigest }),
+        workflows: context.registry.workflowIds,
+        workflowRefusals: inventory?.workflowRefusals ?? [],
+        ...(Object.keys(stages).length === 0 ? {} : { workflowStages: stages }),
+    };
+}
+function applied(catalog, reload) {
+    if (reload.kind === "refused")
+        return failed(reload.code, { detail: reload.detail });
+    const previousBundleDigest = catalog.inventory().bundleDigest ?? null;
+    if (reload.kind === "reloaded")
+        catalog.replace(reload);
+    else
+        catalog.replaceRefusals(reload.workflowRefusals);
+    return result("reload", {
+        status: reload.kind,
+        previousBundleDigest,
+        bundleDigest: reload.kind === "reloaded" ? reload.bundleDigest : previousBundleDigest,
+        workflows: catalog.registry.workflowIds,
+        workflowRefusals: reload.workflowRefusals,
+        reloadedFields: reload.reloadedFields,
+        restartFields: reload.restartFields,
+    });
+}
+export function reloadOperation(parts) {
+    let reloading = false;
+    return async () => {
+        if (reloading)
+            return failed("reload-in-progress", {
+                detail: "A reload is in work. Wait for its reply.",
+            });
+        reloading = true;
+        try {
+            return applied(parts.catalog, await parts.port());
+        }
+        finally {
+            reloading = false;
+        }
+    };
+}
+export function reloadUnavailable() {
+    return Promise.resolve(failed("reload-unavailable", {
+        detail: "This service cannot reload the workflow files. Restart it to read them.",
+    }));
+}

package/dist/src/storage/decision-snapshots.d.ts

@@ -6,7 +6,7 @@ export interface ProjectionSnapshot extends ProjectionRows, DecisionRows {
     readonly deliveries: readonly AttemptRow[];
     readonly pending: readonly string[];
     readonly sequence: number;
-    readonly waits?: readonly CommandWaitRow[];
+    readonly waits: readonly CommandWaitRow[];
 }
 export interface DecidedSnapshot extends DomainSnapshot, DecisionRows {
     readonly documents: readonly DocumentRow[];
@@ -17,7 +17,6 @@ export interface EffectedSnapshot extends DecidedSnapshot {
 export interface CurrentSnapshot extends EffectedSnapshot {
     readonly waits: readonly CommandWaitRow[];
 }
-export declare function loadOperationSnapshot(connection: SqlConnection): Promise<Pick<ProjectionSnapshot, "outbox" | "deliveries">>;
 export declare function loadProjections(connection: SqlConnection): Promise<ProjectionSnapshot>;
 export declare function loadDecided(connection: SqlConnection): Promise<DecidedSnapshot>;
 export declare function loadEffected(connection: SqlConnection): Promise<EffectedSnapshot>;

package/dist/src/storage/decision-snapshots.js

@@ -1,13 +1,7 @@
 import { loadCommandWaits } from "./command-wait-rows.js";
 import { loadDecisions, loadDocuments, } from "./decision-rows.js";
-import { latestSequence, loadAttempts, loadSnapshot, outboxRow, projectionRows, text, } from "./domain-rows.js";
+import { latestSequence, loadAttempts, loadSnapshot, projectionRows, text, } from "./domain-rows.js";
 import { loadEffects } from "./effect-rows.js";
-export async function loadOperationSnapshot(connection) {
-    return {
-        outbox: (await connection.all("SELECT operation_id, kind, run_id, created_sequence, released_sequence FROM outbox ORDER BY created_sequence, rowid")).map(outboxRow),
-        deliveries: await loadAttempts(connection),
-    };
-}
 export async function loadProjections(connection) {
     return {
         waits: await loadCommandWaits(connection),

package/dist/src/storage/domain-changes.d.ts

@@ -43,7 +43,7 @@ export interface DomainChange extends EffectRows {
     readonly documents: readonly DocumentRow[];
     readonly completesAdoption: boolean;
 }
-export declare function persistChange(value: unknown, connection: SqlConnection): Promise<void>;
+export declare function persistChange(value: unknown, connection: SqlConnection): Promise<DomainChange>;
 export declare function gateParameters(row: GateRow): readonly unknown[];
 export declare function detailParameters(row: DetailRow): readonly unknown[];
 export declare function decisionStatements(change: Pick<DomainChange, "gates" | "details" | "documents">): readonly Statement[];

package/dist/src/storage/domain-changes.js

@@ -10,6 +10,7 @@ export async function persistChange(value, connection) {
         throw new Error("stale-authority-sequence");
     for (const statement of statements(change))
         await connection.run(statement.sql, statement.parameters);
+    return change;
 }
 function statements(change) {
     return [

package/dist/src/storage/domain-schema.d.ts

@@ -6,7 +6,8 @@ export declare const effectedVersion = 4;
 export declare const waitingVersion = 5;
 export declare const checkedVersion = 6;
 export declare const spendingVersion = 7;
-export declare const currentVersion = 8;
+export declare const eventIndexVersion = 8;
+export declare const currentVersion = 9;
 export declare const baselineSchema = "\nCREATE TABLE schema_migrations (\n  version INTEGER PRIMARY KEY,\n  checksum TEXT NOT NULL\n) STRICT;\nCREATE TABLE events (\n  sequence INTEGER PRIMARY KEY,\n  type TEXT NOT NULL,\n  run_id TEXT NOT NULL,\n  command_id TEXT NOT NULL UNIQUE,\n  recorded_at TEXT NOT NULL,\n  request TEXT NOT NULL,\n  payload TEXT NOT NULL\n) STRICT;\nCREATE TABLE definitions (\n  pin TEXT PRIMARY KEY,\n  manifest TEXT NOT NULL\n) STRICT;\nCREATE TABLE runs (\n  run_id TEXT PRIMARY KEY,\n  status TEXT NOT NULL,\n  revision INTEGER NOT NULL,\n  workflow TEXT NOT NULL REFERENCES definitions (pin) DEFERRABLE INITIALLY DEFERRED,\n  paused_from TEXT,\n  gates TEXT NOT NULL,\n  sequence INTEGER NOT NULL REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED\n) STRICT;\nCREATE TABLE commands (\n  command_id TEXT PRIMARY KEY,\n  request TEXT NOT NULL,\n  sequence INTEGER NOT NULL UNIQUE REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED\n) STRICT;\nCREATE TABLE outbox (\n  operation_id TEXT PRIMARY KEY,\n  kind TEXT NOT NULL,\n  run_id TEXT NOT NULL REFERENCES runs (run_id) DEFERRABLE INITIALLY DEFERRED,\n  created_sequence INTEGER NOT NULL REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED,\n  released_sequence INTEGER REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED\n) STRICT;\n";
 export type SchemaRefusal = {
     readonly kind: "refused";
@@ -29,6 +30,8 @@ export type SchemaState = {
     readonly kind: "checked";
 } | {
     readonly kind: "indexed";
+} | {
+    readonly kind: "event-indexed";
 } | {
     readonly kind: "current";
 } | SchemaRefusal;

package/dist/src/storage/domain-schema.js

@@ -2,7 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { DatabaseSync } from "node:sqlite";
 import { integer, optionalInteger, optionalText, text, } from "./domain-rows.js";
 import { commandWaitSchema, commandWaitCheckSchema, } from "./command-wait-rows.js";
-import { effectSchema, spendingIndexes } from "./effect-schema.js";
+import { effectSchema, runIndexes, spendingIndexes } from "./effect-schema.js";
 export const baselineVersion = 1;
 export const adoptedVersion = 2;
 export const decidedVersion = 3;
@@ -10,7 +10,8 @@ export const effectedVersion = 4;
 export const waitingVersion = 5;
 export const checkedVersion = 6;
 export const spendingVersion = 7;
-export const currentVersion = 8;
+export const eventIndexVersion = 8;
+export const currentVersion = 9;
 export const baselineSchema = `
 CREATE TABLE schema_migrations (
   version INTEGER PRIMARY KEY,
@@ -116,6 +117,7 @@ const schemas = [
     commandWaitCheckSchema,
     spendingIndexes,
     "CREATE INDEX events_run_type_sequence ON events (run_id, type, sequence);",
+    runIndexes,
 ];
 const checksums = schemas.map((schema) => createHash("sha256").update(schema).digest("hex"));
 const versionKinds = [
@@ -126,6 +128,7 @@ const versionKinds = [
     "waiting",
     "checked",
     "indexed",
+    "event-indexed",
     "current",
 ];
 export async function inspectSchema(connection) {
@@ -159,6 +162,7 @@ export async function createSchema(connection) {
     await upgradeSchema(connection, waitingVersion);
     await upgradeSchema(connection, checkedVersion);
     await upgradeSchema(connection, spendingVersion);
+    await upgradeSchema(connection, eventIndexVersion);
     await upgradeSchema(connection, currentVersion);
 }
 export async function upgradeSchema(connection, version) {

package/dist/src/storage/effect-schema.d.ts

@@ -1,2 +1,3 @@
 export declare const effectSchema = "\nCREATE TABLE run_budgets (\n  run_id TEXT PRIMARY KEY REFERENCES runs (run_id) DEFERRABLE INITIALLY DEFERRED,\n  effect_limit INTEGER NOT NULL,\n  spent INTEGER NOT NULL CHECK (spent <= effect_limit),\n  capabilities TEXT NOT NULL,\n  exhausted_sequence INTEGER REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED\n) STRICT;\nCREATE TABLE operations (\n  operation_id TEXT PRIMARY KEY,\n  run_id TEXT NOT NULL REFERENCES runs (run_id) DEFERRABLE INITIALLY DEFERRED,\n  capability TEXT NOT NULL,\n  method TEXT NOT NULL,\n  target TEXT NOT NULL,\n  payload TEXT NOT NULL,\n  input_digest TEXT NOT NULL,\n  units INTEGER NOT NULL,\n  lease_key TEXT NOT NULL,\n  recovery_limit INTEGER NOT NULL,\n  status TEXT NOT NULL,\n  reason TEXT,\n  attempts INTEGER NOT NULL,\n  receipt TEXT,\n  worker TEXT,\n  result TEXT,\n  requested_sequence INTEGER NOT NULL REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED,\n  wait_sequence INTEGER REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED,\n  settled_sequence INTEGER REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED\n) STRICT;\nCREATE INDEX operations_run ON operations (run_id);\nCREATE INDEX operations_waiting ON operations (wait_sequence) WHERE status = 'waiting';\nCREATE TABLE leases (\n  resource_key TEXT PRIMARY KEY,\n  operation_id TEXT NOT NULL REFERENCES operations (operation_id) DEFERRABLE INITIALLY DEFERRED,\n  generation INTEGER NOT NULL CHECK (generation > 0),\n  expires_at TEXT NOT NULL,\n  state TEXT NOT NULL CHECK (state IN ('held', 'expired', 'released')),\n  granted_sequence INTEGER NOT NULL REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED\n) STRICT;\nCREATE INDEX leases_due ON leases (expires_at) WHERE state = 'held';\nCREATE TABLE effect_evidence (\n  sequence INTEGER PRIMARY KEY REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED,\n  run_id TEXT NOT NULL,\n  operation_id TEXT NOT NULL,\n  disposition TEXT NOT NULL,\n  reason TEXT\n) STRICT;\nCREATE TABLE stopped_operations (\n  operation_id TEXT PRIMARY KEY,\n  run_id TEXT NOT NULL REFERENCES runs (run_id) DEFERRABLE INITIALLY DEFERRED,\n  sequence INTEGER NOT NULL REFERENCES events (sequence) DEFERRABLE INITIALLY DEFERRED\n) STRICT;\nCREATE TABLE dispatch_attempts (\n  effect_id TEXT PRIMARY KEY REFERENCES deliveries (effect_id) DEFERRABLE INITIALLY DEFERRED,\n  purpose TEXT NOT NULL,\n  lease_generation INTEGER,\n  authority_epoch INTEGER NOT NULL\n) STRICT;\n";
 export declare const spendingIndexes = "\nCREATE INDEX events_spend_window ON events (julianday(recorded_at));\nCREATE INDEX operations_worker_settled ON operations (settled_sequence) WHERE capability = 'claude';\nCREATE INDEX operations_worker_open ON operations (requested_sequence) WHERE capability = 'claude' AND settled_sequence IS NULL AND status NOT IN ('refused', 'completed', 'failed', 'stopped', 'cancelled');\n";
+export declare const runIndexes = "\nCREATE INDEX effect_evidence_run_sequence ON effect_evidence (run_id, sequence);\nCREATE INDEX stopped_operations_run ON stopped_operations (run_id);\n";

package/dist/src/storage/effect-schema.js

@@ -62,3 +62,7 @@ CREATE INDEX events_spend_window ON events (julianday(recorded_at));
 CREATE INDEX operations_worker_settled ON operations (settled_sequence) WHERE capability = 'claude';
 CREATE INDEX operations_worker_open ON operations (requested_sequence) WHERE capability = 'claude' AND settled_sequence IS NULL AND status NOT IN ('refused', 'completed', 'failed', 'stopped', 'cancelled');
 `;
+export const runIndexes = `
+CREATE INDEX effect_evidence_run_sequence ON effect_evidence (run_id, sequence);
+CREATE INDEX stopped_operations_run ON stopped_operations (run_id);
+`;

package/dist/src/storage/projection-changes.d.ts

@@ -0,0 +1,12 @@
+import type { ProjectionSnapshot } from "./decision-snapshots.ts";
+import type { DomainChange } from "./domain-changes.ts";
+import type { EventRow } from "./domain-rows.ts";
+import type { OperationRow } from "./effect-rows.ts";
+export declare function binaryOrder(left: string, right: string): number;
+export interface ProjectedChange extends Pick<DomainChange, "previous" | "sequence" | "definitions" | "runs" | "commands" | "added" | "released" | "staged" | "closed" | "gates" | "details" | "waits"> {
+    readonly events: readonly Pick<EventRow, "sequence" | "recordedAt">[];
+    readonly operations: readonly Pick<OperationRow, "operationId" | "status">[];
+}
+export declare function projectedChange(change: DomainChange): ProjectedChange;
+export declare function followingSequence(sequence: number, change: Pick<ProjectedChange, "events">): number;
+export declare function changedProjection(snapshot: ProjectionSnapshot, changes: readonly ProjectedChange[]): ProjectionSnapshot;

package/dist/src/storage/projection-changes.js

@@ -0,0 +1,194 @@
+export function binaryOrder(left, right) {
+    return Buffer.compare(Buffer.from(left), Buffer.from(right));
+}
+function upserted(rows, upsert) {
+    if (upsert.rows.length === 0)
+        return rows;
+    const next = [...rows];
+    const positions = new Map(next.map((row, index) => [upsert.key(row), index]));
+    for (const row of upsert.rows) {
+        const key = upsert.key(row);
+        const position = positions.get(key) ?? next.length;
+        positions.set(key, position);
+        next[position] = row;
+    }
+    return next.sort(upsert.order);
+}
+function definitions(rows, added) {
+    const known = new Set(rows.map((row) => row.pin));
+    const fresh = added.filter((row) => {
+        if (known.has(row.pin))
+            return false;
+        known.add(row.pin);
+        return true;
+    });
+    return upserted(rows, {
+        rows: fresh,
+        key: (row) => row.pin,
+        order: (left, right) => binaryOrder(left.pin, right.pin),
+    });
+}
+function runs(rows, change) {
+    return upserted(rows, {
+        rows: change,
+        key: (row) => row.runId,
+        order: (left, right) => binaryOrder(left.runId, right.runId),
+    });
+}
+function commands(rows, added) {
+    if (added.length === 0)
+        return rows;
+    return [...rows, ...added].sort((left, right) => left.sequence - right.sequence);
+}
+function appendGuarded(table, entry) {
+    const key = table.key(entry.row);
+    if (entry.open)
+        table.open.set(key, [...(table.open.get(key) ?? []), table.rows.length]);
+    table.rows.push(entry.row);
+}
+function guarded(rows, fields) {
+    const table = { rows: [], open: new Map(), key: fields.key };
+    for (const row of rows)
+        appendGuarded(table, { row, open: fields.open(row) });
+    return table;
+}
+function settleGuarded(table, settlement) {
+    for (const index of table.open.get(settlement.key) ?? []) {
+        const row = table.rows[index];
+        if (row === undefined)
+            continue;
+        table.rows[index] = settlement.update(row);
+    }
+    table.open.delete(settlement.key);
+}
+function outbox(rows, changes) {
+    if (changes.every((change) => change.added.length + change.released.length === 0))
+        return rows;
+    const table = guarded(rows, {
+        key: (row) => row.operationId,
+        open: (row) => row.releasedSequence === null,
+    });
+    for (const change of changes) {
+        for (const row of change.added)
+            appendGuarded(table, {
+                row: { ...row, releasedSequence: null },
+                open: true,
+            });
+        for (const { operationId, releasedSequence } of change.released)
+            settleGuarded(table, {
+                key: operationId,
+                update: (row) => ({ ...row, releasedSequence }),
+            });
+    }
+    return table.rows.sort((left, right) => left.createdSequence - right.createdSequence);
+}
+function stagedAttempt(row, sequence) {
+    return {
+        effectId: row.effectId,
+        operationId: row.operationId,
+        inputDigest: row.inputDigest,
+        stagedSequence: sequence,
+        outcome: null,
+        receipt: null,
+        purpose: row.purpose,
+        leaseGeneration: row.leaseGeneration,
+        epoch: row.authorityEpoch,
+    };
+}
+function deliveries(rows, changes) {
+    if (changes.every((change) => change.closed.length + change.staged.length === 0))
+        return rows;
+    const table = guarded(rows, {
+        key: (row) => row.effectId,
+        open: (row) => row.outcome === null,
+    });
+    for (const change of changes) {
+        for (const { effectId, outcome, receipt } of change.closed)
+            settleGuarded(table, {
+                key: effectId,
+                update: (row) => ({ ...row, outcome, receipt }),
+            });
+        for (const row of change.staged)
+            appendGuarded(table, {
+                row: stagedAttempt(row, change.sequence),
+                open: true,
+            });
+    }
+    return table.rows.sort((left, right) => left.stagedSequence - right.stagedSequence);
+}
+function gates(rows, change) {
+    return upserted(rows, {
+        rows: change,
+        key: (row) => JSON.stringify([row.runId, row.gateId]),
+        order: (left, right) => left.openedSequence - right.openedSequence ||
+            binaryOrder(left.gateId, right.gateId),
+    });
+}
+function details(rows, change) {
+    return upserted(rows, {
+        rows: change,
+        key: (row) => row.runId,
+        order: (left, right) => binaryOrder(left.runId, right.runId),
+    });
+}
+function waits(rows, change) {
+    return upserted(rows, {
+        rows: change,
+        key: (row) => JSON.stringify([row.runId, row.name]),
+        order: (left, right) => binaryOrder(left.runId, right.runId) ||
+            binaryOrder(left.name, right.name),
+    });
+}
+function pending(operations, change) {
+    if (change.length === 0)
+        return operations;
+    const next = new Set(operations);
+    for (const row of change)
+        if (row.status === "dispatch-pending")
+            next.add(row.operationId);
+        else
+            next.delete(row.operationId);
+    return [...next].sort(binaryOrder);
+}
+export function projectedChange(change) {
+    return {
+        previous: change.previous,
+        sequence: change.sequence,
+        definitions: change.definitions,
+        events: change.events.map(({ sequence, recordedAt }) => ({
+            sequence,
+            recordedAt,
+        })),
+        runs: change.runs,
+        commands: change.commands,
+        added: change.added,
+        released: change.released,
+        staged: change.staged,
+        closed: change.closed,
+        gates: change.gates,
+        details: change.details,
+        waits: change.waits,
+        operations: change.operations.map(({ operationId, status }) => ({
+            operationId,
+            status,
+        })),
+    };
+}
+export function followingSequence(sequence, change) {
+    return Math.max(sequence, ...change.events.map((event) => event.sequence));
+}
+export function changedProjection(snapshot, changes) {
+    const rows = (select) => changes.flatMap(select);
+    return {
+        definitions: definitions(snapshot.definitions, rows((change) => change.definitions)),
+        runs: runs(snapshot.runs, rows((change) => change.runs)),
+        commands: commands(snapshot.commands, rows((change) => change.commands)),
+        outbox: outbox(snapshot.outbox, changes),
+        gates: gates(snapshot.gates, rows((change) => change.gates)),
+        details: details(snapshot.details, rows((change) => change.details)),
+        waits: waits(snapshot.waits, rows((change) => change.waits)),
+        deliveries: deliveries(snapshot.deliveries, changes),
+        pending: pending(snapshot.pending, rows((change) => change.operations)),
+        sequence: changes.reduce(followingSequence, snapshot.sequence),
+    };
+}

package/dist/src/storage/projection-lookups.d.ts

@@ -0,0 +1,7 @@
+import { type SqlConnection } from "./domain-rows.ts";
+export type MessageOutcome = "committed" | "rolled-back" | "missing";
+export declare function messageOutcomes(connection: SqlConnection, messageIds: readonly string[]): Promise<ReadonlyMap<string, MessageOutcome>>;
+export declare function runTimes(connection: SqlConnection): Promise<ReadonlyMap<string, string>>;
+export declare function recordedTimes(connection: SqlConnection, sequences: readonly number[]): Promise<ReadonlyMap<number, string>>;
+export declare function submittedWorkflows(connection: SqlConnection): Promise<ReadonlyMap<string, string>>;
+export declare function storedWorkflows(connection: SqlConnection, digests: readonly string[]): Promise<ReadonlyMap<string, string | null>>;

package/dist/src/storage/projection-lookups.js

@@ -0,0 +1,30 @@
+import { integer, optionalText, text, } from "./domain-rows.js";
+const workflowColumn = "json_extract(s.body, '$.workflowId') AS workflow_id FROM documents s";
+const workflowFilter = "json_valid(s.body) AND json_type(s.body, '$.workflowId') = 'text'";
+export async function messageOutcomes(connection, messageIds) {
+    const rows = await connection.all("SELECT id, completed_at_ms IS NOT NULL AND rejection IS NULL AND error IS NULL AS committed FROM solid_messages WHERE id IN (SELECT value FROM json_each(?))", [JSON.stringify(messageIds)]);
+    return new Map(rows.map((row) => [
+        text(row, "id"),
+        integer(row, "committed") === 1 ? "committed" : "rolled-back",
+    ]));
+}
+export async function runTimes(connection) {
+    const rows = await connection.all("SELECT r.run_id, e.recorded_at FROM runs r JOIN events e ON e.sequence = r.sequence");
+    return new Map(rows.map((row) => [text(row, "run_id"), text(row, "recorded_at")]));
+}
+export async function recordedTimes(connection, sequences) {
+    if (sequences.length === 0)
+        return new Map();
+    const rows = await connection.all("SELECT sequence, recorded_at FROM events WHERE sequence IN (SELECT value FROM json_each(?))", [JSON.stringify(sequences)]);
+    return new Map(rows.map((row) => [integer(row, "sequence"), text(row, "recorded_at")]));
+}
+export async function submittedWorkflows(connection) {
+    const rows = await connection.all(`SELECT DISTINCT s.digest, ${workflowColumn} JOIN run_details d ON d.submission = s.digest WHERE ${workflowFilter}`);
+    return new Map(rows.map((row) => [text(row, "digest"), text(row, "workflow_id")]));
+}
+export async function storedWorkflows(connection, digests) {
+    if (digests.length === 0)
+        return new Map();
+    const rows = await connection.all(`SELECT s.digest, ${workflowColumn} WHERE s.digest IN (SELECT value FROM json_each(?)) AND ${workflowFilter}`, [JSON.stringify(digests)]);
+    return new Map(rows.map((row) => [text(row, "digest"), optionalText(row, "workflow_id")]));
+}

package/dist/src/workflow-declaration.d.ts

@@ -31,6 +31,7 @@ export interface DeclaredWorkflow extends WorkflowDeclaration {
 }
 export type WorkflowQueueCode = "queue-needs-ticket-field" | "queue-input-incomplete";
 export declare function workflowQueueRefusals(value: unknown): readonly WorkflowQueueCode[];
+export declare function workflowStagesOf(value: unknown): WorkflowStages;
 export declare function isWorkflowStages(value: unknown): value is readonly WorkflowStage[];
 export declare function isWorkflowNames(value: unknown): value is readonly string[];
 export declare function isCommandWaits(value: unknown, permissions: {

package/dist/src/workflow-declaration.js

@@ -89,6 +89,9 @@ function isStage(value) {
 function unique(values) {
     return new Set(values).size === values.length;
 }
+export function workflowStagesOf(value) {
+    return Object.fromEntries(Object.entries(record(value) ?? {}).flatMap(([workflowId, stages]) => isWorkflowStages(stages) ? [[workflowId, stages]] : []));
+}
 export function isWorkflowStages(value) {
     if (!Array.isArray(value) || value.length < 1 || value.length > 12)
         return false;

package/dist/tools/compile-workflows.js

@@ -8,6 +8,9 @@ if (!sourceDirectory || !outputDirectory) {
 }
 const output = resolve(outputDirectory);
 class WorkflowBuilder extends BaseBuilder {
+    async getInputFiles() {
+        return (await super.getInputFiles()).toSorted();
+    }
     async build() {
         const inputFiles = await this.getInputFiles();
         await mkdir(output, { recursive: true });

package/dist/tools/project-configuration.d.ts

@@ -1,4 +1,9 @@
-import { resolveSettings } from "../src/project-settings.ts";
+import { resolveSettings, type TurnSettings } from "../src/project-settings.ts";
+import { type TurnProfiles } from "../src/turn-profile.ts";
+type ProjectConfiguration = ReturnType<typeof resolveSettings>;
 export declare function topLevel(given: string): string;
 export declare function projectRoot(given: string): Promise<string>;
-export declare function projectConfiguration(repository: string, environment: Readonly<NodeJS.ProcessEnv>): Promise<ReturnType<typeof resolveSettings>>;
+export declare function projectConfiguration(repository: string, environment: Readonly<NodeJS.ProcessEnv>): Promise<ProjectConfiguration>;
+export declare function configuredTurnSettings(configuration: ProjectConfiguration): Promise<TurnSettings>;
+export declare function configurationDigests(configuration: ProjectConfiguration, profiles: TurnProfiles): Readonly<Record<string, string>>;
+export {};

package/dist/tools/project-configuration.js

@@ -3,8 +3,10 @@ import { createHash } from "node:crypto";
 import { readFile, realpath } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, join, resolve } from "node:path";
-import { configurationRoot, resolveSettings } from "../src/project-settings.js";
+import { configurationRoot, resolveSettings, settingDigests, } from "../src/project-settings.js";
 import { repositoryFileName } from "../src/repository-identity.js";
+import { parseFallbackModels, parseTokenPrices } from "../src/token-prices.js";
+import { isProfilesFile } from "../src/turn-profile.js";
 async function settingsFile(file) {
     try {
         return await readFile(file.path, "utf8");
@@ -45,3 +47,30 @@ export async function projectConfiguration(repository, environment) {
         }),
     });
 }
+async function configuredProfiles(configuration) {
+    const path = configuration.environment["CLOVING_PROFILES"];
+    if (path === undefined)
+        return configuration.profiles;
+    try {
+        const value = JSON.parse(await readFile(path, "utf8"));
+        if (isProfilesFile(value))
+            return value.profiles;
+    }
+    catch {
+        throw new Error("invalid-profiles");
+    }
+    throw new Error("invalid-profiles");
+}
+export async function configuredTurnSettings(configuration) {
+    const { environment } = configuration;
+    const tokenPrices = parseTokenPrices(environment["CLOVING_TOKEN_PRICES"]);
+    const fallbackModels = parseFallbackModels(environment["CLOVING_FALLBACK_MODELS"]);
+    return {
+        profiles: await configuredProfiles(configuration),
+        fallbackModels,
+        tokenPrices,
+    };
+}
+export function configurationDigests(configuration, profiles) {
+    return settingDigests({ ...configuration, profiles }, (text) => createHash("sha256").update(text).digest("hex"));
+}

package/dist/tools/self-host-processes.js

@@ -1,4 +1,4 @@
-import { execFile, spawn } from "node:child_process";
+import { execFile, spawn, } from "node:child_process";
 import { addAbortListener } from "node:events";
 import { rm } from "node:fs/promises";
 import { extname, join } from "node:path";
@@ -10,7 +10,7 @@ function launched(argumentsList, settings) {
     const child = spawn(process.execPath, argumentsList, {
         cwd: settings.directory,
         env: settings.environment,
-        stdio: "inherit",
+        stdio: settings.stdio ?? "inherit",
     });
     const ended = new Promise((settle, reject) => {
         child.once("error", reject);
@@ -124,25 +124,48 @@ function hostedChildren(settings) {
         name: "daemon",
         directory: settings.project,
         environment: settings.environment ?? process.env,
+        stdio: ["inherit", "inherit", "inherit", "ipc"],
     });
-    const watch = settings.watchPort === "off"
-        ? []
-        : [
-            productChild(settings, [
-                "cli",
-                "watch",
-                "--port",
-                settings.watchPort,
-            ]),
-        ];
     const relay = settings.phoneRelay === "off" ? [] : [productChild(settings, ["relay"])];
-    return { daemon, programs: [daemon, ...watch, ...relay] };
+    return { daemon, programs: [daemon, ...relay] };
+}
+function daemonStart(daemon) {
+    return new Promise((settle) => {
+        daemon.child.once("message", () => {
+            settle("started");
+        });
+        daemon.ended.then(() => {
+            settle("ended");
+        }, () => {
+            settle("ended");
+        });
+    });
+}
+function watchAfterStart(settings, hosting) {
+    if (settings.watchPort === "off")
+        return Promise.resolve();
+    return daemonStart(hosting.daemon).then((start) => {
+        if (start === "ended" || hosting.stopped())
+            return;
+        const watch = productChild(settings, [
+            "cli",
+            "watch",
+            "--port",
+            settings.watchPort,
+        ]);
+        hosting.programs.splice(1, 0, watch);
+    });
 }
 export async function hostedPrograms(settings) {
     const { daemon, programs } = hostedChildren(settings);
     const stopping = new AbortController();
     let updating = false;
     let shutdown;
+    const watching = watchAfterStart(settings, {
+        daemon,
+        programs,
+        stopped: () => shutdown !== undefined,
+    });
     const stop = () => (shutdown ??= stopped(programs, settings.stopMilliseconds ?? 60000));
     const signal = (signal) => {
         stopping.abort();
@@ -178,6 +201,7 @@ export async function hostedPrograms(settings) {
     }
     finally {
         stopping.abort();
+        await watching;
         await stop();
         await polling;
         process.off("SIGINT", interrupt);

package/dist/tools/self-host-project.d.ts

@@ -8,6 +8,7 @@ interface ProjectSettings {
     readonly home: string;
     readonly xdgConfigHome?: string | undefined;
     readonly userFolder?: string | undefined;
+    readonly recordedProject?: string;
 }
 export interface RegisteredWorkflows {
     readonly workflows: readonly WorkflowListing[];
@@ -18,4 +19,5 @@ export interface RegisteredWorkflows {
     readonly workflowRefusals: readonly WorkflowRefusal[];
 }
 export declare function preparedProject(settings: ProjectSettings): Promise<RegisteredWorkflows>;
+export declare function preparedBundle(settings: ProjectSettings): Promise<RegisteredWorkflows>;
 export {};