@vzn/vx 0.0.109 → 0.0.110

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.109",
+  "version": "0.0.110",
   "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.109",
-    "@vzn/vx-linux-arm64": "0.0.109",
-    "@vzn/vx-darwin-x64": "0.0.109",
-    "@vzn/vx-darwin-arm64": "0.0.109"
+    "@vzn/vx-linux-x64": "0.0.110",
+    "@vzn/vx-linux-arm64": "0.0.110",
+    "@vzn/vx-darwin-x64": "0.0.110",
+    "@vzn/vx-darwin-arm64": "0.0.110"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/cache/archive.ts

@@ -49,6 +49,10 @@ const META_ENTRY = '.vx-meta.json'
 /** Archive entry name of the always-present stdout record. */
 const STDOUT_ENTRY = 'stdout'
 
+const WIN32 = process.platform === 'win32'
+// A Windows link target may be spelled with either separator.
+const LINK_SEP = WIN32 ? /[\\/]/ : '/'
+
 /**
  * Sidecar shape. `files` maps an entry name to `[mode, mtimeMs]` — a
  * pair, not an object, because the sidecar is real entropy inside an
@@ -157,12 +161,15 @@ export async function planArtifact(args: PackArgs): Promise<ArtifactPlan> {
           `output ${shown} is not a regular file (a symlink to a directory?): vx stores regular files only — emit a file there, or narrow cache.outputs.files to the files the task produces (output globs take no '!')`,
         )
       }
-      meta.files[name] = [st.mode & 0o777, Math.floor(st.mtimeMs)]
+      // Windows reports 0o666 (0o444 read-only) and never an exec bit: a
+      // Linux restore of that would be world-writable.
+      const mode = WIN32 ? 0o644 : st.mode & 0o777
+      meta.files[name] = [mode, Math.floor(st.mtimeMs)]
       return {
         name,
         abs,
         size: st.size,
-        mode: st.mode & 0o777,
+        mode,
         // ustar's octal field holds no sign: an mtime before 1970 made the
         // header unreadable and every save of it a "corrupt artifact". The
         // sidecar above carries the real value.
@@ -640,7 +647,9 @@ class Extractor {
     let n = 0
     for (const s of this.staged) {
       const [mode, mtimeMs] = metaFor(s.name)
-      if ((mode & 0o777) !== createdMode) chmodSync(s.tmp, mode & 0o777)
+      // Windows has no mode bits: chmod there only sets the read-only
+      // attribute, and a read-only restore refuses the next rename over it.
+      if ((mode & 0o777) !== createdMode && !WIN32) chmodSync(s.tmp, mode & 0o777)
       if (mtimeMs !== undefined) {
         // A Date, not seconds: Bun reads a negative number of seconds as
         // "now", and a Date before 1970 as itself (Bun 1.4.2).
@@ -725,8 +734,10 @@ async function linkOutError(base: string, probe: string, realBase: string): Prom
  * A cycle is the user's tree, not the artifact, so it is refused by name.
  */
 async function resolveThrough(p: string): Promise<string> {
-  const pending = path.resolve(p).split(path.sep).filter(Boolean).reverse()
-  let at: string = path.sep
+  const abs = path.resolve(p)
+  // The root is `/` or a drive (`C:\`): joining a drive onto `\` loses it.
+  let at = path.parse(abs).root
+  const pending = abs.slice(at.length).split(path.sep).filter(Boolean).reverse()
   let hops = 0
   while (pending.length > 0) {
     const next = path.join(at, pending.pop()!)
@@ -747,8 +758,12 @@ async function resolveThrough(p: string): Promise<string> {
           'write through it. Remove the link and re-run.',
       )
     }
-    if (path.isAbsolute(link)) at = path.sep
-    pending.push(...link.split(path.sep).filter(Boolean).reverse())
+    let rest = link
+    if (path.isAbsolute(link)) {
+      at = path.parse(link).root
+      rest = link.slice(at.length)
+    }
+    pending.push(...rest.split(LINK_SEP).filter(Boolean).reverse())
   }
   return at
 }

package/src/cache/cache.ts

@@ -1211,12 +1211,12 @@ export class Cache implements CacheLayer {
   }): Map<string, string> {
     const outputs = new Map<string, string>()
     for (const f of args.outputFiles) {
-      outputs.set(`outputs/${path.relative(args.projectDir, f)}`, f)
+      outputs.set(`outputs/${relPosix(args.projectDir, f)}`, f)
     }
     // Caller passes workspaceRoot whenever workspaceOutputFiles is
     // non-empty; the rels are root-anchored by construction.
     for (const f of args.workspaceOutputFiles ?? []) {
-      outputs.set(`${WORKSPACE_OUTPUT_PREFIX}${path.relative(args.workspaceRoot!, f)}`, f)
+      outputs.set(`${WORKSPACE_OUTPUT_PREFIX}${relPosix(args.workspaceRoot!, f)}`, f)
     }
     return outputs
   }

package/src/cli/plugin-commands.ts

@@ -113,12 +113,10 @@ export async function pluginVerbs(cwd = process.cwd()): Promise<string[]> {
 export async function pluginCommandHelp(cwd = process.cwd()): Promise<string[]> {
   const ws = await workspacePlugins(cwd).catch(() => null)
   if (ws === null || 'loadError' in ws) return []
+  // A verb has one owner: the workspace load refuses two plugins declaring it.
   const lines: string[] = []
-  const seen = new Set<string>()
   for (const plugin of ws.plugins) {
     for (const [verb, command] of Object.entries(plugin.commands ?? {})) {
-      if (seen.has(verb)) continue
-      seen.add(verb)
       lines.push(`  vx ${verb.padEnd(17)} ${command.description} (${plugin.name})`)
     }
   }

package/src/orchestrator/run-lock.ts

@@ -240,7 +240,7 @@ async function place(lockDir: string): Promise<string | null> {
   await mkdir(staging)
   try {
     await writeFile(path.join(staging, entry), '')
-    await rename(staging, lockDir)
+    await (WIN32 ? renameWin32(staging, lockDir) : rename(staging, lockDir))
     return entry
   } catch (err) {
     await rm(staging, { recursive: true, force: true })
@@ -250,6 +250,36 @@ async function place(lockDir: string): Promise<string | null> {
   }
 }
 
+const WIN32 = process.platform === 'win32'
+
+/**
+ * Windows renames no directory onto another, even an empty one: EPERM
+ * where POSIX gives ENOTEMPTY, which read as a refusal and ran every
+ * contender unlocked. A name that exists is taken; an empty one (a
+ * holder's leave that lost its rmdir) is removed and the rename tried
+ * once more, as POSIX's rename onto it would replace it.
+ */
+async function renameWin32(staging: string, lockDir: string): Promise<void> {
+  try {
+    await rename(staging, lockDir)
+    return
+  } catch (err) {
+    const code = (err as NodeJS.ErrnoException).code
+    if (code !== 'EPERM' && code !== 'EACCES') throw err
+    const empty = await rmdir(lockDir).then(
+      () => true,
+      () => false,
+    )
+    if (!empty) throw Object.assign(new Error('run lock taken'), { code: 'EEXIST' })
+  }
+  await rename(staging, lockDir).catch((err: NodeJS.ErrnoException) => {
+    if (err.code === 'EPERM' || err.code === 'EACCES') {
+      throw Object.assign(new Error('run lock taken'), { code: 'EEXIST' })
+    }
+    throw err
+  })
+}
+
 /**
  * Unlink one taking's entry, then the directory if that left it empty.
  * Gone already is not an error (another waiter reclaimed it first); a