@smithers-orchestrator/engine 0.16.0

package/src/effect/BuilderNode.ts

@@ -0,0 +1,52 @@
+import type { BuilderStepHandle } from "./BuilderStepHandle.ts";
+
+type SequenceNode = {
+	kind: "sequence";
+	children: BuilderNode[];
+};
+type ParallelNode = {
+	kind: "parallel";
+	children: BuilderNode[];
+	maxConcurrency?: number;
+};
+type LoopNode = {
+	kind: "loop";
+	id?: string;
+	children: BuilderNode;
+	until: (outputs: Record<string, unknown>) => boolean;
+	maxIterations?: number;
+	onMaxReached?: "fail" | "return-last";
+	handles?: BuilderStepHandle[];
+};
+type MatchNode = {
+	kind: "match";
+	source: BuilderStepHandle;
+	when: (value: unknown) => boolean;
+	then: BuilderNode;
+	else?: BuilderNode;
+};
+type BranchNode = {
+	kind: "branch";
+	condition: (ctx: Record<string, unknown>) => boolean;
+	needs?: Record<string, BuilderStepHandle>;
+	then: BuilderNode;
+	else?: BuilderNode;
+};
+type WorktreeNode = {
+	kind: "worktree";
+	id?: string;
+	path: string;
+	branch?: string;
+	skipIf?: (ctx: Record<string, unknown>) => boolean;
+	needs?: Record<string, BuilderStepHandle>;
+	children: BuilderNode;
+};
+
+export type BuilderNode =
+	| BuilderStepHandle
+	| SequenceNode
+	| ParallelNode
+	| LoopNode
+	| MatchNode
+	| BranchNode
+	| WorktreeNode;

package/src/effect/BuilderStepHandle.ts

@@ -0,0 +1,47 @@
+import type { Effect, Schema } from "effect";
+import type { SQLiteTable } from "drizzle-orm/sqlite-core";
+import type { CachePolicy } from "@smithers-orchestrator/scheduler/CachePolicy";
+import type { RetryPolicy } from "@smithers-orchestrator/scheduler/RetryPolicy";
+
+type AnySchema = Schema.Schema<unknown, unknown, never>;
+type AnyEffect = unknown | Promise<unknown> | Effect.Effect<unknown, unknown, unknown>;
+
+type BuilderStepContext = Record<string, unknown> & {
+	input: unknown;
+	executionId: string;
+	stepId: string;
+	attempt: number;
+	signal: AbortSignal;
+	iteration: number;
+	heartbeat: (data?: unknown) => void;
+	lastHeartbeat: unknown | null;
+};
+
+type ApprovalOptions = {
+	needs?: Record<string, BuilderStepHandle>;
+	request: (ctx: Record<string, unknown>) => {
+		title: string;
+		summary?: string | null;
+	};
+	onDeny?: "fail" | "continue" | "skip";
+};
+
+export type BuilderStepHandle = {
+	kind: "step" | "approval";
+	id: string;
+	localId: string;
+	tableKey: string;
+	tableName: string;
+	table: SQLiteTable;
+	output: AnySchema;
+	needs: Record<string, BuilderStepHandle>;
+	run?: (ctx: BuilderStepContext) => AnyEffect;
+	request?: ApprovalOptions["request"];
+	onDeny?: "fail" | "continue" | "skip";
+	retries: number;
+	retryPolicy?: RetryPolicy;
+	timeoutMs: number | null;
+	skipIf?: (ctx: BuilderStepContext) => boolean;
+	loopId?: string;
+	cache?: CachePolicy;
+};

package/src/effect/CancelPayload.ts

@@ -0,0 +1,3 @@
+export type CancelPayload = {
+	runId: string;
+};

package/src/effect/CancelResult.ts

@@ -0,0 +1,4 @@
+export type CancelResult = {
+	runId: string;
+	status: "cancelling" | "cancelled";
+};

package/src/effect/DeferredResolution.ts

@@ -0,0 +1,7 @@
+import type { Exit } from "effect";
+import type { ApprovalDeferredResolution } from "./ApprovalDeferredResolution.ts";
+
+export type DeferredResolution = Exit.Exit<
+	ApprovalDeferredResolution | void,
+	never
+>;

