@nifrajs/cli 4.0.0 → 5.0.0

package/src/sync-manifest.ts

@@ -21,6 +21,14 @@ const GENERATED_MARKER = "GENERATED by @nifrajs/web generateServerManifest"
 // routes dir relative to the manifest and strips imports to route-relative keys.
 const ROUTES_PREFIX = /["'](\.{1,2}(?:\/[^"'/]+)*?\/routes\/)[^"']+["']/
 const IGNORED = /(^|\/)(node_modules|dist(-[a-z0-9]+)?|build|\.nifra|\.git|\.wrangler|coverage)\//
+// The fs codes that mean the routes dir is absent or unreadable. Every other throw is the route table
+// refusing to build, which must fail the command rather than read as "no manifest found".
+const ROUTES_DIR_UNAVAILABLE = new Set(["ENOENT", "ENOTDIR", "EACCES", "EPERM"])
+
+function routesDirUnavailable(error: unknown): boolean {
+  if (typeof error !== "object" || error === null || !("code" in error)) return false
+  return typeof error.code === "string" && ROUTES_DIR_UNAVAILABLE.has(error.code)
+}
 
 export interface SyncManifestResult {
   /** The committed server-manifest file (relative to cwd). */
@@ -34,12 +42,16 @@ export interface SyncManifestResult {
   /** Set when the sync was REFUSED because discovery found zero routes for a manifest that had some
    * (`routes/` likely emptied by mistake) - the manifest was left untouched rather than wiped. */
   readonly refusedEmpty?: boolean
+  /** Set when the `routes/` tree could not be built into a route table (a duplicate route, two routes of
+   * one shape sharing a path, ...) - the manifest was left untouched and the sync failed. */
+  readonly error?: string
 }
 
 /**
  * Discover every generated `server-manifest.ts` under `cwd` and re-sync its route table from the live
  * `routes/` tree, preserving baked client assets. Returns one result per generated manifest. Never throws
- * on a per-manifest miss (an unreadable/absent routes dir is skipped).
+ * on a per-manifest failure: an absent or unreadable routes dir is skipped, and a route table that fails
+ * to build is reported in that manifest's `error`.
  */
 export async function syncServerManifests(cwd: string): Promise<SyncManifestResult[]> {
   const { discoverRoutes } = await import("@nifrajs/web/fs")
@@ -60,8 +72,11 @@ export async function syncServerManifests(cwd: string): Promise<SyncManifestResu
     let next: string
     try {
       next = resyncServerManifestSource(source, discoverRoutes(routesDir), routesPrefix)
-    } catch {
-      continue // routes dir gone/unreadable - not a manifest we can sync
+    } catch (error) {
+      if (routesDirUnavailable(error)) continue // not a manifest we can sync
+      const message = error instanceof Error ? error.message : String(error)
+      results.push({ file: rel, changed: false, added: [], removed: [], error: message })
+      continue
     }
     const before = parseManifestRouteFiles(source, routesPrefix)
     const after = parseManifestRouteFiles(next, routesPrefix)
@@ -81,33 +96,48 @@ export async function syncServerManifests(cwd: string): Promise<SyncManifestResu
   return results.sort((a, b) => codeUnitOrder(a.file, b.file))
 }
 
-/** CLI entry: sync every generated manifest, print a per-file summary + the client-rebuild caveat. */
-export async function runSyncManifest(cwd: string): Promise<boolean> {
-  const results = await syncServerManifests(cwd)
-  if (results.length === 0) {
-    console.log("nifra sync-manifest: no generated server-manifest.ts found under this directory.")
-    return true
-  }
+/** True when no manifest's route table failed to build. */
+export function syncManifestsOk(results: readonly SyncManifestResult[]): boolean {
+  return results.every((r) => r.error === undefined)
+}
+
+/** Per-file summary lines + the client-rebuild caveat. */
+export function renderSyncManifestResults(results: readonly SyncManifestResult[]): string[] {
+  if (results.length === 0)
+    return ["nifra sync-manifest: no generated server-manifest.ts found under this directory."]
+  const lines: string[] = []
   let anyChanged = false
   for (const r of results) {
-    if (r.refusedEmpty) {
-      console.log(
+    if (r.error !== undefined) {
+      lines.push(
+        `✖ ${r.file}: routes/ does not build a route table; left untouched.`,
+        `    ${r.error}`,
+      )
+    } else if (r.refusedEmpty) {
+      lines.push(
         `⚠ ${r.file}: refused - routes/ has zero routes but the manifest had some; left untouched (delete the manifest yourself if this is intentional).`,
       )
     } else if (r.changed) {
       anyChanged = true
-      console.log(`✓ synced ${r.file}`)
-      if (r.added.length > 0) console.log(`    added:   ${r.added.join(", ")}`)
-      if (r.removed.length > 0) console.log(`    removed: ${r.removed.join(", ")}`)
+      lines.push(`✓ synced ${r.file}`)
+      if (r.added.length > 0) lines.push(`    added:   ${r.added.join(", ")}`)
+      if (r.removed.length > 0) lines.push(`    removed: ${r.removed.join(", ")}`)
     } else {
-      console.log(`• ${r.file} already in sync`)
+      lines.push(`• ${r.file} already in sync`)
     }
   }
   if (anyChanged) {
-    console.log(
+    lines.push(
       "\nRe-synced the server manifest's route table. If you added or changed a HYDRATING route\n" +
         "component (not just a loader / SSR-only route), also run a full build so the client bundle matches.",
     )
   }
-  return true
+  return lines
+}
+
+/** CLI entry: sync every generated manifest and print the summary. False when a route table failed to build. */
+export async function runSyncManifest(cwd: string): Promise<boolean> {
+  const results = await syncServerManifests(cwd)
+  console.log(renderSyncManifestResults(results).join("\n"))
+  return syncManifestsOk(results)
 }

package/src/test-tool.ts

@@ -1,4 +1,9 @@
-import { type HeadTailOutput, readHeadTail } from "./mcp-io.ts"
+import {
+  type HeadTailOutput,
+  OWN_PROCESS_GROUP,
+  readHeadTail,
+  signalProcessGroup,
+} from "./mcp-io.ts"
 import { mcpProjectPathError, resolveMcpProjectPath } from "./mcp-path.ts"
 
 export interface TestToolArgs {
@@ -58,6 +63,8 @@ function normalizeTimeout(value: unknown): number {
   return Math.min(Math.max(Math.trunc(value), 1_000), MAX_TIMEOUT_MS)
 }
 
+const KILL_GRACE_MS = 2_000
+
 const ANSI = new RegExp(`${String.fromCharCode(27)}\\[[0-?]*[ -/]*[@-~]`, "g")
 
 // A UTF-8 character is at most four bytes, so these hold every character the result can show.
@@ -146,17 +153,24 @@ export async function collectTestResult(
     env: process.env,
     stdout: "pipe",
     stderr: "pipe",
+    detached: OWN_PROCESS_GROUP,
   })
   let timedOut = false
   let cancelled = false
+  let escalation: ReturnType<typeof setTimeout> | undefined
+  // A test can ignore SIGTERM, so the group gets SIGKILL once the grace period runs out.
+  const stop = (): void => {
+    signalProcessGroup(proc, "SIGTERM")
+    escalation ??= setTimeout(() => signalProcessGroup(proc, "SIGKILL"), KILL_GRACE_MS)
+  }
   const abort = (): void => {
     cancelled = true
-    proc.kill()
+    stop()
   }
   opts.signal?.addEventListener("abort", abort, { once: true })
   const timer = setTimeout(() => {
     timedOut = true
-    proc.kill()
+    stop()
   }, timeoutMs)
   const empty: HeadTailOutput = { head: "", tail: "", droppedBytes: 0 }
   let stdoutRaw = empty
@@ -175,6 +189,7 @@ export async function collectTestResult(
     exitCode = result[2]
   } finally {
     clearTimeout(timer)
+    clearTimeout(escalation)
     opts.signal?.removeEventListener("abort", abort)
   }
   const stdout = clean(stdoutRaw)

package/src/typecheck-coverage.ts

@@ -0,0 +1,134 @@
+/**
+ * Which zoned files the typecheck never read. `tsc --noEmit` passes for code outside its program, so
+ * a stale tsconfig `include` (a folder moved under `backend/`, say) turns the contract gate into a
+ * pass that checked nothing there. The check runs tsc with `--listFiles` and compares the program
+ * against the app's zone folders.
+ */
+import { existsSync, readFileSync, realpathSync } from "node:fs"
+import { dirname, isAbsolute, join, relative, resolve } from "node:path"
+import { stripComments } from "./check-scan.ts"
+
+const ZONE_FOLDER = new Set(["routes", "frontend", "backend", "shared"])
+const TS_SOURCE = /\.(?:[cm]?ts|tsx)$/
+const NOT_PROGRAM_CODE = /\.d\.[cm]?ts$|\.(?:test|spec)\.[cm]?tsx?$/
+const TSC_DIAGNOSTIC = /\(\d+,\d+\):\s*(?:error|warning)\s+TS\d+:/
+
+/** Split `tsc --listFiles` output into the program's files and the compiler's own output. */
+export function splitListedFiles(output: string): {
+  readonly programFiles: readonly string[]
+  readonly output: string
+} {
+  const programFiles: string[] = []
+  const rest: string[] = []
+  for (const line of output.split(/\r?\n/)) {
+    if (line !== "" && line === line.trim() && isAbsolute(line) && !TSC_DIAGNOSTIC.test(line))
+      programFiles.push(line)
+    else rest.push(line)
+  }
+  return { programFiles, output: rest.join("\n").trim() }
+}
+
+const real = (path: string): string => {
+  try {
+    return realpathSync.native(path)
+  } catch {
+    return path
+  }
+}
+
+// tsc prints forward slashes, and on Windows the drive letter's case is not stable.
+const canonical = (path: string): string => {
+  const posix = path.replaceAll("\\", "/")
+  return process.platform === "win32" ? posix.toLowerCase() : posix
+}
+
+/** The zone folder a project file sits in (`backend`, `apps/web/routes`), or `undefined`. */
+export function zoneFolderOf(file: string): string | undefined {
+  const parts = file.split("/")
+  const at = parts.findIndex((part, i) => i < parts.length - 1 && ZONE_FOLDER.has(part))
+  return at === -1 ? undefined : parts.slice(0, at + 1).join("/")
+}
+
+/** True when a tsconfig between the app root and `cwd` makes the app its own program. */
+function hasOwnProgram(cwd: string, app: string): boolean {
+  let dir = app
+  while (dir !== "" && dir !== ".") {
+    if (existsSync(join(cwd, dir, "tsconfig.json"))) return true
+    const parent = dirname(dir)
+    if (parent === dir) return false
+    dir = parent
+  }
+  return false
+}
+
+/**
+ * The `exclude` patterns of `<cwd>/tsconfig.json`, inherited through relative `extends` as tsc does,
+ * rewritten relative to `cwd`. A file a tsconfig excludes is out of the program on purpose.
+ */
+export function tsconfigExcludes(cwd: string): string[] {
+  let path = join(cwd, "tsconfig.json")
+  for (let depth = 0; depth < 8 && existsSync(path); depth++) {
+    let config: unknown
+    try {
+      config = JSON.parse(stripComments(readFileSync(path, "utf8")).replace(/,(\s*[}\]])/g, "$1"))
+    } catch {
+      return []
+    }
+    if (typeof config !== "object" || config === null) return []
+    const exclude: unknown = Reflect.get(config, "exclude")
+    if (Array.isArray(exclude)) {
+      const from = dirname(path)
+      return exclude
+        .filter((pattern): pattern is string => typeof pattern === "string")
+        .map((pattern) => relative(cwd, resolve(from, pattern)).replaceAll("\\", "/"))
+    }
+    const base: unknown = Reflect.get(config, "extends")
+    if (typeof base !== "string" || !base.startsWith(".")) return []
+    path = resolve(dirname(path), base.endsWith(".json") ? base : `${base}.json`)
+  }
+  return []
+}
+
+// tsc reads a pattern that names a folder as everything below it.
+const excludedBy = (patterns: readonly string[], file: string): boolean =>
+  patterns.some(
+    (pattern) => new Bun.Glob(pattern).match(file) || new Bun.Glob(`${pattern}/**`).match(file),
+  )
+
+/**
+ * The TypeScript files under a zone folder that `programFiles` does not contain, project-relative and
+ * in input order. Declaration files and tests are left out: a project may typecheck tests with a
+ * separate config. So is an app nested under its own tsconfig, which this program does not own, and a
+ * file the tsconfig's `exclude` names.
+ */
+export function filesOutsideProgram(
+  cwd: string,
+  files: readonly string[],
+  programFiles: readonly string[],
+): string[] {
+  const program = new Set<string>()
+  for (const file of programFiles) {
+    program.add(canonical(file))
+    if (!file.includes("/node_modules/")) program.add(canonical(real(file)))
+  }
+  const ownProgram = new Map<string, boolean>()
+  const excluded = tsconfigExcludes(cwd)
+  const outside: string[] = []
+  for (const file of files) {
+    if (!TS_SOURCE.test(file) || NOT_PROGRAM_CODE.test(file)) continue
+    if (excludedBy(excluded, file)) continue
+    const folder = zoneFolderOf(file)
+    if (folder === undefined) continue
+    const app = dirname(folder)
+    let own = ownProgram.get(app)
+    if (own === undefined) {
+      own = hasOwnProgram(cwd, app)
+      ownProgram.set(app, own)
+    }
+    if (own) continue
+    const abs = join(cwd, file)
+    if (program.has(canonical(abs)) || program.has(canonical(real(abs)))) continue
+    outside.push(file)
+  }
+  return outside
+}