@oh-my-pi/pi-utils 9.6.4 → 9.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-utils",
-	"version": "9.6.4",
+	"version": "9.7.0",
 	"description": "Shared utilities for pi packages",
 	"type": "module",
 	"main": "./src/index.ts",

package/src/index.ts

@@ -5,6 +5,7 @@ export * from "./glob";
 export * as logger from "./logger";
 export * as postmortem from "./postmortem";
 export * as procmgr from "./procmgr";
+export { setNativeKillTree } from "./procmgr";
 export * as ptree from "./ptree";
 export { AbortError, ChildProcess, Exception, NonZeroExitError } from "./ptree";
 export * from "./stream";

package/src/procmgr.ts

@@ -184,13 +184,32 @@ export function getShellConfig(customShellPath?: string): ShellConfig {
 	return cachedShellConfig;
 }
 
+/**
+ * Function signature for native process tree killing.
+ * Returns the number of processes killed.
+ */
+export type KillTreeFn = (pid: number, signal: number) => number;
+
+/**
+ * Global native kill tree function, injected by pi-natives when loaded.
+ * Falls back to platform-specific behavior if not set.
+ */
+export let nativeKillTree: KillTreeFn | undefined;
+
+/**
+ * Set the native kill tree function. Called by pi-natives on load.
+ */
+export function setNativeKillTree(fn: KillTreeFn): void {
+	nativeKillTree = fn;
+}
+
 /**
  * Options for terminating a process and all its descendants.
  */
 export interface TerminateOptions {
 	/** The process to terminate */
 	target: Subprocess | number;
-	/** Whether to terminate the process group (Windows only) */
+	/** Whether to terminate the process tree (all descendants) */
 	group?: boolean;
 	/** Timeout in milliseconds */
 	timeout?: number;
@@ -293,31 +312,22 @@ export async function terminate(options: TerminateOptions): Promise<boolean> {
 			}
 		} catch {}
 
-		if (group) {
+		if (nativeKillTree) {
+			nativeKillTree(pid, 9);
+		} else {
+			if (group && !IS_WINDOWS) {
+				try {
+					process.kill(-pid, "SIGKILL");
+				} catch {}
+			}
 			try {
-				if (IS_WINDOWS) {
-					const taskkill = Bun.spawn({
-						cmd: ["taskkill", "/F", "/T", "/PID", pid.toString()],
-						stdin: "ignore",
-						stdout: "ignore",
-						stderr: "ignore",
-						timeout: 5000,
-						windowsHide: true,
-					});
-					void taskkill.exited.catch(() => {});
-					taskkill.unref();
+				if (typeof target === "number") {
+					process.kill(target, "SIGKILL");
 				} else {
-					process.kill(-pid, "SIGKILL");
+					target.kill("SIGKILL");
 				}
 			} catch {}
 		}
-		try {
-			if (typeof target === "number") {
-				process.kill(target, "SIGKILL");
-			} else {
-				target.kill("SIGKILL");
-			}
-		} catch {}
 
 		return await Promise.race([Bun.sleep(timeout).then(() => false), exitPromise]);
 	} finally {

package/src/ptree.ts

@@ -10,11 +10,8 @@
  */
 
 import type { Spawn, Subprocess } from "bun";
-import { postmortem } from ".";
 import { terminate } from "./procmgr";
 
-const managedChildren = new Set<ChildProcess>();
-
 /** A Bun subprocess with stdout/stderr always piped (stdin may vary). */
 type PipedSubprocess<In extends InMask = InMask> = Subprocess<In, "pipe", "pipe">;
 
@@ -98,15 +95,9 @@ async function pump(
  * - Unix: negative PID signals the process group
  */
 async function killChild(child: ChildProcess) {
-	await terminate({ target: child.proc, group: child.isProcessGroup });
+	await terminate({ target: child.proc });
 }
 
-postmortem.register("managed-children", async () => {
-	const children = Array.from(managedChildren);
-	managedChildren.clear();
-	await Promise.all(children.map(killChild));
-});
-
 /**
  * Options for waiting for process exit and capturing output.
  */
@@ -205,10 +196,7 @@ export class ChildProcess<In extends InMask = InMask> {
 	#stderrDone: Promise<void>;
 	#exited: Promise<number>;
 
-	constructor(
-		public readonly proc: PipedSubprocess<In>,
-		public readonly isProcessGroup: boolean,
-	) {
+	constructor(public readonly proc: PipedSubprocess<In>) {
 		const { promise: stderrDone, resolve: resolveStderrDone } = Promise.withResolvers<void>();
 		this.#stderrDone = stderrDone;
 
@@ -245,8 +233,6 @@ export class ChildProcess<In extends InMask = InMask> {
 		const { promise, resolve, reject } = Promise.withResolvers<number>();
 		this.#exited = promise;
 
-		if (this.proc.exitCode === null) managedChildren.add(this);
-
 		// Normalize Bun's exited promise into our "exitReason / exitedCleanly" model.
 		proc.exited
 			.catch(() => null)
@@ -279,9 +265,6 @@ export class ChildProcess<In extends InMask = InMask> {
 
 				this.#exitReason = ex;
 				reject(ex);
-			})
-			.finally(() => {
-				managedChildren.delete(this);
 			});
 	}
 
@@ -426,7 +409,7 @@ export class ChildProcess<In extends InMask = InMask> {
  */
 type ChildSpawnOptions<In extends InMask = InMask> = Omit<
 	Spawn.SpawnOptions<In, "pipe", "pipe">,
-	"stdout" | "stderr"
+	"stdout" | "stderr" | "detached"
 > & {
 	/** AbortSignal to cancel the process */
 	signal?: AbortSignal;
@@ -441,16 +424,15 @@ type ChildSpawnOptions<In extends InMask = InMask> = Omit<
  * @returns A ChildProcess instance.
  */
 export function spawn<In extends InMask = InMask>(cmd: string[], options?: ChildSpawnOptions<In>): ChildProcess<In> {
-	const { detached = false, timeout = -1, signal, ...rest } = options ?? {};
+	const { timeout = -1, signal, ...rest } = options ?? {};
 	const child = Bun.spawn(cmd, {
 		stdin: "ignore",
 		stdout: "pipe",
 		stderr: "pipe",
-		detached,
 		windowsHide: true,
 		...rest,
 	});
-	const cproc = new ChildProcess(child, detached);
+	const cproc = new ChildProcess(child);
 	if (signal) cproc.attachSignal(signal);
 	if (timeout > 0) cproc.attachTimeout(timeout);
 	return cproc;