Handle Deno subprocess stdin failures (#1418)

* Handle Deno subprocess stdin failures * Read the start message with raw fd reads so the fixture can close stdin without aborting ---------

morluto committed 3 months ago

Commit d3610e31 parent 8c717445 files · +193 −37Browse files

Unified · Split

5 files

.changeset/handle-deno-stdin-failures.md +5 −0
packages/kernel/runtime-deno-subprocess/src/deno-worker-process.ts +47 −2
packages/kernel/runtime-deno-subprocess/src/fixtures/close-stdin-worker.mjs +37 −0
packages/kernel/runtime-deno-subprocess/src/index.test.ts +23 −0
packages/kernel/runtime-deno-subprocess/src/index.ts +81 −35

.changeset/handle-deno-stdin-failures.md+5−0

@@ -0,0 +1,5 @@
	1	---
	2	"executor": patch
	3	---
	4
	5	Return an execution error when a Deno subprocess closes stdin instead of emitting an unhandled write failure.

packages/kernel/runtime-deno-subprocess/src/deno-worker-process.ts+47−2

   onStdoutLine: (line: string) => void;
   onStderr: (chunk: string) => void;
   onError: (error: Error) => void;
+  onStdinError: (error: Error) => void;
   onExit: (code: number | null, signal: NodeJS.Signals | null) => void;
 };
 export type DenoWorkerProcess = {
-  stdin: NodeJS.WritableStream;
+  ready: Promise<void>;
+  write: (data: string) => Promise<void>;
   dispose: () => void;
 };
     throw new Error("Failed to create piped stdio for Deno worker subprocess");
   }
+  const ready = new Promise<void>((resolve, reject) => {
+    const onSpawn = () => {
+      child.removeListener("error", onSpawnError);
+      resolve();
+    };
+    const onSpawnError = (cause: unknown) => {
+      child.removeListener("spawn", onSpawn);
+      reject(normalizeError(cause));
+    };
+    child.once("spawn", onSpawn);
+    child.once("error", onSpawnError);
+  });
   child.stdout.setEncoding("utf8");
   child.stderr.setEncoding("utf8");
     callbacks.onError(normalizeError(cause));
   };
+  const onStdinError = (cause: unknown) => {
+    callbacks.onStdinError(normalizeError(cause));
+  };
+  const onStdinClose = () => {
+    child.stdin.removeListener("error", onStdinError);
+  };
   const onExit = (code: number | null, signal: NodeJS.Signals | null) => {
     callbacks.onExit(code, signal);
   };
   child.stdout.on("data", onStdoutData);
   child.stderr.on("data", onStderrData);
+  child.stdin.on("error", onStdinError);
+  child.stdin.once("close", onStdinClose);
   child.on("error", onError);
   child.on("exit", onExit);
   let disposed = false;