package/src/effect/DiffBundle.ts

@@ -0,0 +1,7 @@
+import type { FilePatch } from "./FilePatch.ts";
+
+export type DiffBundle = {
+	seq: number;
+	baseRef: string;
+	patches: FilePatch[];
+};

package/src/effect/ExecuteTaskActivityOptions.ts

@@ -0,0 +1,7 @@
+import type { TaskActivityRetryOptions } from "./TaskActivityRetryOptions.ts";
+
+export type ExecuteTaskActivityOptions = {
+	initialAttempt?: number;
+	retry?: false | TaskActivityRetryOptions;
+	includeAttemptInIdempotencyKey?: boolean;
+};

package/src/effect/FilePatch.ts

@@ -0,0 +1,6 @@
+export type FilePatch = {
+	path: string;
+	operation: "add" | "modify" | "delete";
+	diff: string;
+	binaryContent?: string;
+};

package/src/effect/GetRunPayload.ts

@@ -0,0 +1,3 @@
+export type GetRunPayload = {
+	runId: string;
+};

package/src/effect/GetRunResult.ts

@@ -0,0 +1,3 @@
+import type { RunSummary } from "./RunSummary.ts";
+
+export type GetRunResult = RunSummary | null;

package/src/effect/LegacyExecuteTaskFn.ts

@@ -0,0 +1,24 @@
+import type { BunSQLiteDatabase } from "drizzle-orm/bun-sqlite";
+import type { SQLiteTable } from "drizzle-orm/sqlite-core";
+import type { TaskDescriptor } from "@smithers-orchestrator/graph/TaskDescriptor";
+import type { SmithersDb } from "@smithers-orchestrator/db/adapter";
+import type { EventBus } from "../events.js";
+import type { HijackState } from "../HijackState.ts";
+import type { TaskBridgeToolConfig } from "./TaskBridgeToolConfig.ts";
+
+export type LegacyExecuteTaskFn = (
+	adapter: SmithersDb,
+	db: BunSQLiteDatabase<Record<string, unknown>>,
+	runId: string,
+	desc: TaskDescriptor,
+	descriptorMap: Map<string, TaskDescriptor>,
+	inputTable: SQLiteTable,
+	eventBus: EventBus,
+	toolConfig: TaskBridgeToolConfig,
+	workflowName: string,
+	cacheEnabled: boolean,
+	signal?: AbortSignal,
+	disabledAgents?: Set<string>,
+	runAbortController?: AbortController,
+	hijackState?: HijackState,
+) => Promise<void>;

package/src/effect/ListRunsPayload.ts

@@ -0,0 +1,6 @@
+import type { RunStatusSchema } from "./RunStatusSchema.ts";
+
+export type ListRunsPayload = {
+	limit?: number;
+	status?: RunStatusSchema;
+};

package/src/effect/RunStatusSchema.ts

@@ -0,0 +1,9 @@
+export type RunStatusSchema =
+	| "running"
+	| "waiting-approval"
+	| "waiting-event"
+	| "waiting-timer"
+	| "finished"
+	| "continued"
+	| "failed"
+	| "cancelled";

package/src/effect/RunSummary.ts

@@ -0,0 +1,23 @@
+import type { RunStatusSchema } from "./RunStatusSchema.ts";
+
+export type RunSummary = {
+	runId: string;
+	parentRunId: string | null;
+	workflowName: string;
+	workflowPath: string | null;
+	workflowHash: string | null;
+	status: RunStatusSchema;
+	createdAtMs: number;
+	startedAtMs: number | null;
+	finishedAtMs: number | null;
+	heartbeatAtMs: number | null;
+	runtimeOwnerId: string | null;
+	cancelRequestedAtMs: number | null;
+	hijackRequestedAtMs: number | null;
+	hijackTarget: string | null;
+	vcsType: string | null;
+	vcsRoot: string | null;
+	vcsRevision: string | null;
+	errorJson: string | null;
+	configJson: string | null;
+};

package/src/effect/SignalPayload.ts

@@ -0,0 +1,7 @@
+export type SignalPayload = {
+	runId: string;
+	signalName: string;
+	data?: unknown;
+	correlationId?: string;
+	sentBy?: string;
+};

