@voyantjs/workflows-orchestrator-cloudflare 0.6.7 → 0.6.9

package/src/cf-container-runner.ts

@@ -24,8 +24,7 @@
 // workflow registry already loaded. See
 // `apps/workflows-node-step-container/` for the reference image.
 
-import type { StepJournalEntry } from "@voyantjs/workflows/handler";
-import type { StepRunner } from "@voyantjs/workflows/handler";
+import type { StepJournalEntry, StepRunner } from "@voyantjs/workflows/handler"
 
 /**
  * Minimal subset of `DurableObjectNamespace` that the runner actually
@@ -34,8 +33,8 @@ import type { StepRunner } from "@voyantjs/workflows/handler";
  * tests can pass a stub.
  */
 export interface ContainerNamespaceLike {
-  idFromName(name: string): { toString(): string };
-  get(id: { toString(): string }): { fetch(request: Request): Promise<Response> };
+  idFromName(name: string): { toString(): string }
+  get(id: { toString(): string }): { fetch(request: Request): Promise<Response> }
 }
 
 export interface BundleLocation {
@@ -44,7 +43,7 @@ export interface BundleLocation {
    * from R2. Expected TTL is minutes, not hours — scoped tightly to
    * the specific `<projectId>/<workflowVersion>/container.mjs` key.
    */
-  url: string;
+  url: string
   /**
    * SHA-256 hex of the bundle bytes, computed at deploy time and
    * stored alongside the bundle. The container verifies the
@@ -52,7 +51,7 @@ export interface BundleLocation {
    * integrity check and as a pin preventing stale-cache confusion.
    * Accepts both plain hex and `sha256:<hex>` formats.
    */
-  hash: string;
+  hash: string
 }
 
 export interface CfContainerRunnerDeps {
@@ -61,7 +60,7 @@ export interface CfContainerRunnerDeps {
    * `env.NODE_STEP_POOL` wired in wrangler.jsonc to a `Container`-
    * extending class (from `@cloudflare/containers`).
    */
-  namespace: ContainerNamespaceLike;
+  namespace: ContainerNamespaceLike
   /**
    * Resolve a signed R2 URL + manifest hash for the bundle the
    * container should import for this dispatch. Called on every
@@ -73,26 +72,26 @@ export interface CfContainerRunnerDeps {
    * resolver; single-tenant / dev images can skip it.
    */
   resolveBundle?: (args: {
-    runId: string;
-    workflowId: string;
-    workflowVersion: string;
-    projectId: string;
-    organizationId: string;
-  }) => Promise<BundleLocation> | BundleLocation;
+    runId: string
+    workflowId: string
+    workflowVersion: string
+    projectId: string
+    organizationId: string
+  }) => Promise<BundleLocation> | BundleLocation
   /**
    * Base URL presented to the container. The container's Worker
    * proxy only inspects the path, so this is cosmetic — defaults to
    * `https://node-step.voyant.internal`.
    */
-  baseUrl?: string;
+  baseUrl?: string
   /**
    * Optional HMAC signer for the `X-Voyant-Step-Auth` header so the
    * container can verify the request came from a Voyant orchestrator.
    * Shape matches `createHmacSigner` from `@voyantjs/workflows/auth`.
    */
-  sign?: (body: string) => Promise<string> | string;
+  sign?: (body: string) => Promise<string> | string
   /** Optional structured logger. */
-  logger?: (level: "info" | "warn" | "error", msg: string, data?: object) => void;
+  logger?: (level: "info" | "warn" | "error", msg: string, data?: object) => void
   /**
    * Build the container-addressing id for a given step invocation.
    * Default: `"<runId>:<attempt>:<stepId>"` — deterministic and
@@ -100,37 +99,37 @@ export interface CfContainerRunnerDeps {
    * containers, so the CF addressing model isolates them).
    */
   containerId?: (args: {
-    runId: string;
-    workflowId: string;
-    workflowVersion: string;
-    stepId: string;
-    attempt: number;
-  }) => string;
+    runId: string
+    workflowId: string
+    workflowVersion: string
+    stepId: string
+    attempt: number
+  }) => string
 }
 
 interface StepDispatchPayload {
-  runId: string;
-  workflowId: string;
-  workflowVersion: string;
-  projectId: string;
-  organizationId: string;
-  stepId: string;
-  attempt: number;
-  input: unknown;
+  runId: string
+  workflowId: string
+  workflowVersion: string
+  projectId: string
+  organizationId: string
+  stepId: string
+  attempt: number
+  input: unknown
   options: {
-    machine?: string;
-    timeout?: string | number;
-  };
+    machine?: string
+    timeout?: string | number
+  }
   /** Signed R2 URL + hash for the bundle to import. Absent when the
    *  container is single-tenant (bundle baked into the image). */
