@cruxy/cli 0.29.2 → 0.29.4

package/dist/utils/child-tree.js

@@ -1,9 +1,11 @@
 /**
- * Shared no-orphan machinery for long-lived child processes (C.12 LSP servers,
- * C.27 MCP servers). A child is spawned `detached` so it leads its own process
- * group; every kill here uses a **negative-PID** `SIGKILL` so the whole tree —
- * the child AND any grandchildren it forked (gopls's `go`, an MCP server's
- * helper) — dies together.
+ * The process-EXIT backstop for long-lived child trees (C.12 LSP servers, C.27
+ * MCP servers). The platform-aware spawn/kill primitives themselves now live in
+ * {@link ./process-tree.js} — {@link killTree} is re-exported here unchanged so
+ * existing LSP/MCP importers keep their import path, and so this backstop and
+ * those transports reap trees the SAME way on every platform (negative-PID
+ * `SIGKILL` on POSIX, `taskkill /T /F` on win32 — no more orphaned grandchildren
+ * on Windows).
  *
  * A per-session graceful shutdown covers the normal path, but a hard exit
  * (Ctrl-C, an uncaught throw) would otherwise orphan these trees. So every live
@@ -15,26 +17,10 @@
  * and MCP (newline-delimited JSON) share the SAME backstop, so `killTrackedTrees`
  * on exit reaps both and there is a single source of truth for "no orphans".
  */
-/**
- * Kill a process's entire group (POSIX negative-PID `SIGKILL`), falling back to
- * a direct kill when there is no group (or on win32). Swallows errors — the
- * process may already be gone.
- */
-export function killTree(pid) {
-    if (pid === undefined)
-        return;
-    try {
-        process.kill(-pid, "SIGKILL");
-    }
-    catch {
-        try {
-            process.kill(pid, "SIGKILL");
-        }
-        catch {
-            /* already exited */
-        }
-    }
-}
+import { killTree } from "./process-tree.js";
+// Re-exported so LSP/MCP transports (and their tests) keep importing `killTree`
+// from here; the implementation is the shared, platform-aware one.
+export { killTree };
 const livePids = new Set();
 let handlersInstalled = false;
 /**

package/dist/utils/process-tree.d.ts

@@ -0,0 +1,16 @@
+import { type ChildProcess, type SpawnOptions } from "node:child_process";
+/**
+ * Spawn a child as the head of a killable process tree, applying the
+ * platform-correct grouping options on top of the caller's own (`shell`, `cwd`,
+ * `stdio`, `env`, …). Any `detached`/`windowsHide` the caller passes is
+ * overridden — grouping is this module's responsibility, not the call site's.
+ */
+export declare function spawnTree(command: string, args?: readonly string[], options?: SpawnOptions): ChildProcess;
+/**
+ * Kill a child's ENTIRE process tree — the child and every descendant it
+ * spawned. POSIX: negative-PID `SIGKILL` targets the process group created by
+ * {@link spawnTree}'s `detached`. win32: `taskkill /PID <pid> /T /F` walks the
+ * OS tree (`/T`) and force-terminates it (`/F`). Fire-and-forget and
+ * error-swallowing on both paths — the tree may already be gone.
+ */
+export declare function killTree(pid: number | undefined): void;

package/dist/utils/process-tree.js

