@vzn/vx 0.0.594 → 0.0.595

package/src/workspace/config-schema.ts

@@ -28,7 +28,7 @@ import {
   asTrees,
   isLiteralPattern,
 } from '../util/index.js'
-import { compileNameGlob } from './filter.js'
+import { compileNameGlob, parseFilter } from './filter.js'
 import { nonJsonMessage, nonJsonPaths } from './json-data.js'
 
 // Mirrors `WorkspaceConfig` in src/config.ts. Unknown keys are REJECTED for
@@ -78,6 +78,7 @@ const RETENTION_FIELDS = new Set(['olderThan', 'maxSize'])
 
 function validateRetention(retention: unknown, configPath: string): void {
   const where = `${configPath}: \`cacheRetention\``
+  const field = (key: string) => `${configPath}: \`cacheRetention.${key}\``
   if (retention === null || typeof retention !== 'object' || Array.isArray(retention)) {
     throw new UserError(`${where} must be { olderThan?: '30d', maxSize?: '10G' }`)
   }
@@ -91,23 +92,27 @@ function validateRetention(retention: unknown, configPath: string): void {
     olderThan !== undefined &&
     (typeof olderThan !== 'string' || parseDuration(olderThan) === null)
   ) {
-    throw new UserError(`${where}.olderThan must be a duration like '30d', '12h', '90m' or '45s'`)
+    throw new UserError(
+      `${field('olderThan')} must be a duration like '30d', '12h', '90m' or '45s' (got ${JSON.stringify(olderThan)})`,
+    )
   }
   if (maxSize !== undefined && (typeof maxSize !== 'string' || parseSize(maxSize) === null)) {
-    throw new UserError(`${where}.maxSize must be a size like '10G', '500MB' or '64KB'`)
+    throw new UserError(
+      `${field('maxSize')} must be a size like '10G', '500MB' or '64KB' (got ${JSON.stringify(maxSize)})`,
+    )
   }
   // The bounds `vx cache prune` refuses, for the same reason: each evicts
   // every entry, and here it would do so at the end of every run, the
   // entries that run just saved included, so nothing ever hits (item 969).
   if (olderThan !== undefined && parseDuration(olderThan) === 0) {
-    throw new UserError(`${where}.olderThan of 0 evicts every entry after every run`)
+    throw new UserError(`${field('olderThan')} of 0 evicts every entry after every run`)
   }
   if (maxSize !== undefined && parseSize(maxSize) === 0) {
-    throw new UserError(`${where}.maxSize of 0 evicts every entry after every run`)
+    throw new UserError(`${field('maxSize')} of 0 evicts every entry after every run`)
   }
   if (maxSize !== undefined && /^\d+$/.test(maxSize)) {
     throw new UserError(
-      `${where}.maxSize '${maxSize}' reads as ${maxSize} bytes — give a unit (e.g. '${maxSize}M', '${maxSize}G')`,
+      `${field('maxSize')} '${maxSize}' reads as ${maxSize} bytes — give a unit (e.g. '${maxSize}M', '${maxSize}G')`,
     )
   }
 }
@@ -230,6 +235,12 @@ export function validateWorkspace(config: WorkspaceConfig, configPath: string):
         if (plug.commands === null || typeof plug.commands !== 'object') {
           throw new UserError(`${configPath}: \`plugins[${i}].commands\` must be an object`)
         }
