@vzn/vx 0.0.652 → 0.0.653

package/src/workspace/workspace.ts

@@ -11,6 +11,7 @@ import path from 'node:path'
 import type { ProjectConfig, WorkspaceConfig } from '../config.js'
 import {
   executablePath,
+  gitCaseArgs,
   gitEnv,
   gitSpawnRefusal,
   hasControl,
@@ -21,7 +22,13 @@ import {
   relPosix,
   UserError,
 } from '../util/index.js'
-import { gitTop, WORKSPACE_CONFIG_FILENAMES, workspaceFile, workspaceRootOf } from '../handoff.js'
+import {
+  gitTop,
+  WORKSPACE_CONFIG_FILENAMES,
+  workspaceFile,
+  workspaceFileBroken,
+  workspaceRootOf,
+} from '../handoff.js'
 import { canonicalDir } from './canonical-dir.js'
 import { parseFilter } from './filter.js'
 import { repoIdOf } from './repo-id.js'
@@ -86,6 +93,7 @@ export async function findWorkspaceRoot(
       { code: 'VX_E_NO_WORKSPACE', message: `${headline} — run \`vx init\` to create one` },
     )
   }
+  if (workspaceFileBroken(file)) await refuseNotAFile(file)
   const root = workspaceRootOf(file)
   if (uid !== 0 && root !== start && (await gitTop(start)) === null) {
     // The link itself and the `.vx` holding it, not what a link names: a
@@ -110,6 +118,22 @@ export async function findWorkspaceRoot(
   return root
 }
 
+/**
+ * Refuses a config path that is no file: it marks a root or a project all
+ * the same, so skipping it ran nothing there and said nothing. Learned by
+ * `lstat` here, off the normal path.
+ */
+async function refuseNotAFile(file: string): Promise<never> {
+  const link = await stat(file).then(
+    () => false,
+    () => true,
+  )
+  throw new UserError(
+    `${file}: is ${link ? 'a broken link' : 'not a file'} — fix or remove it`,
+    'VX_E_CONFIG',
+  )
+}
+
 /**
  * The workspace's own cache directory (index, history, memos):
  * `VX_CACHE_DIR`, else the workspace's `cache.dir`, else `.vx/cache`,
@@ -249,6 +273,8 @@ export interface ProjectConfigs {
   readonly strayReviews: string[]
   /** Absolute: config files a higher-precedence one beside them hides, the root's workspace config among them, by the one read. */
   readonly shadowed: { file: string; read: string }[]
+  /** Absolute, sorted: the outermost directories holding their own `.vx/workspace.*`. */
+  readonly nestedWorkspaces: string[]
 }
 
 /**
@@ -265,11 +291,16 @@ export interface ProjectConfigs {
 export async function findProjectConfigs(root: string): Promise<ProjectConfigs> {
   const inGit = (await gitTop(root)) !== null
   const rels = inGit ? await gitConfigs(root) : await scanConfigs(root)
-  const nested: string[] = []
-  for (const rel of rels) {
+  // Each on disk, a broken link included, as the root walk takes one: git
+  // lists a tracked one deleted from the worktree, which marks no root.
+  const marks = rels.filter((rel) => {
     const at = rel.lastIndexOf('/.vx/')
-    if (at > 0 && WORKSPACE_RANK.has(rel.slice(at + 1))) nested.push(rel.slice(0, at))
-  }
+    return at > 0 && WORKSPACE_RANK.has(rel.slice(at + 1))
+  })
+  const onDisk = await Promise.all(marks.map((rel) => entryAt(path.join(root, rel))))
+  const nested = marks
+    .filter((_, i) => onDisk[i])
+    .map((rel) => rel.slice(0, rel.lastIndexOf('/.vx/')))
   if (inGit) nested.push(...(await unlistedNested(root, rels, nested)))
   const byDir = new Map<string, string[]>()
   const reviewed: string[] = []
@@ -286,8 +317,10 @@ export async function findProjectConfigs(root: string): Promise<ProjectConfigs>
   }
   const shadowed: { file: string; read: string }[] = []
   // The files among `names` (ranked), the first of them the one read: git
-  // lists a tracked config deleted from the worktree, and a directory may
-  // carry a config's name. Every other file is shadowed, said by `vx lock`.
+  // lists a tracked config deleted from the worktree, which is skipped.
+  // Every other file is shadowed, said by `vx lock`. With no file, an entry
+  // by a config's name (a broken link, a directory) is refused, as the root
+  // walk refuses one: skipped, its project was in no lock and nothing said so.
   const firstFile = async (
     dir: string,
     names: string[],
@@ -297,6 +330,9 @@ export async function findProjectConfigs(root: string): Promise<ProjectConfigs>
     const files = (
       await Promise.all(names.map(async (n) => ((await isFile(path.join(dir, n))) ? n : null)))
     ).filter((n) => n !== null)
+    if (files.length === 0)
+      for (const n of names)
+        if (await entryAt(path.join(dir, n))) await refuseNotAFile(path.join(dir, n))
     for (const n of files.slice(1))
       shadowed.push({ file: path.join(dir, n), read: path.join(dir, files[0]!) })
     return files[0] === undefined ? null : path.join(dir, files[0])
@@ -329,7 +365,12 @@ export async function findProjectConfigs(root: string): Promise<ProjectConfigs>
   )
     .filter((f) => f !== null)
     .sort()
-  return { configs, strayReviews, shadowed }
+  // A project's outputs stop at each, as at a nested project (computeNestedProjectDirs).
+  const nestedWorkspaces = nested
+    .filter((n) => !nested.some((m) => n.startsWith(`${m}/`)))
+    .map((rel) => path.join(root, rel))
+    .sort()
+  return { configs, strayReviews, shadowed, nestedWorkspaces: [...new Set(nestedWorkspaces)] }
 }
 
 /**
@@ -368,6 +409,17 @@ async function unlistedNested(
   return found.filter((d) => d !== null)
 }
 
+/** An entry by that name, whatever it is (`lstat`): a broken link counts. */
+async function entryAt(p: string): Promise<boolean> {
+  try {
+    await lstat(p)
+    return true
+  } catch (err) {
+    if (isOutOfFds(err)) throw err
+    return false
+  }
+}
+
 async function isFile(p: string): Promise<boolean> {
   try {
     return (await stat(p)).isFile()
@@ -386,21 +438,26 @@ async function isFile(p: string): Promise<boolean> {
  */
 async function gitConfigs(root: string): Promise<string[]> {
   const [configs, index, untracked] = await Promise.all([
-    gitZ(root, [
-      'ls-files',
-      '-z',
-      '--cached',
-      '--others',
-      '--exclude-standard',
-      '--',
-      ':(glob)**/vx.config.*',
-      ':(glob)**/.vx/workspace.*',
-      `:(glob)**/${REVIEW_FILE}`,
-      NOT_INSTALLS,
-    ]),
-    gitZ(root, ['ls-files', '-z', '--stage', '--', NOT_INSTALLS]),
+    gitZ(
+      root,
+      [
+        'ls-files',
+        '-z',
+        '--cached',
+        '--others',
+        '--exclude-standard',
+        '--',
+        ':(glob)**/vx.config.*',
+        ':(glob)**/.vx/workspace.*',
+        `:(glob)**/${REVIEW_FILE}`,
+        NOT_INSTALLS,
+        ...NOT_VX_STATE,
+      ],
+      true,
+    ),
+    gitZ(root, ['ls-files', '-z', '--stage', '--', NOT_INSTALLS, NOT_IN_VX]),
     // An embedded repository is the one untracked entry git lists as `dir/`.
-    gitZ(root, ['ls-files', '-z', '--others', '--exclude-standard', '--', NOT_INSTALLS]),
+    gitZ(root, ['ls-files', '-z', '--others', '--exclude-standard', '--', NOT_INSTALLS, NOT_IN_VX]),
   ])
   // A submodule's `.git` is a file, an embedded repository's a directory.
   const isRepo = (rel: string): Promise<boolean> =>
@@ -431,12 +488,32 @@ async function gitConfigs(root: string): Promise<string[]> {
  */
 const NOT_INSTALLS = ':(exclude,glob)**/node_modules/**'
 
-/** `git <args>`'s NUL-separated output at `cwd`. */
-async function gitZ(cwd: string, args: string[]): Promise<string[]> {
+/**
+ * Nothing under a `.vx` directory is a project, as the walk outside git
+ * skips it: a config git listed in `.vx/cache/x` made one only in git.
+ */
+const NOT_IN_VX = ':(exclude,glob)**/.vx/**'
+/** `NOT_IN_VX` that keeps `.vx/workspace.*`, which marks a nested workspace. */
+const NOT_VX_STATE = [
+  ':(exclude,glob)**/.vx/*/**',
+  ':(exclude,glob)**/.vx/vx.config.*',
+  `:(exclude,glob)**/.vx/${REVIEW_FILE}`,
+]
+
+/** Whether root-relative POSIX `rel` lies under a `.vx` directory, where no project lives. */
+export function inVxDir(rel: string): boolean {
+  return rel.startsWith('.vx/') || rel.includes('/.vx/')
+}
+
+/**
+ * `git <args>`'s NUL-separated output at `cwd`. `strict`: a path not valid
+ * UTF-8 is refused, as decoding turns it into one no file has.
+ */
+async function gitZ(cwd: string, args: string[], strict = false): Promise<string[]> {
   let proc: Bun.Subprocess<'ignore', 'pipe', 'pipe'>
   try {
     proc = Bun.spawn({
-      cmd: [executablePath('git'), ...args],
+      cmd: [executablePath('git'), ...gitCaseArgs(cwd), ...args],
       cwd,
       env: gitEnv(),
       stdin: 'ignore',
@@ -454,10 +531,53 @@ async function gitZ(cwd: string, args: string[]): Promise<string[]> {
   ])
   if (code !== 0)
     throw new UserError(`git ls-files failed (exit ${code}): ${err.trim()}`, 'VX_E_GIT')
-  return new TextDecoder('utf-8', { ignoreBOM: true })
-    .decode(out)
-    .split('\0')
-    .filter((p) => p !== '')
+  const text = new TextDecoder('utf-8', { ignoreBOM: true }).decode(out)
+  // U+FFFD alone is cheap to look for; a valid name may hold it, so the bytes confirm.
+  if (strict && text.includes('\uFFFD')) {
+    let start = 0
+    for (let i = 0; i <= out.length; i++) {
+      if (i < out.length && out[i] !== 0) continue
+      const entry = out.subarray(start, i)
+      start = i + 1
+      if (!isUtf8(entry)) {
+        const slash = entry.lastIndexOf(0x2f)
+        throw notUtf8(slash === -1 ? entry : entry.subarray(0, slash))
+      }
+    }
+  }
+  return text.split('\0').filter((p) => p !== '')
+}
+
+const strictUtf8 = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true })
+
+function isUtf8(bytes: Uint8Array): boolean {
+  try {
+    strictUtf8.decode(bytes)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/** `rel`, a root-relative directory, with each byte that is not UTF-8 shown as `\xNN`. */
+function notUtf8(rel: Uint8Array): UserError {
+  let shown = ''
+  for (let i = 0; i < rel.length;) {
+    const lead = rel[i]!
+    const n =
+      lead < 0x80 ? 1 : lead < 0xc2 ? 0 : lead < 0xe0 ? 2 : lead < 0xf0 ? 3 : lead < 0xf5 ? 4 : 0
+    const seq = rel.subarray(i, i + n)
+    if (n > 0 && isUtf8(seq)) {
+      shown += strictUtf8.decode(seq)
+      i += n
+    } else {
+      shown += `\\x${lead.toString(16).padStart(2, '0')}`
+      i++
+    }
+  }
+  return new UserError(
+    `${printable(shown)}: the directory's name is not valid UTF-8, which no project path may hold — rename it`,
+  )
 }
 
 /** The config paths under `root` outside git, root-relative: none under `node_modules`, `.git` or `.vx`. */
@@ -475,17 +595,56 @@ async function scanConfigs(root: string): Promise<string[]> {
     if (rel !== '' && entries.some((e) => e.name === '.vx') && (await workspaceFileIn(root, rel)))
       return
     const below: string[] = []
+    let lossy = false
     for (const e of entries) {
       const child = rel === '' ? e.name : `${rel}/${e.name}`
       if (CONFIG_RANK.has(e.name) || e.name === REVIEW_FILE) out.push(child)
-      else if (e.isDirectory() && !SCAN_SKIPS.has(e.name)) below.push(child)
+      else if (e.isDirectory() && !SCAN_SKIPS.has(e.name)) {
+        below.push(child)
+        // A name not valid UTF-8 decodes to one no directory has (a valid one may hold U+FFFD).
+        if (e.name.includes('\uFFFD')) lossy = true
+      }
     }
+    if (lossy) await refuseNotUtf8(root, rel)
     await Promise.all(below.map(walk))
   }
   await walk('')
   return out
 }
 
+/**
+ * Refuses a directory in `rel` whose name is not valid UTF-8 and that holds
+ * a config: walked by bytes, as no string path reaches it.
+ */
+async function refuseNotUtf8(root: string, rel: string): Promise<void> {
+  const dir = Buffer.from(rel === '' ? root : path.join(root, rel))
+  for (const name of await readdir(dir, { encoding: 'buffer' })) {
+    if (isUtf8(name)) continue
+    if (await holdsConfig(Buffer.concat([dir, Buffer.from('/'), name]))) {
+      throw notUtf8(rel === '' ? name : Buffer.concat([Buffer.from(`${rel}/`), name]))
+    }
+  }
+}
+
+// Bun 1.4.4 drops `withFileTypes` under `encoding: 'buffer'`, so each entry is an lstat.
+async function holdsConfig(dir: Buffer): Promise<boolean> {
+  let names: Buffer[]
+  try {
+    names = await readdir(dir, { encoding: 'buffer' })
+  } catch (err) {
+    if (isOutOfFds(err)) throw err
+    return false
+  }
+  for (const name of names) {
+    const shown = name.toString()
+    if (CONFIG_RANK.has(shown)) return true
+    if (SCAN_SKIPS.has(shown)) continue
+    const at = Buffer.concat([dir, Buffer.from('/'), name])
+    if ((await lstat(at)).isDirectory() && (await holdsConfig(at))) return true
+  }
+  return false
+}
+
 // `.vx` holds vx's state (the cache), which a checkout ignores.
 const SCAN_SKIPS = new Set(['node_modules', '.git', '.vx'])
 
@@ -635,6 +794,7 @@ export function projectNameProblem(name: string): string | null {
     return walk
   }
   if (f.withDeps || f.withDependents || f.onlyDeps || f.onlyDependents) return walk
+  if (f.within !== undefined) return "ends in '{…}', which a filter reads as a directory"
   if (f.gitSince !== undefined)
     return `ends in "[${f.gitSince}]", which a filter reads as a git range`
   if (f.tag === true) return "starts with 'tag:', which a filter reads as a tag selector"