@@ -0,0 +1,84 @@
+import { spawn, } from "node:child_process";
+/**
+ * The single platform-aware primitive for spawning a killable process tree and
+ * reaping it whole. Both halves — {@link spawnTree} and {@link killTree} — MUST
+ * come from here as a pair, because how a child is spawned decides how its tree
+ * can be killed, and the two differ by platform:
+ *
+ * - POSIX: spawn `detached` so the child leads its own process group, then kill
+ *   the whole group with a negative-PID `SIGKILL`. One signal reaps the shell
+ *   AND everything it forked (a `shell:true` grandchild, gopls's `go`, …).
+ * - win32: there is no process-group signalling to lean on. `detached` there
+ *   means "new console / new group" — the wrong semantics, and a flashing
+ *   window. So we DON'T detach (just `windowsHide`), and kill by walking the
+ *   real OS parent-PID tree with `taskkill /T /F`, which a negative-PID signal
+ *   could never do on Windows (it would kill only the direct child and orphan
+ *   the grandchildren).
+ *
+ * This module exists because that pairing used to be copy-pasted — four
+ * POSIX-only `killTree` variants (run_command, the test runner, the LSP/MCP
+ * backstop, and the docker client), each of which silently orphaned
+ * grandchildren on Windows. There is now one implementation; a change to the
+ * kill discipline changes every path. Spawn sites likewise route through
+ * `spawnTree` (run_command, run_tests, LSP, MCP, docker) so none re-introduces
+ * the win32 `detached` console-flash the grouping logic exists to avoid.
+ */
+const isWindows = process.platform === "win32";
+/**
+ * Spawn a child as the head of a killable process tree, applying the
+ * platform-correct grouping options on top of the caller's own (`shell`, `cwd`,
+ * `stdio`, `env`, …). Any `detached`/`windowsHide` the caller passes is
+ * overridden — grouping is this module's responsibility, not the call site's.
+ */
+export function spawnTree(command, args = [], options = {}) {
+    const grouped = isWindows
+        ? { ...options, detached: false, windowsHide: true }
+        : { ...options, detached: true };
+    return spawn(command, args, grouped);
+}
+/**
+ * Kill a child's ENTIRE process tree — the child and every descendant it
+ * spawned. POSIX: negative-PID `SIGKILL` targets the process group created by
+ * {@link spawnTree}'s `detached`. win32: `taskkill /PID <pid> /T /F` walks the
+ * OS tree (`/T`) and force-terminates it (`/F`). Fire-and-forget and
+ * error-swallowing on both paths — the tree may already be gone.
+ */
+export function killTree(pid) {
+    if (pid === undefined)
+        return;
+    if (isWindows) {
+        killTreeWindows(pid);
+        return;
+    }
+    try {
+        // Negative PID = "the whole group led by `pid`", not just `pid`.
+        process.kill(-pid, "SIGKILL");
+    }
+    catch {
+        // Already exited, or no group — nothing to kill.
+    }
+}
+/**
+ * Reap `pid`'s tree via `taskkill`. The killer is itself a child process, so we
+ * reap IT too: `stdio: "ignore"` gives it nothing to block on, the `error`
+ * handler swallows a missing-`taskkill`/EPIPE rejection (an unhandled `error`
+ * event would otherwise crash the process), and `unref` keeps this short-lived
+ * helper from holding the event loop open. taskkill exits on its own; we neither
+ * wait for it nor let it leak.
+ */
+function killTreeWindows(pid) {
+    try {
+        const killer = spawn("taskkill", ["/PID", String(pid), "/T", "/F"], {
+            stdio: "ignore",
+            windowsHide: true,
+        });
+        killer.on("error", () => {
+            // taskkill unavailable (should not happen on win32) — nothing more to do.
+        });
+        killer.unref();
+    }
+    catch {
+        // Even the spawn attempt failed — the tree, if any, outlives us. Nothing
+        // more we can do from here.
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cruxy/cli",
-  "version": "0.29.2",
+  "version": "0.29.4",
   "description": "an agentic coding CLI",
   "type": "module",
   "bin": {
@@ -29,7 +29,6 @@
     "directory": "packages/cli"
   },
   "dependencies": {
-    "better-sqlite3": "^12.11.1",
     "commander": "^12.1.0",
     "fastembed": "^2.1.0",
     "picocolors": "^1.1.1",
@@ -39,6 +38,9 @@
     "zod-to-json-schema": "^3.23.5",
     "@cruxy/sdk": "0.2.1"
   },
+  "optionalDependencies": {
+    "better-sqlite3": "^12.11.1"
+  },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^22.10.0",