@smithers-orchestrator/engine 0.16.0

package/src/effect/entity-worker.js

@@ -0,0 +1,154 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./TaggedWorkerError.ts").TaggedWorkerError} TaggedWorkerError */
+/** @typedef {import("./TaskFailure.ts").TaskFailure} TaskFailure */
+/** @typedef {import("./TaskResult.ts").TaskResult} TaskResult */
+/** @typedef {import("./UnknownWorkerError.ts").UnknownWorkerError} UnknownWorkerError */
+/** @typedef {import("./WorkerDispatchKind.ts").WorkerDispatchKind} WorkerDispatchKind */
+/** @typedef {import("./WorkerTask.ts").WorkerTask} WorkerTask */
+/** @typedef {import("./WorkerTaskError.ts").WorkerTaskError} WorkerTaskError */
+/** @typedef {import("./WorkerTaskKind.ts").WorkerTaskKind} WorkerTaskKind */
+// @smithers-type-exports-end
+
+import * as Entity from "@effect/cluster/Entity";
+import * as Rpc from "@effect/rpc/Rpc";
+import { Schema } from "effect";
+/** @typedef {import("@smithers-orchestrator/graph/TaskDescriptor").TaskDescriptor} _TaskDescriptor */
+
+export const WorkerTaskKind = Schema.Literal("agent", "compute", "static");
+export const WorkerDispatchKind = Schema.Literal("compute", "static", "legacy");
+export const WorkerTask = Schema.Struct({
+    executionId: Schema.String,
+    bridgeKey: Schema.String,
+    workflowName: Schema.String,
+    runId: Schema.String,
+    nodeId: Schema.String,
+    iteration: Schema.Number,
+    retries: Schema.Number,
+    taskKind: WorkerTaskKind,
+    dispatchKind: WorkerDispatchKind,
+});
+const WorkerErrorDetails = Schema.Record({
+    key: Schema.String,
+    value: Schema.Unknown,
+});
+const TaskAbortedError = Schema.Struct({
+    _tag: Schema.Literal("TaskAborted"),
+    message: Schema.String,
+    details: Schema.optional(WorkerErrorDetails),
+    name: Schema.optional(Schema.String),
+});
+const TaskTimeoutError = Schema.Struct({
+    _tag: Schema.Literal("TaskTimeout"),
+    message: Schema.String,
+    nodeId: Schema.String,
+    attempt: Schema.Number,
+    timeoutMs: Schema.Number,
+});
+const TaskHeartbeatTimeoutError = Schema.Struct({
+    _tag: Schema.Literal("TaskHeartbeatTimeout"),
+    message: Schema.String,
+    nodeId: Schema.String,
+    iteration: Schema.Number,
+    attempt: Schema.Number,
+    timeoutMs: Schema.Number,
+    staleForMs: Schema.Number,
+    lastHeartbeatAtMs: Schema.Number,
+});
+const RunNotFoundError = Schema.Struct({
+    _tag: Schema.Literal("RunNotFound"),
+    message: Schema.String,
+    runId: Schema.String,
+});
+const InvalidInputError = Schema.Struct({
+    _tag: Schema.Literal("InvalidInput"),
+    message: Schema.String,
+    details: Schema.optional(WorkerErrorDetails),
+});
+const DbWriteFailedError = Schema.Struct({
+    _tag: Schema.Literal("DbWriteFailed"),
+    message: Schema.String,
+    details: Schema.optional(WorkerErrorDetails),
+});
+const AgentCliError = Schema.Struct({
+    _tag: Schema.Literal("AgentCliError"),
+    message: Schema.String,
+    details: Schema.optional(WorkerErrorDetails),
+});
+const WorkflowFailedError = Schema.Struct({
+    _tag: Schema.Literal("WorkflowFailed"),
+    message: Schema.String,
+    details: Schema.optional(WorkerErrorDetails),
+    status: Schema.optional(Schema.Number),
+});
+export const TaggedWorkerError = Schema.Union(TaskAbortedError, TaskTimeoutError, TaskHeartbeatTimeoutError, RunNotFoundError, InvalidInputError, DbWriteFailedError, AgentCliError, WorkflowFailedError);
+const UnknownWorkerError = Schema.Struct({
+    _tag: Schema.Literal("UnknownWorkerError"),
+    errorId: Schema.String,
+    message: Schema.String,
+});
+export const WorkerTaskError = Schema.Union(TaggedWorkerError, UnknownWorkerError);
+const TaskSuccess = Schema.Struct({
+    _tag: Schema.Literal("Success"),
+    executionId: Schema.String,
+    terminal: Schema.Boolean,
+});
+const TaskFailure = Schema.Struct({
+    _tag: Schema.Literal("Failure"),
+    executionId: Schema.String,
+    error: WorkerTaskError,
+});
+export const TaskResult = Schema.Union(TaskSuccess, TaskFailure);
+export const TaskWorkerEntity = Entity.make("TaskWorker", [
+    Rpc.make("execute", {
+        payload: WorkerTask,
+        success: TaskResult,
+    }),
+]);
+/**
+ * @param {_TaskDescriptor} desc
+ * @returns {WorkerTaskKind}
+ */
+function getWorkerTaskKind(desc) {
+    if (desc.agent) {
+        return "agent";
+    }
+    if (desc.computeFn) {
+        return "compute";
+    }
+    return "static";
+}
+/**
+ * @param {string} bridgeKey
+ * @param {string} workflowName
+ * @param {string} runId
+ * @param {_TaskDescriptor} desc
+ * @param {WorkerDispatchKind} dispatchKind
+ * @returns {WorkerTask}
+ */
+export function makeWorkerTask(bridgeKey, workflowName, runId, desc, dispatchKind) {
+    return {
+        executionId: bridgeKey,
+        bridgeKey,
+        workflowName,
+        runId,
+        nodeId: desc.nodeId,
+        iteration: desc.iteration,
+        retries: desc.retries,
+        taskKind: getWorkerTaskKind(desc),
+        dispatchKind,
+    };
+}
+/**
+ * @param {TaskResult} result
+ * @returns {result is TaskFailure}
+ */
+export function isTaskResultFailure(result) {
+    return result._tag === "Failure";
+}
+/**
+ * @param {WorkerTaskError} error
+ * @returns {error is UnknownWorkerError}
+ */
+export function isUnknownWorkerError(error) {
+    return error._tag === "UnknownWorkerError";
+}

