@osolmaz/pi-workflows 0.13.4 → 0.15.0

package/src/host/worker-store.ts

@@ -0,0 +1,229 @@
+import { randomUUID } from "node:crypto";
+import type { JsonValue } from "../state/json.js";
+import type { WorkflowSettingsScopeRecord } from "../workflows/settings.js";
+import {
+  createDefinitionSnapshot,
+  type InitializeWorkflowRunOptions,
+  type LoadedWorkflowRun,
+  type ReadWorkflowRunOptions,
+  type WorkflowExecutionStore,
+} from "../workflows/store.js";
+import type {
+  HumanDecisionRequest,
+  ResolvedHumanDecision,
+  WorkflowDefinition,
+  WorkflowEffectRecovery,
+  WorkflowEffectReservation,
+  WorkflowNotificationReceipt,
+  WorkflowNotificationRequest,
+  WorkflowRunState,
+  WorkflowTraceEvent,
+  WorkflowTraceEventDraft,
+  WorkflowUpdateInput,
+  WorkflowUpdateRecord,
+} from "../workflows/types.js";
+import type { WorkerMessageKind, WorkerStoreOperation } from "./worker-protocol.js";
+import { workerKindForOperation } from "./worker-protocol.js";
+
+export interface WorkerStoreTransport {
+  request(options: {
+    messageId: string;
+    operation: WorkerStoreOperation;
+    kind: WorkerMessageKind;
+    expectedRevision: number;
+    attemptId?: string;
+    payload: JsonValue;
+  }): Promise<{ result?: JsonValue; revision?: number }>;
+}
+
+/** A worker-side store that can only propose state changes to its host. */
+export class HostBackedWorkflowStore implements WorkflowExecutionStore {
+  readonly databasePath = "host://pi-workflows-state";
+  private revision: number;
+
+  constructor(
+    private readonly runId: string,
+    private readonly transport: WorkerStoreTransport,
+    initialRevision = 0,
+  ) {
+    this.revision = initialRevision;
+  }
+
+  async initializeRun(
+    workflow: WorkflowDefinition,
+    state: WorkflowRunState,
+    options: InitializeWorkflowRunOptions = {},
+  ): Promise<string> {
+    return await this.call<string>("store.initializeRun", {
+      snapshot: createDefinitionSnapshot(workflow),
+      workflowName: workflow.name,
+      state,
+      options,
+    });
+  }
+
+  async prepareRunResume(runId: string): Promise<LoadedWorkflowRun> {
+    return await this.call<LoadedWorkflowRun>("store.prepareRunResume", { runId });
+  }
+
+  async readRun(
+    runId: string,
+    options: ReadWorkflowRunOptions = {},
+  ): Promise<LoadedWorkflowRun | null> {
+    return await this.call<LoadedWorkflowRun | null>("store.readRun", { runId, options });
+  }
+
+  async writeSnapshot(
+    runId: string,
+    state: WorkflowRunState,
+    event: WorkflowTraceEventDraft,
+  ): Promise<WorkflowTraceEvent> {
+    return await this.call<WorkflowTraceEvent>(
+      "store.writeSnapshot",
+      { runId, state, event },
+      event.attemptId,
+    );
+  }
+
+  async publishUpdate(
+    runId: string,
+    state: WorkflowRunState,
+    nodeId: string,
+    attemptId: string,
+    update: WorkflowUpdateInput,
+  ): Promise<{ event: WorkflowTraceEvent; record: WorkflowUpdateRecord }> {
+    return await this.call<{ event: WorkflowTraceEvent; record: WorkflowUpdateRecord }>(
+      "store.publishUpdate",
+      { runId, state, nodeId, attemptId, update },
+      attemptId,
+    );
+  }
+
+  async findSettingsScope(
+    runId: string,
+    mountPath: string,
+    invocation: number,
+  ): Promise<WorkflowSettingsScopeRecord | undefined> {
+    return await this.call<WorkflowSettingsScopeRecord | undefined>("store.findSettingsScope", {
+      runId,
+      mountPath,
+      invocation,
+    });
+  }
+
+  async ensureSettingsScope(options: {
+    runId: string;
+    mountPath: string;
+    invocation: number;
+    settings: JsonValue;
+  }): Promise<WorkflowSettingsScopeRecord> {
+    return await this.call<WorkflowSettingsScopeRecord>("store.ensureSettingsScope", { options });
+  }
+
+  async getSettingsScopeAtChange(
+    scopeId: string,
+    changeNumber: number,
+  ): Promise<WorkflowSettingsScopeRecord | undefined> {
+    return await this.call<WorkflowSettingsScopeRecord | undefined>(
+      "store.getSettingsScopeAtChange",
+      { scopeId, changeNumber },
+    );
+  }
+
+  async createHumanDecisionRequest(request: HumanDecisionRequest): Promise<"created" | "adopted"> {
+    return await this.call<"created" | "adopted">(
+      "store.createHumanDecisionRequest",
+      { request },
+      request.attemptId,
+    );
+  }
+
+  async readResolvedHumanDecision(decisionId: string): Promise<ResolvedHumanDecision | null> {
+    return await this.call<ResolvedHumanDecision | null>("store.readResolvedHumanDecision", {
+      decisionId,
+    });
+  }
+
+  async reserveEffect(options: {
+    runId: string;
+    attemptId: string;
+    effectType: string;
+    idempotencyKey: string;
+    request: JsonValue;
+    recovery: WorkflowEffectRecovery;
+  }): Promise<WorkflowEffectReservation> {
+    return await this.call<WorkflowEffectReservation>(
+      "store.reserveEffect",
+      { options },
+      options.attemptId,
+    );
+  }
+
+  async settleEffect(options: {
+    runId: string;
+    effectId: string;
+    attemptNumber: number;
+    outcome: "applied" | "rejected" | "ambiguous" | "cancelled";
+    result?: JsonValue;
+    error?: string;
+  }): Promise<void> {
+    await this.call("store.settleEffect", { options });
+  }
+
+  async requestInteraction(options: {
+    attemptId: string;
+    kind: "agent" | "assistant" | "decision";
+    contract: JsonValue;
+  }): Promise<void> {
+    await this.call("interaction.request", { runId: this.runId, ...options }, options.attemptId);
+  }
+
+  async acceptInteraction(options: {
+    requestId: string;
+    submissionId: string;
+    attemptId: string;
+    value: JsonValue;
+  }): Promise<void> {
+    await this.call("interaction.accept", options, options.attemptId);
+  }
+
+  async rejectInteraction(options: {
+    requestId: string;
+    submissionId: string;
+    attemptId: string;
+    error: string;
+  }): Promise<void> {
+    await this.call("interaction.reject", options, options.attemptId);
+  }
+
+  async requestNotification(
+    request: WorkflowNotificationRequest,
+  ): Promise<WorkflowNotificationReceipt> {
+    return await this.call<WorkflowNotificationReceipt>(
+      "notification.request",
+      { request },
+      request.attemptId,
+    );
+  }
+
+  async requestPresentation(instructions: string): Promise<void> {
+    await this.call("presentation.request", { instructions });
+  }
+
+  private async call<T>(
+    operation: WorkerStoreOperation,
+    payload: Record<string, unknown>,
+    attemptId?: string,
+  ): Promise<T> {
+    const response = await this.transport.request({
+      messageId: randomUUID(),
+      operation,
+      kind: workerKindForOperation(operation, payload),
+      expectedRevision: this.revision,
+      ...(attemptId === undefined ? {} : { attemptId }),
+      payload: payload as JsonValue,
+    });
+    if (response.revision !== undefined) this.revision = response.revision;
+    return response.result as T;
+  }
+}

