@vzn/vx 0.0.58 → 0.0.60

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.58",
+  "version": "0.0.60",
   "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.60",
+    "@vzn/vx-linux-arm64": "0.0.60",
+    "@vzn/vx-darwin-x64": "0.0.60",
+    "@vzn/vx-darwin-arm64": "0.0.60"
   },
   "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) {

package/src/orchestrator/events.ts

@@ -91,6 +91,9 @@ export function createEventBus(): EventBus {
  * renderer subscribes via `terminalSubscriber`.
  */
 export function busLogger(bus: EventBus): Logger {
+  // run() reaches runEnd on its success path, in its finally and from a
+  // signal; a plugin's onRunEnd hears the first only.
+  let ended = false
   return {
     status: (line) => bus.emit({ kind: 'run:status', line }),
     taskStdout: (node, chunk) => bus.emit({ kind: 'task:stdout', node, chunk }),
@@ -98,7 +101,11 @@ export function busLogger(bus: EventBus): Logger {
     taskComplete: (node, outcome) => bus.emit({ kind: 'task:complete', node, outcome }),
     runStart: (info) => bus.emit({ kind: 'run:start', info }),
     taskStart: (node) => bus.emit({ kind: 'task:start', node }),
-    runEnd: () => bus.emit({ kind: 'run:end' }),
+    runEnd: () => {
+      if (ended) return
+      ended = true
+      bus.emit({ kind: 'run:end' })
+    },
   }
 }
 
@@ -142,19 +149,12 @@ export function terminalSubscriber(sink: Logger): RunEventSubscriber {
  * it to `send` — the shared run→consumer forwarding path for whatever an
  * embedder builds on it (an NDJSON stream, an enveloped protocol; core
  * ships neither). Group-task start/complete events are dropped (no command,
- * pure scheduling noise). `run()` emits run:end twice (normal + finally)
- * plus trailing summary status lines; we forward the run once and then go
- * quiet, so a consumer sees exactly one terminal frame per run. `send`
+ * pure scheduling noise). Summary status lines that follow run:end are
+ * forwarded too. `send`
  * must be fire-and-forget and tolerant of its own failures (a dead
  * consumer can never break the run); the bus already isolates throws.
  */
 export function wireForwarder(send: (event: WireEvent) => void): RunEventSubscriber {
-  // run() emits run:end TWICE (normal + finally), with the summary footer
-  // (run:status lines) emitted in BETWEEN. Drop the duplicate run:end, but
-  // keep forwarding everything else — including those post-run:end status
-  // lines, so a consumer that renders them gets the footer, and one that
-  // ignores run:status is unaffected.
-  let endForwarded = false
   // Which tasks the consumer has been told about. A skipped task never
   // reaches the scheduler's onStart, so its completion arrives with no
   // preceding task:start — and `createWireRenderer` resolves a completion's
@@ -164,10 +164,7 @@ export function wireForwarder(send: (event: WireEvent) => void): RunEventSubscri
   // fidelity (real requested/surfaced/command) instead of a stand-in.
   const started = new Set<string>()
   return (event) => {
-    if (event.kind === 'run:end') {
-      if (endForwarded) return
-      endForwarded = true
-    } else if (
+    if (
       (event.kind === 'task:start' || event.kind === 'task:complete') &&
       isGroupTask(event.node)
     ) {

package/src/orchestrator/telemetry.ts

@@ -413,7 +413,6 @@ export function createTelemetrySource(args: {
     }
   }
 
-  let endEmitted = false
   const subscriber: RunEventSubscriber = (event: RunEvent) => {
     const ts = Date.now()
     switch (event.kind) {
@@ -472,9 +471,6 @@ export function createTelemetrySource(args: {
       case 'run:status':
         return // status lines are terminal-rendering noise, not telemetry
       case 'run:end':
-        // run() emits run:end twice (normal + finally); emit one record.
-        if (endEmitted) return
-        endEmitted = true
         deliver({ v: TELEMETRY_SCHEMA_VERSION, kind: 'run.end', runId, ts })
         return
     }