package/src/effect/SignalResult.ts

@@ -0,0 +1,6 @@
+export type SignalResult = {
+	runId: string;
+	signalName: string;
+	delivered: boolean;
+	status: "signalled" | "ignored";
+};

package/src/effect/SmithersSqliteOptions.ts

@@ -0,0 +1,3 @@
+export type SmithersSqliteOptions = {
+	filename: string;
+};

package/src/effect/SqlMessageStorageEventHistoryQuery.ts

@@ -0,0 +1,7 @@
+export type SqlMessageStorageEventHistoryQuery = {
+	afterSeq?: number;
+	limit?: number;
+	nodeId?: string;
+	types?: readonly string[];
+	sinceTimestampMs?: number;
+};

package/src/effect/TaggedWorkerError.ts

@@ -0,0 +1,46 @@
+export type TaggedWorkerError =
+	| {
+			_tag: "TaskAborted";
+			message: string;
+			details?: Record<string, unknown>;
+			name?: string;
+	  }
+	| {
+			_tag: "TaskTimeout";
+			message: string;
+			nodeId: string;
+			attempt: number;
+			timeoutMs: number;
+	  }
+	| {
+			_tag: "TaskHeartbeatTimeout";
+			message: string;
+			nodeId: string;
+			iteration: number;
+			attempt: number;
+			timeoutMs: number;
+			staleForMs: number;
+			lastHeartbeatAtMs: number;
+	  }
+	| { _tag: "RunNotFound"; message: string; runId: string }
+	| {
+			_tag: "InvalidInput";
+			message: string;
+			details?: Record<string, unknown>;
+	  }
+	| {
+			_tag: "DbWriteFailed";
+			message: string;
+			details?: Record<string, unknown>;
+	  }
+	| {
+			_tag: "AgentCliError";
+			message: string;
+			details?: Record<string, unknown>;
+	  }
+	| {
+			_tag: "WorkflowFailed";
+			message: string;
+			details?: Record<string, unknown>;
+			status?: number;
+	  };

package/src/effect/TaskActivityContext.ts

@@ -0,0 +1,4 @@
+export type TaskActivityContext = {
+	attempt: number;
+	idempotencyKey: string;
+};

package/src/effect/TaskActivityRetryOptions.ts

@@ -0,0 +1,4 @@
+export type TaskActivityRetryOptions = {
+	times: number;
+	while?: (error: unknown) => boolean;
+};

package/src/effect/TaskBridgeToolConfig.ts

@@ -0,0 +1,6 @@
+export type TaskBridgeToolConfig = {
+	rootDir: string;
+	allowNetwork: boolean;
+	maxOutputBytes: number;
+	toolTimeoutMs: number;
+};

package/src/effect/TaskFailure.ts

@@ -0,0 +1,3 @@
+import type { TaskResult } from "./TaskResult.ts";
+
+export type TaskFailure = Extract<TaskResult, { _tag: "Failure" }>;

package/src/effect/TaskResult.ts

@@ -0,0 +1,5 @@
+import type { WorkerTaskError } from "./WorkerTaskError.ts";
+
+export type TaskResult =
+	| { _tag: "Success"; executionId: string; terminal: boolean }
+	| { _tag: "Failure"; executionId: string; error: WorkerTaskError };

package/src/effect/UnknownWorkerError.ts

@@ -0,0 +1,5 @@
+export type UnknownWorkerError = {
+	_tag: "UnknownWorkerError";
+	errorId: string;
+	message: string;
+};

package/src/effect/WaitForEventDurableDeferredResolution.ts

@@ -0,0 +1,11 @@
+import type { Schema } from "effect";
+
+export type WaitForEventDurableDeferredResolution = Schema.Schema.Type<
+	Schema.Struct<{
+		signalName: typeof Schema.String;
+		correlationId: Schema.NullOr<typeof Schema.String>;
+		payloadJson: typeof Schema.String;
+		seq: typeof Schema.Number;
+		receivedAtMs: typeof Schema.Number;
+	}>
+>;

package/src/effect/WorkerDispatchKind.ts

@@ -0,0 +1 @@
+export type WorkerDispatchKind = "compute" | "static" | "legacy";