+        // A list of commands loaded as the verbs `0`, `1`, … that help listed.
+        if (Array.isArray(plug.commands)) {
+          throw new UserError(
+            `${configPath}: \`plugins[${i}].commands\` must be an object keyed by verb, not an array`,
+          )
+        }
         for (const [verb, cmd] of Object.entries(plug.commands as Record<string, unknown>)) {
           const c = cmd as { description?: unknown; run?: unknown } | null
           if (
@@ -345,6 +356,15 @@ export function validateProjectConfig(config: ProjectConfig, configPath: string)
   ) {
     throw new UserError(`${configPath}: \`tags\` must be an array of non-empty strings`)
   }
+  for (const tag of (tags ?? []) as string[]) {
+    const why = tagProblem(tag)
+    if (why !== null) {
+      throw new UserError(
+        `${configPath}: tag ${JSON.stringify(tag)} ${why} — \`--filter tag:<name>\` could not ` +
+          `name it. Rename the tag.`,
+      )
+    }
+  }
   const tasks = config.tasks
   if (tasks === undefined) return
   if (typeof tasks !== 'object' || tasks === null || Array.isArray(tasks)) {
@@ -1367,6 +1387,22 @@ export function taskNameProblem(name: string): string | null {
             : null
 }
 
+/**
+ * Why `--filter tag:<tag>` cannot name `tag`, or null. Asked of the filter
+ * parser itself, so a suffix it learns to read is refused here too: `v1...`
+ * read as a dependency walk from `v1`, `v[2]` as `v` changed since ref `2`.
+ */
+function tagProblem(tag: string): string | null {
+  if (tag.trim() !== tag) return 'has surrounding whitespace'
+  if (tag.includes('*')) return "holds '*', which makes it a pattern"
+  const f = parseFilter(`tag:${tag}`, '/')
+  if (f.gitSince !== undefined) {
+    return `ends in "[${f.gitSince}]", which a filter reads as a git range`
+  }
+  if (f.withDeps || f.onlyDeps) return "ends in '...', which a filter reads as a dependency walk"
+  return null
+}
+
 /**
  * Refuse a non-empty glob list made up ENTIRELY of negations.
  *
@@ -1488,6 +1524,12 @@ function assertStringArray(v: unknown, where: string): void {
   if (!Array.isArray(v) || v.some((s) => typeof s !== 'string' || s.length === 0)) {
     throw new UserError(`${where} must be an array of non-empty strings`)
   }
+  // No path, host or name holds a NUL; a write grant with one reached the
+  // placeholder create as an internal error.
+  const nul = (v as string[]).find((s) => s.includes('\0'))
+  if (nul !== undefined) {
+    throw new UserError(`${where}: ${JSON.stringify(nul)} holds a NUL byte`)
+  }
 }
 
 /**

package/src/workspace/migrate-scripts.ts

@@ -541,7 +541,7 @@ function siblingRun(script: string, dir: string, others: readonly string[]): str
 function lernaPackages(dir: string): string[] | undefined {
   let json: unknown
   try {
-    json = JSON.parse(readFileSync(path.join(dir, 'lerna.json'), 'utf8'))
+    json = JSON.parse(readFileSync(path.join(dir, 'lerna.json'), 'utf8').replace(/^\uFEFF/, ''))
   } catch {
     return undefined
   }

package/src/workspace/package-graph.ts

@@ -73,7 +73,7 @@ export function buildPackageGraph(
     const dev = bucket(p.packageJson.devDependencies)
     const add = (key: string, spec: unknown, installed: boolean, into: Set<string>): void => {
       if (typeof spec !== 'string') return
-      const target = linked(key, spec.trim(), p.dir, installed)
+      const target = linked(key, fromCatalog(p, key, spec.trim()), p.dir, installed)
       if (target !== undefined && target !== p.name) into.add(target)
     }
     // Which entry is installed when a key sits in more than one field,
@@ -300,6 +300,19 @@ export function buildPackageGraph(
   }
 }
 
+/**
+ * The spec a `catalog:` / `catalog:<name>` entry stands for in the
+ * workspace's catalog, so it is an edge by the rule its range or protocol
+ * meets (zenstack's `nuxt: "catalog:"` is `4.3.1`, which the workspace's
+ * versionless `nuxt` sample does not satisfy). A catalog the graph was not
+ * given or that lacks the key leaves the spec, which keeps its edge.
+ */
+function fromCatalog(p: ProjectMeta, key: string, spec: string): string {
+  if (p.catalogs === undefined || !spec.startsWith('catalog:')) return spec
+  const resolved = p.catalogs.get(spec.slice('catalog:'.length).trim() || 'default')?.[key]
+  return typeof resolved === 'string' && !resolved.startsWith('catalog:') ? resolved.trim() : spec
+}
+
 function bucket(field: unknown): Readonly<Record<string, unknown>> {
   return typeof field === 'object' && field !== null ? (field as Record<string, unknown>) : {}
 }
@@ -377,8 +390,7 @@ function linkedTarget(
     if (!MAY_POINT_ELSEWHERE.test(spec)) {
       const local = byName.get(key)
       if (local === undefined) return undefined
-      // A catalog entry's range lives where the graph does not read
-      // (`pnpm-workspace.yaml`, bun's root `catalog`): it keeps the edge.
+      // A catalog entry its workspace's catalog did not resolve keeps the edge.
       if (!installed || spec.startsWith('catalog:')) return key
       return satisfies(local, spec) ? key : undefined
     }

package/src/workspace/project-loader.ts

@@ -479,6 +479,7 @@ export async function loadProjectConfigs(
   let env: Readonly<Record<string, string | undefined>> = {}
   let cwd = ''
   let umask = -1
+  let unredirect: (() => void) | undefined
   // More than one evaluation in flight: a change seen after one load may
   // be another's.
   let overlapping = false
@@ -588,6 +589,7 @@ export async function loadProjectConfigs(
       else misses.push(i)
     }
     if (misses.length > 0) {
+      unredirect = stdoutToStderr()
       builtins = builtinSnapshot()
       env = { ...process.env }
       cwd = process.cwd()
@@ -651,6 +653,7 @@ export async function loadProjectConfigs(
       )
     return results.map((r) => (r as Loaded).config)
   } finally {
+    unredirect?.()
     endRound()
     if (store !== undefined && !tainted) {
       if (evals.length > 0) {
@@ -665,6 +668,72 @@ export async function loadProjectConfigs(
   }
 }
 
+/**
+ * Every route to fd 1 sent to stderr while configs evaluate in this
+ * process; returns the release. A verb's stdout is its output (`vx show
+ * --format json`), and a config's `console.log` came out ahead of the
+ * JSON. The worker does the same for a repeat load (D-64), `vx mcp` for
+ * its whole serve. Taken before a round's built-in snapshot and released
+ * after its check, so the guard sees no change of vx's own.
+ *
+ * Counted, because rounds overlap (`--affected`'s per-file sweep loads each
+ * config in a round of its own): a second install over the first moved
+ * `Bun.write` and `console` under the first round's snapshot, which refused
+ * the loads, and the undos ran out of order and left a redirect in place
+ * for good. The first taker installs; the last release restores.
+ */
+let redirectHolders = 0
+let undoRedirect = (): void => {}
+/**
+ * Bun's own `Console`, taken at load: the console a round finds may be a
+ * constructed one (`vx mcp` serves under its own), which has no `Console`.
+ * The global's, not `node:console`'s: the playground bundles this module
+ * for the browser, where that specifier is a stub.
+ */
+const BunConsole = (globalThis.console as { Console?: typeof console.Console }).Console
+
+function stdoutToStderr(): () => void {
+  if (redirectHolders++ === 0) undoRedirect = installRedirect()
+  return () => {
+    if (--redirectHolders === 0) undoRedirect()
+  }
+}
+
+function installRedirect(): () => void {
+  const out = process.stdout
+  const ownWrite = Object.getOwnPropertyDescriptor(out, 'write')
+  const ownConsole = globalThis.console
+  const bun = Bun as { write: typeof Bun.write }
+  const ownBunWrite = Bun.write
+  const ownWriter = Object.getOwnPropertyDescriptor(Bun.stdout, 'writer')
+  out.write = ((...args: Parameters<typeof process.stderr.write>) =>
+    process.stderr.write(...args)) as typeof out.write
+  bun.write = ((dest: unknown, ...rest: unknown[]) =>
+    (ownBunWrite as (...a: unknown[]) => Promise<number>)(
+      dest === Bun.stdout ? Bun.stderr : dest,
+      ...rest,
+    )) as typeof Bun.write
+  ;(Bun.stdout as { writer: typeof Bun.stdout.writer }).writer = ((
+    ...args: Parameters<typeof Bun.stderr.writer>
+  ) => Bun.stderr.writer(...args)) as typeof Bun.stdout.writer
+  // Bun's console adds `write`, which a constructed Console lacks.
+  globalThis.console = Object.assign(new BunConsole!(process.stderr, process.stderr), {
+    write: (...data: string[]) => {
+      const text = data.join('')
+      process.stderr.write(text)
+      return text.length
+    },
+  })
+  return () => {
+    if (ownWrite === undefined) delete (out as { write?: unknown }).write
+    else Object.defineProperty(out, 'write', ownWrite)
+    bun.write = ownBunWrite
+    if (ownWriter === undefined) delete (Bun.stdout as { writer?: unknown }).writer
+    else Object.defineProperty(Bun.stdout, 'writer', ownWriter)
+    globalThis.console = ownConsole
+  }
+}
+
 /**
  * The built-in prototypes a config's object is read through. A config that
  * set `Object.prototype.exec` gave every other project's task that
@@ -751,6 +820,7 @@ const BUN_MEMBERS_VX_READS: readonly PropertyKey[] = [
   'sleep',
   'spawn',
   'spawnSync',
+  'stderr',
   'stdout',
   'stringWidth',
   'stripANSI',
@@ -1039,6 +1109,7 @@ export async function loadWorkspaceConfig(root: string): Promise<WorkspaceConfig
     // left out: it loads first in every run, filtered or not, so none
     // depends on what else loaded (D-122's case), and plugins' tests and
     // tools hand state through them.
+    const unredirect = stdoutToStderr()
     const builtins = builtinSnapshot('globalThis', true)
     const env = { ...process.env }
     const cwd = process.cwd()
@@ -1053,6 +1124,7 @@ export async function loadWorkspaceConfig(root: string): Promise<WorkspaceConfig
         ...restoreCwd(cwd),
         ...restoreUmask(umask),
       ]
+      unredirect()
       // eslint-disable-next-line no-unsafe-finally -- the refusal outranks the load's own error
       if (changed.length > 0) throw builtinsChanged(changed, configPath)
     }

package/src/workspace/workspace.ts

@@ -31,8 +31,18 @@ export interface Workspace {
   root: string
   /** Glob patterns relative to root that match project directories. */
   packageGlobs: string[]
+  /** The package manager's catalogs, when the root declares any. */
+  catalogs?: Catalogs
 }
 
+/**
+ * Catalog name → dependency → the spec a `catalog:<name>` entry stands
+ * for; `catalog:` alone is `default`. pnpm's from `pnpm-workspace.yaml`
+ * (`catalog`, `catalogs`), bun's from the root `package.json` (the same
+ * keys, top level or under `workspaces`).
+ */
+export type Catalogs = ReadonlyMap<string, Readonly<Record<string, unknown>>>
+
 export interface ProjectMeta {
   /** Canonical name from package.json. */
   name: string
@@ -41,6 +51,8 @@ export interface ProjectMeta {
   packageJson: PackageJson
   /** Absolute path to vx.config.{ts,mts,js,mjs,cts,cjs} or null. */
   configPath: string | null
+  /** The workspace's catalogs, which the package graph resolves `catalog:` specs through. */
+  catalogs?: Catalogs
 }
 
 /** A discovered project joined with its loaded vx config. */
@@ -168,9 +180,12 @@ async function claimsMember(
     const normalized = pattern.replace(/\/+$/, '')
     // `.` means the root itself is the project — never a directory below it.
     if (normalized === '' || normalized === '.') continue
-    const glob = new Bun.Glob(normalized)
+    // Matched as discovery scans, on the manifest: `packages/**` lists
+    // `packages/package.json`, while against the directory `**` needs a
+    // segment below `packages`, and a run from there was its own root.
+    const glob = new Bun.Glob(`${normalized}/package.json`)
     for (const rel of rels) {
-      if (!glob.match(rel)) continue
+      if (!glob.match(`${rel}/package.json`)) continue
       // `match` has no `dot: false`: `packages/*` matched `packages/.tpl`,
       // which discovery skips, and a run from inside it found a workspace
       // that does not list it. Such a path asks discovery's own walk.
@@ -231,17 +246,30 @@ function excludedBy(rel: string, negative: readonly string[]): boolean {
  * the root itself is the only project, hence `['.']`.
  */
 async function readPackageGlobs(dir: string, reads?: LoadReads): Promise<string[] | null> {
+  return (await readRootManifests(dir, reads)).globs
+}
+
+/** `readPackageGlobs`, and the catalogs the same manifests declare. */
+async function readRootManifests(
+  dir: string,
+  reads?: LoadReads,
+): Promise<{ globs: string[] | null; catalogs: Catalogs | undefined }> {
   const yamlPath = path.join(dir, 'pnpm-workspace.yaml')
   const yaml = await readOnce(reads, yamlPath)
   let yamlWithoutPackages = false
+  // pnpm reads its catalogs from this file alone, bun from package.json.
+  let catalogs: Catalogs | undefined
   if (yaml !== null) {
     const parsed = parseManifest(decoder.decode(yaml), yamlPath, Bun.YAML.parse)
     if (parsed !== null && parsed !== undefined) {
       if (typeof parsed !== 'object' || Array.isArray(parsed)) {
         throw new UserError(`${yamlPath}: must be a mapping (\`packages:\` and pnpm's settings)`)
       }
+      catalogs = catalogsOf([parsed])
       const packages = (parsed as { packages?: unknown }).packages
-      if (packages !== undefined) return assertGlobList(packages, yamlPath, 'packages')
+      if (packages !== undefined) {
+        return { globs: assertGlobList(packages, yamlPath, 'packages'), catalogs }
+      }
     }
     // No `packages:`: pnpm 10 keeps its settings and catalogs in this file
     // for a single-package repo too. The root's package.json decides, as it
@@ -251,18 +279,46 @@ async function readPackageGlobs(dir: string, reads?: LoadReads): Promise<string[
   }
   const pkgPath = path.join(dir, 'package.json')
   const pkgBytes = await readOnce(reads, pkgPath)
-  if (pkgBytes === null) return yamlWithoutPackages ? [] : null
+  if (pkgBytes === null) return { globs: yamlWithoutPackages ? [] : null, catalogs }
   const pkg = parsePackageJson(decoder.decode(pkgBytes), pkgPath)
   const ws = pkg.workspaces as unknown
-  if (ws === undefined || ws === null) return ['.']
+  if (yaml === null) {
+    catalogs = catalogsOf(
+      ws !== null && typeof ws === 'object' && !Array.isArray(ws) ? [pkg, ws] : [pkg],
+    )
+  }
+  if (ws === undefined || ws === null) return { globs: ['.'], catalogs }
   if (ws && typeof ws === 'object' && !Array.isArray(ws) && 'packages' in ws) {
-    return assertGlobList(
+    const globs = assertGlobList(
       (ws as { packages?: unknown }).packages ?? [],
       pkgPath,
       'workspaces.packages',
     )
+    return { globs, catalogs }
   }
-  return assertGlobList(ws, pkgPath, 'workspaces')
+  return { globs: assertGlobList(ws, pkgPath, 'workspaces'), catalogs }
+}
+
+/**
+ * The `catalog` and `catalogs` keys of the manifests (bun reads them at
+ * the top level and under `workspaces`), or undefined when none declares
+ * one. An entry that is not a mapping is no catalog: a `catalog:` spec
+ * through it keeps its edge, as one through an unknown catalog does.
+ */
+function catalogsOf(manifests: readonly object[]): Catalogs | undefined {
+  const isMap = (v: unknown): v is Record<string, unknown> =>
+    typeof v === 'object' && v !== null && !Array.isArray(v)
+  let out: Map<string, Readonly<Record<string, unknown>>> | undefined
+  for (const m of manifests) {
+    const { catalog, catalogs } = m as { catalog?: unknown; catalogs?: unknown }
+    if (isMap(catalogs)) {
+      for (const [name, c] of Object.entries(catalogs))
+        if (isMap(c)) (out ??= new Map()).set(name, c)
+    }
+    // `catalog` is the default catalog to pnpm and bun.
+    if (isMap(catalog)) (out ??= new Map()).set('default', catalog)
+  }
+  return out
 }
 
 /**
@@ -435,14 +491,14 @@ const repoIds = new Map<string, Promise<string | null>>()
  * itself is treated as a single-project workspace.
  */
 export async function loadWorkspace(root: string, reads?: LoadReads): Promise<Workspace> {
-  const packageGlobs = await readPackageGlobs(root, reads)
+  const { globs: packageGlobs, catalogs } = await readRootManifests(root, reads)
   if (packageGlobs === null) {
     // The CLI never lands here (findWorkspaceRoot returns only a dir that
     // passes one of the two checks); a direct call of this public function
     // on a bare dir does (D-58).
     throw new UserError(`workspace root ${root} has neither pnpm-workspace.yaml nor package.json`)
   }
-  return { root, packageGlobs }
+  return catalogs === undefined ? { root, packageGlobs } : { root, packageGlobs, catalogs }
 }
 
 // `<dir>/*` — the shape of nearly every workspace glob. Anything with another
@@ -720,6 +776,16 @@ export async function discoverProjects(
   for (const entry of loaded) {
     if (entry === null) continue
     const { dir, pkg, configPath } = entry
+    // npm and pnpm take `../ext/*`, but `--affected` asks git from the root
+    // and sees nothing outside it: an edit there moved the task's key and
+    // selected nothing, green.
+    const rel = relPosix(workspace.root, dir)
+    if (rel === '..' || rel.startsWith('../') || path.isAbsolute(rel)) {
+      throw new UserError(
+        `workspace member ${rel} (${dir}) is outside the workspace root ${workspace.root}: ` +
+          'vx keeps every project under the root. Move the workspace root up to a directory that holds every member.',
+      )
+    }
     if (!pkg.name) {
       nameless?.push(dir)
       // A nameless manifest can't be addressed, filtered, or made affected —
@@ -753,7 +819,7 @@ export async function discoverProjects(
     }
     if (group.length === 1) {
       const { dir, pkg, configPath } = group[0]!
-      projects.push({ name, dir, packageJson: pkg, configPath })
+      projects.push(withCatalogs({ name, dir, packageJson: pkg, configPath }, workspace))
       continue
     }
     // The root's own manifest is '' relative to itself, and the refusal read
@@ -884,5 +950,10 @@ export async function namedProject(
       `${where} "${named.name}" at ${shown}: its package.json names it "${pkg.name ?? ''}"`,
     )
   }
-  return { name: named.name, dir, packageJson: pkg, configPath }
+  return withCatalogs({ name: named.name, dir, packageJson: pkg, configPath }, workspace)
+}
+
+function withCatalogs(meta: ProjectMeta, workspace: Workspace): ProjectMeta {
+  if (workspace.catalogs !== undefined) meta.catalogs = workspace.catalogs
+  return meta
 }