package/src/effect/http-runner.js

@@ -0,0 +1,86 @@
+import { HttpRunner } from "@effect/cluster";
+import { mkdir, cp, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { Effect, Layer } from "effect";
+import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
+import { spawnCaptureEffect } from "@smithers-orchestrator/driver/child-process";
+import { toSmithersError } from "@smithers-orchestrator/errors/toSmithersError";
+import { SandboxEntityExecutor } from "@smithers-orchestrator/sandbox/effect/sandbox-entity";
+/**
+ * @param {SandboxTransportConfig} config
+ * @returns {SandboxHandle}
+ */
+function baseHandle(config) {
+    const sandboxRoot = join(config.rootDir, ".smithers", "sandboxes", config.runId, config.sandboxId);
+    return {
+        runtime: config.runtime,
+        runId: config.runId,
+        sandboxId: config.sandboxId,
+        sandboxRoot,
+        requestPath: join(sandboxRoot, "request"),
+        resultPath: join(sandboxRoot, "result"),
+    };
+}
+export const DockerSandboxExecutorLive = Layer.succeed(SandboxEntityExecutor, SandboxEntityExecutor.of({
+    create: (config) => Effect.gen(function* () {
+        const handle = baseHandle(config);
+        yield* spawnCaptureEffect("docker", ["info"], {
+            cwd: config.rootDir,
+            env: process.env,
+            timeoutMs: 10_000,
+            maxOutputBytes: 200_000,
+        }).pipe(Effect.catchAll(() => Effect.fail(new SmithersError("PROCESS_SPAWN_FAILED", "Docker daemon not reachable.", { runtime: "docker" }))));
+        yield* Effect.tryPromise({
+            try: async () => {
+                await mkdir(handle.requestPath, { recursive: true });
+                await mkdir(handle.resultPath, { recursive: true });
+            },
+            catch: (cause) => toSmithersError(cause, "create docker sandbox workspace"),
+        });
+        return handle;
+    }),
+    ship: (bundlePath, handle) => Effect.tryPromise({
+        try: async () => {
+            await rm(handle.requestPath, { recursive: true, force: true });
+            await mkdir(handle.requestPath, { recursive: true });
+            await cp(bundlePath, handle.requestPath, { recursive: true });
+        },
+        catch: (cause) => toSmithersError(cause, "ship docker bundle"),
+    }),
+    execute: (_command, _handle) => Effect.succeed({ exitCode: 0 }),
+    collect: (handle) => Effect.succeed({ bundlePath: handle.resultPath }),
+    cleanup: (_handle) => Effect.void,
+}));
+export const CodeplaneSandboxExecutorLive = Layer.succeed(SandboxEntityExecutor, SandboxEntityExecutor.of({
+    create: (config) => Effect.gen(function* () {
+        const apiUrl = process.env.CODEPLANE_API_URL;
+        const apiKey = process.env.CODEPLANE_API_KEY;
+        if (!apiUrl || !apiKey) {
+            yield* Effect.fail(new SmithersError("INVALID_INPUT", "Codeplane runtime requires CODEPLANE_API_URL and CODEPLANE_API_KEY."));
+        }
+        const handle = baseHandle(config);
+        yield* Effect.tryPromise({
+            try: async () => {
+                await mkdir(handle.requestPath, { recursive: true });
+                await mkdir(handle.resultPath, { recursive: true });
+            },
+            catch: (cause) => toSmithersError(cause, "create codeplane sandbox workspace"),
+        });
+        return {
+            ...handle,
+            workspaceId: `${config.runId}:${config.sandboxId}`,
+        };
+    }),
+    ship: (bundlePath, handle) => Effect.tryPromise({
+        try: async () => {
+            await rm(handle.requestPath, { recursive: true, force: true });
+            await mkdir(handle.requestPath, { recursive: true });
+            await cp(bundlePath, handle.requestPath, { recursive: true });
+        },
+        catch: (cause) => toSmithersError(cause, "ship codeplane bundle"),
+    }),
+    execute: (_command, _handle) => Effect.succeed({ exitCode: 0 }),
+    collect: (handle) => Effect.succeed({ bundlePath: handle.resultPath }),
+    cleanup: (_handle) => Effect.void,
+}));
+export const SandboxHttpRunner = HttpRunner;

package/src/effect/rpc-schema.js

@@ -0,0 +1,101 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./ApprovalPayload.ts").ApprovalPayload} ApprovalPayload */
+/** @typedef {import("./ApprovalResult.ts").ApprovalResult} ApprovalResult */
+/** @typedef {import("./CancelPayload.ts").CancelPayload} CancelPayload */
+/** @typedef {import("./CancelResult.ts").CancelResult} CancelResult */
+/** @typedef {import("./GetRunPayload.ts").GetRunPayload} GetRunPayload */
+/** @typedef {import("./GetRunResult.ts").GetRunResult} GetRunResult */
+/** @typedef {import("./ListRunsPayload.ts").ListRunsPayload} ListRunsPayload */
+/** @typedef {import("./RunStatusSchema.ts").RunStatusSchema} RunStatusSchema */
+/** @typedef {import("./RunSummary.ts").RunSummary} RunSummary */
+/** @typedef {import("./SignalPayload.ts").SignalPayload} SignalPayload */
+/** @typedef {import("./SignalResult.ts").SignalResult} SignalResult */
+// @smithers-type-exports-end
+
+import * as Rpc from "@effect/rpc/Rpc";
+import * as RpcGroup from "@effect/rpc/RpcGroup";
+import { Schema } from "effect";
+export const RunStatusSchema = Schema.Literal("running", "waiting-approval", "waiting-event", "waiting-timer", "finished", "continued", "failed", "cancelled");
+export const ApprovalPayloadSchema = Schema.Struct({
+    runId: Schema.String,
+    nodeId: Schema.String,
+    iteration: Schema.optional(Schema.Number),
+    note: Schema.optional(Schema.String),
+    decidedBy: Schema.optional(Schema.String),
+});
+export const ApprovalResultSchema = Schema.Struct({
+    runId: Schema.String,
+    nodeId: Schema.String,
+    iteration: Schema.Number,
+    approved: Schema.Boolean,
+});
+export const CancelPayloadSchema = Schema.Struct({
+    runId: Schema.String,
+});
+export const CancelResultSchema = Schema.Struct({
+    runId: Schema.String,
+    status: Schema.Literal("cancelling", "cancelled"),
+});
+export const SignalPayloadSchema = Schema.Struct({
+    runId: Schema.String,
+    signalName: Schema.String,
+    data: Schema.optional(Schema.Unknown),
+    correlationId: Schema.optional(Schema.String),
+    sentBy: Schema.optional(Schema.String),
+});
+export const SignalResultSchema = Schema.Struct({
+    runId: Schema.String,
+    signalName: Schema.String,
+    delivered: Schema.Boolean,
+    status: Schema.Literal("signalled", "ignored"),
+});
+export const ListRunsPayloadSchema = Schema.Struct({
+    limit: Schema.optional(Schema.Number),
+    status: Schema.optional(RunStatusSchema),
+});
+export const RunSummarySchema = Schema.Struct({
+    runId: Schema.String,
+    parentRunId: Schema.NullOr(Schema.String),
+    workflowName: Schema.String,
+    workflowPath: Schema.NullOr(Schema.String),
+    workflowHash: Schema.NullOr(Schema.String),
+    status: RunStatusSchema,
+    createdAtMs: Schema.Number,
+    startedAtMs: Schema.NullOr(Schema.Number),
+    finishedAtMs: Schema.NullOr(Schema.Number),
+    heartbeatAtMs: Schema.NullOr(Schema.Number),
+    runtimeOwnerId: Schema.NullOr(Schema.String),
+    cancelRequestedAtMs: Schema.NullOr(Schema.Number),
+    hijackRequestedAtMs: Schema.NullOr(Schema.Number),
+    hijackTarget: Schema.NullOr(Schema.String),
+    vcsType: Schema.NullOr(Schema.String),
+    vcsRoot: Schema.NullOr(Schema.String),
+    vcsRevision: Schema.NullOr(Schema.String),
+    errorJson: Schema.NullOr(Schema.String),
+    configJson: Schema.NullOr(Schema.String),
+});
+export const GetRunPayloadSchema = Schema.Struct({
+    runId: Schema.String,
+});
+export const GetRunResultSchema = Schema.NullOr(RunSummarySchema);
+export const approve = Rpc.make("approve", {
+    payload: ApprovalPayloadSchema,
+    success: ApprovalResultSchema,
+});
+export const cancel = Rpc.make("cancel", {
+    payload: CancelPayloadSchema,
+    success: CancelResultSchema,
+});
+export const signal = Rpc.make("signal", {
+    payload: SignalPayloadSchema,
+    success: SignalResultSchema,
+});
+export const listRuns = Rpc.make("listRuns", {
+    payload: ListRunsPayloadSchema,
+    success: Schema.Array(RunSummarySchema),
+});
+export const getRun = Rpc.make("getRun", {
+    payload: GetRunPayloadSchema,
+    success: GetRunResultSchema,
+});
+export const SmithersRpcGroup = RpcGroup.make(approve, cancel, signal, listRuns, getRun);

package/src/effect/single-runner.js

@@ -0,0 +1,189 @@
+import * as SingleRunner from "@effect/cluster/SingleRunner";
+import * as SqliteClient from "@effect/sql-sqlite-bun/SqliteClient";
+import { Effect, Layer, Scope } from "effect";
+import { fromTaggedErrorPayload } from "@smithers-orchestrator/errors/fromTaggedErrorPayload";
+import { toTaggedErrorPayload } from "@smithers-orchestrator/errors/toTaggedErrorPayload";
+import { isUnknownWorkerError, isTaskResultFailure, TaskWorkerEntity, } from "./entity-worker.js";
+/**
+ * @typedef {(task: WorkerTask) => void} TaskWorkerDispatchSubscriber
+ */
+/**
+ * @typedef {{ terminal: boolean; }} WorkerExecutionResult
+ */
+/** @typedef {import("./WorkerTask.ts").WorkerTask} WorkerTask */
+/** @typedef {import("./TaskResult.ts").TaskResult} TaskResult */
+/** @typedef {import("./TaskFailure.ts").TaskFailure} TaskFailure */
+/** @typedef {import("./WorkerTaskError.ts").WorkerTaskError} WorkerTaskError */
+
+const workerExecutions = new Map();
+const workerErrors = new Map();
+const dispatchSubscribers = new Set();
+let singleRunnerRuntimePromise;
+/**
+ * @param {WorkerTask} task
+ */
+function notifyDispatchSubscribers(task) {
+    for (const subscriber of dispatchSubscribers) {
+        try {
+            subscriber(task);
+        }
+        catch {
+            // Dispatch observers are best-effort and should not affect execution.
+        }
+    }
+}
+/**
+ * @param {WorkerTask} task
+ * @returns {Extract<TaskResult, { _tag: "Failure" }>}
+ */
+function buildMissingExecutionResult(task) {
+    return {
+        _tag: "Failure",
+        executionId: task.executionId,
+        error: {
+            _tag: "UnknownWorkerError",
+            errorId: `missing:${task.executionId}`,
+            message: `No worker execution registered for ${task.executionId}`,
+        },
+    };
+}
+/**
+ * @param {string} executionId
+ * @param {unknown} error
+ * @returns {string}
+ */
+function storeWorkerError(executionId, error) {
+    const errorId = `${executionId}:error`;
+    workerErrors.set(errorId, error);
+    return errorId;
+}
+/**
+ * @param {string} executionId
+ * @param {unknown} error
+ * @returns {WorkerTaskError}
+ */
+function toWorkerTaskError(executionId, error) {
+    const taggedError = toTaggedErrorPayload(error);
+    if (taggedError) {
+        return taggedError;
+    }
+    return {
+        _tag: "UnknownWorkerError",
+        errorId: storeWorkerError(executionId, error),
+        message: error instanceof Error ? error.message : String(error),
+    };
+}
+/**
+ * @param {TaskFailure} result
+ * @returns {unknown}
+ */
+function consumeWorkerError(result) {
+    if (!isUnknownWorkerError(result.error)) {
+        return fromTaggedErrorPayload(result.error);
+    }
+    const error = workerErrors.get(result.error.errorId);
+    workerErrors.delete(result.error.errorId);
+    if (error !== undefined) {
+        return error;
+    }
+    return new Error(result.error.message);
+}
+/**
+ * @param {WorkerTask} task
+ * @returns {Promise<TaskResult>}
+ */
+async function runRegisteredExecution(task) {
+    const registered = workerExecutions.get(task.executionId);
+    if (!registered) {
+        return buildMissingExecutionResult(task);
+    }
+    try {
+        notifyDispatchSubscribers(registered.task);
+        const result = await registered.execute();
+        return {
+            _tag: "Success",
+            executionId: task.executionId,
+            terminal: result.terminal,
+        };
+    }
+    catch (error) {
+        return {
+            _tag: "Failure",
+            executionId: task.executionId,
+            error: toWorkerTaskError(task.executionId, error),
+        };
+    }
+    finally {
+        if (workerExecutions.get(task.executionId) === registered) {
+            workerExecutions.delete(task.executionId);
+        }
+    }
+}
+/**
+ * @returns {Promise<SingleRunnerRuntime>}
+ */
+async function buildSingleRunnerRuntime() {
+    const runnerLayer = SingleRunner.layer({ runnerStorage: "memory" }).pipe(Layer.provide(Layer.orDie(SqliteClient.layer({
+        filename: ":memory:",
+        disableWAL: true,
+    }))));
+    const layer = TaskWorkerEntity.toLayer(TaskWorkerEntity.of({
+        execute: (request) => Effect.promise(() => runRegisteredExecution(request.payload)),
+    }), { concurrency: "unbounded" }).pipe(Layer.provideMerge(runnerLayer));
+    const scope = await Effect.runPromise(Scope.make());
+    const context = await Effect.runPromise(Layer.buildWithScope(layer, scope));
+    const client = await Effect.runPromise(TaskWorkerEntity.client.pipe(Effect.provide(context)));
+    return {
+        client: client,
+        context,
+    };
+}
+/**
+ * @returns {Promise<SingleRunnerRuntime>}
+ */
+async function getSingleRunnerRuntime() {
+    if (!singleRunnerRuntimePromise) {
+        singleRunnerRuntimePromise = buildSingleRunnerRuntime().catch((error) => {
+            singleRunnerRuntimePromise = undefined;
+            throw error;
+        });
+    }
+    return singleRunnerRuntimePromise;
+}
+/**
+ * @param {WorkerTask} task
+ * @param {() => Promise<WorkerExecutionResult>} execute
+ * @returns {Promise<WorkerExecutionResult>}
+ */
+export async function dispatchWorkerTask(task, execute) {
+    const runtime = await getSingleRunnerRuntime();
+    const registered = {
+        task,
+        execute,
+    };
+    workerExecutions.set(task.executionId, registered);
+    try {
+        const result = await Effect.runPromise(runtime.client(task.bridgeKey).execute(task).pipe(Effect.provide(runtime.context)));
+        if (isTaskResultFailure(result)) {
+            throw consumeWorkerError(result);
+        }
+        return {
+            terminal: result.terminal,
+        };
+    }
+    finally {
+        if (workerExecutions.get(task.executionId) === registered) {
+            workerExecutions.delete(task.executionId);
+        }
+    }
+}
+/**
+ * @param {TaskWorkerDispatchSubscriber} subscriber
+ * @returns {() => void}
+ */
+export function subscribeTaskWorkerDispatches(subscriber) {
+    dispatchSubscribers.add(subscriber);
+    return () => {
+        dispatchSubscribers.delete(subscriber);
+    };
+}