package/src/effect/WorkerTask.ts

@@ -0,0 +1,14 @@
+import type { WorkerTaskKind } from "./WorkerTaskKind.ts";
+import type { WorkerDispatchKind } from "./WorkerDispatchKind.ts";
+
+export type WorkerTask = {
+	executionId: string;
+	bridgeKey: string;
+	workflowName: string;
+	runId: string;
+	nodeId: string;
+	iteration: number;
+	retries: number;
+	taskKind: WorkerTaskKind;
+	dispatchKind: WorkerDispatchKind;
+};

package/src/effect/WorkerTaskError.ts

@@ -0,0 +1,4 @@
+import type { TaggedWorkerError } from "./TaggedWorkerError.ts";
+import type { UnknownWorkerError } from "./UnknownWorkerError.ts";
+
+export type WorkerTaskError = TaggedWorkerError | UnknownWorkerError;

package/src/effect/WorkerTaskKind.ts

@@ -0,0 +1 @@
+export type WorkerTaskKind = "agent" | "compute" | "static";

package/src/effect/WorkflowPatchDecisionRecord.ts

@@ -0,0 +1,4 @@
+export type WorkflowPatchDecisionRecord = {
+	patchId: string;
+	decision: boolean;
+};

package/src/effect/WorkflowPatchDecisions.ts

@@ -0,0 +1 @@
+export type WorkflowPatchDecisions = Record<string, boolean>;

package/src/effect/WorkflowVersioningRuntime.ts

@@ -0,0 +1,7 @@
+import type { WorkflowPatchDecisions } from "./WorkflowPatchDecisions.ts";
+
+export type WorkflowVersioningRuntime = {
+	resolve(patchId: string): boolean;
+	flush(): Promise<void>;
+	snapshot(): WorkflowPatchDecisions;
+};

package/src/effect/activity-bridge.js

