@vzn/vx 0.0.71 → 0.0.73

package/package.json

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

package/src/cache/cache.ts

@@ -62,6 +62,7 @@ import {
   type DeclaredOutputs,
   type IngestMeta,
   type InvocationRecord,
+  isIndexFull,
   type OutputDirRow,
   type OutputFileRow,
   type PruneOptions,
@@ -1483,7 +1484,12 @@ export class Cache implements CacheLayer {
       // node's writeFile, not Bun.write: the latter copies the buffer first
       // (measured on 150 MiB: +151 MiB and 33 ms against +0 and 21 ms).
       const endWrite = span('save: write temp')
-      await writeFile(tmpPath, compressed)
+      // A write that fails part-way (a full disk) leaves the temp behind,
+      // and a fresh one is an orphan only an hour on (A-14).
+      await writeFile(tmpPath, compressed).catch(async (err: unknown) => {
+        await unlink(tmpPath).catch(() => undefined)
+        throw err
+      })
       endWrite()
     } else {
       // `save` or `ingest` already streamed the artifact into its temp.
@@ -1625,6 +1631,16 @@ export class Cache implements CacheLayer {
     const hashes = [...this.touched]
     this.touched.clear()
     const now = Date.now()
+    // LRU bookkeeping: on a full disk the bumps are dropped, never the prune
+    // or the stats that asked for them (A-14).
+    try {
+      this.writeAccessed(hashes, now)
+    } catch (err) {
+      if (!isIndexFull(err)) throw err
+    }
+  }
+
+  private writeAccessed(hashes: readonly string[], now: number): void {
     // Chunked: SQLite's bound-parameter ceiling is 32k on modern
     // builds, but 900 keeps us safe on any build at negligible cost.
     for (let i = 0; i < hashes.length; i += 900) {
@@ -1824,15 +1840,25 @@ export class Cache implements CacheLayer {
     if (victims.size > 0 || stale.length > 0) {
       const hashes = [...victims]
       const rows = [...hashes, ...stale]
-      this.db.transaction(() => {
+      // Artifacts first: a row whose artifact is gone reads as a miss, so the
+      // order is safe, and on a full disk the delete's own journal needs the
+      // space the unlinks free. Rows-first failed there before any file went,
+      // and the one verb meant to free a full disk freed nothing (A-14).
+      await Promise.all(hashes.map((h) => rm(this.tarPath(h), { force: true })))
+      const deleteRows = this.db.transaction(() => {
         for (let i = 0; i < rows.length; i += 900) {
           const chunk = rows.slice(i, i + 900)
           this.db
             .prepare(`DELETE FROM entries WHERE hash IN (${chunk.map(() => '?').join(',')})`)
             .run(...(chunk as readonly SQLQueryBindings[]))
         }
-      })()
-      await Promise.all(hashes.map((h) => rm(this.tarPath(h), { force: true })))
+      })
+      try {
+        deleteRows()
+      } catch (err) {
+        if (!isIndexFull(err)) throw err
+        deleteRows()
+      }
     }
 
     const orphans = await this.reapOrphans()
@@ -1853,9 +1879,14 @@ export class Cache implements CacheLayer {
   private async reapOrphans(
     now: number = Date.now(),
   ): Promise<{ orphans: number; orphanBytes: number }> {
-    this.db
-      .prepare('INSERT OR REPLACE INTO schema_meta(key, value) VALUES (?, ?)')
-      .run(SWEPT_AT, String(now))
+    try {
+      this.db
+        .prepare('INSERT OR REPLACE INTO schema_meta(key, value) VALUES (?, ?)')
+        .run(SWEPT_AT, String(now))
+    } catch (err) {
+      // The sweep's clock: on a full disk the sweep runs again next time.
+      if (!isIndexFull(err)) throw err
+    }
     let orphans = 0
     let orphanBytes = 0
     await Promise.all(

package/src/cache/file-hashes.ts

@@ -10,7 +10,7 @@ import type { Database } from 'bun:sqlite'
 import { lstatSync, readlinkSync } from 'node:fs'
 import path from 'node:path'
 import { fileIdentity, repoFacts } from './git-inputs.js'
-import { FILE_HASH_RACY_MS, racyWindowMs } from './layer.js'
+import { FILE_HASH_RACY_MS, isIndexFull, racyWindowMs } from './layer.js'
 
 const FILE_HASHES_SWEPT_AT = 'file_hashes_swept_at'
 const DAY_MS = 24 * 60 * 60 * 1000
@@ -163,7 +163,12 @@ export class FileHashStore {
     // than memoised; the warm path never meets it (keys are derived long
     // after the files were written).
     if (this.write && Date.now() - ctimeMs >= racyWindowMs(st.ctimeMs, FILE_HASH_RACY_MS)) {
-      this.upsertFileHash.run(filePath, mtimeMs, size, ctimeMs, ino, ch, Date.now())
+      // A memo: on a full disk the digest stands and the row is skipped.
+      try {
+        this.upsertFileHash.run(filePath, mtimeMs, size, ctimeMs, ino, ch, Date.now())
+      } catch (err) {
+        if (!isIndexFull(err)) throw err
+      }
     }
     return fileIdentity(mode, ch)
   }
@@ -261,20 +266,30 @@ export class FileHashStore {
       misses.map((p) => this.hashFileFromDisk(p).catch(() => undefined)),
     )
     const now = Date.now()
-    this.db.transaction(() => {
-      for (let i = 0; i < misses.length; i++) {
-        const digest = digests[i]
-        if (digest === undefined) continue
-        const p = misses[i]!
-        const st = stats.get(p)!
-        out.set(p, fileIdentity(st.mode, digest))
-        // The same racy-clean rule as `hashFile`: a stat taken within the
-        // window of the file's last change is not memoised.
-        if (this.write && now - st.ctimeMs >= racyWindowMs(st.ctimeRaw, FILE_HASH_RACY_MS)) {
+    const rows: Array<[string, Stat, string]> = []
+    for (let i = 0; i < misses.length; i++) {
+      const digest = digests[i]
+      if (digest === undefined) continue
+      const p = misses[i]!
+      const st = stats.get(p)!
+      out.set(p, fileIdentity(st.mode, digest))
+      // The same racy-clean rule as `hashFile`: a stat taken within the
+      // window of the file's last change is not memoised.
+      if (this.write && now - st.ctimeMs >= racyWindowMs(st.ctimeRaw, FILE_HASH_RACY_MS)) {
+        rows.push([p, st, digest])
+      }
+    }
+    // Every digest is in `out` before the memo is written: on a full disk the
+    // rows are skipped and the answer stands.
+    try {
+      this.db.transaction(() => {
+        for (const [p, st, digest] of rows) {
           this.upsertFileHash.run(p, st.mtimeMs, st.size, st.ctimeMs, st.ino, digest, now)
         }
-      }
-    })()
+      })()
+    } catch (err) {
+      if (!isIndexFull(err)) throw err
+    }
     return out
   }
 

package/src/cache/layer.ts

@@ -438,6 +438,16 @@ export interface IngestMeta {
   outputs?: DeclaredOutputs
 }
 
+/**
+ * SQLite's answer when the disk under the index is full. It is a code on
+ * the `SQLiteError` (`SQLITE_FULL`), never an `ENOSPC` errno, so
+ * `isDiskFull` does not see it: a memo write, a snapshot flush or a prune's
+ * delete on a full disk reached the user as a stack (A-14).
+ */
+export function isIndexFull(err: unknown): boolean {
+  return (err as { code?: unknown } | null)?.code === 'SQLITE_FULL'
+}
+
 /**
  * The supplied artifact bytes don't decompress/parse as a vx artifact.
  * Thrown by `save`/`ingest` BEFORE anything reaches the final cache

package/src/cache/output-index.ts

@@ -16,6 +16,7 @@ import {
   OUTPUT_DIRS_CAP,
   OUTPUT_DIRS_RACY_MS,
   type OutputDirRow,
+  isIndexFull,
   racyWindowMs,
   type OutputFileRow,
   WORKSPACE_OUTPUT_PREFIX,
@@ -265,6 +266,16 @@ export class OutputIndex {
 
   /** Land every pending stamp and snapshot in one transaction each; a null snapshot clears its rows. */
   flushOutputDirs(): void {
+    // A memo either way: on a full disk the pending rows are dropped (the
+    // next hit walks, or restores), never a failed run (A-14).
+    try {
+      this.flushPending()
+    } catch (err) {
+      if (!isIndexFull(err)) throw err
+    }
+  }
+
+  private flushPending(): void {
     if (this.pendingStamps.size > 0) {
       const stamps = [...this.pendingStamps]
       this.pendingStamps.clear()

package/src/cli/upgrade.ts

@@ -304,10 +304,27 @@ export async function upgradeCmd(args: readonly string[]): Promise<number> {
   // rather than this process guessing, and one that cannot is rolled back.
   let installed = ''
   await replaceBinary(dest, asset.url, asset.sha256, (bin) => {
-    const proc = Bun.spawnSync({ cmd: [bin, '--version'], stdout: 'pipe', stderr: 'pipe' })
-    installed = new TextDecoder().decode(proc.stdout).trim()
-    return proc.exitCode === 0 && installed.startsWith('vx ')
+    installed = startedVersion(bin) ?? ''
+    return installed !== ''
   })
   process.stdout.write(`vx upgrade: installed ${installed}\n`)
   return 0
 }
+
+/**
+ * `bin --version` when it answers as vx within `timeoutMs`, else null. The
+ * answer decides whether a replaced binary is rolled back, so it is
+ * bounded: a binary that hung on start held `vx upgrade` forever, new
+ * binary in place, old one never restored.
+ */
+export function startedVersion(bin: string, timeoutMs = 10_000): string | null {
+  const proc = Bun.spawnSync({
+    cmd: [bin, '--version'],
+    stdin: 'ignore',
+    stdout: 'pipe',
+    stderr: 'pipe',
+    timeout: timeoutMs,
+  })
+  const out = new TextDecoder().decode(proc.stdout).trim()
+  return proc.exitCode === 0 && out.startsWith('vx ') ? out : null
+}

package/src/graph/scheduler.ts

@@ -178,6 +178,12 @@ export interface ScheduleOptions {
   execute: (node: TaskNode, upstream: TaskOutcome[]) => Promise<TaskOutcome>
   onStart?: (node: TaskNode) => void
   onFinish?: (outcome: TaskOutcome) => void
+  /**
+   * Where the line naming a rejected `execute` goes, before its failed
+   * outcome lands. Absent = stderr. The run gives it the task's own
+   * stderr, so its frame and the failure recap carry the reason.
+   */
+  onError?: (node: TaskNode, line: string) => void
   /**
    * What an outcome still owes before its dependents may start — a cache
    * save that runs off the execution slot (the orchestrator's save lane):
@@ -722,19 +728,15 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
             })
             leave()
             untrack()
-            finishOne(id, outcome)
-            // Surface the error live; the outcome itself doesn't
-            // carry captured stderr (that's the logger's job). A
-            // UserError is a config/input failure (e.g. a failed
+            // A UserError is a config/input failure (e.g. a failed
             // `cache.inputs.runtime` command), not a vx bug — report it
             // plainly, never as an "internal error".
+            let line: string
             if (isUserError(err) || isFsRefusal(err)) {
               const text = isUserError(err) ? message : `${message} — ${fsRefusalHint(err)}`
               const first = refusedBy.get(text)
               if (first === undefined) refusedBy.set(text, id)
-              process.stderr.write(
-                `[vx] ${id}: ${first === undefined ? text : `as ${first} above`}\n`,
-              )
+              line = `[vx] ${id}: ${first === undefined ? text : `as ${first} above`}\n`
             } else {
               const named = err instanceof Error && err.name !== 'Error' ? `${err.name}: ` : ''
               // A wrapped error's cause is the fact the reader needs (a
@@ -746,8 +748,15 @@ export async function runGraph(options: ScheduleOptions): Promise<Map<string, Ta
                 cause === undefined
                   ? ''
                   : ` (cause: ${(cause as NodeJS.ErrnoException).code ?? cause.name}: ${cause.message})`
-              process.stderr.write(`[vx] internal error in ${id}: ${named}${message}${because}\n`)
+              line = `[vx] internal error in ${id}: ${named}${message}${because}\n`
             }
+            try {
+              if (options.onError === undefined) process.stderr.write(line)
+              else options.onError(node, line)
+            } catch {
+              process.stderr.write(line)
+            }
+            finishOne(id, outcome)
             tick()
           },
         )

package/src/orchestrator/run.ts

@@ -806,6 +806,7 @@ async function runOnBus(
         log.taskComplete(o.node, o)
         narrowDemand(o.node.id)
       },
+      onError: (node, line) => log.taskStderr(node, line),
       execute: (node, upstream) => executeWithDedup(node, keyUpstream(node, upstream)),
       // A `schedule` plugin's weights; the scheduler keeps its structural
       // baseline as the tie-break. Empty map → baseline only.