+  const write = (data: string): Promise<void> =>
+    new Promise((resolve, reject) => {
+      if (disposed || !child.stdin.writable) {
+        reject(new Error("Deno subprocess stdin is not writable"));
+        return;
+      }
+      child.stdin.write(data, (cause: Error | null | undefined) => {
+        if (cause) {
+          reject(cause);
+          return;
+        }
+        resolve();
+      });
+    });
   const dispose = () => {
     if (disposed) {
       return;
     child.stderr!.removeListener("data", onStderrData);
     child.removeListener("error", onError);
     child.removeListener("exit", onExit);
+    child.stdin.destroy();
     if (!child.killed) {
       child.kill("SIGKILL");
   };
   return {
-    stdin: child.stdin,
+    ready,
+    write,
     dispose,
   };
 };

packages/kernel/runtime-deno-subprocess/src/fixtures/close-stdin-worker.mjs+37−0

@@ -0,0 +1,37 @@
	1	#!/usr/bin/env node
	2
	3	// Reads the start message with raw fd reads instead of a stdin stream: only
	4	// an unwatched fd can be closed here, since libuv aborts the process when
	5	// fd 0 is closed while a stream watcher is attached, and a stream destroy()
	6	// never closes the underlying stdio fd, so the host's writes would keep
	7	// succeeding instead of failing with EPIPE.
	8
	9	import { closeSync, readSync } from "node:fs";
	10
	11	let buffered = "";
	12	const chunk = Buffer.alloc(4096);
	13	while (!buffered.includes("\n")) {
	14	try {
	15	const bytesRead = readSync(0, chunk, 0, chunk.length);
	16	if (bytesRead <= 0) break;
	17	buffered += chunk.toString("utf8", 0, bytesRead);
	18	} catch (error) {
	19	if (error.code === "EAGAIN") continue;
	20	throw error;
	21	}
	22	}
	23
	24	const { nonce } = JSON.parse(buffered.slice(0, buffered.indexOf("\n")));
	25
	26	closeSync(0);
	27	process.stdout.write(
	28	`@@executor-ipc@@${JSON.stringify({
	29	type: "tool_call",
	30	nonce,
	31	requestId: "request-1",
	32	toolPath: "test.call",
	33	args: {},
	34	})}\n`,
	35	);
	36
	37	setTimeout(() => process.exit(0), 5_000);

packages/kernel/runtime-deno-subprocess/src/index.test.ts+23−0

@@ -1,3 +1,5 @@
		1	import { fileURLToPath } from "node:url";
		2
1	import { describe, expect, it } from "@effect/vitest";	3	import { describe, expect, it } from "@effect/vitest";
2	import * as Data from "effect/Data";	4	import * as Data from "effect/Data";
3	import * as Effect from "effect/Effect";	5	import * as Effect from "effect/Effect";
@@ -39,6 +41,27 @@ it.effect("returns an actionable error when Deno is missing", () => · 35 unmodified lines
39	}),	41	}),
40	);	42	);
41		43
		44	it.effect.skipIf(process.platform === "win32")(
		45	"returns an execution error when the subprocess closes stdin",
		46	() =>
		47	Effect.gen(function* () {
		48	const executor = makeDenoSubprocessExecutor({
		49	denoExecutable: fileURLToPath(
		50	new URL("./fixtures/close-stdin-worker.mjs", import.meta.url),
		51	),
		52	timeoutMs: 5_000,
		53	});
		54	const toolInvoker = makeTestInvoker({
		55	"test.call": () => "done",
		56	});
		57
		58	const output = yield* executor.execute("return tools.test.call({});", toolInvoker);
		59
		60	expect(output.result).toBeNull();
		61	expect(output.error).toContain("Failed to write to Deno subprocess stdin");
		62	}),
		63	);
		64
