@vzn/vx 0.0.26 → 0.0.28

package/package.json

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

package/src/exec/executor.ts

@@ -254,15 +254,26 @@ export function assertExecuteResult(
  * Place one task: the first executor, in declaration order, that may take
  * it — a `remote` executor is skipped for a `pinnedLocal` task, then
  * `accepts()` decides. Decided once per task before scheduling. The local
- * executor accepts everything, so with it declared this cannot throw.
+ * executor accepts everything, so with it declared the only throw is an
+ * `accepts()` that threw: refused as `label` names that executor, where it
+ * surfaced as a bare stack naming no plugin (item 1022).
  */
 export function selectExecutor(
   executors: readonly TaskExecutor[],
   task: TaskPlacement,
+  label: (executor: TaskExecutor) => string = (e) => `executor '${e.name}'`,
 ): TaskExecutor {
   for (const executor of executors) {
     if (task.pinnedLocal && executor.remote === true) continue
-    if (executor.accepts === undefined || executor.accepts(task)) return executor
+    if (executor.accepts === undefined) return executor
+    let taken: boolean
+    try {
+      taken = executor.accepts(task)
+    } catch (err) {
+      const m = err instanceof Error ? err.message : String(err)
+      throw new UserError(`${label(executor)} failed in accepts for ${task.taskId}: ${m}`)
+    }
+    if (taken) return executor
   }
   throw new Error(
     `no executor accepted ${task.taskId} (declared: ${executors.map((e) => e.name).join(', ')}). Core's local executor accepts every task, so this means it is missing from the list.`,

package/src/orchestrator/placement.ts

@@ -10,7 +10,7 @@ import { selectExecutor, type TaskExecutor } from '../exec/index.js'
 import { isGroupTask, type TaskNode } from '../graph/index.js'
 import { resolveDownloadModes } from './download-policy.js'
 import type { Logger } from './logger.js'
-import { resolveExecutors } from './plugin-host.js'
+import { executorLabel, resolveExecutors } from './plugin-host.js'
 import type { prepareRun } from './prepare.js'
 
 /**
@@ -100,14 +100,18 @@ export function placeTasks(
   }
   for (const node of nodes.values()) {
     if (isGroupTask(node) || node.config.exec?.persistent !== undefined) continue
-    const executor = selectExecutor(executors, {
-      taskId: node.id,
-      projectName: node.projectName,
-      projectDir: node.projectDir,
-      command: node.config.exec!.command,
-      pinnedLocal: pinned.has(node.id),
-      cacheable: node.config.cache !== undefined,
-    })
+    const executor = selectExecutor(
+      executors,
+      {
+        taskId: node.id,
+        projectName: node.projectName,
+        projectDir: node.projectDir,
+        command: node.config.exec!.command,
+        pinnedLocal: pinned.has(node.id),
+        cacheable: node.config.cache !== undefined,
+      },
+      executorLabel,
+    )
     placements.executors.set(node.id, executor)
     if (node.config.exec?.remote === 'only') {
       // A pinned 'only' task (it transitively depends on a persistent one)

package/src/orchestrator/plugin-host.ts

@@ -364,6 +364,17 @@ export async function resolveCache(
   })
 }
 
+/** The plugin each resolved executor came from, so a hook of it that throws is named. */
+const executorPlugin = new WeakMap<TaskExecutor, string>()
+
+/** How a message names `executor`: its plugin and its own name, or its name alone (the floor). */
+export function executorLabel(executor: TaskExecutor): string {
+  const plugin = executorPlugin.get(executor)
+  return plugin === undefined
+    ? `executor '${executor.name}'`
+    : `plugin '${plugin}' (executor '${executor.name}')`
+}
+
 /**
  * Collect every plugin's `executor`, in declaration order, with core's
  * own appended at the tail: per task, `selectExecutor` takes the first
@@ -383,6 +394,7 @@ export async function resolveExecutors(
     if (typeof executor.name !== 'string' || executor.name.length === 0) {
       throw new UserError(`plugin '${plugin.name}' returned an executor with no name`)
     }
+    executorPlugin.set(executor, plugin.name)
     executors.push(executor)
   }
   // Core's own executor is the TAIL of every list, so a plugin executor
@@ -396,9 +408,10 @@ export async function resolveExecutors(
  * End-of-run plugin lifecycle: each plugin's optional `teardown()`, in
  * declaration order. Crash-isolated — a throwing teardown is logged and
  * skipped, never propagated — and each call is time-bounded by
- * {@link teardownTimeoutMs}. Runs on the normal completion path only; the
- * finally-path disposers just unsubscribe. (Telemetry sinks flush before
- * this, in telemetry-host.ts, with the same reporting rule.)
+ * {@link teardownTimeoutMs}. Runs on every exit of a run once its plugins'
+ * factories ran, and of a plan (item 1021); the finally-path disposers
+ * just unsubscribe. (Telemetry sinks flush before this, in
+ * telemetry-host.ts, with the same reporting rule.)
  *
  * The bound is PER CALL and the calls are sequential, so the worst case
  * composes: measured at the 3s default, 1/2/3 simultaneously-hung plugins

package/src/orchestrator/plugin.ts

@@ -442,6 +442,20 @@ export interface InstallPluginsArgs {
   warn?: (message: string) => void
 }
 
+/**
+ * A plugin's `setup` threw. It names the plugin so the run can tear down
+ * every other one: their capability factories and setups ran, and the
+ * one that failed set up nothing to release.
+ */
+export class PluginSetupError extends UserError {
+  constructor(
+    readonly plugin: Plugin,
+    message: string,
+  ) {
+    super(message)
+  }
+}
+
 /**
  * Install every plugin's `setup` hook against a shared bus + context.
  * Synchronous loop; setup() promises are awaited in order so a plugin's
@@ -534,7 +548,8 @@ export async function installPlugins(args: InstallPluginsArgs): Promise<() => vo
     try {
       await plugin.setup(ctx)
     } catch (err) {
-      throw new UserError(
+      throw new PluginSetupError(
+        plugin,
         `plugin '${plugin.name}' failed to load: ${err instanceof Error ? err.message : String(err)}`,
       )
     }

package/src/orchestrator/run.ts

@@ -39,8 +39,8 @@ import { admitTasks, taintTracker } from './admission.js'
 import { excludedTaint } from './excluded-keys.js'
 import { keyUpstream } from './upstream.js'
 import { busLogger, createEventBus, terminalSubscriber, type EventBus } from './events.js'
-import { installPlugins } from './plugin.js'
-import { buildAdmission, resolveExecutors, teardownPlugins } from './plugin-host.js'
+import { installPlugins, PluginSetupError } from './plugin.js'
+import { buildAdmission, executorLabel, resolveExecutors, teardownPlugins } from './plugin-host.js'
 import { subscribeTelemetry, type TelemetryHandle } from './telemetry-host.js'
 import { assembleRunSummary, isPassStatus } from './telemetry.js'
 import type { RunContextRecord } from './telemetry.js'
@@ -217,6 +217,19 @@ async function runOnBus(
 
   const prepared = await prepareRun(options, log)
   mark('plugin stages')
+  // Every exit from here tears the plugins down: their capability
+  // factories ran in prepareRun, and teardown is what releases what those
+  // opened (a client, a channel). Until item 1021 only the normal end did,
+  // so an early return, a refused setup or a throw left them held — once
+  // per cycle under `vx watch`. A plugin whose own setup threw set up
+  // nothing, and is the one left out.
+  let tornDown = false
+  const teardown = async (except?: unknown): Promise<void> => {
+    if (tornDown) return
+    tornDown = true
+    const plugins = prepared.plugins.filter((p) => p !== except)
+    await teardownPlugins(plugins, (m) => log.status(m))
+  }
   // A task whose command re-enters `vx run` in the workspace running it
   // is refused. When the inner run reaches this task again it forks a run
   // per run until the machine gives out; when it does not (`ci` shelling
@@ -226,6 +239,7 @@ async function runOnBus(
   // name the task; the check is on the root so both shapes are caught.
   const outerRoot = process.env[VX_RUN_WORKSPACE_ENV]
   if (outerRoot !== undefined && path.resolve(outerRoot) === path.resolve(prepared.workspaceRoot)) {
+    await teardown()
     prepared.cache.close()
     throw new UserError(
       `task ${process.env[VX_RUN_TASK_ENV] ?? '<unknown>'} runs \`vx run\` inside its own workspace: a nested run is invisible to the outer graph (its tasks escape the schedule, the concurrency budget and the cache key) and a loop back to this task forks without bound. Declare what it needs with dependsOn instead.`,
@@ -241,6 +255,7 @@ async function runOnBus(
     log.status(
       `No projects declare task(s): ${prepared.unresolvedTasks.join(', ')}.${didYouMean(prepared.unresolvedTasks, prepared.projects)}${await initHint(prepared)}`,
     )
+    await teardown()
     prepared.cache.close()
     return { ok: false, outcomes: [] }
   }
@@ -254,6 +269,7 @@ async function runOnBus(
         ? `No projects declare task(s): ${options.tasks.join(', ')}.${await initHint(prepared)}`
         : 'No tasks to run.'
     log.status(msg)
+    await teardown()
     prepared.cache.close()
     return { ok: false, outcomes: [] }
   }
@@ -273,9 +289,21 @@ async function runOnBus(
     })
   } catch (err) {
     disposePlugins?.()
+    await teardown(err instanceof PluginSetupError ? err.plugin : undefined)
     prepared.cache.close()
     throw err
   }
+  // Until the run's own try below, a throw leaves through here.
+  const abandoning = async <T>(step: () => T | Promise<T>): Promise<T> => {
+    try {
+      return await step()
+    } catch (err) {
+      disposePlugins?.()
+      await teardown()
+      prepared.cache.close()
+      throw err
+    }
+  }
   const {
     workspaceRoot,
     workspaceConfig,
@@ -293,24 +321,19 @@ async function runOnBus(
 
   // Resolved ONCE per run, in declaration order, the local executor last.
   // A broken factory aborts here, before any task starts.
-  let executors: readonly TaskExecutor[]
-  try {
-    executors = await resolveExecutors(prepared.plugins, {
+  const executors: readonly TaskExecutor[] = await abandoning(() =>
+    resolveExecutors(prepared.plugins, {
       workspaceRoot: prepared.workspaceRoot,
       cacheDir: prepared.cacheDir,
       warn: (m: string) => log.status(m),
       concurrency,
-    })
-  } catch (err) {
-    disposePlugins?.()
-    prepared.cache.close()
-    throw err
-  }
+    }),
+  )
   // Placement: decided ONCE per task, before scheduling, so the scheduler
   // can admit a remote-pooled task against its pool instead of a local
   // worker slot. Group tasks run nothing; persistent tasks never reach an
   // executor (local by construction) — both stay off the map.
-  const placements = placeTasks(nodes, executors)
+  const placements = await abandoning(() => placeTasks(nodes, executors))
   // A `remote: 'only'` task nobody takes succeeds WITHOUT running. That is
   // deliberate — on a machine with no remote pool the ambient state already
   // is what the task would have produced — but it must not be SILENT: a task
@@ -341,14 +364,26 @@ async function runOnBus(
     remaining.add(id)
   }
   // The SAME set is handed back every time, narrowed in place: a consumer
-  // reading it later sees the truth rather than a stale snapshot.
-  for (const [executor, remaining] of demandOf) executor.demand!(remaining)
+  // reading it later sees the truth rather than a stale snapshot. A hint,
+  // as `admit` is: one that throws is named once and asked no more, where
+  // it surfaced as a bare stack, or mid-run from the completion path
+  // (item 1022).
+  const tellDemand = (executor: TaskExecutor, remaining: ReadonlySet<string>): void => {
+    try {
+      executor.demand!(remaining)
+    } catch (err) {
+      demandOf.delete(executor)
+      const m = err instanceof Error ? err.message : String(err)
+      log.status(`[vx] ${executorLabel(executor)} failed in demand: ${m}; not asked again this run`)
+    }
+  }
+  for (const [executor, remaining] of demandOf) tellDemand(executor, remaining)
   const narrowDemand =
     demandOf.size === 0
       ? (): void => {}
       : (id: string): void => {
           for (const [executor, remaining] of demandOf) {
-            if (remaining.delete(id)) executor.demand!(remaining)
+            if (remaining.delete(id)) tellDemand(executor, remaining)
           }
         }
 
@@ -457,10 +492,12 @@ async function runOnBus(
   }
   // Taken after the early exits above (nothing they do touches a tree) and
   // before the schedule: from here on tasks clean, restore and write.
-  const releaseRunLock = await acquireRunLock(prepared.workspaceRoot, {
-    log: (m) => log.status(m),
-    signal: stopRun.signal,
-  })
+  const releaseRunLock = await abandoning(() =>
+    acquireRunLock(prepared.workspaceRoot, {
+      log: (m) => log.status(m),
+      signal: stopRun.signal,
+    }),
+  )
   try {
     // One run-id per `vx run` invocation. Every task in the resulting
     // graph carries it so analytics queries can group by invocation.
@@ -900,8 +937,8 @@ async function runOnBus(
     }
     // End-of-run plugin lifecycle: each plugin's teardown(). Crash-isolated
     // + time-bounded inside teardownPlugins, so a faulty plugin can neither
-    // fail nor hang the run. Normal completion path only — the finally
-    // below just unsubscribes.
+    // fail nor hang the run. Here on the normal path, after the drains
+    // below; every other exit takes it through `teardown` too.
     // Drain any still-in-flight background prefetches before closing the
     // cache handle — a prefetch ingesting into a closed SQLite DB would
     // throw. Tasks that resolved as local hits never awaited their
@@ -939,7 +976,7 @@ async function runOnBus(
     // Not on a stopped run: one stopped while it waited on another run's
     // lock never held it, and its prune evicted under that run (item 858).
     if (!stopRun.signal.aborted) await applyCacheRetention(prepared, log)
-    await teardownPlugins(prepared.plugins, (m) => log.status(m))
+    await teardown()
     await closeCache()
     mark('close')
     printTimings()
@@ -1019,6 +1056,8 @@ async function runOnBus(
     // released here. Idempotent; safe even if installPlugins threw.
     disposePlugins?.()
     telemetry?.dispose()
+    // No-op after the normal path's teardown; on a throw, the only one.
+    await teardown()
     // No-op after the normal path's close. On a throw this is the only
     // close there is, and it must not itself throw — that would replace
     // the run's real error with a teardown one. Background uploads are
@@ -1123,6 +1162,9 @@ export async function planRun(options: RunOptions): Promise<RunPlan> {
     mark('plan')
     return planned
   } finally {
+    // The plan called the cache and executor factories; teardown releases
+    // what they opened, as a run's end does (item 1021).
+    await teardownPlugins(prepared.plugins, (m) => log.status(m))
     prepared.cache.close()
     // The same table a run prints: a dry run is how the prepare stages
     // (discovery, config load, the git enumeration) get profiled on a