@vzn/vx 0.0.152 → 0.0.154

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.152",
+  "version": "0.0.154",
   "description": "A fast, correct task runner and build cache for JavaScript monorepos.",
   "type": "module",
   "exports": {
@@ -17,10 +17,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.152",
-    "@vzn/vx-linux-arm64": "0.0.152",
-    "@vzn/vx-darwin-x64": "0.0.152",
-    "@vzn/vx-darwin-arm64": "0.0.152"
+    "@vzn/vx-linux-x64": "0.0.154",
+    "@vzn/vx-linux-arm64": "0.0.154",
+    "@vzn/vx-darwin-x64": "0.0.154",
+    "@vzn/vx-darwin-arm64": "0.0.154"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/cache/file-hashes.ts

@@ -11,6 +11,7 @@ import { lstatSync, readlinkSync } from 'node:fs'
 import path from 'node:path'
 import { fileIdentity, repoFacts } from './git-inputs.js'
 import { FILE_HASH_RACY_MS, isIndexFull, racyWindowMs } from './layer.js'
+import { isPermissionError, UserError } from '../util/index.js'
 
 const FILE_HASHES_SWEPT_AT = 'file_hashes_swept_at'
 const DAY_MS = 24 * 60 * 60 * 1000
@@ -301,7 +302,19 @@ export class FileHashStore {
    * spawn per file.
    */
   private async hashFileFromDisk(filePath: string): Promise<string> {
-    return this.hashBytes(await Bun.file(filePath).bytes(), filePath)
+    let bytes: Uint8Array
+    try {
+      bytes = await Bun.file(filePath).bytes()
+    } catch (err) {
+      // Left raw, the scheduler added the write hint to an input vx only
+      // reads: "a path vx must write is not writable by this user".
+      if (!isPermissionError(err)) throw err
+      throw new UserError(
+        `${filePath} is not readable by this user (${err.code}), and vx reads it to derive a ` +
+          'cache key. Make it readable, or, for a task input, take it out of cache.inputs.files.',
+      )
+    }
+    return this.hashBytes(bytes, filePath)
   }
 
   /**

package/src/orchestrator/persistent.ts

@@ -3,7 +3,7 @@
 // ownership moves to the run's registry, and this is the one place that
 // decides which of them outlive the graph and how the rest go down.
 
-import type { TaskNode } from '../graph/index.js'
+import { isGroupTask, type TaskNode } from '../graph/index.js'
 import { killGraceMs } from '../util/index.js'
 import { holdGroups, killTree, untilGroupsGone } from '../exec/index.js'
 
@@ -25,9 +25,12 @@ export interface KeepAlive {
 /**
  * A persistent task the user REQUESTED (or one surfaced for display) is the
  * run's whole purpose — it is left running and blocked on at the very end,
- * after the summary. Only in the real CLI foreground: a custom logger or
- * `handleSignals: false` (watch mode, embedders) expects `run()` to return,
- * not to sit on a server.
+ * after the summary. So is every persistent task a kept one depends on,
+ * directly or through groups: `vx run dev --filter app` stopped the api#dev
+ * its app#dev was started against (C-46). A one-shot's persistent deps are
+ * not kept on its account; it has finished with them. Only in the real CLI
+ * foreground: a custom logger or `handleSignals: false` (watch mode,
+ * embedders) expects `run()` to return, not to sit on a server.
  */
 export function selectKeepAlive(
   registry: ReadonlyMap<string, Child>,
@@ -36,13 +39,25 @@ export function selectKeepAlive(
 ): KeepAlive {
   const out: KeepAlive = { nodes: [], children: [] }
   if (!foreground) return out
-  for (const [id, child] of registry) {
+  const stack = [...registry.keys()].filter((id) => {
     const n = nodes.get(id)
-    if (n !== undefined && (n.requested || n.surfaced === true)) {
-      out.nodes.push(n)
-      out.children.push(child)
+    return n !== undefined && (n.requested || n.surfaced === true)
+  })
+  const reached = new Set<string>()
+  while (stack.length > 0) {
+    const id = stack.pop()!
+    if (reached.has(id)) continue
+    reached.add(id)
+    for (const dep of nodes.get(id)?.deps ?? []) {
+      const d = nodes.get(dep)
+      if (d !== undefined && (registry.has(dep) || isGroupTask(d))) stack.push(dep)
     }
   }
+  for (const [id, child] of registry) {
+    if (!reached.has(id)) continue
+    out.nodes.push(nodes.get(id)!)
+    out.children.push(child)
+  }
   return out
 }