42	describe.skipIf(!isDenoAvailable())("runtime-deno-subprocess", () => {	65	describe.skipIf(!isDenoAvailable())("runtime-deno-subprocess", () => {
43	it.effect("executes simple code and returns result", () =>	66	it.effect("executes simple code and returns result", () =>
44	Effect.gen(function* () {	67	Effect.gen(function* () {

packages/kernel/runtime-deno-subprocess/src/index.ts+81−35

 import * as Queue from "effect/Queue";
 import * as Schema from "effect/Schema";
-import { type DenoPermissions, spawnDenoWorkerProcess } from "./deno-worker-process";
+import {
+  type DenoPermissions,
+  type DenoWorkerProcess,
+  spawnDenoWorkerProcess,
+} from "./deno-worker-process";
 export type { DenoPermissions };
   }
 }
+class DenoProcessWriteError extends Data.TaggedError("DenoProcessWriteError")<{
+  readonly reason: unknown;
+}> {
+  override get message() {
+    const detail = this.reason instanceof Error ? this.reason.message : String(this.reason);
+    return `Failed to write to Deno subprocess stdin: ${detail}`;
+  }
+}
 // ---------------------------------------------------------------------------
 // IPC schemas
 // ---------------------------------------------------------------------------
   return String(squashed);
 };
-const writeMessage = (stdin: NodeJS.WritableStream, message: HostToWorkerMessage): void => {
+const writeMessage = (
-  stdin.write(`${JSON.stringify(message)}\n`);
+  worker: DenoWorkerProcess,
-};
+  message: HostToWorkerMessage,
+): Effect.Effect<void, DenoProcessWriteError> =>
+  Effect.tryPromise({
+    try: () => worker.write(`${JSON.stringify(message)}\n`),
+    catch: (reason) => new DenoProcessWriteError({ reason }),
+  });
 // ---------------------------------------------------------------------------
 // Core execution
                 }),
               );
             },
+            onStdinError: (cause) => {
+              runSync(
+                completeWith({
+                  result: null,
+                  error: new DenoProcessWriteError({ reason: cause }).message,
+                }),
+              );
+            },
             onExit: (exitCode, signal) => {
               runSync(
                 completeWith({
     let inFlight = 0;
     let lastReturnedAt = start;
-    // Send code to the subprocess
+    const startError = yield* Effect.gen(function* () {
-    writeMessage(worker.stdin, { type: "start", code: recoveredBody, nonce });
+      yield* Effect.tryPromise({
+        try: () => worker.ready,
+        catch: (reason) => new DenoSpawnError({ executable: denoExecutable, reason }),
+      });
+      yield* writeMessage(worker, { type: "start", code: recoveredBody, nonce });
+    }).pipe(
+      Effect.as<Error | undefined>(undefined),
+      Effect.catch((error) => Effect.succeed(error)),
+      Effect.onInterrupt(() => Effect.sync(worker.dispose)),
+    );
+    if (startError) {
+      worker.dispose();
+      return { result: null, error: startError.message };
+    }
     // Measure only continuous autonomous subprocess compute. Tool dispatches
     // suspend the clock and each return grants a fresh timeout budget.
               // must run even if the invoke or write dies, or the watchdog's
               // in-flight guard would suspend the timeout forever.
               inFlight += 1;
-              yield* toolInvoker.invoke({ path: msg.toolPath, args: msg.args }).pipe(
+              const writeSucceeded = yield* toolInvoker
-                Effect.map(
+                .invoke({ path: msg.toolPath, args: msg.args })
-                  (value): HostToWorkerMessage => ({
+                .pipe(
-                    type: "tool_result",
+                  Effect.map(
-                    nonce,
+                    (value): HostToWorkerMessage => ({
-                    requestId: msg.requestId,
+                      type: "tool_result",
-                    ok: true,
+                      nonce,
-                    value,
+                      requestId: msg.requestId,
-                  }),
+                      ok: true,
-                ),
+                      value,
-                Effect.catchCause((cause) =>
+                    }),
-                  Effect.succeed<HostToWorkerMessage>({
+                  ),
-                    type: "tool_result",
+                  Effect.catchCause((cause) =>
-                    nonce,
+                    Effect.succeed<HostToWorkerMessage>({
-                    requestId: msg.requestId,
+                      type: "tool_result",
-                    ok: false,
+                      nonce,
-                    error: causeMessage(cause),
+                      requestId: msg.requestId,
-                  }),
+                      ok: false,
-                ),
+                      error: causeMessage(cause),
-                Effect.flatMap((toolResult) =>
+                    }),
-                  Effect.sync(() => writeMessage(worker.stdin, toolResult)),
+                  ),
-                ),
+                  Effect.flatMap((toolResult) => writeMessage(worker, toolResult)),
-                Effect.ensuring(
+                  Effect.as(true),
-                  Effect.sync(() => {
+                  Effect.catchTag("DenoProcessWriteError", (error) =>
-                    inFlight -= 1;
+                    completeWith({ result: null, error: error.message }).pipe(Effect.as(false)),
-                    lastReturnedAt = Date.now();
+                  ),
-                  }),
+                  Effect.ensuring(
-                ),
+                    Effect.sync(() => {
-              );
+                      inFlight -= 1;
+                      lastReturnedAt = Date.now();
+                    }),
+                  ),
+                );
+              if (!writeSucceeded) {
+                return;
+              }
               break;
             }

Handle Deno subprocess stdin failures (#1418)

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code