-  bundle?: BundleLocation;
+  bundle?: BundleLocation
   /**
    * Journal slice at dispatch time. The container uses it to
    * short-circuit already-completed steps on body replay and to stop
    * the drive cleanly after the target step. Passed as opaque JSON
    * here; the container knows how to consume it.
    */
-  journal?: unknown;
+  journal?: unknown
 }
 
 /**
@@ -149,10 +148,8 @@ interface StepDispatchPayload {
  * `runtime: "edge"` (or unset) continues to run inline.
  */
 export function createCfContainerStepRunner(deps: CfContainerRunnerDeps): StepRunner {
-  const baseUrl = deps.baseUrl ?? "https://node-step.voyant.internal";
-  const idOf =
-    deps.containerId
-      ?? (({ runId, attempt, stepId }) => `${runId}:${attempt}:${stepId}`);
+  const baseUrl = deps.baseUrl ?? "https://node-step.voyant.internal"
+  const idOf = deps.containerId ?? (({ runId, attempt, stepId }) => `${runId}:${attempt}:${stepId}`)
 
   return async ({
     stepId,
@@ -167,8 +164,8 @@ export function createCfContainerStepRunner(deps: CfContainerRunnerDeps): StepRu
     options,
     journal,
   }): Promise<StepJournalEntry> => {
-    const startedAt = Date.now();
-    let bundle: BundleLocation | undefined;
+    const startedAt = Date.now()
+    let bundle: BundleLocation | undefined
     if (deps.resolveBundle) {
       try {
         bundle = await deps.resolveBundle({
@@ -177,14 +174,14 @@ export function createCfContainerStepRunner(deps: CfContainerRunnerDeps): StepRu
           workflowVersion,
           projectId,
           organizationId,
-        });
+        })
       } catch (err) {
         deps.logger?.("error", "cf-container: resolveBundle threw", {
           runId,
           stepId,
           error: err instanceof Error ? err.message : String(err),
-        });
-        return failed(attempt, startedAt, "BUNDLE_RESOLVE_FAILED", err);
+        })
+        return failed(attempt, startedAt, "BUNDLE_RESOLVE_FAILED", err)
       }
     }
     const payload: StepDispatchPayload = {
@@ -205,83 +202,78 @@ export function createCfContainerStepRunner(deps: CfContainerRunnerDeps): StepRu
       },
       bundle,
       journal,
-    };
-    const body = JSON.stringify(payload);
+    }
+    const body = JSON.stringify(payload)
     const headers: Record<string, string> = {
       "content-type": "application/json; charset=utf-8",
-    };
+    }
     if (deps.sign) {
-      headers["x-voyant-step-auth"] = await deps.sign(body);
+      headers["x-voyant-step-auth"] = await deps.sign(body)
     }
 
     const id = deps.namespace.idFromName(
       idOf({ runId, workflowId, workflowVersion, stepId, attempt }),
-    );
-    const stub = deps.namespace.get(id);
+    )
+    const stub = deps.namespace.get(id)
     const request = new Request(`${baseUrl}/step`, {
       method: "POST",
       headers,
       body,
       signal: stepCtx.signal,
-    });
+    })
 
     deps.logger?.("info", "cf-container: dispatching step", {
       runId,
       workflowId,
       stepId,
       attempt,
-    });
+    })
 
-    let response: Response;
+    let response: Response
     try {
-      response = await stub.fetch(request);
+      response = await stub.fetch(request)
     } catch (err) {
       deps.logger?.("error", "cf-container: fetch threw", {
         runId,
         stepId,
         error: err instanceof Error ? err.message : String(err),
-      });
-      return failed(attempt, startedAt, "CONTAINER_DISPATCH_FAILED", err);
+      })
+      return failed(attempt, startedAt, "CONTAINER_DISPATCH_FAILED", err)
     }
 
