@vzn/vx 0.0.59 → 0.0.61

package/package.json

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

package/src/cache/inputs.ts

@@ -386,6 +386,9 @@ async function runRuntimeCommand(
       stdin: 'ignore',
       stdout: 'pipe',
       stderr: 'pipe',
+      // Its own group, so the probe's whole tree can be taken down with vx
+      // (`killProbesOnExit`).
+      detached: true,
     })
   } catch (err) {
     // The probe runs through `sh -c` like a task: a box without sh names
@@ -397,11 +400,18 @@ async function runRuntimeCommand(
     }
     throw new UserError(`cache.inputs runtime command failed to spawn: ${command} (cwd: ${cwd})`)
   }
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-    proc.exited,
-  ])
+  liveProbes.add(proc)
+  killProbesOnExit()
+  let stdout, stderr, exitCode
+  try {
+    ;[stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited,
+    ])
+  } finally {
+    liveProbes.delete(proc)
+  }
   const output = `${stdout}${stderr}`.trim()
   if (exitCode !== 0) {
     throw new UserError(
@@ -412,6 +422,31 @@ async function runRuntimeCommand(
   return output
 }
 
+/**
+ * Runtime probes still running. A probe that outlives its answer's need — a
+ * run stopped by Ctrl-C, or ended by a refusal, while `node -e …` or a hung
+ * `git` still ran — was left behind: vx exited and the probe's shell and
+ * what it started ran on under init (A-9). Every probe is its own group, and
+ * the ones still listed when vx exits are SIGKILLed with their trees. A
+ * `kill -9` of vx runs no exit hook; that residual is the task groups' guard's
+ * (exec/kill-tree.ts), which probes are not on.
+ */
+const liveProbes = new Set<ReturnType<typeof Bun.spawn>>()
+let probeExitHooked = false
+function killProbesOnExit(): void {
+  if (probeExitHooked) return
+  probeExitHooked = true
+  process.on('exit', () => {
+    for (const p of liveProbes) {
+      try {
+        process.kill(-p.pid, 'SIGKILL')
+      } catch {
+        // the group is gone
+      }
+    }
+  })
+}
+
 /**
  * Resolve a list of runtime-input commands to sorted [command, output]
  * pairs. Dedups via the shared `memo` (Promise per key): the first

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
     }