fix(child_process): kill() returns false once the child has exited

docs/runtime/child-process.mdx

@@ -559,7 +559,7 @@ interface Subprocess extends AsyncDisposable {
   readonly signalCode: NodeJS.Signals | null;
   readonly killed: boolean;
 
-  kill(exitCode?: number | NodeJS.Signals): void;
+  kill(signal?: number | NodeJS.Signals): boolean;
   ref(): void;
   unref(): void;
 

packages/bun-types/bun.d.ts

@@ -7249,10 +7249,13 @@ declare module "bun" {
     readonly killed: boolean;
 
     /**
-     * Kill the process
-     * @param exitCode The exitCode to send to the process
+     * Send a signal to the process, or probe for its existence with `0`
+     * (POSIX-style existence check that does not terminate the child).
+     * @param signal The signal to send to the process. Defaults to `"SIGTERM"`.
+     * @returns `true` if the signal was sent (or, for `signal === 0`, the
+     * process is still alive); `false` if the process has already exited.
      */
-    kill(exitCode?: number | NodeJS.Signals): void;
+    kill(signal?: number | NodeJS.Signals): boolean;
 
     /**
      * This method will tell Bun to wait for this process to exit after you already

src/js/node/child_process.ts

@@ -1484,15 +1484,12 @@
 
     const handle = this.#handle;
     if (handle) {
-      if (handle.killed) {
-        this.killed = true;
-        return true;
-      }
-
       try {
-        handle.kill(signal);
-        this.killed = true;
-        return true;
+        // Don't gate on handle.killed: Bun flips it on any exit, signalled or not.
+        const delivered = handle.kill(signal);
+        // kill(0) is a POSIX existence probe, not a kill — don't mark killed.
+        if (delivered && signal !== 0) this.killed = true;
+        return delivered;
       } catch (e) {
         this.emit("error", e);
       }

src/jsc/ProcessAutoKiller.zig

@@ -31,7 +31,7 @@ fn killProcesses(this: *ProcessAutoKiller) u32 {
         defer process.key.deref();
         if (!process.key.hasExited()) {
             log("process.kill {d}", .{process.key.pid});
-            count += @as(u32, @intFromBool(process.key.kill(@intFromEnum(bun.SignalCode.default)) == .result));
+            count += @intFromBool(process.key.kill(@intFromEnum(bun.SignalCode.default)).isTrue());
         }
     }
     return count;

src/runtime/api/bun/process.zig

@@ -573,7 +573,18 @@ pub const Process = struct {
         bun.destroy(this);
     }
 
-    pub fn kill(this: *Process, signal: u8) Maybe(void) {
+    /// Sends `signal` to the process.
+    ///
+    /// Returns:
+    /// - `.result = true` if the signal was delivered.
+    /// - `.result = false` if the child could not be reached — either the
+    ///   poller is already `.detached` (we observed the exit on our side)
+    ///   or the OS reported `ESRCH`. Callers that just want best-effort
+    ///   termination can ignore this, but anything JS-visible (e.g.
+    ///   `subprocess.kill()`) needs to propagate it so Node's
+    ///   `ChildProcess.kill()` can return `false`.
+    /// - `.err` for any other error.
+    pub fn kill(this: *Process, signal: u8) Maybe(bool) {
         if (comptime Environment.isPosix) {
             switch (this.poller) {
                 .waiter_thread, .fd => {
@@ -584,9 +595,17 @@ pub const Process = struct {
                         // if the process was already killed don't throw
                         if (errno_ != .SRCH)
                             return .{ .err = bun.sys.Error.fromCode(errno_, .kill) };
+
+                        return .{ .result = false };
                     }
+
+                    return .{ .result = true };
                 },
-                else => {},
+                // `.detached` means we never armed the poller or we already
+                // called `detach()` from `onExit`. Either way there is no
+                // live child to signal — report "not delivered" rather than
+                // claiming success we didn't attempt.
+                .detached => return .{ .result = false },
             }
         } else if (comptime Environment.isWindows) {
             switch (this.poller) {
@@ -596,19 +615,17 @@ pub const Process = struct {
                         if (err.errno != @intFromEnum(bun.sys.E.SRCH)) {
                             return .{ .err = err };
                         }
+
+                        return .{ .result = false };
                     }
 
-                    return .{
-                        .result = {},
-                    };
+                    return .{ .result = true };
                 },
-                else => {},
+                .detached => return .{ .result = false },
             }
         }
 
-        return .{
-            .result = {},
-        };
+        return .{ .result = false };
     }
 };
 

src/runtime/api/bun/subprocess.zig

@@ -394,27 +394,31 @@
 
     if (globalThis.hasException()) return .zero;
 
     switch (this.tryKill(sig)) {
-        .result => {},
+        // `true` when the signal was sent, `false` when the process had
+        // already exited (nothing to signal). Node's `ChildProcess.kill()`
+        // needs to see `false` to return `false` to user code.
+        .result => |delivered| return JSValue.jsBoolean(delivered),
         .err => |err| {
             // EINVAL or ENOSYS means the signal is not supported in the current platform (most likely unsupported on windows)
             return globalThis.throwValue(try err.toJS(globalThis));
         },
     }
-
-    return .js_undefined;
 }
 
 pub fn hasKilled(this: *const Subprocess) bool {
     return this.process.hasKilled();
 }
 
-pub fn tryKill(this: *Subprocess, sig: SignalCode) bun.sys.Maybe(void) {
+/// Returns `.result = true` if `sig` was delivered to the child, or
+/// `.result = false` if the child had already exited (either because we
+/// already saw the exit on our side or the OS reported `ESRCH`).
+pub fn tryKill(this: *Subprocess, sig: SignalCode) bun.sys.Maybe(bool) {
     if (this.hasExited()) {
-        return .success;
+        return .{ .result = false };
     }
     return this.process.kill(@intFromEnum(sig));
 }
 
 fn hasCalledGetter(this: *Subprocess, comptime getter: @Type(.enum_literal)) bool {
     return this.observable_getters.contains(getter);

src/runtime/shell/subproc.zig

@@ -498,7 +498,9 @@ pub const ShellSubprocess = struct {
             return .success;
         }
 
-        return this.process.kill(@intCast(sig));
+        // Shell kill is best-effort — drop the "delivered?" bool, keep errors.
+        if (this.process.kill(@intCast(sig)).asErr()) |err| return .{ .err = err };
+        return .success;
     }
 
     // fn hasCalledGetter(this: *Subprocess, comptime getter: @Type(.enum_literal)) bool {

test/integration/bun-types/fixture/spawn.ts

@@ -119,10 +119,10 @@ function depromise<T>(_promise: Promise<T>): T {
   proc.killed; // boolean — was the process killed?
   proc.exitCode; // null | number
   proc.signalCode; // null | "SIGABRT" | "SIGALRM" | ...
-  proc.kill();
+  tsd.expectType(proc.kill()).is<boolean>();
   proc.killed; // true
 
-  proc.kill(); // specify an exit code
+  tsd.expectType(proc.kill(9)).is<boolean>(); // specify a signal
   proc.unref();
 }
 

test/regression/issue/29001.test.ts

@@ -0,0 +1,73 @@
+import { spawn as bunSpawn } from "bun";
+import { describe, expect, test } from "bun:test";
+import { bunEnv, bunExe, isPosix } from "harness";
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+
+// https://github.com/oven-sh/bun/issues/29001 — kill() must return false
+// once the child has exited, matching Node.
+describe.concurrent("issue #29001 — kill() reports failure after exit", () => {
+  test.if(isPosix)("node:child_process ChildProcess.kill() returns false after exit", async () => {
+    const proc = spawn(bunExe(), ["-e", "process.exit(0)"], {
+      env: bunEnv,
+      stdio: "ignore",
+    });
+
+    // Assert the clean exit first so a fixture crash surfaces clearly.
+    const [code, signal] = await once(proc, "close");
+    expect(code).toBe(0);
+    expect(signal).toBe(null);
+
+    expect(proc.kill("SIGTERM")).toBe(false);
+    expect(proc.kill("SIGQUIT")).toBe(false);
+    expect(proc.kill(0)).toBe(false);
+
+    // Child exited on its own — proc.killed only flips on our signal.
+    expect(proc.killed).toBe(false);
+  });
+
+  test.if(isPosix)("node:child_process ChildProcess.kill() returns true while alive", async () => {
+    const proc = spawn("cat", [], { stdio: ["pipe", "ignore", "ignore"] });
+
+    try {
+      // Signal 0 is an existence probe — succeeds but must not mark killed.
+      expect(proc.kill(0)).toBe(true);
+      expect(proc.killed).toBe(false);
+    } finally {
+      proc.kill("SIGKILL");
+      await once(proc, "close");
+    }
+  });
+
+  // These Bun.spawn tests cover the cross-platform hasExited() fast path
+  // in Subprocess.tryKill (short-circuits before Process.kill), so they
+  // don't exercise the OS-level ESRCH branch.
+  test("Bun.spawn subprocess.kill() returns false after exit", async () => {
+    await using proc = bunSpawn({
+      cmd: [bunExe(), "-e", "process.exit(0)"],
+      env: bunEnv,
+      stdio: ["ignore", "ignore", "ignore"],
+    });
+
+    const exitCode = await proc.exited;
+    expect(exitCode).toBe(0);
+    expect(proc.signalCode).toBe(null);
+
+    expect(proc.kill("SIGTERM")).toBe(false);
+    expect(proc.kill(0)).toBe(false);
+  });
+
+  test.if(isPosix)("Bun.spawn subprocess.kill() returns true while alive", async () => {
+    await using proc = bunSpawn({
+      cmd: ["cat"],
+      stdio: ["pipe", "ignore", "ignore"],
+    });
+
+    try {
+      expect(proc.kill(0)).toBe(true);
+    } finally {
+      proc.kill("SIGKILL");
+      await proc.exited;
+    }
+  });
+});