-    const text = await response.text();
+    const text = await response.text()
     if (response.status !== 200) {
       deps.logger?.("warn", "cf-container: non-200 response", {
         runId,
         stepId,
         status: response.status,
         body: text.slice(0, 500),
-      });
+      })
       return failed(
         attempt,
         startedAt,
         "CONTAINER_HTTP_ERROR",
         new Error(`container returned HTTP ${response.status}: ${text}`),
-      );
+      )
     }
     try {
-      const entry = JSON.parse(text) as StepJournalEntry;
+      const entry = JSON.parse(text) as StepJournalEntry
       // Trust the container's own timestamps; they reflect the actual
       // step body execution, not the dispatch round-trip.
-      return entry;
+      return entry
     } catch (err) {
       return failed(
         attempt,
         startedAt,
         "CONTAINER_INVALID_RESPONSE",
         new Error(`container returned non-JSON body: ${String(err)}`),
-      );
+      )
     }
-  };
+  }
 }
 
-function failed(
-  attempt: number,
-  startedAt: number,
-  code: string,
-  err: unknown,
-): StepJournalEntry {
-  const e = err instanceof Error ? err : new Error(String(err));
+function failed(attempt: number, startedAt: number, code: string, err: unknown): StepJournalEntry {
+  const e = err instanceof Error ? err : new Error(String(err))
   return {
     attempt,
     status: "err",
@@ -294,5 +286,5 @@ function failed(
       name: e.name,
       stack: e.stack,
     },
-  };
+  }
 }

package/src/dispatch-handler.ts

@@ -9,17 +9,17 @@ import {
   createHttpStepHandler,
   type StepHandler,
   type WorkflowStepRequest,
-} from "@voyantjs/workflows-orchestrator";
-import type { DispatchNamespaceLike } from "./types.js";
+} from "@voyantjs/workflows-orchestrator"
+import type { DispatchNamespaceLike } from "./types.js"
 
 export interface DispatchHandlerDeps {
-  dispatcher: DispatchNamespaceLike;
+  dispatcher: DispatchNamespaceLike
   /** Optional HMAC signer for the X-Voyant-Dispatch-Auth header. */
-  sign?: (body: string) => Promise<string> | string;
+  sign?: (body: string) => Promise<string> | string
   /** Optional logger for step-level observability. */
-  logger?: (level: "info" | "warn" | "error", msg: string, data?: object) => void;
+  logger?: (level: "info" | "warn" | "error", msg: string, data?: object) => void
   /** Base URL to present to the tenant. Defaults to `https://tenant.voyant.internal`. */
-  baseUrl?: string;
+  baseUrl?: string
 }
 
 /**
@@ -33,21 +33,19 @@ export function createDispatchStepHandler(
   tenantScript: string,
   deps: DispatchHandlerDeps,
 ): StepHandler {
-  const baseUrl = deps.baseUrl ?? "https://tenant.voyant.internal";
+  const baseUrl = deps.baseUrl ?? "https://tenant.voyant.internal"
   return createHttpStepHandler({
-    sign: deps.sign
-      ? (body) => deps.sign!(body)
-      : undefined,
+    sign: deps.sign ? (body) => deps.sign!(body) : undefined,
     logger: deps.logger,
     resolveTarget(_req: WorkflowStepRequest) {
-      const binding = deps.dispatcher.get(tenantScript);
+      const binding = deps.dispatcher.get(tenantScript)
       return {
         url: `${baseUrl}/__voyant/workflow-step`,
         label: tenantScript,
         fetch(request: Request) {
-          return binding.fetch(request);
+          return binding.fetch(request)
         },
-      };
+      }
     },
-  });
+  })
 }

package/src/do-store.ts

@@ -8,32 +8,30 @@
 // through the global run index (lives in voyant-cloud's Postgres,
 // not here).
 
-import type { RunRecord, RunRecordStore } from "@voyantjs/workflows-orchestrator";
-import type { DurableObjectStorageLike } from "./types.js";
+import type { RunRecord, RunRecordStore } from "@voyantjs/workflows-orchestrator"
+import type { DurableObjectStorageLike } from "./types.js"
 
-const RECORD_KEY = "record";
+const RECORD_KEY = "record"
 
-export function createDurableObjectRunStore(
-  storage: DurableObjectStorageLike,
-): RunRecordStore {
+export function createDurableObjectRunStore(storage: DurableObjectStorageLike): RunRecordStore {
   return {
     async get(id) {
-      const r = await storage.get<RunRecord>(RECORD_KEY);
-      if (!r || r.id !== id) return undefined;
-      return r;
+      const r = await storage.get<RunRecord>(RECORD_KEY)
+      if (!r || r.id !== id) return undefined
+      return r
     },
 
     async save(record) {
-      await storage.put<RunRecord>(RECORD_KEY, record);
-      return record;
+      await storage.put<RunRecord>(RECORD_KEY, record)
+      return record
     },
 
     async list(filter = {}) {
-      const r = await storage.get<RunRecord>(RECORD_KEY);
-      if (!r) return [];
-      if (filter.workflowId && r.workflowId !== filter.workflowId) return [];
-      if (filter.status && r.status !== filter.status) return [];
-      return [r];
+      const r = await storage.get<RunRecord>(RECORD_KEY)
+      if (!r) return []
+      if (filter.workflowId && r.workflowId !== filter.workflowId) return []
+      if (filter.status && r.status !== filter.status) return []
+      return [r]
     },
-  };
+  }
 }

package/src/durable-object.ts

@@ -19,44 +19,44 @@
 
 import {
   applyWaitpointInjection,
-  cancel as orchestratorCancel,
   driveUntilPaused,
+  cancel as orchestratorCancel,
   resume as orchestratorResume,
   trigger as orchestratorTrigger,
   type PendingWaitpoint,
   type RunRecord,
   type StepHandler,
-} from "@voyantjs/workflows-orchestrator";
+} from "@voyantjs/workflows-orchestrator"
+import { createDurableObjectRunStore } from "./do-store.js"
 import type {
   CancelPayload,
   DurableObjectStorageLike,
   ResumePayload,
   TriggerPayload,
-} from "./types.js";
-import { createDurableObjectRunStore } from "./do-store.js";
+} from "./types.js"
 
 export interface DurableObjectDeps {
-  storage: DurableObjectStorageLike;
+  storage: DurableObjectStorageLike
   /**
    * Resolve the StepHandler to use for a given tenant script. Called
    * with the tenantScript (from the trigger payload) so the DO can
    * route to the correct tenant Worker. In production this closes
    * over the dispatch namespace; in tests it returns a mock.
    */