package/src/host/worker-supervisor.ts

@@ -0,0 +1,74 @@
+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);
+  }
+}

package/src/render/canvas.ts

@@ -1,3 +1,5 @@
+import { visibleWidth } from "@earendil-works/pi-tui";
+
 /**
  * A sparse character grid for drawing the workflow graph. Box-drawing
  * characters merge by connectivity (│ crossing ─ becomes ┼) so overlapping
@@ -94,6 +96,9 @@ export class CharCanvas {
       return;
     }
     if (existing) {
+      if (existing.char === "") {
+        return;
+      }
       const existingMask = CHAR_TO_MASK[existing.char];
       const incomingMask = CHAR_TO_MASK[char];
       if (existingMask !== undefined && incomingMask !== undefined) {
@@ -112,11 +117,40 @@ export class CharCanvas {
     row.set(x, { char, style });
   }
 
-  /** Write a text run left to right (labels, node lines). */
-  text(x: number, y: number, value: string, style: CanvasStyle = "plain"): void {
-    for (const [index, char] of [...value].entries()) {
-      this.put(x + index, y, char, style);
+  private writeText(
+    x: number,
+    y: number,
+    value: string,
+    style: CanvasStyle,
+    preserveSpaces: boolean,
+  ): void {
+    const row = this.row(y);
+    let cursor = x;
+    for (const char of value) {
+      const width = visibleWidth(char);
+      if (width === 0) {
+        let anchor = cursor - 1;
+        while (row.get(anchor)?.char === "") anchor -= 1;
+        const cell = row.get(anchor);
+        if (cell !== undefined && cell.char !== " ") cell.char += char;
+        continue;
+      }
+      if (char === " ") {
+        if (preserveSpaces) row.set(cursor, { char, style });
+      } else {
+        this.put(cursor, y, char, style);
+      }
+      for (let offset = 1; offset < width; offset += 1) {
+        row.set(cursor + offset, { char: "", style });
+      }
+      cursor += width;
     }
+    this.maxX = Math.max(this.maxX, cursor - 1);
+  }
+
+  /** Write a text run left to right in terminal display cells. */
+  text(x: number, y: number, value: string, style: CanvasStyle = "plain"): void {
+    this.writeText(x, y, value, style, false);
   }
 
   /**
@@ -129,7 +163,7 @@ export class CharCanvas {
       return false;
     }
     const row = this.cells.get(y);
-    const width = [...value].length;
+    const width = visibleWidth(value);
     for (let index = 0; index < width; index += 1) {
       if (row?.has(x + index)) {
         return false;
@@ -150,17 +184,17 @@ export class CharCanvas {
     if (x < 1 || y < 0) {
       return false;
     }
-    const chars = [...value];
+    const width = visibleWidth(value);
     const row = this.cells.get(y);
-    for (let index = -1; index <= chars.length; index += 1) {
+    for (let index = -1; index <= width; index += 1) {
       if (row?.get(x + index)?.char !== "─") {
         return false;
       }
     }
-    for (const [index, char] of chars.entries()) {
-      this.row(y).set(x + index, { char, style });
+    for (let index = 0; index < width; index += 1) {
+      this.row(y).delete(x + index);
     }
-    this.maxX = Math.max(this.maxX, x + chars.length - 1);
+    this.writeText(x, y, value, style, true);
     return true;
   }