@vzn/vx 0.0.60 → 0.0.62

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.60",
+  "version": "0.0.62",
   "description": "An open, extensible monorepo task runner.",
   "type": "module",
   "exports": {
@@ -17,10 +17,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@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"
+    "@vzn/vx-linux-x64": "0.0.62",
+    "@vzn/vx-linux-arm64": "0.0.62",
+    "@vzn/vx-darwin-x64": "0.0.62",
+    "@vzn/vx-darwin-arm64": "0.0.62"
   },
   "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/run-artifacts.ts

@@ -29,6 +29,8 @@ export interface SummarizeArgs {
   totalMs: number
   /** The run's verdict — the same value the CLI turns into the exit code. */
   ok: boolean
+  /** The process's exit code where it is not `ok ? 0 : 1`: a stopping signal's. */
+  exitCode?: number
   outcomes: readonly TaskOutcome[]
   /** What `detectFlaky` found this run; the footer's Flaky section, typed. */
   flaky?: readonly FlakyFinding[]
@@ -96,12 +98,13 @@ export async function writeRunSummary(args: SummarizeArgs): Promise<string> {
   // parser must not be told less than a human is.
   const aborted = args.outcomes.filter((o) => !isGroupTask(o.node) && o.status === 'aborted')
   const flakyById = new Map((args.flaky ?? []).map((f) => [f.taskId, f]))
+  const exitCode = args.exitCode ?? (args.ok ? 0 : 1)
   const payload = {
     runId: args.runId,
     // The run-level verdict, first: a consumer gating on this artifact must
     // not have to re-derive it by re-implementing the bucket rules.
-    ok: args.ok,
-    exitCode: args.ok ? 0 : 1,
+    ok: exitCode === 0,
+    exitCode,
     startedAt: new Date(args.startedAtMs).toISOString(),
     endedAt: new Date(args.endedAtMs).toISOString(),
     totalMs: args.totalMs,

package/src/orchestrator/run.ts

@@ -58,6 +58,7 @@ import { prepareRun, type PreparedRun } from './prepare.js'
 import { acquireRunLock } from './run-lock.js'
 import {
   forwardedSignal,
+  type StopSignal,
   forwardSignals,
   SIGNAL_SHUTDOWN_GRACE_MS,
   terminateChildren,
@@ -456,7 +457,7 @@ async function runOnBus(
   // handler exited before any outcome landed, and a Ctrl-C'd run then read
   // in `vx last` as FAILED with 0 tasks (item 854). An embedder's abort is
   // its own call and keeps its record.
-  let stoppedBySignal = false
+  let stoppedBy: StopSignal | undefined
   let leftRun = (): void => {}
   const runLeft = new Promise<void>((resolve) => {
     leftRun = resolve
@@ -468,7 +469,7 @@ async function runOnBus(
     liveChildren,
     persistentRegistry,
     stop: (signal) => {
-      stoppedBySignal = true
+      stoppedBy = signal
       stopRun.abort(signal)
     },
     done: runLeft,
@@ -903,7 +904,10 @@ async function runOnBus(
 
     // Optional artifacts. Errors are surfaced to the user but don't
     // change the run's exit code — the run already happened.
-    if (options.summarize !== undefined) {
+    // Written again after the keep-alive wait: a kept server's crash or a
+    // Ctrl-C there is the process's exit, and the first write said ok.
+    const summarize = async (runOk: boolean): Promise<void> => {
+      if (options.summarize === undefined) return
       try {
         const wrote = await writeRunSummary({
           target: options.summarize,
@@ -913,7 +917,8 @@ async function runOnBus(
           startedAtMs: endedAtMsAtStart,
           endedAtMs,
           totalMs,
-          ok,
+          ok: runOk,
+          ...(stoppedBy !== undefined && { exitCode: signalExitCode(stoppedBy) }),
           outcomes: list,
           flaky,
         })
@@ -923,6 +928,7 @@ async function runOnBus(
         log.status(`vx: failed to write summary: ${msg}`)
       }
     }
+    await summarize(ok)
     if (options.profile !== undefined) {
       try {
         const wrote = await writeRunProfile({
@@ -964,7 +970,7 @@ async function runOnBus(
       withTelemetry: telemetry !== undefined,
     })
     try {
-      if (!stoppedBySignal) cache.recordRunBundle(records)
+      if (stoppedBy === undefined) cache.recordRunBundle(records)
     } catch (err) {
       // History is observability: a full cache disk at the very end must
       // not turn a finished run's verdict into a stack and exit 1 (seen as
@@ -1105,6 +1111,7 @@ async function runOnBus(
         )
       }
       await terminateChildren(() => keepAlive.children)
+      await summarize(ok && first.code === 0)
       return { ok: ok && first.code === 0, outcomes: list }
     }