bun-workspaces 1.11.0 → 1.11.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bun-workspaces",
-  "version": "1.11.0",
+  "version": "1.11.1",
   "description": "A monorepo management tool for Bun, with a CLI and API to enhance Bun's native workspaces.",
   "license": "MIT",
   "exports": {

package/src/internal/core/runtime/onExit.mjs

@@ -33,7 +33,14 @@ const registerListeners = () => {
     const handleSignal = () => {
       runAllHandlers(signal);
       process.off(signal, handleSignal);
-      process.kill(0, signal);
+      // Re-raise the signal on ourselves so we exit with the conventional
+      // 128 + signum code via the signal's default action. Descendant
+      // cleanup is handled per-child by the subprocess registry (see
+      // src/runScript/subprocesses.ts), which kills each tracked child's
+      // process group individually. Broadcasting here via `kill(0, signal)`
+      // would also signal anyone sharing our pgid (e.g. a vitest worker
+      // that imported this code), which can deadlock the host runner.
+      process.kill(process.pid, signal);
     };
     process.on(signal, handleSignal);
   }

package/src/runScript/runScript.mjs

@@ -3,7 +3,7 @@ import {
   createProcessOutput,
 } from "./output/index.mjs";
 import { createScriptExecutor } from "./scriptExecution.mjs";
-import { createSubprocess } from "./subprocesses.mjs";
+import { createSubprocess, killSubprocessTree } from "./subprocesses.mjs";
 
 const SIGNAL_MAP = {
   130: "SIGINT",
@@ -79,7 +79,7 @@ const SIGNAL_MAP = {
     output: processOutput,
     exit,
     metadata,
-    kill: (exit) => proc.kill(exit),
+    kill: (exit) => killSubprocessTree(proc, exit ?? "SIGTERM"),
   };
 };
 

package/src/runScript/subprocesses.mjs

@@ -2,18 +2,54 @@ import { IS_WINDOWS, runOnExit } from "../internal/core/index.mjs";
 import { logger } from "../internal/logger/index.mjs";
 
 const SUBPROCESS_REGISTRY = {};
+/**
+ * Kill a tracked subprocess together with any descendants it has spawned.
+ *
+ * On POSIX, subprocesses are spawned with `detached: true`, which makes each
+ * child the leader of its own process group (pgid === pid). Signalling
+ * `-pid` therefore delivers the signal to every descendant in that group,
+ * not just the direct child. This is required for the common case of a
+ * shell wrapping a temp script: a plain `subprocess.kill()` only reaches
+ * the shell, leaving any grandchild (e.g. `bun build`) orphaned and
+ * reparented to init when the shell exits.
+ *
+ * On Windows there's no equivalent process-group semantics, so we fall back
+ * to a direct kill via the Bun.Subprocess handle.
+ */ const killSubprocessTree = (subprocess, signal) => {
+  if (IS_WINDOWS) {
+    subprocess.kill(signal);
+    return;
+  }
+  try {
+    process.kill(-subprocess.pid, signal);
+  } catch (error) {
+    const code = error.code;
+    if (code === "ESRCH") return;
+    if (code === "EPERM") {
+      try {
+        subprocess.kill(signal);
+      } catch (innerError) {
+        if (innerError.code !== "ESRCH") {
+          throw innerError;
+        }
+      }
+      return;
+    }
+    throw error;
+  }
+};
 runOnExit((codeOrSignal) => {
   Object.values(SUBPROCESS_REGISTRY).forEach((subprocess) => {
     /**
      * @todo Windows support for killing subprocesses is needed.
      * subprocess.kill() will throw with not-implemented error
      */ if (!subprocess.killed && subprocess.exitCode === null && !IS_WINDOWS) {
+      const signal =
+        typeof codeOrSignal === "string" ? codeOrSignal : "SIGTERM";
       logger.debug(
-        `Killing subprocess ${subprocess.pid} with signal ${codeOrSignal}`,
-      );
-      subprocess.kill(
-        typeof codeOrSignal === "string" ? codeOrSignal : "SIGTERM",
+        `Killing subprocess ${subprocess.pid} with signal ${signal}`,
       );
+      killSubprocessTree(subprocess, signal);
     }
   });
 });
@@ -23,7 +59,20 @@ runOnExit((codeOrSignal) => {
   argv,
   options,
 ) => {
-  const subprocess = Bun.spawn(argv, options);
+  const subprocess = Bun.spawn(argv, {
+    ...options,
+    // On POSIX, each tracked subprocess becomes the leader of its own
+    // process group so the registry can kill its full descendant tree via
+    // `process.kill(-pid, signal)` (see killSubprocessTree). Scoping the
+    // kill per child keeps the blast radius off the parent's process group,
+    // which matters when bun-workspaces is loaded inside another runner
+    // (e.g. a vitest worker) that shares our pgid.
+    ...(IS_WINDOWS
+      ? {}
+      : {
+          detached: true,
+        }),
+  });
   logger.debug(`Subprocess spawned with pid ${subprocess.pid}`);
   SUBPROCESS_REGISTRY[subprocess.pid] = subprocess;
   subprocess.exited.finally(() => {
@@ -32,4 +81,4 @@ runOnExit((codeOrSignal) => {
   return subprocess;
 };
 
-export { createSubprocess };
+export { createSubprocess, killSubprocessTree };