@testmuai/rook 0.1.0

package/bin/rook.test.mjs

@@ -0,0 +1,456 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import {
+  mkdirSync,
+  rmSync,
+  writeFileSync,
+  chmodSync,
+  existsSync,
+  readFileSync,
+} from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync, spawn } from "node:child_process";
+import { EventEmitter } from "node:events";
+
+const BIN_DIR = dirname(fileURLToPath(import.meta.url));
+
+function fakePkgRoot(tag) {
+  return join(BIN_DIR, "node_modules", "@testmuai", `rook-node-${tag}`);
+}
+
+function writeFakePackage(tag, binName) {
+  const root = fakePkgRoot(tag);
+  mkdirSync(join(root, "bin"), { recursive: true });
+  writeFileSync(
+    join(root, "package.json"),
+    JSON.stringify({ name: `@testmuai/rook-node-${tag}` }),
+  );
+  writeFileSync(join(root, "bin", binName), "#!/bin/sh\n");
+  return join(root, "bin", binName);
+}
+
+describe("rook.cjs bundled runtime resolution", () => {
+  const originalPlatform = process.platform;
+  const originalArch = process.arch;
+
+  beforeEach(() => {
+    delete process.env.ROOK_SYSTEM_NODE;
+    // findBundledNode()'s require.resolve() caches a SUCCESSFUL resolution
+    // even after the resolved file is later deleted (verified directly:
+    // Node's Module._pathCache does not invalidate on filesystem changes).
+    // vi.resetModules() forces rook.cjs to be genuinely re-evaluated on the
+    // next import() (verified: without it, a plain `?t=` query on the
+    // import specifier does NOT force re-evaluation — the module runs once
+    // for the whole file) — but a stale-resolved SPECIFIER can still leak
+    // across tests within the same process even so, which is why "no
+    // platform package resolves" below deliberately probes a tag no other
+    // test in this file ever creates a real package for, rather than
+    // relying on re-evaluation alone to avoid the collision.
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    Object.defineProperty(process, "platform", { value: originalPlatform });
+    Object.defineProperty(process, "arch", { value: originalArch });
+    rmSync(join(BIN_DIR, "node_modules"), { recursive: true, force: true });
+  });
+
+  it("resolves the bundled node path when the platform package is installed (darwin-arm64)", async () => {
+    const expected = writeFakePackage("darwin-arm64", "node");
+    Object.defineProperty(process, "platform", { value: "darwin" });
+    Object.defineProperty(process, "arch", { value: "arm64" });
+
+    const { findBundledNode } = await import("./rook.cjs?t=" + Date.now());
+    expect(findBundledNode()).toBe(expected);
+  });
+
+  it("resolves the bundled node path on darwin-x64", async () => {
+    const expected = writeFakePackage("darwin-x64", "node");
+    Object.defineProperty(process, "platform", { value: "darwin" });
+    Object.defineProperty(process, "arch", { value: "x64" });
+
+    const { findBundledNode } = await import("./rook.cjs?t=" + Date.now());
+    expect(findBundledNode()).toBe(expected);
+  });
+
+  it("resolves the bundled node path on linux-arm64", async () => {
+    const expected = writeFakePackage("linux-arm64", "node");
+    Object.defineProperty(process, "platform", { value: "linux" });
+    Object.defineProperty(process, "arch", { value: "arm64" });
+
+    const { findBundledNode } = await import("./rook.cjs?t=" + Date.now());
+    expect(findBundledNode()).toBe(expected);
+  });
+
+  it("resolves node.exe on win32/x64", async () => {
+    const expected = writeFakePackage("win-x64", "node.exe");
+    Object.defineProperty(process, "platform", { value: "win32" });
+    Object.defineProperty(process, "arch", { value: "x64" });
+
+    const { findBundledNode } = await import("./rook.cjs?t=" + Date.now());
+    expect(findBundledNode()).toBe(expected);
+  });
+
+  it("returns null when no platform package resolves (linux-x64)", async () => {
+    // Deliberately linux-x64, not darwin-arm64: no other test in this file
+    // ever creates a real @testmuai/rook-node-linux-x64 package, so this
+    // is the only specifier require.resolve() ever sees for that exact
+    // string — guaranteeing a genuine, uncached MODULE_NOT_FOUND rather
+    // than accidentally observing a stale successful resolution left by an
+    // earlier test that happened to install the same-tagged package.
+    Object.defineProperty(process, "platform", { value: "linux" });
+    Object.defineProperty(process, "arch", { value: "x64" });
+
+    const { findBundledNode } = await import("./rook.cjs?t=" + Date.now());
+    expect(findBundledNode()).toBeNull();
+  });
+
+  it("returns null when ROOK_SYSTEM_NODE=1, even though the platform package resolves", async () => {
+    writeFakePackage("darwin-arm64", "node");
+    process.env.ROOK_SYSTEM_NODE = "1";
+    Object.defineProperty(process, "platform", { value: "darwin" });
+    Object.defineProperty(process, "arch", { value: "arm64" });
+
+    const { findBundledNode } = await import("./rook.cjs?t=" + Date.now());
+    expect(findBundledNode()).toBeNull();
+  });
+
+  it("returns null on an unsupported platform, even if a same-named package would resolve", async () => {
+    writeFakePackage("darwin-arm64", "node");
+    Object.defineProperty(process, "platform", { value: "aix" });
+
+    const { findBundledNode } = await import("./rook.cjs?t=" + Date.now());
+    expect(findBundledNode()).toBeNull();
+  });
+});
+
+// shouldForward is a pure function of its (signal, platform) arguments
+// (unlike findBundledNode, which reads process.platform/arch directly), so
+// no Object.defineProperty override or module reset is needed to exercise
+// every branch.
+describe("rook.cjs shouldForward", () => {
+  it("does not forward SIGINT or SIGHUP on win32 — child.kill() there is always an unconditional hard kill (SIGINT would duplicate a shutdown the child already gets natively) or throws outright (SIGHUP isn't in libuv's supported set on Windows)", async () => {
+    const { shouldForward } = await import("./rook.cjs");
+    expect(shouldForward("SIGINT", "win32")).toBe(false);
+    expect(shouldForward("SIGHUP", "win32")).toBe(false);
+  });
+
+  it("still forwards SIGTERM on win32 — the one signal with no native Windows delivery path to the child at all", async () => {
+    const { shouldForward } = await import("./rook.cjs");
+    expect(shouldForward("SIGTERM", "win32")).toBe(true);
+  });
+
+  it("forwards SIGINT, SIGTERM, and SIGHUP on POSIX platforms, unchanged from before the win32 fix", async () => {
+    const { shouldForward } = await import("./rook.cjs");
+    for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+      expect(shouldForward(signal, "darwin")).toBe(true);
+      expect(shouldForward(signal, "linux")).toBe(true);
+    }
+  });
+});
+
+// wireSignalForwarding is the actual behavioral fix — shouldForward alone
+// only proves which signals are eligible, not that the surrounding
+// signaled/spawned/killFailed control flow reacts to them correctly. A
+// fake child (plain EventEmitter + a stubbed kill()) and a fake process
+// object (records what it's told rather than doing it) let these run
+// fully deterministically and in-process: driving the real `process`
+// through this code would register real signal listeners on the test
+// runner and could call its real process.exit()/process.kill(), which is
+// exactly why the OS-level tests further down spawn a genuine subprocess
+// instead. Here we don't need real OS signal delivery or real process
+// lifecycle — only that the function reacts to the events correctly.
+describe("rook.cjs wireSignalForwarding", () => {
+  function fakeChild() {
+    const child = new EventEmitter();
+    child.killCalls = [];
+    child.kill = vi.fn((signal) => {
+      child.killCalls.push(signal);
+    });
+    return child;
+  }
+
+  function fakeProcess() {
+    const listeners = new Map();
+    const events = [];
+    return {
+      events,
+      pid: 4242,
+      on(signal, fn) {
+        if (!listeners.has(signal)) listeners.set(signal, new Set());
+        listeners.get(signal).add(fn);
+      },
+      removeListener(signal, fn) {
+        listeners.get(signal)?.delete(fn);
+      },
+      emit(signal) {
+        for (const fn of listeners.get(signal) ?? []) fn(signal);
+      },
+      exit(code) {
+        events.push({ type: "exit", code });
+      },
+      kill(pid, signal) {
+        events.push({ type: "kill", pid, signal });
+      },
+      stderr: {
+        write(text) {
+          events.push({ type: "stderr", text });
+        },
+      },
+    };
+  }
+
+  it("falls back to the system Node path even when a signal was forwarded just before the spawn failure is detected — the race a naive signaled-only check would hang on", async () => {
+    const { wireSignalForwarding } = await import("./rook.cjs");
+    const child = fakeChild();
+    const proc = fakeProcess();
+    const onSpawnFailure = vi.fn();
+
+    wireSignalForwarding(child, {
+      bundledNode: "/fake/node",
+      entry: "/fake/entry.js",
+      platform: "linux",
+      proc,
+      onSpawnFailure,
+    });
+
+    // A signal arrives and is forwarded before the child has ever
+    // confirmed it actually spawned.
+    proc.emit("SIGTERM");
+    expect(child.killCalls).toEqual(["SIGTERM"]);
+
+    // The async spawn failure is now detected — no 'spawn' event was ever
+    // emitted, so this can only be a genuine spawn failure, not a failed
+    // kill, regardless of the signal that already landed.
+    child.emit("error", new Error("spawn ENOENT"));
+
+    expect(onSpawnFailure).toHaveBeenCalledTimes(1);
+    expect(onSpawnFailure).toHaveBeenCalledWith("/fake/entry.js");
+  });
+
+  it("does not launch a second CLI instance when a signal delivery fails after the child is confirmed alive — waits for the real exit instead", async () => {
+    const { wireSignalForwarding } = await import("./rook.cjs");
+    const child = fakeChild();
+    const proc = fakeProcess();
+    const onSpawnFailure = vi.fn();
+
+    wireSignalForwarding(child, {
+      bundledNode: "/fake/node",
+      entry: "/fake/entry.js",
+      platform: "linux",
+      proc,
+      onSpawnFailure,
+    });
+
+    child.emit("spawn");
+    proc.emit("SIGTERM");
+    expect(child.killCalls).toEqual(["SIGTERM"]);
+
+    // The kill attempt itself failed (delivered as 'error', not a throw) —
+    // the child may still be alive.
+    child.emit("error", new Error("kill EPERM"));
+    expect(onSpawnFailure).not.toHaveBeenCalled();
+
+    // The child genuinely exits later (the forwarded signal landing after
+    // all, or the child dying on its own) — normal cleanup must still run,
+    // proving settled was never latched by the branch above.
+    child.emit("exit", null, "SIGTERM");
+    expect(proc.events).toContainEqual({
+      type: "kill",
+      pid: proc.pid,
+      signal: "SIGTERM",
+    });
+  });
+
+  it("force-exits on the next signal after a kill attempt has already failed, instead of swallowing every later signal forever", async () => {
+    const { wireSignalForwarding } = await import("./rook.cjs");
+    const child = fakeChild();
+    child.kill = vi.fn(() => {
+      throw new Error("unsupported signal");
+    });
+    const proc = fakeProcess();
+
+    wireSignalForwarding(child, {
+      bundledNode: "/fake/node",
+      entry: "/fake/entry.js",
+      platform: "win32",
+      proc,
+      onSpawnFailure: vi.fn(),
+    });
+
+    proc.emit("SIGTERM"); // shouldForward("SIGTERM", "win32") is true; kill() throws
+    expect(proc.events.some((e) => e.type === "exit")).toBe(false);
+
+    proc.emit("SIGTERM"); // killFailed already true — give up and force-exit
+    expect(proc.events).toContainEqual({ type: "exit", code: 1 });
+  });
+
+  it("listens for SIGINT on win32 but never calls child.kill() for it — the observe-without-forwarding path", async () => {
+    const { wireSignalForwarding } = await import("./rook.cjs");
+    const child = fakeChild();
+    const proc = fakeProcess();
+
+    wireSignalForwarding(child, {
+      bundledNode: "/fake/node",
+      entry: "/fake/entry.js",
+      platform: "win32",
+      proc,
+      onSpawnFailure: vi.fn(),
+    });
+
+    proc.emit("SIGINT");
+    expect(child.killCalls).toEqual([]);
+  });
+});
+
+// Spawns rook.cjs as a genuine subprocess (via the real system Node, not
+// import()) rather than calling main() in-process — main() calls
+// process.exit()/process.kill() on every path, which would kill the test
+// runner itself. This is also the only way to observe what a real caller
+// sees: Node's own spawnSync result.signal, not a shell's collapsed exit
+// code, which cannot tell "exited 143" and "killed by SIGTERM" apart.
+describe("rook.cjs signal propagation (real subprocess)", () => {
+  const originalPlatform = process.platform;
+  const originalArch = process.arch;
+
+  beforeEach(() => {
+    delete process.env.ROOK_SYSTEM_NODE;
+  });
+
+  afterEach(() => {
+    Object.defineProperty(process, "platform", { value: originalPlatform });
+    Object.defineProperty(process, "arch", { value: originalArch });
+    rmSync(join(BIN_DIR, "node_modules"), { recursive: true, force: true });
+    rmSync(join(BIN_DIR, "child.pid"), { force: true });
+  });
+
+  // Both fixtures below need this file's own platform/arch (spawnSync's
+  // child inherits the real host, unlike the Object.defineProperty
+  // overrides used above, which only affect the current in-process
+  // module). Only darwin/linux are covered — there's no POSIX self-kill
+  // shell fixture for a win32 host, and this is exercising main()'s
+  // signal-handling logic, not per-OS behavior.
+  function hostTag() {
+    if (process.platform === "darwin" && process.arch === "arm64")
+      return "darwin-arm64";
+    if (process.platform === "darwin" && process.arch === "x64")
+      return "darwin-x64";
+    if (process.platform === "linux" && process.arch === "arm64")
+      return "linux-arm64";
+    if (process.platform === "linux" && process.arch === "x64")
+      return "linux-x64";
+    return null;
+  }
+
+  function writeExecutableFixture(tag, script) {
+    const root = fakePkgRoot(tag);
+    mkdirSync(join(root, "bin"), { recursive: true });
+    writeFileSync(
+      join(root, "package.json"),
+      JSON.stringify({ name: `@testmuai/rook-node-${tag}` }),
+    );
+    const binPath = join(root, "bin", "node");
+    writeFileSync(binPath, script);
+    chmodSync(binPath, 0o755);
+    return binPath;
+  }
+
+  it("propagates a bundled runtime's signal death instead of collapsing to exit 1", () => {
+    const tag = hostTag();
+    if (!tag) return; // no POSIX fixture for this host — see hostTag()
+    writeExecutableFixture(tag, "#!/bin/sh\nkill -TERM $$\n");
+
+    const result = spawnSync(process.execPath, [join(BIN_DIR, "rook.cjs")], {
+      cwd: BIN_DIR,
+    });
+
+    expect(result.signal).toBe("SIGTERM");
+    expect(result.status).toBeNull();
+  });
+
+  // Positive control for the test above: proves the fixture/spawn harness
+  // itself works and that a normal (non-signal) exit still passes its real
+  // code straight through unchanged — so the signal test failing "for
+  // real" (status stays null, no SIGTERM observed) can't be mistaken for a
+  // broken fixture rather than a broken fix.
+  it("exits with the bundled runtime's real exit code on a normal exit", () => {
+    const tag = hostTag();
+    if (!tag) return;
+    writeExecutableFixture(tag, "#!/bin/sh\nexit 7\n");
+
+    const result = spawnSync(process.execPath, [join(BIN_DIR, "rook.cjs")], {
+      cwd: BIN_DIR,
+    });
+
+    expect(result.signal).toBeNull();
+    expect(result.status).toBe(7);
+  });
+
+  // The two tests above cover a signal death starting IN the child and
+  // propagating UP to the trampoline. This one covers the other direction:
+  // a signal sent to the trampoline's own PID (docker stop, systemd
+  // KillMode=process, timeout(1), a supervisor targeting the advertised
+  // PID) has to be forwarded DOWN to the bundled child, or the child is
+  // left running, orphaned, with inherited stdio — reproduced directly
+  // before the fix (kill -TERM to just the trampoline's PID left the
+  // fixture child alive afterward). Needs async spawn(), not spawnSync():
+  // the trampoline must still be running when the signal arrives so there
+  // is something to send it to.
+  it("forwards a signal sent to just the trampoline's PID down to the bundled child, instead of orphaning it", async () => {
+    const tag = hostTag();
+    if (!tag) return;
+    const childPidFile = join(BIN_DIR, "child.pid");
+    rmSync(childPidFile, { force: true });
+    writeExecutableFixture(
+      tag,
+      `#!/bin/sh\necho $$ > ${JSON.stringify(childPidFile)}\nsleep 30\n`,
+    );
+
+    const trampoline = spawn(process.execPath, [join(BIN_DIR, "rook.cjs")], {
+      cwd: BIN_DIR,
+      stdio: "ignore",
+    });
+
+    const childPid = await waitForFileContent(childPidFile, 5000);
+    expect(childPid).toBeTruthy();
+
+    const exited = new Promise((resolve) => trampoline.on("exit", resolve));
+    // kill(pid) (no leading dash) always targets exactly that one
+    // process, never its process group — unlike an interactive
+    // terminal's Ctrl-C, which reaches the whole group and would mask
+    // this bug even without the fix.
+    process.kill(trampoline.pid, "SIGTERM");
+    await exited;
+    // Give the forwarded signal a moment to actually land before checking.
+    await new Promise((resolve) => setTimeout(resolve, 300));
+
+    expect(isAlive(Number(childPid))).toBe(false);
+  });
+});
+
+function waitForFileContent(path, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  return new Promise((resolve, reject) => {
+    const poll = () => {
+      if (existsSync(path)) {
+        resolve(readFileSync(path, "utf8").trim());
+        return;
+      }
+      if (Date.now() > deadline) {
+        reject(new Error(`timed out waiting for ${path}`));
+        return;
+      }
+      setTimeout(poll, 20);
+    };
+    poll();
+  });
+}
+
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}