@osolmaz/pi-workflows 0.16.1 → 0.16.3

package/src/host/controller-worker-supervisor.ts

@@ -1,79 +0,0 @@
-import fs from "node:fs";
-import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
-import { canonicalJson, type JsonValue } from "../state/json.js";
-import { ChildWorkerSupervisor, type SupervisedWorkerResult } from "./child-worker-supervisor.js";
-import {
-  encodeControllerWorkerLine,
-  parseControllerWorkerMessage,
-  type ControllerWorkerLaunchEnvelope,
-  type ControllerWorkerMessage,
-  type ControllerWorkerResponse,
-} from "./controller-worker-protocol.js";
-import { HostProcessRegistry, type ProcessIdentity } from "./processes.js";
-import type { WorkerOutcome } from "./state.js";
-
-export class ControllerWorkerSupervisor {
-  private readonly supervisor: ChildWorkerSupervisor<
-    ControllerWorkerMessage,
-    ControllerWorkerResponse
-  >;
-
-  constructor(
-    readonly envelope: ControllerWorkerLaunchEnvelope,
-    private readonly options: {
-      registry: HostProcessRegistry;
-      onMessage: (message: ControllerWorkerMessage) => Promise<ControllerWorkerResponse>;
-      env?: Record<string, string>;
-      startupTimeoutMs?: number;
-      workerEntryPath?: string;
-      onSpawn?: (identity: ProcessIdentity) => void;
-      onDiagnostic?: (message: string) => void;
-    },
-  ) {
-    this.supervisor = new ChildWorkerSupervisor({
-      label: "Controller worker",
-      registry: options.registry,
-      onMessage: options.onMessage,
-      parseMessage: parseControllerWorkerMessage,
-      encodeResponse: encodeControllerWorkerLine,
-      isReady: (message) => message.operation === "worker.ready",
-      isTerminal: (message) =>
-        message.operation === "worker.finished" || message.operation === "worker.failed",
-      ...(options.startupTimeoutMs === undefined
-        ? {}
-        : { startupTimeoutMs: options.startupTimeoutMs }),
-      ...(options.onSpawn === undefined ? {} : { onSpawn: options.onSpawn }),
-      ...(options.onDiagnostic === undefined ? {} : { onDiagnostic: options.onDiagnostic }),
-    });
-  }
-
-  async start(): Promise<void> {
-    const builtEntry = fileURLToPath(new URL("./controller-worker-entry.js", import.meta.url));
-    const sourceEntry = fileURLToPath(new URL("./controller-worker-entry.ts", import.meta.url));
-    const workerEntry = this.options.workerEntryPath ?? builtEntry;
-    const args =
-      this.options.workerEntryPath === undefined && !fs.existsSync(builtEntry)
-        ? ["--import", createRequire(import.meta.url).resolve("tsx"), sourceEntry]
-        : [workerEntry];
-    await this.supervisor.start({
-      args,
-      cwd: this.envelope.projectPath,
-      env: {
-        ...process.env,
-        ...this.options.env,
-        PI_WORKFLOWS_CONTROLLER_WORKER_LAUNCH: Buffer.from(
-          canonicalJson(this.envelope as unknown as JsonValue),
-        ).toString("base64url"),
-      },
-    });
-  }
-
-  async wait(): Promise<SupervisedWorkerResult> {
-    return await this.supervisor.wait();
-  }
-
-  async stop(outcome: WorkerOutcome = "cancelled"): Promise<void> {
-    await this.supervisor.stop(outcome);
-  }
-}

package/src/host/worker-protocol.ts

