@vzn/vx 0.0.58 → 0.0.59

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.58",
+  "version": "0.0.59",
   "description": "An open, extensible monorepo task runner.",
   "type": "module",
   "exports": {
@@ -17,10 +17,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.58",
-    "@vzn/vx-linux-arm64": "0.0.58",
-    "@vzn/vx-darwin-x64": "0.0.58",
-    "@vzn/vx-darwin-arm64": "0.0.58"
+    "@vzn/vx-linux-x64": "0.0.59",
+    "@vzn/vx-linux-arm64": "0.0.59",
+    "@vzn/vx-darwin-x64": "0.0.59",
+    "@vzn/vx-darwin-arm64": "0.0.59"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/exec/kill-tree.ts

@@ -103,18 +103,31 @@ function guardWrite(line: string): void {
 }
 
 /**
- * Spawn a task child and list its group for the guard to kill if vx dies
- * holding it. The guard starts BEFORE the spawn: started after it, the
- * guard's own spawn was a window in which the task ran and a `kill -9`
- * of vx found its group unlisted — under a traced sandbox, a third of
- * the kills landed there. What is left is the step from the spawn's
- * return to one pipe write.
+ * Spawn a task child whose group the guard kills if vx dies holding it.
+ * The CHILD lists its own group, before it runs anything: vx wrote the
+ * line after the spawn returned, and under load the child ran first, so a
+ * `kill -9` of vx in between left its group unlisted and alive (4 of 40
+ * runs at tenfold load; B-9). `spawn` gets the guard's pipe, to hand the
+ * child at some descriptor `n`, and runs `guardLine(n)` in the child's
+ * shell first. The child holds the pipe until it has written, so the
+ * guard cannot reach EOF before the line: vx's death alone no longer
+ * races it. The guard starts BEFORE the spawn, so there is a pipe to hand.
+ * `undefined` when the guard could not start: nothing lists anything.
  */
-export function spawnGuarded(spawn: () => Child): Child {
+export function spawnGuarded(spawn: (guard: number | undefined) => Child): Child {
   startGuard()
-  const child = spawn()
-  if (child.pid > 0) guardWrite(`+${child.pid}\n`)
-  return child
+  return spawn(typeof guardFd === 'number' ? guardFd : undefined)
+}
+
+/**
+ * The shell line that lists `$$`'s group on the guard's pipe at `fd` and
+ * closes it, so the task never holds the guard open. `$$` is the spawned
+ * shell, which leads its group (every guarded spawn is `detached`); a
+ * program that is not a shell is `exec`'d after it. A write to a guard
+ * that has died is ignored rather than a SIGPIPE that kills the task.
+ */
+export function guardLine(fd: number): string {
+  return `trap '' PIPE; printf '+%s\\n' $$ >&${fd} 2>/dev/null; trap - PIPE; exec ${fd}>&-; `
 }
 
 /**

package/src/exec/runner.ts

@@ -14,6 +14,7 @@ import {
   markGroupIfGone,
   releaseGroup,
   signalThrough,
+  guardLine,
   spawnGuarded,
   untilGroupsGone,
 } from './kill-tree.js'
@@ -435,27 +436,40 @@ export function runPersistent(opts: PersistentOptions): PersistentSpawn {
 
   let child: ReturnType<typeof Bun.spawn>
   try {
-    child = spawnGuarded(() =>
-      Bun.spawn([executablePath('sh'), '-c', execWrap(opts.command)], {
-        argv0: 'sh',
-        cwd: opts.cwd,
-        env: opts.env as Record<string, string>,
-        // A pipe vx holds and never writes: stdin stays open while vx
-        // lives and ends when it does. A dev server that exits on stdin
-        // EOF (esbuild --watch, Vite's case in turborepo#8915) became ready
-        // and exited 0 under 'ignore'. Not the terminal: several servers
-        // would steal each other's keystrokes, and a CI's /dev/null stdin
-        // is the same EOF. The one-shot spawn below keeps 'ignore', so a
-        // task that reads stdin can never hang CI.
-        stdio:
-          opts.signalChannel === true ? ['pipe', 'pipe', 'pipe', 'pipe'] : ['pipe', 'pipe', 'pipe'],
-        // Its own session and process group, so a kill reaches what it
-        // forked (kill-tree.ts). stdin is a pipe, so a background group
-        // never stops on a terminal read.
-        detached: true,
-      }),
+    const signalFd = opts.signalChannel === true
+    child = spawnGuarded((guard) =>
+      Bun.spawn(
+        [
+          executablePath('sh'),
+          '-c',
+          (guard === undefined ? '' : guardLine(signalFd ? 4 : 3)) + execWrap(opts.command),
+        ],
+        {
+          argv0: 'sh',
+          cwd: opts.cwd,
+          env: opts.env as Record<string, string>,
+          // A pipe vx holds and never writes: stdin stays open while vx
+          // lives and ends when it does. A dev server that exits on stdin
+          // EOF (esbuild --watch, Vite's case in turborepo#8915) became ready
+          // and exited 0 under 'ignore'. Not the terminal: several servers
+          // would steal each other's keystrokes, and a CI's /dev/null stdin
+          // is the same EOF. The one-shot spawn below keeps 'ignore', so a
+          // task that reads stdin can never hang CI.
+          stdio: [
+            'pipe',
+            'pipe',
+            'pipe',
+            ...(signalFd ? ['pipe' as const] : []),
+            ...(guard === undefined ? [] : [guard]),
+          ],
+          // Its own session and process group, so a kill reaches what it
+          // forked (kill-tree.ts). stdin is a pipe, so a background group
+          // never stops on a terminal read.
+          detached: true,
+        },
+      ),
     )
-    if (opts.signalChannel === true) {
+    if (signalFd) {
       signalThrough(child, child.stdio[3] as number)
       const spawned = child
       void spawned.exited.then(() => closeSignalChannel(spawned))
@@ -651,19 +665,24 @@ export async function runCommand(opts: RunOptions): Promise<RunResult> {
 
   let proc: ReturnType<typeof Bun.spawn>
   try {
-    proc = spawnGuarded(() =>
-      Bun.spawn([executablePath('sh'), '-c', execWrap(fullCommand)], {
-        argv0: 'sh',
-        cwd: opts.cwd,
-        env: opts.env as Record<string, string>,
-        stdin: 'ignore',
-        stdout: 'pipe',
-        stderr: 'pipe',
-        // Its own session and process group, so a kill reaches what it
-        // forked (kill-tree.ts). stdin is ignored, so a background group
-        // never stops on a terminal read.
-        detached: true,
-      }),
+    proc = spawnGuarded((guard) =>
+      Bun.spawn(
+        [
+          executablePath('sh'),
+          '-c',
+          (guard === undefined ? '' : guardLine(3)) + execWrap(fullCommand),
+        ],
+        {
+          argv0: 'sh',
+          cwd: opts.cwd,
+          env: opts.env as Record<string, string>,
+          stdio: ['ignore', 'pipe', 'pipe', ...(guard === undefined ? [] : [guard])],
+          // Its own session and process group, so a kill reaches what it
+          // forked (kill-tree.ts). stdin is ignored, so a background group
+          // never stops on a terminal read.
+          detached: true,
+        },
+      ),
     )
   } catch (err) {
     const stderr = spawnFailureText(err, opts.cwd)

package/src/exec/sandbox-runtime.ts

@@ -64,6 +64,7 @@ import {
   killTree,
   releaseGroup,
   signalThrough,
+  guardLine,
   spawnGuarded,
 } from './kill-tree.js'
 
@@ -902,13 +903,20 @@ function spawnHostBridges(ports: readonly number[], tag: string): void {
       // listening on the port under init, where the next run's bridge
       // could not bind it (item 873).
       procs.push(
-        spawnGuarded(() =>
-          Bun.spawn(portBridgeHostArgv(tag, p), {
-            stdin: 'ignore',
-            stdout: 'ignore',
-            stderr: 'ignore',
-            detached: true,
-          }),
+        spawnGuarded((guard) =>
+          guard === undefined
+            ? Bun.spawn(portBridgeHostArgv(tag, p), {
+                stdio: ['ignore', 'ignore', 'ignore'],
+                detached: true,
+              })
+            : Bun.spawn(
+                [
+                  executablePath('sh'),
+                  '-c',
+                  `${guardLine(3)}exec ${portBridgeHostArgv(tag, p).map(shellQuote).join(' ')}`,
+                ],
+                { stdio: ['ignore', 'ignore', 'ignore', guard], detached: true },
+              ),
         ),
       )
     } catch {
@@ -1086,16 +1094,35 @@ async function runSandboxedOnce(
           wrapped,
         ]
       : [sh, '-c', wrapped]
-    proc = spawnGuarded(() =>
-      Bun.spawn(spawnArgv, {
-        argv0: straceLog ? 'strace' : 'sh',
-        cwd: args.cwd,
-        env: args.env as Record<string, string>,
-        // fd 3 is the signal channel the in-sandbox watcher reads.
-        stdio: forwardsSignals ? ['ignore', 'pipe', 'pipe', 'pipe'] : ['ignore', 'pipe', 'pipe'],
-        // As the unsandboxed spawn: its own process group (kill-tree.ts).
-        detached: true,
-      }),
+    // With the guard, a shell lists the group first and `exec`s the
+    // spawn: strace itself would hold the guard's pipe for its lifetime.
+    const guardAt = forwardsSignals ? 4 : 3
+    proc = spawnGuarded((guard) =>
+      Bun.spawn(
+        guard === undefined
+          ? spawnArgv
+          : [
+              sh,
+              '-c',
+              guardLine(guardAt) +
+                (straceLog ? `exec ${spawnArgv.map(shellQuote).join(' ')}` : wrapped),
+            ],
+        {
+          argv0: straceLog && guard === undefined ? 'strace' : 'sh',
+          cwd: args.cwd,
+          env: args.env as Record<string, string>,
+          // fd 3 is the signal channel the in-sandbox watcher reads.
+          stdio: [
+            'ignore',
+            'pipe',
+            'pipe',
+            ...(forwardsSignals ? ['pipe' as const] : []),
+            ...(guard === undefined ? [] : [guard]),
+          ],
+          // As the unsandboxed spawn: its own process group (kill-tree.ts).
+          detached: true,
+        },
+      ),
     )
     if (forwardsSignals) signalThrough(proc, proc.stdio[3] as number)
   } catch (err) {