@vzn/vx 0.0.277 → 0.0.279

package/package.json

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

package/src/bin.ts

@@ -1,26 +1,25 @@
 #!/usr/bin/env -S bun --no-env-file --no-install
-import { registerCoreAlias, run } from './cli/index.js'
-import {
-  fsRefusalHint,
-  isFsRefusal,
-  isOutOfFds,
-  isUserError,
-  OUT_OF_FDS_HINT,
-} from './util/index.js'
-
-// Every `import … from '@vzn/vx'` this process evaluates — a plugin
-// package, a workspace or project config — resolves to THIS core, not to
-// a second copy from node_modules (core-alias.ts says why and what it
-// costs). Registered before any verb runs; the façade loads on first use.
-registerCoreAlias(() => import('./index.js') as Promise<Record<string, unknown>>)
-
 // Wrapped in an explicit async main so `bun build --compile` accepts
 // the file. The compile target doesn't allow top-level await.
 let settled = false
 
 async function main(): Promise<void> {
+  const argv = process.argv.slice(2)
   try {
-    const code = await run(process.argv.slice(2))
+    // `vx --version` needs one leaf module; the dispatcher and the util
+    // barrel it pulled in were 20 ms of its 28 (2026-10-01).
+    if (argv.length === 1 && (argv[0] === '--version' || argv[0] === 'version')) {
+      process.stdout.write(`vx ${(await import('./version.js')).VERSION}\n`)
+      settled = true
+      return
+    }
+    const { registerCoreAlias, run } = await import('./cli/index.js')
+    // Every `import … from '@vzn/vx'` this process evaluates — a plugin
+    // package, a workspace or project config — resolves to THIS core, not to
+    // a second copy from node_modules (core-alias.ts says why and what it
+    // costs). Registered before any verb runs; the façade loads on first use.
+    registerCoreAlias(() => import('./index.js') as Promise<Record<string, unknown>>)
+    const code = await run(argv)
     // NOTHING calls `process.exit` here, and that is the fix rather than a
     // simplification. Bun drops what a pipe has not yet taken when
     // `process.exit` follows a large write: 300 KB written then exit
@@ -34,6 +33,8 @@ async function main(): Promise<void> {
     // several hundred spawns of this binary would show at once.
     process.exitCode = code
   } catch (err) {
+    const { fsRefusalHint, isFsRefusal, isOutOfFds, isUserError, OUT_OF_FDS_HINT } =
+      await import('./util/index.js')
     // UserError (workspace not found, cycle, config invalid, ...) —
     // print the message only; the stack is noise the user can't act
     // on. Everything else gets the full stack so internal bugs are

package/src/cli/init.ts

@@ -180,7 +180,9 @@ async function adopt(
       : `wrote ${name}.`
   const cacheLine =
     remote === undefined
-      ? ''
+      ? runner === 'nx' && usesNxCloud(root)
+        ? 'nx.json connects Nx Cloud, whose cache vx cannot share: runs cache on this machine (nxCache() serves a self-hosted Nx cache).\n'
+        : ''
       : kept && !readFileSync(path.join(root, existing), 'utf8').includes(`${cache}(`)
         ? `${remote}: add ${cache}() from @vzn/vx-migrate to its plugins and vx shares that remote cache.\n`
         : kept
@@ -195,6 +197,31 @@ async function adopt(
 
 const REMOTE_CACHE = { turbo: 'turboCache', nx: 'nxCache' } as const
 
+/**
+ * nx.json names an Nx Cloud workspace (`nxCloudId`, `nxCloudAccessToken`,
+ * or the legacy `nx-cloud` runner). Its wire is Nx's own, so a user who
+ * expected their remote cache under vx heard nothing and ran cold.
+ */
+function usesNxCloud(root: string): boolean {
+  let json: {
+    nxCloudId?: unknown
+    nxCloudAccessToken?: unknown
+    tasksRunnerOptions?: { default?: { runner?: unknown } }
+  } | null
+  try {
+    json = Bun.JSONC.parse(readFileSync(path.join(root, 'nx.json'), 'utf8')) as typeof json
+  } catch {
+    return false
+  }
+  const set = (v: unknown) => typeof v === 'string' && v !== ''
+  const runner = json?.tasksRunnerOptions?.default?.runner
+  return (
+    set(json?.nxCloudId) ||
+    set(json?.nxCloudAccessToken) ||
+    (typeof runner === 'string' && /(^|\/)nx-cloud$/.test(runner))
+  )
+}
+
 /** The variable each runner's self-hosted remote cache is set by, as its plugin reads it. */
 const REMOTE_CACHE_ENV = { turbo: 'TURBO_TOKEN', nx: 'NX_SELF_HOSTED_REMOTE_CACHE_SERVER' } as const
 
@@ -202,7 +229,7 @@ const CI_FILES = ['.gitlab-ci.yml', '.circleci/config.yml']
 
 /**
  * Where the repo shows a remote cache its runner uses, or undefined: turbo.json's
- * enabled `remoteCache`, or a CI file that sets the runner's cache variable (a
+ * enabled `remoteCache`, a `turbo link`ed `.turbo/config.json`, or a CI file that sets the runner's cache variable (a
  * local repo holds no token; CI does).
  */
 function remoteCacheSignal(root: string, runner: 'turbo' | 'nx'): string | undefined {
@@ -222,6 +249,21 @@ function remoteCacheSignal(root: string, runner: 'turbo' | 'nx'): string | undef
         return `${f} names a remoteCache`
       }
     }
+    // `turbo link` writes the team here (gitignored, on the machine that
+    // linked); turboCache() reads it, so a linked repo has a remote cache.
+    let linked: unknown
+    try {
+      linked = JSON.parse(readFileSync(path.join(root, '.turbo', 'config.json'), 'utf8'))
+    } catch {}
+    if (
+      typeof linked === 'object' &&
+      linked !== null &&
+      Object.entries(linked).some(
+        ([k, v]) => /^(teamid|teamslug|token)$/i.test(k) && typeof v === 'string' && v !== '',
+      )
+    ) {
+      return '.turbo/config.json links a team (turbo link)'
+    }
   }
   const variable = REMOTE_CACHE_ENV[runner]
   // A line that sets it (`TURBO_TOKEN: …`, `TURBO_TOKEN=…`), not one that

package/src/cli/show.ts

@@ -6,6 +6,7 @@
 // <task>`: one task. `<task>`: that task in every project declaring it.
 // Deliberately NOT the lock — vx-lock.json is already the frozen JSON.
 
+import path from 'node:path'
 import type { ProjectConfig, TaskConfig } from '../config.js'
 import { declaredTask } from '../graph/index.js'
 import { flagHint, seeHelp } from './help.js'
@@ -65,6 +66,10 @@ export async function showCmd(args: readonly string[]): Promise<number> {
   const metas = await discoverCliProjects(await loadWorkspace(root, reads))
   const byName = new Map(metas.map((m) => [m.name, m]))
 
+  // `//#task` is Turbo's root package's task: the root project here (D-39).
+  const rootMeta = metas.find((m) => path.resolve(m.dir) === path.resolve(root))
+  if (parsed.target?.startsWith('//#') && rootMeta !== undefined)
+    parsed.target = `${rootMeta.name}#${parsed.target.slice(3)}`
   const hashAt = parsed.target?.indexOf('#') ?? -1
   const projectName =
     parsed.target === undefined

package/src/cli/why.ts

@@ -5,6 +5,7 @@
 // names the exact cache-key components that differ. Read-only over cache.db —
 // no config evaluation, no re-hash.
 
+import path from 'node:path'
 import { Cache, noteSchemaReset } from '../cache/index.js'
 import { flagHint, seeHelp } from './help.js'
 import { splitTaskId } from '../graph/index.js'
@@ -159,6 +160,16 @@ function resolveTarget(cache: Cache, target: string): string {
 
 const fmtWhen = (ms: number): string => new Date(ms).toISOString()
 
+/** `//#task`, Turbo's root package, as the root project's id: its package.json name (D-39). */
+async function rootSpelled(root: string, target: string): Promise<string> {
+  if (!target.startsWith('//#')) return target
+  const name = await Bun.file(path.join(root, 'package.json'))
+    .json()
+    .then((j: { name?: unknown }) => j.name)
+    .catch(() => undefined)
+  return typeof name === 'string' && name !== '' ? `${name}#${target.slice(3)}` : target
+}
+
 export async function whyCmd(args: readonly string[]): Promise<number> {
   const parsed = parseWhyArgs(args)
   if (parsed.error !== undefined) throw new UserError(`vx why: ${parsed.error}`)
@@ -171,7 +182,7 @@ export async function whyCmd(args: readonly string[]): Promise<number> {
   noteSchemaReset(cache, warnToStderr)
   try {
     const db = cache.dbHandle()
-    const taskId = resolveTarget(cache, parsed.target)
+    const taskId = resolveTarget(cache, await rootSpelled(root, parsed.target))
     const runId =
       parsed.runId !== undefined
         ? (resolveRunId(db, parsed.runId, 'vx why') ?? parsed.runId)