-  resolveStepHandler: (tenantScript: string) => StepHandler;
-  now?: () => number;
+  resolveStepHandler: (tenantScript: string) => StepHandler
+  now?: () => number
 }
 
 export async function handleDurableObjectRequest(
   req: Request,
   deps: DurableObjectDeps,
 ): Promise<Response> {
-  const url = new URL(req.url);
-  const store = createDurableObjectRunStore(deps.storage);
+  const url = new URL(req.url)
+  const store = createDurableObjectRunStore(deps.storage)
 
   if (req.method === "POST" && url.pathname === "/trigger") {
-    const payload = (await req.json()) as TriggerPayload;
-    const handler = deps.resolveStepHandler(payload.tenantMeta.tenantScript);
+    const payload = (await req.json()) as TriggerPayload
+    const handler = deps.resolveStepHandler(payload.tenantMeta.tenantScript)
     const record = await orchestratorTrigger(
       {
         workflowId: payload.workflowId,
@@ -68,52 +68,52 @@ export async function handleDurableObjectRequest(
         runId: payload.runId,
       },
       { store, handler, now: deps.now },
-    );
-    await reconcileAlarm(record, store, deps);
-    return json(200, record);
+    )
+    await reconcileAlarm(record, store, deps)
+    return json(200, record)
   }
 
   if (req.method === "POST" && url.pathname === "/resume") {
-    const payload = (await req.json()) as ResumePayload;
-    const existing = await store.get((await getStoredRunId(store)) ?? "");
-    if (!existing) return json(404, { error: "not_found", message: "no run stored in this DO" });
-    const handler = deps.resolveStepHandler(existing.tenantMeta.tenantScript ?? "");
+    const payload = (await req.json()) as ResumePayload
+    const existing = await store.get((await getStoredRunId(store)) ?? "")
+    if (!existing) return json(404, { error: "not_found", message: "no run stored in this DO" })
+    const handler = deps.resolveStepHandler(existing.tenantMeta.tenantScript ?? "")
     const out = await orchestratorResume(
       { runId: existing.id, injection: payload.injection },
       { store, handler, now: deps.now },
-    );
+    )
     if (!out.ok) {
-      const status = out.status === "not_found" ? 404 : out.status === "no_match" ? 400 : 409;
-      return json(status, { error: out.status, message: out.message });
+      const status = out.status === "not_found" ? 404 : out.status === "no_match" ? 400 : 409
+      return json(status, { error: out.status, message: out.message })
     }
-    await reconcileAlarm(out.record, store, deps);
-    return json(200, out.record);
+    await reconcileAlarm(out.record, store, deps)
+    return json(200, out.record)
   }
 
   if (req.method === "POST" && url.pathname === "/cancel") {
-    const payload = (await req.json()) as CancelPayload;
-    const existing = await store.get((await getStoredRunId(store)) ?? "");
-    if (!existing) return json(404, { error: "not_found", message: "no run stored in this DO" });
-    const handler = deps.resolveStepHandler(existing.tenantMeta.tenantScript ?? "");
+    const payload = (await req.json()) as CancelPayload
+    const existing = await store.get((await getStoredRunId(store)) ?? "")
+    if (!existing) return json(404, { error: "not_found", message: "no run stored in this DO" })
+    const handler = deps.resolveStepHandler(existing.tenantMeta.tenantScript ?? "")
     const out = await orchestratorCancel(
       { runId: existing.id, reason: payload.reason },
       { store, handler, now: deps.now },
-    );
+    )
     if (!out.ok) {
-      const status = out.status === "not_found" ? 404 : 409;
-      return json(status, { error: out.status, message: out.message });
+      const status = out.status === "not_found" ? 404 : 409
+      return json(status, { error: out.status, message: out.message })
     }