@@ -1,165 +0,0 @@
-import { MAX_PROTOCOL_MESSAGE_BYTES } from "../client/protocol.js";
-import { canonicalJson, parseJson, type JsonValue } from "../state/json.js";
-
-export const WORKER_MESSAGE_SCHEMA = "pi-workflows.worker-message.v1" as const;
-export const WORKER_RESPONSE_SCHEMA = "pi-workflows.worker-response.v1" as const;
-
-export const WORKER_MESSAGE_KINDS = [
-  "worker.ready",
-  "node.started",
-  "node.update",
-  "node.finished",
-  "node.failed",
-  "run.parked",
-  "run.finished",
-  "interaction.requested",
-  "interaction.accepted",
-  "interaction.rejected",
-  "notification.requested",
-  "presentation.requested",
-  "effect.reserve",
-  "effect.settle",
-  "worker.progress",
-  "worker.exiting",
-] as const;
-
-export type WorkerMessageKind = (typeof WORKER_MESSAGE_KINDS)[number];
-export type WorkerStoreOperation =
-  | "store.initializeRun"
-  | "store.prepareRunResume"
-  | "store.readRun"
-  | "store.writeSnapshot"
-  | "store.publishUpdate"
-  | "store.findSettingsScope"
-  | "store.ensureSettingsScope"
-  | "store.getSettingsScopeAtChange"
-  | "store.createHumanDecisionRequest"
-  | "store.readResolvedHumanDecision"
-  | "store.reserveEffect"
-  | "store.settleEffect"
-  | "process.register"
-  | "process.unregister"
-  | "interaction.request"
-  | "interaction.accept"
-  | "interaction.reject"
-  | "notification.request"
-  | "presentation.request";
-
-export type WorkerMessage = {
-  schema: typeof WORKER_MESSAGE_SCHEMA;
-  launchSchema: "pi-workflows.worker-launch.v1";
-  messageId: string;
-  kind: WorkerMessageKind;
-  operation: WorkerStoreOperation | "worker.ready" | "worker.exiting";
-  runId: string;
-  generation: number;
-  workerEpoch: string;
-  expectedRevision: number;
-  attemptId?: string;
-  payload: JsonValue;
-};
-
-export type WorkerResponse = {
-  schema: typeof WORKER_RESPONSE_SCHEMA;
-  messageId: string;
-  outcome: "accepted" | "adopted" | "rejected" | "claimLost";
-  revision?: number;
-  result?: JsonValue;
-  error?: string;
-};
-
-export function workerKindForOperation(
-  operation: WorkerStoreOperation,
-  payload: Record<string, unknown>,
-): WorkerMessageKind {
-  if (operation === "store.publishUpdate") return "node.update";
-  if (operation === "store.reserveEffect") return "effect.reserve";
-  if (operation === "store.settleEffect") return "effect.settle";
-  if (operation === "store.createHumanDecisionRequest" || operation === "interaction.request") {
-    return "interaction.requested";
-  }
-  if (operation === "interaction.accept") return "interaction.accepted";
-  if (operation === "interaction.reject") return "interaction.rejected";
-  if (operation === "notification.request") return "notification.requested";
-  if (operation === "presentation.request") return "presentation.requested";
-  if (operation === "store.writeSnapshot") {
-    const event = payload.event;
-    const eventType = isRecord(event) && typeof event.type === "string" ? event.type : "";
-    if (eventType === "node_started") return "node.started";
-    if (eventType === "node_finished") return "node.finished";
-    if (eventType === "node_failed" || eventType === "node_timed_out") return "node.failed";
-    if (eventType === "run_waiting" || eventType.includes("park")) return "run.parked";
-    if (eventType.startsWith("run_") && eventType !== "run_started") return "run.finished";
-  }
-  return "worker.progress";
-}
-
-export function encodeWorkerLine(message: WorkerMessage | WorkerResponse): Buffer {
-  const encoded = Buffer.from(`${canonicalJson(message)}\n`, "utf8");
-  if (encoded.byteLength > MAX_PROTOCOL_MESSAGE_BYTES) {
-    throw new Error("Worker protocol message exceeds 1 MiB");
-  }
-  return encoded;
-}
-
-export function parseWorkerMessage(line: Buffer | string): WorkerMessage {
-  const value = parseWorkerValue(line);
-  if (
-    value.schema !== WORKER_MESSAGE_SCHEMA ||
-    value.launchSchema !== "pi-workflows.worker-launch.v1"
-  ) {
-    throw new Error("Invalid worker message schema");
-  }
-  requireText(value.messageId, "messageId");
-  requireText(value.runId, "runId");
-  requireText(value.workerEpoch, "workerEpoch");
-  if (!WORKER_MESSAGE_KINDS.includes(value.kind as WorkerMessageKind)) {
-    throw new Error("Invalid worker message kind");
-  }
-  if (!Number.isSafeInteger(value.generation) || (value.generation as number) <= 0) {
-    throw new Error("Worker generation must be positive");
-  }
-  if (!Number.isSafeInteger(value.expectedRevision) || (value.expectedRevision as number) < 0) {
-    throw new Error("Worker expectedRevision must be non-negative");
-  }
-  requireText(value.operation, "operation");
-  if (value.attemptId !== undefined) requireText(value.attemptId, "attemptId");
-  if (!Object.hasOwn(value, "payload")) throw new Error("Worker payload is required");
-  return value as WorkerMessage;
-}
-
-export function parseWorkerResponse(line: Buffer | string): WorkerResponse {
-  const value = parseWorkerValue(line);
-  if (value.schema !== WORKER_RESPONSE_SCHEMA) throw new Error("Invalid worker response schema");
-  requireText(value.messageId, "messageId");
-  if (!["accepted", "adopted", "rejected", "claimLost"].includes(value.outcome as string)) {
-    throw new Error("Invalid worker response outcome");
-  }
-  if (value.error !== undefined && typeof value.error !== "string") {
-    throw new Error("Worker response error must be text");
-  }
-  return value as WorkerResponse;
-}
-
-function parseWorkerValue(line: Buffer | string): Record<string, unknown> {
-  const buffer = Buffer.isBuffer(line) ? line : Buffer.from(line, "utf8");
-  if (buffer.byteLength + 1 > MAX_PROTOCOL_MESSAGE_BYTES) {
-    throw new Error("Worker protocol message exceeds 1 MiB");
-  }
-  const text = buffer.toString("utf8");
-  const value = parseJson(text);
-  if (!isRecord(value) || canonicalJson(value) !== text) {
-    throw new Error("Worker protocol message must be a canonical JSON object");
-  }
-  return value;
-}
-
-function requireText(value: unknown, field: string): asserts value is string {
-  if (typeof value !== "string" || value.length === 0 || value.length > 256) {
-    throw new Error(`Worker ${field} must be nonempty bounded text`);
-  }
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/src/host/worker-supervisor.ts

@@ -1,74 +0,0 @@
-import fs from "node:fs";
-import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
-import { canonicalJson } from "../state/json.js";
-import { ChildWorkerSupervisor, type SupervisedWorkerResult } from "./child-worker-supervisor.js";
-import { HostProcessRegistry, type ProcessIdentity } from "./processes.js";
-import type { WorkerLaunchEnvelope, WorkerOutcome } from "./state.js";
-import {
-  encodeWorkerLine,
-  parseWorkerMessage,
-  type WorkerMessage,
-  type WorkerResponse,
-} from "./worker-protocol.js";
-
-export type WorkflowWorkerResult = SupervisedWorkerResult;
-
-export class WorkflowWorkerSupervisor {
-  private readonly supervisor: ChildWorkerSupervisor<WorkerMessage, WorkerResponse>;
-
-  constructor(
-    readonly envelope: WorkerLaunchEnvelope,
-    private readonly options: {
-      registry: HostProcessRegistry;
-      onMessage: (message: WorkerMessage) => Promise<WorkerResponse>;
-      env?: Record<string, string>;
-      startupTimeoutMs?: number;
-      workerEntryPath?: string;
-      onSpawn?: (identity: ProcessIdentity) => void;
-      onDiagnostic?: (message: string) => void;
-    },
-  ) {
-    this.supervisor = new ChildWorkerSupervisor({
-      label: "Workflow worker",
-      registry: options.registry,
-      onMessage: options.onMessage,
-      parseMessage: parseWorkerMessage,
-      encodeResponse: encodeWorkerLine,
-      isReady: (message) => message.kind === "worker.ready",
-      isTerminal: (message) => message.kind === "worker.exiting",
-      ...(options.startupTimeoutMs === undefined
-        ? {}
-        : { startupTimeoutMs: options.startupTimeoutMs }),
-      ...(options.onSpawn === undefined ? {} : { onSpawn: options.onSpawn }),
-      ...(options.onDiagnostic === undefined ? {} : { onDiagnostic: options.onDiagnostic }),
-    });
-  }
-
-  async start(): Promise<void> {
-    const builtEntry = fileURLToPath(new URL("./worker-entry.js", import.meta.url));
-    const sourceEntry = fileURLToPath(new URL("./worker-entry.ts", import.meta.url));
-    const workerEntry = this.options.workerEntryPath ?? builtEntry;
-    const args =
-      this.options.workerEntryPath === undefined && !fs.existsSync(builtEntry)
-        ? ["--import", createRequire(import.meta.url).resolve("tsx"), sourceEntry]
-        : [workerEntry];
-    await this.supervisor.start({
-      args,
-      cwd: this.envelope.projectPath,
-      env: {
-        ...process.env,
-        ...this.options.env,
-        PI_WORKFLOWS_WORKER_LAUNCH: Buffer.from(canonicalJson(this.envelope)).toString("base64url"),
-      },
-    });
-  }
-
-  async wait(): Promise<WorkflowWorkerResult> {
-    return await this.supervisor.wait();
-  }
-
-  async stop(outcome: WorkerOutcome = "cancelled"): Promise<void> {
-    await this.supervisor.stop(outcome);
-  }
-}