@nifrajs/cli 2.8.0 → 2.8.2

package/src/check.ts

@@ -45,10 +45,15 @@ const FETCH_CALL = /(?<![.\w])fetch\s*\(/g
 const HTTP_VERBS = new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"])
 const SIMPLE_REWRITE_METHODS = new Set(["GET", "DELETE", "HEAD", "OPTIONS"])
 
-// Don't scan deps, build output, generated client entries, or tests (which legitimately drive `fetch`).
-// `dist(-<runtime>)?` also covers per-runtime output dirs (dist-bun/dist-node/dist-deno/dist-vercel).
-const IGNORED =
-  /(^|\/)(node_modules|dist(-[a-z0-9]+)?|build|\.nifra|\.git|\.wrangler|coverage)\/|\.(test|spec)\.[cm]?[jt]sx?$/
+// Don't scan deps, build output, or generated client entries. `dist(-<runtime>)?` also covers
+// per-runtime output dirs (dist-bun/dist-node/dist-deno/dist-vercel). Never source, for any scan.
+const IGNORED_DIR =
+  /(^|\/)(node_modules|dist(-[a-z0-9]+)?|build|\.nifra|\.git|\.wrangler|coverage)\//
+// A test/spec module. Excluded from `nifra check`'s scans, which are about what SHIPS - a test
+// legitimately drives `fetch`, hand-rolls a client, and calls a route directly. It is NOT excluded from
+// `nifra doctor`: tsc typechecks tests, so an import a test declares nowhere is a real broken build.
+const TEST_FILE = /\.(test|spec)\.[cm]?[jt]sx?$/
+const IGNORED = new RegExp(`${IGNORED_DIR.source}|${TEST_FILE.source}`)
 
 // A file under `routes/` - a page module bundled for the browser, where a server-only import is unsafe.
 const ROUTE_FILE = /(^|\/)routes\//
@@ -1190,8 +1195,12 @@ export function scanResponseRoutes(file: string, content: string): SourceFinding
 /** The opt-out pragma that suppresses the {@link scanResponseRoutes} advisory for an intentional raw Response. */
 const RAW_RESPONSE_PRAGMA = "nifra-expect raw-response"
 
-/** Walk the project's `.ts`/`.tsx` source (skipping deps/build/tests), calling `visit` per file.
- * Exported so `nifra doctor` ({@link ./doctor.ts}) scans the same source surface as `nifra check`. */
+/** Walk the project's `.ts`/`.tsx` source (skipping deps and build output), calling `visit` per file.
+ * Exported so `nifra doctor` ({@link ./doctor.ts}) scans the same source surface as `nifra check`.
+ *
+ * `includeTests` widens the surface to `*.test.ts`/`*.spec.ts`, which the default excludes. It exists
+ * for `nifra doctor`: `tsc` compiles tests, so a test importing a package no manifest declares is a
+ * build that a clean install cannot produce - the exact false confidence doctor is for. */
 /**
  * Paths git considers ignored under `cwd`, in ONE batched `git check-ignore` call - so `.gitignore`
  * (root + nested + the global excludesfile) is honoured, not just the built-in {@link IGNORED} list. This
@@ -1228,12 +1237,14 @@ async function gitIgnored(cwd: string, rels: readonly string[]): Promise<Set<str
 export async function walkSource(
   cwd: string,
   visit: (rel: string, content: string) => void,
+  opts: { readonly includeTests?: boolean } = {},
 ): Promise<void> {
+  const skip = opts.includeTests === true ? IGNORED_DIR : IGNORED
   // List candidates first (cheap - no reads), drop the built-in ignores, then exclude gitignored paths in
   // one batch before the (expensive) reads. So a gitignored generated/build tree is never read or scanned.
   const rels: string[] = []
   for await (const rel of new Glob("**/*.{ts,tsx,mts,cts}").scan({ cwd, dot: false })) {
-    if (!IGNORED.test(rel)) rels.push(rel)
+    if (!skip.test(rel)) rels.push(rel)
   }
   const ignored = await gitIgnored(cwd, rels)
   for (const rel of rels) {

package/src/cli.ts

@@ -148,7 +148,7 @@ Port: \`dev\` and \`start\` share the default ${DEFAULT_DEV_PORT}. Override with
 \`PORT\` env var (\`--port\` wins over \`PORT\`, which wins over the default).`
 
 // Kept in lockstep with packages/cli/package.json by check:publish's version-consistency gate.
-const CLI_VERSION = "2.8.0"
+const CLI_VERSION = "2.8.2"
 
 // A render adapter + nifra server are opaque to the CLI (it just forwards them); cast at the seam.
 const asAdapter = (v: unknown): RenderAdapter => v as RenderAdapter

package/src/doctor.ts

@@ -9,6 +9,12 @@
  * declared by the package that imports it (for `tsc` and for that package to install on its own) even
  * when a monorepo would hoist it. Relative paths, runtime builtins (node core, `node:`/`bun:`, `bun`),
  * the package's own name, and tsconfig `paths` aliases are excluded - none of them are npm deps.
+ *
+ * The diff is against DECLARED dependency sets only; what happens to be installed on disk is never
+ * consulted. That is the point: a package pulled in transitively by some other dependency resolves fine
+ * locally while no manifest declares it, so resolvability is not evidence of declaration. The scan
+ * therefore also covers `*.test.ts`/`*.spec.ts`, which `nifra check` skips - `tsc` compiles them, so an
+ * undeclared import there fails a clean `bun install --frozen-lockfile` build just the same.
  */
 import type { Dirent } from "node:fs"
 import { readdir, realpath, stat } from "node:fs/promises"
@@ -679,12 +685,19 @@ export async function collectDoctorResult(cwd: string): Promise<DoctorResult> {
   const scopes = await doctorPackageScopes(cwd, pkg)
 
   const findings: DoctorFinding[] = []
-  await walkSource(cwd, (rel, content) => {
-    const scope = scopeForFile(scopes, rel)
-    for (const f of scanUndeclaredImports(rel, content, scope.declared, scope.isAlias)) {
-      findings.push({ file: f.file, line: f.line, package: f.snippet })
-    }
-  })
+  // `includeTests`: tests are part of the typechecked surface, so an import they declare nowhere is a
+  // real break. Excluding them is what let an undeclared `zod` in a `*.test.ts` pass doctor, pass a
+  // hoisted local `tsc`, and then fail CI on a clean install with `TS2307: Cannot find module 'zod'`.
+  await walkSource(
+    cwd,
+    (rel, content) => {
+      const scope = scopeForFile(scopes, rel)
+      for (const f of scanUndeclaredImports(rel, content, scope.declared, scope.isAlias)) {
+        findings.push({ file: f.file, line: f.line, package: f.snippet })
+      }
+    },
+    { includeTests: true },
+  )
   findings.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line)
   const duplicateInstalls = await collectDuplicateInstalls(cwd, pkg)
   const staleDists = await collectStaleWorkspaceDists(cwd, pkg)

package/src/mcp-http.ts

@@ -29,7 +29,7 @@ export { docsTools } from "./mcp-docs-tools.ts"
 export type { TypeEntry } from "./types-search.ts"
 
 // Kept in lockstep with packages/cli/package.json by check:publish's version-consistency gate.
-const VERSION = "2.8.0"
+const VERSION = "2.8.2"
 const SERVER_INFO = { name: "nifra-docs", version: VERSION }
 // Derive the GET/health tool list from the tools actually served, so the line can never drift from them.
 const docsHealth = (tools: McpTool[]): string =>

package/src/scaffold.ts

@@ -9,7 +9,7 @@
  * `nifra_example` for the body, rather than hand-writing an SFC we can't typecheck here.
  */
 
-import { mkdir, writeFile } from "node:fs/promises"
+import { lstat, mkdir, realpath, writeFile } from "node:fs/promises"
 import { dirname, resolve, sep } from "node:path"
 
 export type Framework = "react" | "preact" | "solid" | "vue" | "svelte" | "vanilla"
@@ -122,6 +122,37 @@ function resolveInsideCwd(cwd: string, relativeFile: string): string {
   return target
 }
 
+/** Lexical containment is not enough when an existing route directory is a symlink. Check every
+ * existing ancestor and its real path before scaffolding so an agent cannot redirect a write outside
+ * the selected project. The target itself is created with `wx`, so an existing target symlink is also
+ * never followed/overwritten. */
+async function assertNoSymlinkedAncestors(root: string, target: string): Promise<void> {
+  const rootPath = resolve(root)
+  const realRoot = await realpath(rootPath)
+  let current = dirname(target)
+  while (current !== rootPath) {
+    if (!current.startsWith(`${rootPath}${sep}`)) {
+      throw new Error(`refusing to write outside project root: ${target}`)
+    }
+    try {
+      if ((await lstat(current)).isSymbolicLink()) {
+        throw new Error(`refusing to write through symlinked directory: ${current}`)
+      }
+      const actual = await realpath(current)
+      if (actual !== realRoot && !actual.startsWith(`${realRoot}${sep}`)) {
+        throw new Error(`refusing to write outside project root through: ${current}`)
+      }
+    } catch (err) {
+      if (err && typeof err === "object" && (err as { code?: string }).code === "ENOENT") {
+        current = dirname(current)
+        continue
+      }
+      throw err
+    }
+    current = dirname(current)
+  }
+}
+
 /** Write a scaffolded route stub when the framework has a verified ready-to-write body. The write is
  * intentionally conservative: it refuses non-JSX stubs (where we only return contract guidance) and
  * uses `wx`, so an agent cannot overwrite user work by accident. */
@@ -139,7 +170,9 @@ export async function writeScaffoldRoute(
     }
   }
   const target = resolveInsideCwd(cwd, result.file)
+  await assertNoSymlinkedAncestors(cwd, target)
   await mkdir(dirname(target), { recursive: true })
+  await assertNoSymlinkedAncestors(cwd, target)
   try {
     await writeFile(target, result.content, { flag: "wx" })
   } catch (err) {