fix: force-kill worker pools and ptys on timeout/signal to prevent Windows CI hangs

On Windows, node-pty child processes survive process.exit() due to
conpty handle inheritance (microsoft/node-pty#887). When the global
timeout fires or the runner receives SIGTERM/SIGINT, worker pools
were not terminated, leaving orphaned pty processes that cause
GitHub Actions jobs to hang indefinitely.

Changes:
- Track active worker pools and terminate them before process.exit()
- Add SIGTERM/SIGINT handlers in the runner for graceful shutdown
- Track active terminals in workers and kill them on process exit

Co-authored-by: factory-droid[bot] <138933559+factory-droid[bot]@users.noreply.github.com>

Author: factory-davidgu

src/runner/runner.ts

@@ -41,8 +41,10 @@ type ExecutionOptions = {
 
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
 
+const activePools = new Set<Pool>();
+
 const createWorkerPool = (maxWorkers: number): Pool => {
-  return workerpool.pool(path.join(__dirname, "worker.js"), {
+  const pool = workerpool.pool(path.join(__dirname, "worker.js"), {
     workerType: "process",
     maxWorkers,
     forkOpts: {
@@ -54,6 +56,16 @@ const createWorkerPool = (maxWorkers: number): Pool => {
     },
     emitStdStreams: true,
   });
+  activePools.add(pool);
+  return pool;
+};
+
+const terminateAllPools = async () => {
+  const promises = [...activePools].map((pool) =>
+    pool.terminate(true).catch(() => {})
+  );
+  await Promise.allSettled(promises);
+  activePools.clear();
 };
 
 const runSuites = async (
@@ -118,6 +130,7 @@ const runSuites = async (
         }
         await filePool.exec("afterAllWorker", []);
       } finally {
+        activePools.delete(filePool);
         try {
           await filePool.terminate(true);
         } catch {
@@ -288,15 +301,28 @@ export const run = async (options: ExecutionOptions) => {
   }
   await reporter.start(allTests.length, shells, config.workers);
 
+  const forceExit = async (reason: string, code: number) => {
+    console.error(reason);
+    await terminateAllPools();
+    process.exit(code);
+  };
+
   if (config.globalTimeout > 0) {
     setTimeout(() => {
-      console.error(
-        `Error: global timeout (${config.globalTimeout} ms) exceeded`
+      void forceExit(
+        `Error: global timeout (${config.globalTimeout} ms) exceeded`,
+        1
       );
-      process.exit(1);
     }, config.globalTimeout);
   }
 
+  process.on("SIGTERM", () => {
+    void forceExit("Received SIGTERM, shutting down", 1);
+  });
+  process.on("SIGINT", () => {
+    void forceExit("Received SIGINT, shutting down", 1);
+  });
+
   await runSuites(
     rootSuite.suites,
     new Set(allTests.map((test) => test.id)),

src/runner/worker.ts

@@ -6,7 +6,7 @@ import { EventEmitter } from "node:events";
 import workerpool from "workerpool";
 
 import { Suite } from "../test/suite.js";
-import { spawn } from "../terminal/term.js";
+import { spawn, Terminal } from "../terminal/term.js";
 import { defaultShell } from "../terminal/shell.js";
 import { Snapshot, TestCase, TestStatus } from "../test/testcase.js";
 import { expect } from "../test/test.js";
@@ -15,6 +15,8 @@ import { poll } from "../utils/poll.js";
 import { flushSnapshotExecutionCache } from "../test/matchers/toMatchSnapshot.js";
 import { saveTrace, TracePoint } from "../trace/tracer.js";
 
+const activeTerminals = new Set<Terminal>();
+
 type WorkerResult = {
   error?: string;
   stdout?: string;
@@ -103,6 +105,7 @@ const runTest = async (
     trace,
     traceEmitter
   );
+  activeTerminals.add(terminal);
 
   // add slight delay for node-pty teardown
   let programExited: Promise<void> | undefined;
@@ -174,6 +177,7 @@ const runTest = async (
 
     await Promise.resolve(test.testFunction(testArgs));
   } finally {
+    activeTerminals.delete(terminal);
     try {
       terminal.kill();
     } catch {
@@ -456,6 +460,16 @@ if (!workerpool.isMainThread) {
   process.on("unhandledRejection", () => {
     // prevent worker crashes from unhandled promise rejections
   });
+  process.on("exit", () => {
+    for (const t of activeTerminals) {
+      try {
+        t.kill();
+      } catch {
+        // ignore
+      }
+    }
+    activeTerminals.clear();
+  });
   workerpool.worker({
     testWorker: testWorker,
     afterAllWorker: afterAllWorker,