@vzn/vx 0.0.80 → 0.0.82

package/launcher.mjs

@@ -15,8 +15,8 @@
 //      with no prebuilt binary if the user happens to have Bun).
 // Anything else is a clear, actionable error.
 
-import { spawnSync } from 'node:child_process'
-import { existsSync } from 'node:fs'
+import { execFileSync, spawn, spawnSync } from 'node:child_process'
+import { existsSync, readFileSync } from 'node:fs'
 import { createRequire } from 'node:module'
 import { constants as osConstants } from 'node:os'
 import { dirname, join } from 'node:path'
@@ -57,35 +57,63 @@ function hasBun() {
   return probe.status === 0
 }
 
+// Is this launcher in its terminal's foreground process group? Then a
+// keyboard Ctrl-C reached the binary too, and a forward would be its second
+// signal, which vx reads as "stop now".
+function inForeground() {
+  try {
+    const stat = readFileSync('/proc/self/stat', 'utf8')
+    const f = stat.slice(stat.lastIndexOf(')') + 2).split(' ')
+    return f[2] === f[5] // pgrp === tpgid
+  } catch {
+    try {
+      const out = execFileSync('ps', ['-o', 'pgid=,tpgid=', '-p', String(process.pid)], {
+        encoding: 'utf8',
+      })
+      const [pgid, tpgid] = out.trim().split(/\s+/)
+      return pgid === tpgid
+    } catch {
+      return false
+    }
+  }
+}
+
 function run(cmd, cmdArgs) {
-  const res = spawnSync(cmd, cmdArgs, { stdio: 'inherit' })
-  if (res.error) {
-    process.stderr.write(`${base}: failed to launch (${res.error.message})\n`)
-    process.exit(1)
+  const child = spawn(cmd, cmdArgs, { stdio: 'inherit' })
+  // A signal sent to this launcher alone (`kill`, a process manager, a CI
+  // cancel) reaches vx only through here; unhandled, it killed the launcher
+  // and left vx running under init. Either way the launcher waits for vx.
+  for (const sig of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
+    process.on(sig, () => {
+      if (!inForeground()) child.kill(sig)
+    })
   }
+  child.on('error', (err) => {
+    process.stderr.write(`${base}: failed to launch (${err.message})\n`)
+    process.exit(1)
+  })
   // Mirror the child's exit; a signal death maps to the POSIX 128+signo code.
-  if (res.signal) process.exit(128 + (osConstants.signals[res.signal] ?? 1))
-  process.exit(res.status ?? 0)
+  child.on('exit', (code, signal) => {
+    process.exit(signal ? 128 + (osConstants.signals[signal] ?? 1) : (code ?? 0))
+  })
 }
 
 const bin = platformBinary()
-if (bin !== undefined) {
-  run(bin, args)
-}
-
 // No prebuilt binary for this platform — fall back to the shipped source if Bun
 // is available (a source checkout, or an unsupported platform + Bun installed).
 const source = join(here, sourceEntry)
-if (existsSync(source) && hasBun()) {
+if (bin !== undefined) {
+  run(bin, args)
+} else if (existsSync(source) && hasBun()) {
   run('bun', [source, ...args])
+} else {
+  const supported = SUPPORTED.join(', ')
+  process.stderr.write(
+    `${base}: no prebuilt binary for ${key}.\n` +
+      `  Supported platforms: ${supported}.\n` +
+      `  If your platform should be supported, reinstall so npm fetches the\n` +
+      `  matching ${name}-${key} optionalDependency, or install Bun (>=1.4) to\n` +
+      `  run ${base} from source.\n`,
+  )
+  process.exit(1)
 }
-
-const supported = SUPPORTED.join(', ')
-process.stderr.write(
-  `${base}: no prebuilt binary for ${key}.\n` +
-    `  Supported platforms: ${supported}.\n` +
-    `  If your platform should be supported, reinstall so npm fetches the\n` +
-    `  matching ${name}-${key} optionalDependency, or install Bun (>=1.4) to\n` +
-    `  run ${base} from source.\n`,
-)
-process.exit(1)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vzn/vx",
-  "version": "0.0.80",
+  "version": "0.0.82",
   "description": "An open, extensible monorepo task runner.",
   "type": "module",
   "exports": {
@@ -17,10 +17,10 @@
     "node": ">=18"
   },
   "optionalDependencies": {
-    "@vzn/vx-linux-x64": "0.0.80",
-    "@vzn/vx-linux-arm64": "0.0.80",
-    "@vzn/vx-darwin-x64": "0.0.80",
-    "@vzn/vx-darwin-arm64": "0.0.80"
+    "@vzn/vx-linux-x64": "0.0.82",
+    "@vzn/vx-linux-arm64": "0.0.82",
+    "@vzn/vx-darwin-x64": "0.0.82",
+    "@vzn/vx-darwin-arm64": "0.0.82"
   },
   "dependencies": {
     "@anthropic-ai/sandbox-runtime": "^0.0.76"

package/src/cache/git-inputs.ts

@@ -483,6 +483,8 @@ async function dropFilteredOids(
   args: {
     /** Every path the enumeration listed: tracked (dirty ones too) and untracked. */
     listed: readonly string[]
+    /** Whether `git status` named an ignored `.gitattributes`, which git applies too. */
+    ignoredAttributes: boolean
     workspaceRoot: string
     gitDir: string
     gitPrefix: string
@@ -501,6 +503,7 @@ async function dropFilteredOids(
   // a line scan of `git var -l`, three stats, and a key walk that exits on the
   // first `.gitattributes` it does not find.
   let attributesPossible =
+    args.ignoredAttributes ||
     attributeFilesOutsideTree(args.gitVars, process.env).some((f) =>
       existsSync(path.resolve(args.workspaceRoot, f)),
     ) ||
@@ -715,14 +718,25 @@ export function attributeFilesOutsideTree(
 function parseStatusOutput(
   out: string,
   undecodableRecords: ReadonlySet<string>,
-): { dirty: Set<string>; untracked: string[]; undecodable: Set<string> } {
+): {
+  dirty: Set<string>
+  untracked: string[]
+  undecodable: Set<string>
+  ignoredAttributes: boolean
+} {
   const tokens = out.split('\0')
   const dirty = new Set<string>()
   const untracked: string[] = []
   const undecodable = new Set<string>()
+  let ignoredAttributes = false
   for (let i = 0; i < tokens.length; i++) {
     const token = tokens[i]!
     if (token.length < 4) continue
+    if (token[0] === '!') {
+      if (token === '!! .gitattributes' || token.endsWith('/.gitattributes'))
+        ignoredAttributes = true
+      continue
+    }
     if (undecodableRecords.size > 0 && undecodableRecords.has(token))
       undecodable.add(token.slice(3))
     if (token[0] === '?') {
@@ -743,7 +757,7 @@ function parseStatusOutput(
       dirty.add(tokens[i]!)
     }
   }
-  return { dirty, untracked, undecodable }
+  return { dirty, untracked, undecodable, ignoredAttributes }
 }
 
 /**
@@ -885,7 +899,10 @@ export async function startGitEnumeration(
   // time (~50 ms of CPU, concurrent with status but contending with it).
   const running = Promise.all([
     spawnGit(['ls-files', '-s', '-v', '-z', '--', ...pathspecs]),
-    spawnGit(['status', '--porcelain', '-z', '-uall', '--', ...pathspecs]),
+    // `--ignored=matching` names an ignored path without descending into an
+    // ignored directory: git applies an ignored `.gitattributes` as it does
+    // any other, and the filter gate below must see it (A-19).
+    spawnGit(['status', '--porcelain', '-z', '-uall', '--ignored=matching', '--', ...pathspecs]),
     // The gate for whether a clean filter can rewrite bytes between the
     // index and the worktree: git's merged config (`core.autocrlf`) and,
     // from git 2.42, the attributes files it reads outside the tree
@@ -983,6 +1000,7 @@ export async function startGitEnumeration(
   // ONLY where a filter can actually apply.
   await dropFilteredOids(trusted, {
     listed: all,
+    ignoredAttributes: parsedStatus?.ignoredAttributes ?? false,
     workspaceRoot,
     gitDir,
     gitPrefix,

package/src/orchestrator/logger.ts

@@ -97,10 +97,11 @@ export interface DefaultLogger extends Logger {
  *   broad       — news only: one `success` line per executed task,
  *                 full frames for failures, silence for cache hits.
  *
- * `gha` (full mode only): wrap each task's block in `::group::` /
- * `::endgroup::` workflow commands so tasks collapse in the GitHub
- * Actions log viewer — except failed tasks, which stay pre-expanded
- * and emit an `::error` annotation instead.
+ * `gha` (on GitHub Actions, any mode): task output is fenced from
+ * workflow commands. In full mode each task's block is also wrapped in
+ * `::group::` / `::endgroup::` so tasks collapse in the log viewer —
+ * except failed tasks, which stay pre-expanded and emit an `::error`
+ * annotation instead.
  *
  * `ci`: a truthy CI env was detected. Suppresses the dynamic status
  * line even if stdout happens to be a TTY.
@@ -163,7 +164,7 @@ export function resolveOutputView(
   const gha = truthyEnv(env['GITHUB_ACTIONS'])
   const mk = (mode: OutputView['mode']): OutputView => ({
     mode,
-    ...(mode === 'full' && gha ? { gha: true } : {}),
+    ...(gha ? { gha: true } : {}),
     ...(ci ? { ci: true } : {}),
   })
   if (options.outputLogs !== undefined) return mk(options.outputLogs)
@@ -232,6 +233,10 @@ export function defaultLogger(
   // One per run, and only in GHA mode: the fence token must be something the
   // fenced task output cannot print.
   const ghaToken = view.gha === true ? crypto.randomUUID() : ''
+  // A task's own text, fenced on GitHub Actions: the frames `errors-only`
+  // and `broad` defer and a server's tail printed a task's `::error::` raw.
+  const fenced = (block: string): string =>
+    view.gha === true && block.length > 0 ? ghaFence(block, ghaToken) : block
 
   // All stdout flows through the writer so the status line can never
   // interleave with content. Inert (pure passthrough) on non-TTY
@@ -487,12 +492,14 @@ export function defaultLogger(
             // its buffered output belongs to the frame it never got.
             if (t.outcome === undefined) continue
             emitBlock(
-              formatPersistentTailBlock(
-                t.node,
-                t.outcome,
-                { stdout: tailText(t.out), stderr: tailText(t.err) },
-                { stdout: t.out.dropped, stderr: t.err.dropped },
-                colors,
+              fenced(
+                formatPersistentTailBlock(
+                  t.node,
+                  t.outcome,
+                  { stdout: tailText(t.out), stderr: tailText(t.err) },
+                  { stdout: t.out.dropped, stderr: t.err.dropped },
+                  colors,
+                ),
               ),
             )
           }
@@ -508,7 +515,7 @@ export function defaultLogger(
       // Guarded for repeat runEnd calls.
       if (!flushedFailures && deferredFailures.length > 0) {
         flushedFailures = true
-        for (const block of deferredFailures) emitBlock(block)
+        for (const block of deferredFailures) emitBlock(fenced(block))
       }
       // The summary and the CLI's own lines follow on the stream directly:
       // nothing may still be held, and nothing after this is.

package/src/workspace/workspace.ts

@@ -470,11 +470,17 @@ async function findConfigFile(dir: string): Promise<string | null> {
     } catch {
       return null
     }
-    const byName = new Map(entries.map((e) => [e.name, e]))
-    for (const name of PROJECT_CONFIG_FILENAMES) {
-      const entry = byName.get(name)
+    // By precedence slot, not a Map per directory, and no `path.join`: at
+    // 5,000 projects that cut `listProjects` from 53.5 to 47.7 ms (min of
+    // 15, six interleaved rounds, A/A 54.7).
+    const found: Dirent[] = []
+    for (const e of entries) {
+      const rank = CONFIG_RANK.get(e.name)
+      if (rank !== undefined) found[rank] = e
+    }
+    for (const entry of found) {
       if (entry === undefined) continue
-      const candidate = path.join(dir, name)
+      const candidate = dir + path.sep + entry.name
       if (entry.isFile()) return candidate
       if (entry.isSymbolicLink() && (await isFile(candidate))) return candidate
     }
@@ -487,6 +493,8 @@ async function findConfigFile(dir: string): Promise<string | null> {
   return null
 }
 
+const CONFIG_RANK = new Map(PROJECT_CONFIG_FILENAMES.map((n, i) => [n, i]))
+
 async function isFile(p: string): Promise<boolean> {
   try {
     return (await stat(p)).isFile()
@@ -518,7 +526,7 @@ export async function listProjects(workspace: Workspace): Promise<ProjectMeta[]>
   // a 1000-member workspace.
   const loaded = await Promise.all(
     [...matches].map(async (dir) => {
-      const pkgJsonPath = path.join(dir, 'package.json')
+      const pkgJsonPath = dir + path.sep + 'package.json'
       const [configPath, text] = await Promise.all([
         findConfigFile(dir),
         Bun.file(pkgJsonPath)