@@ -0,0 +1,131 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./TaskActivityRetryOptions.ts").TaskActivityRetryOptions} TaskActivityRetryOptions */
+/** @typedef {import("./ExecuteTaskActivityOptions.ts").ExecuteTaskActivityOptions} ExecuteTaskActivityOptions */
+/** @typedef {import("./TaskActivityContext.ts").TaskActivityContext} TaskActivityContext */
+// @smithers-type-exports-end
+
+import * as Activity from "@effect/workflow/Activity";
+import { Effect, Schema } from "effect";
+/** @typedef {import("@smithers-orchestrator/db/adapter").SmithersDb} _SmithersDb */
+/** @typedef {import("@smithers-orchestrator/graph/TaskDescriptor").TaskDescriptor} _TaskDescriptor */
+
+const adapterNamespaces = new WeakMap();
+const completedActivityResults = new Map();
+let nextAdapterNamespace = 0;
+/**
+ * @param {_SmithersDb} adapter
+ * @returns {string}
+ */
+const getAdapterNamespace = (adapter) => {
+    const existing = adapterNamespaces.get(adapter);
+    if (existing) {
+        return existing;
+    }
+    const created = `adapter-${++nextAdapterNamespace}`;
+    adapterNamespaces.set(adapter, created);
+    return created;
+};
+export class RetriableTaskFailure extends Error {
+    nodeId;
+    attempt;
+    /**
+   * @param {string} nodeId
+   * @param {number} attempt
+   */
+    constructor(nodeId, attempt) {
+        super(`Task ${nodeId} failed on attempt ${attempt} and should be retried`);
+        this.name = "RetriableTaskFailure";
+        this.nodeId = nodeId;
+        this.attempt = attempt;
+    }
+}
+/**
+ * @param {unknown} error
+ * @returns {error is RetriableTaskFailure}
+ */
+const isRetriableTaskFailure = (error) => error instanceof RetriableTaskFailure;
+/**
+ * @param {_SmithersDb} adapter
+ * @param {string} workflowName
+ * @param {string} runId
+ * @param {_TaskDescriptor} desc
+ * @returns {string}
+ */
+export const makeTaskBridgeKey = (adapter, workflowName, runId, desc) => [
+    "smithers-task-bridge",
+    getAdapterNamespace(adapter),
+    workflowName,
+    runId,
+    desc.nodeId,
+    String(desc.iteration),
+].join(":");
+/**
+ * @param {_SmithersDb} adapter
+ * @param {string} workflowName
+ * @param {string} runId
+ * @param {_TaskDescriptor} desc
+ * @param {number} attempt
+ * @param {boolean} [includeAttempt]
+ * @returns {string}
+ */
+const makeActivityIdempotencyKey = (adapter, workflowName, runId, desc, attempt, includeAttempt) => {
+    const base = makeTaskBridgeKey(adapter, workflowName, runId, desc);
+    return includeAttempt ? `${base}:attempt:${attempt}` : base;
+};
+/**
+ * @template A
+ * @param {_TaskDescriptor} desc
+ * @param {(context: TaskActivityContext) => Promise<A> | A} executeFn
+ * @param {Pick<ExecuteTaskActivityOptions, "includeAttemptInIdempotencyKey">} [options]
+ */
+export const makeTaskActivity = (desc, executeFn, options) => Activity.make({
+    name: desc.nodeId,
+    success: Schema.Unknown,
+    error: Schema.Unknown,
+    execute: Effect.gen(function* () {
+        const attempt = yield* Activity.CurrentAttempt;
+        const idempotencyKey = yield* Activity.idempotencyKey(desc.nodeId, {
+            includeAttempt: options?.includeAttemptInIdempotencyKey,
+        });
+        return yield* Effect.tryPromise({
+            try: () => Promise.resolve(executeFn({ attempt, idempotencyKey })),
+            catch: (error) => error,
+        });
+    }),
+});
+/**
+ * @template A
+ * @param {_SmithersDb} adapter
+ * @param {string} workflowName
+ * @param {string} runId
+ * @param {_TaskDescriptor} desc
+ * @param {(context: TaskActivityContext) => Promise<A> | A} executeFn
+ * @param {ExecuteTaskActivityOptions} [options]
+ * @returns {Promise<A>}
+ */
+export const executeTaskActivity = async (adapter, workflowName, runId, desc, executeFn, options) => {
+    const initialAttempt = Math.max(1, options?.initialAttempt ?? 1);
+    const retry = options?.retry === undefined
+        ? { times: desc.retries, while: isRetriableTaskFailure }
+        : options.retry;
+    let attempt = initialAttempt;
+    while (true) {
+        const idempotencyKey = makeActivityIdempotencyKey(adapter, workflowName, runId, desc, attempt, options?.includeAttemptInIdempotencyKey);
+        if (completedActivityResults.has(idempotencyKey)) {
+            return completedActivityResults.get(idempotencyKey);
+        }
+        try {
+            const result = await Promise.resolve(executeFn({ attempt, idempotencyKey }));
+            completedActivityResults.set(idempotencyKey, result);
+            return result;
+        }
+        catch (error) {
+            if (retry === false ||
+                attempt - initialAttempt >= retry.times ||
+                !(retry.while ?? isRetriableTaskFailure)(error)) {
+                throw error;
+            }
+            attempt += 1;
+        }
+    }
+};

package/src/effect/bridge-utils.js

@@ -0,0 +1,45 @@
+import { TaskAborted } from "@smithers-orchestrator/errors/TaskAborted";
+/**
+ * @returns {TaskAborted}
+ */
+export function makeAbortError(message = "Task aborted") {
+    return new TaskAborted({
+        message,
+        name: "AbortError",
+    });
+}
+/**
+ * @param {AbortController} controller
+ * @param {AbortSignal} [signal]
+ */
+export function wireAbortSignal(controller, signal) {
+    if (!signal) {
+        return () => { };
+    }
+    const forwardAbort = () => {
+        controller.abort(signal.reason ?? makeAbortError());
+    };
+    if (signal.aborted) {
+        forwardAbort();
+        return () => { };
+    }
+    signal.addEventListener("abort", forwardAbort, { once: true });
+    return () => signal.removeEventListener("abort", forwardAbort);
+}
+/**
+ * @param {string | null} [metaJson]
+ * @returns {Record<string, unknown>}
+ */
+export function parseAttemptMetaJson(metaJson) {
+    if (!metaJson)
+        return {};
+    try {
+        const parsed = JSON.parse(metaJson);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}