Fix entry respawn signal forwarding

Fixes #931

src/process/spawn-with-signal-forwarding.test.ts

@@ -0,0 +1,104 @@
+import net from "node:net";
+import path from "node:path";
+import process from "node:process";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+import { spawnWithSignalForwarding } from "./spawn-with-signal-forwarding.js";
+
+function waitForLine(stream: NodeJS.ReadableStream, timeoutMs = 10_000): Promise<string> {
+  return new Promise((resolve, reject) => {
+    let buffer = "";
+
+    const timeout = setTimeout(() => {
+      cleanup();
+      reject(new Error("timeout waiting for line"));
+    }, timeoutMs);
+
+    const onData = (chunk: Buffer | string): void => {
+      buffer += chunk.toString();
+      const idx = buffer.indexOf("\n");
+      if (idx >= 0) {
+        const line = buffer.slice(0, idx).trim();
+        cleanup();
+        resolve(line);
+      }
+    };
+
+    const onError = (err: unknown): void => {
+      cleanup();
+      reject(err);
+    };
+
+    const cleanup = (): void => {
+      clearTimeout(timeout);
+      stream.off("data", onData);
+      stream.off("error", onError);
+    };
+
+    stream.on("data", onData);
+    stream.on("error", onError);
+  });
+}
+
+function canConnect(port: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    const socket = net.createConnection({ host: "127.0.0.1", port });
+    socket.once("connect", () => {
+      socket.end();
+      resolve(true);
+    });
+    socket.once("error", () => resolve(false));
+  });
+}
+
+describe("spawnWithSignalForwarding", () => {
+  const children: Array<{ kill: (signal?: NodeJS.Signals) => boolean }> = [];
+
+  afterEach(() => {
+    for (const child of children) {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+        // ignore
+      }
+    }
+    children.length = 0;
+  });
+
+  it(
+    "forwards SIGTERM to spawned child",
+    async () => {
+      const tsxPath = path.resolve(process.cwd(), "node_modules/.bin/tsx");
+      const childPath = path.resolve(process.cwd(), "test/fixtures/signal-forwarding/child.ts");
+
+      const { child } = spawnWithSignalForwarding(tsxPath, [childPath], {
+        stdio: ["ignore", "pipe", "inherit"],
+        env: process.env,
+      });
+      children.push(child);
+
+      if (!child.stdout) throw new Error("expected stdout");
+      const portLine = await waitForLine(child.stdout);
+      const port = Number(portLine);
+      expect(Number.isFinite(port)).toBe(true);
+
+      expect(await canConnect(port)).toBe(true);
+
+      // Simulate systemd sending SIGTERM to the parent process.
+      process.emit("SIGTERM");
+
+      await new Promise<void>((resolve, reject) => {
+        const timeout = setTimeout(() => reject(new Error("timeout waiting for child exit")), 10_000);
+        child.once("exit", () => {
+          clearTimeout(timeout);
+          resolve();
+        });
+      });
+
+      await new Promise((r) => setTimeout(r, 250));
+      expect(await canConnect(port)).toBe(false);
+    },
+    20_000,
+  );
+});

src/process/spawn-with-signal-forwarding.ts

@@ -0,0 +1,40 @@
+import type { ChildProcess, SpawnOptions } from "node:child_process";
+import { spawn } from "node:child_process";
+import process from "node:process";
+
+export type SpawnWithSignalForwardingOptions = {
+  signals?: NodeJS.Signals[];
+};
+
+export function spawnWithSignalForwarding(
+  command: string,
+  args: string[],
+  options: SpawnOptions,
+  { signals = ["SIGTERM", "SIGINT", "SIGHUP", "SIGQUIT"] }: SpawnWithSignalForwardingOptions = {},
+): { child: ChildProcess; detach: () => void } {
+  const child = spawn(command, args, options);
+
+  const listeners = new Map<NodeJS.Signals, () => void>();
+  for (const signal of signals) {
+    const listener = (): void => {
+      try {
+        child.kill(signal);
+      } catch {
+        // ignore
+      }
+    };
+    listeners.set(signal, listener);
+    process.on(signal, listener);
+  }
+
+  const detach = (): void => {
+    for (const [signal, listener] of listeners) {
+      process.off(signal, listener);
+    }
+    listeners.clear();
+  };
+
+  child.once("exit", detach);
+
+  return { child, detach };
+}