@osolmaz/pi-workflows 0.16.2 → 0.16.3

package/src/server/resource-runner-supervisor.ts

@@ -0,0 +1,76 @@
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { canonicalJson, type JsonValue } from "../state/json.js";
+import { ChildRunnerSupervisor, type SupervisedRunnerResult } from "./child-runner-supervisor.js";
+import { ServerProcessRegistry, type ProcessIdentity } from "./processes.js";
+import {
+  encodeResourceRunnerLine,
+  parseResourceRunnerMessage,
+  type ResourceRunnerLaunchEnvelope,
+  type ResourceRunnerMessage,
+  type ResourceRunnerResponse,
+} from "./resource-runner-protocol.js";
+import type { RunnerOutcome } from "./state.js";
+
+export class ResourceRunnerSupervisor {
+  private readonly supervisor: ChildRunnerSupervisor<ResourceRunnerMessage, ResourceRunnerResponse>;
+
+  constructor(
+    readonly envelope: ResourceRunnerLaunchEnvelope,
+    private readonly options: {
+      registry: ServerProcessRegistry;
+      onMessage: (message: ResourceRunnerMessage) => Promise<ResourceRunnerResponse>;
+      env?: Record<string, string>;
+      startupTimeoutMs?: number;
+      runnerEntryPath?: string;
+      onSpawn?: (identity: ProcessIdentity) => void;
+      onDiagnostic?: (message: string) => void;
+    },
+  ) {
+    this.supervisor = new ChildRunnerSupervisor({
+      label: "Resource runner",
+      registry: options.registry,
+      onMessage: options.onMessage,
+      parseMessage: parseResourceRunnerMessage,
+      encodeResponse: encodeResourceRunnerLine,
+      isReady: (message) => message.operation === "runner.ready",
+      isTerminal: (message) =>
+        message.operation === "runner.finished" || message.operation === "runner.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("./resource-runner-entry.js", import.meta.url));
+    const sourceEntry = fileURLToPath(new URL("./resource-runner-entry.ts", import.meta.url));
+    const runnerEntry = this.options.runnerEntryPath ?? builtEntry;
+    const args =
+      this.options.runnerEntryPath === undefined && !fs.existsSync(builtEntry)
+        ? ["--import", createRequire(import.meta.url).resolve("tsx"), sourceEntry]
+        : [runnerEntry];
+    await this.supervisor.start({
+      args,
+      cwd: this.envelope.projectPath,
+      env: {
+        ...process.env,
+        ...this.options.env,
+        PI_WORKFLOWS_RESOURCE_RUNNER_LAUNCH: Buffer.from(
+          canonicalJson(this.envelope as unknown as JsonValue),
+        ).toString("base64url"),
+      },
+    });
+  }
+
+  async wait(): Promise<SupervisedRunnerResult> {
+    return await this.supervisor.wait();
+  }
+
+  async stop(outcome: RunnerOutcome = "cancelled"): Promise<void> {
+    await this.supervisor.stop(outcome);
+  }
+}

package/src/{host → server}/rpc-bridge.ts

@@ -8,9 +8,9 @@ export const RPC_SUBMISSION_PREFIX = "PI_WORKFLOWS_STEP_SUBMISSION ";
 
 /**
  * Loaded into headless `pi --mode rpc` children spawned by the standalone
- * host. The child has no workflow engine, so this bridge only registers the
- * `workflow` tool and reports every submission to the host over stderr; the
- * host validates against the engine and re-prompts on rejection.
+ * server. The child has no workflow engine, so this bridge only registers the
+ * `workflow` tool and reports every submission to the server over stderr; the
+ * server validates against the engine and re-prompts on rejection.
  */
 export default function piWorkflowsRpcBridge(pi: ExtensionAPI) {
   pi.registerTool({

package/src/{host → server}/rpc-executor.ts

@@ -47,7 +47,7 @@ export type RpcStepExecutorOptions = {
   abortGraceMs?: number;
   /** Absolute path to the pi binary; defaults to the installed `pi`. */
   piBin?: string;
-  /** Extra environment for the child; the host's environment is inherited. */
+  /** Extra environment for the child; the server's environment is inherited. */
   env?: Record<string, string>;
   /** Extra pi arguments, for example a model override. */
   piArgs?: string[];
@@ -163,7 +163,7 @@ export class RpcStepExecutor implements AgentStepExecutor {
         "--no-session",
         // Isolation is required: an installed pi-workflows extension would
         // otherwise load beside the bridge, register a competing workflow
-        // tool, and start its own resume and controller workers.
+        // tool, and start its own resume and resource runners.
         "--no-extensions",
         "-e",
         BRIDGE_PATH,
@@ -182,7 +182,7 @@ export class RpcStepExecutor implements AgentStepExecutor {
       this.wakeSubmissionWaiters();
     });
     // A failed spawn (missing binary, EACCES) emits error instead of exit;
-    // without a listener it would crash the host as an uncaught exception.
+    // without a listener it would crash the server as an uncaught exception.
     child.on("error", (error) => {
       this.childExited = { code: null, signal: error.message };
       this.wakeSubmissionWaiters();
@@ -258,7 +258,7 @@ export class RpcStepExecutor implements AgentStepExecutor {
       if (found?.action === "submit") return found;
       if (found?.action === "update") {
         if (request.publishUpdate === undefined) {
-          throw new Error("This workflow host does not support step updates");
+          throw new Error("This workflow server does not support step updates");
         }
         try {
           await request.publishUpdate(found.update, found.idempotencyKey);

package/src/{host/host-entry.ts → server/server-entry.ts}

@@ -1,19 +1,19 @@
 #!/usr/bin/env node
 import { errorMessage } from "../workflows/errors.js";
-import { WorkflowHost } from "./runner.js";
+import { WorkflowServer } from "./server.js";
 
 async function main(): Promise<void> {
   const databaseIndex = process.argv.indexOf("--database");
   const databasePath = databaseIndex < 0 ? undefined : process.argv[databaseIndex + 1];
-  const host = new WorkflowHost({
+  const server = new WorkflowServer({
     ...(databasePath === undefined ? {} : { databasePath }),
-    onLog: (message) => process.stderr.write(`[pi-workflows host] ${message}\n`),
+    onLog: (message) => process.stderr.write(`[pi-workflows server] ${message}\n`),
   });
-  const shutdown = () => void host.stop();
+  const shutdown = () => void server.stop();
   process.once("SIGINT", shutdown);
   process.once("SIGTERM", shutdown);
   try {
-    await host.start();
+    await server.start();
   } catch (error) {
     process.stderr.write(`${errorMessage(error)}\n`);
     process.exitCode = 1;