-    await reconcileAlarm(out.record, store, deps);
-    return json(200, out.record);
+    await reconcileAlarm(out.record, store, deps)
+    return json(200, out.record)
   }
 
   if (req.method === "GET" && url.pathname === "/get") {
-    const existing = await store.get((await getStoredRunId(store)) ?? "");
-    if (!existing) return json(404, { error: "not_found" });
-    return json(200, existing);
+    const existing = await store.get((await getStoredRunId(store)) ?? "")
+    if (!existing) return json(404, { error: "not_found" })
+    return json(200, existing)
   }
 
-  return json(404, { error: "route_not_found", path: url.pathname });
+  return json(404, { error: "route_not_found", path: url.pathname })
 }
 
 /**
@@ -122,48 +122,46 @@ export async function handleDurableObjectRequest(
  * re-drives the run, and reschedules the next alarm if the run
  * parked on another DATETIME.
  */
-export async function handleDurableObjectAlarm(
-  deps: DurableObjectDeps,
-): Promise<void> {
-  const store = createDurableObjectRunStore(deps.storage);
-  const existingId = await getStoredRunId(store);
-  if (!existingId) return;
-  const record = await store.get(existingId);
-  if (!record) return;
+export async function handleDurableObjectAlarm(deps: DurableObjectDeps): Promise<void> {
+  const store = createDurableObjectRunStore(deps.storage)
+  const existingId = await getStoredRunId(store)
+  if (!existingId) return
+  const record = await store.get(existingId)
+  if (!record) return
   if (record.status !== "waiting") {
-    await deps.storage.deleteAlarm?.();
-    return;
+    await deps.storage.deleteAlarm?.()
+    return
   }
 
-  const now = (deps.now ?? (() => Date.now()))();
-  const stillPending: PendingWaitpoint[] = [];
-  let resolvedAny = false;
+  const now = (deps.now ?? (() => Date.now()))()
+  const stillPending: PendingWaitpoint[] = []
+  let resolvedAny = false
   for (const wp of record.pendingWaitpoints) {
-    const wakeAt = typeof wp.meta.wakeAt === "number" ? wp.meta.wakeAt : undefined;
+    const wakeAt = typeof wp.meta.wakeAt === "number" ? wp.meta.wakeAt : undefined
     if (wp.kind === "DATETIME" && wakeAt !== undefined && wakeAt <= now) {
       record.journal.waitpointsResolved[wp.clientWaitpointId] = {
         kind: "DATETIME",
         resolvedAt: now,
         source: "replay",
-      };
-      resolvedAny = true;
+      }
+      resolvedAny = true
     } else {
-      stillPending.push(wp);
+      stillPending.push(wp)
     }
   }
-  record.pendingWaitpoints = stillPending;
+  record.pendingWaitpoints = stillPending
   if (!resolvedAny) {
     // Spurious alarm — nothing due. Persist and reconcile.
-    await store.save(record);
-    await reconcileAlarm(record, store, deps);
-    return;
+    await store.save(record)
+    await reconcileAlarm(record, store, deps)
+    return
   }
 
-  record.status = "running";
-  const handler = deps.resolveStepHandler(record.tenantMeta.tenantScript ?? "");
-  await driveUntilPaused(record, { handler, now: deps.now });
-  await store.save(record);
-  await reconcileAlarm(record, store, deps);
+  record.status = "running"
+  const handler = deps.resolveStepHandler(record.tenantMeta.tenantScript ?? "")
+  await driveUntilPaused(record, { handler, now: deps.now })
+  await store.save(record)
+  await reconcileAlarm(record, store, deps)
 }
 
 /**
@@ -177,29 +175,29 @@ async function reconcileAlarm(
   store: ReturnType<typeof createDurableObjectRunStore>,
   deps: DurableObjectDeps,
 ): Promise<void> {
-  const now = (deps.now ?? (() => Date.now()))();
+  const now = (deps.now ?? (() => Date.now()))()
   if (record.status !== "waiting") {
-    await deps.storage.deleteAlarm?.();
-    return;
+    await deps.storage.deleteAlarm?.()
+    return
   }
-  let earliest: number | undefined;
-  let dirty = false;
+  let earliest: number | undefined
+  let dirty = false
   for (const wp of record.pendingWaitpoints) {
-    if (wp.kind !== "DATETIME") continue;
-    let wakeAt = typeof wp.meta.wakeAt === "number" ? wp.meta.wakeAt : undefined;
+    if (wp.kind !== "DATETIME") continue
+    let wakeAt = typeof wp.meta.wakeAt === "number" ? wp.meta.wakeAt : undefined
     if (wakeAt === undefined) {
-      const ms = wp.timeoutMs ?? (typeof wp.meta.durationMs === "number" ? wp.meta.durationMs : 0);
-      wakeAt = now + ms;
-      wp.meta.wakeAt = wakeAt;
-      dirty = true;
+      const ms = wp.timeoutMs ?? (typeof wp.meta.durationMs === "number" ? wp.meta.durationMs : 0)
+      wakeAt = now + ms
+      wp.meta.wakeAt = wakeAt
+      dirty = true
     }
-    earliest = earliest === undefined ? wakeAt : Math.min(earliest, wakeAt);
+    earliest = earliest === undefined ? wakeAt : Math.min(earliest, wakeAt)
   }
-  if (dirty) await store.save(record);
+  if (dirty) await store.save(record)
   if (earliest !== undefined) {
-    await deps.storage.setAlarm?.(earliest);
+    await deps.storage.setAlarm?.(earliest)
   } else {
-    await deps.storage.deleteAlarm?.();
+    await deps.storage.deleteAlarm?.()
   }
 }
 
@@ -207,18 +205,20 @@ async function reconcileAlarm(
  * One DO holds one run, keyed by `record`. Returns the id of that
  * stored run, if any.
  */
-async function getStoredRunId(store: ReturnType<typeof createDurableObjectRunStore>): Promise<string | undefined> {
-  const all = await store.list();
-  return all[0]?.id;
+async function getStoredRunId(
+  store: ReturnType<typeof createDurableObjectRunStore>,
+): Promise<string | undefined> {
+  const all = await store.list()
+  return all[0]?.id
 }
 
 function json(status: number, body: unknown): Response {
   return new Response(JSON.stringify(body), {
     status,
     headers: { "content-type": "application/json; charset=utf-8" },
-  });
+  })
 }
 
+export type { RunRecord }
 // Re-exported for callers building their own DO class via composition.
-export { applyWaitpointInjection, driveUntilPaused };
-export type { RunRecord };
+export { applyWaitpointInjection, driveUntilPaused }