@lownoise-studio/rendershield 0.1.4 → 0.3.0

package/src/commands/build.ts

@@ -1,72 +1,185 @@
-import fs from "fs-extra";
-import path from "node:path";
-import { loadConfig } from "../core/loadConfig.js";
-import { loadAllMarkdownDocs } from "../core/loadMarkdown.js";
-import { renderPageHtml } from "../core/renderHtml.js";
-import { generateSitemapXml } from "../core/generateSitemap.js";
-import { generateRobotsTxt } from "../core/generateRobots.js";
-import { generateWorkerJs } from "../core/generateWorker.js";
-import { validatePrerenderHtml } from "../core/validateOutput.js";
-
-function routeToOutDir(outDirAbs: string, routePath: string): string {
-  // /blog/slug -> outDir/blog/slug/index.html
-  const clean = routePath.replace(/^\//, "");
-  return path.join(outDirAbs, clean);
-}
-
-export async function cmdBuild(cwd = process.cwd()) {
-  const cfg = await loadConfig(cwd);
-  const outDirAbs = path.join(cwd, cfg.output.outDir);
-
-  // Clean output (boring + deterministic)
-  await fs.remove(outDirAbs);
-  await fs.ensureDir(outDirAbs);
-
-  const docs = await loadAllMarkdownDocs(cfg, cwd);
-
-  if (docs.length === 0) {
-    throw new Error("No markdown documents found. Check content paths/patterns.");
-  }
-
-  // Generate pages (validate BEFORE writing)
-  for (const doc of docs) {
-    const pageDir = routeToOutDir(outDirAbs, doc.routePath);
-    await fs.ensureDir(pageDir);
-
-    const outFile = path.join(pageDir, "index.html");
-    const html = renderPageHtml(cfg, doc);
-
-    validatePrerenderHtml({
-      html,
-      outFile,
-      routePath: doc.routePath,
-    });
-
-    await fs.writeFile(outFile, html, "utf8");
-  }
-
-  // sitemap.xml
-  if (cfg.sitemap.enabled) {
-    const sitemapXml = generateSitemapXml(cfg, docs);
-    const sitemapPath = path.join(outDirAbs, cfg.sitemap.path.replace(/^\//, ""));
-    await fs.writeFile(sitemapPath, sitemapXml, "utf8");
-  }
-
-  // robots.txt
-  if (cfg.robots.enabled) {
-    const robotsTxt = generateRobotsTxt(cfg);
-    const robotsPath = path.join(outDirAbs, cfg.robots.path.replace(/^\//, ""));
-    await fs.writeFile(robotsPath, robotsTxt, "utf8");
-  }
-
-  // worker.js
-  if (cfg.worker.enabled) {
-    const workerJs = generateWorkerJs(cfg);
-    await fs.writeFile(path.join(outDirAbs, "worker.js"), workerJs, "utf8");
-  }
-
-  console.log(`Built ${docs.length} pages into ${cfg.output.outDir}/`);
-  console.log(
-    `Output includes: ${cfg.sitemap.enabled ? "sitemap.xml " : ""}${cfg.robots.enabled ? "robots.txt " : ""}${cfg.worker.enabled ? "worker.js" : ""}`
-  );
-}
+import fs from "fs-extra";
+import path from "node:path";
+import { loadConfig } from "../core/loadConfig.js";
+import { loadAllMarkdownDocs } from "../core/loadMarkdown.js";
+import { renderPageHtml } from "../core/renderHtml.js";
+import { generateSitemapXml } from "../core/generateSitemap.js";
+import { generateRobotsTxt } from "../core/generateRobots.js";
+import { generateWorkerJs } from "../core/generateWorker.js";
+import { validatePrerenderHtml } from "../core/validateOutput.js";
+
+function routeToOutDir(outDirAbs: string, routePath: string): string {
+  // /blog/slug -> outDir/blog/slug/index.html
+  const clean = routePath.replace(/^\//, "");
+  return path.join(outDirAbs, clean);
+}
+
+/**
+ * Validates output path before any destructive operation (fs.remove).
+ * Pass: outDir is a subdirectory inside project root; no symlink escape.
+ * Fail: "/", "C:\", "..", "../", or outDir (or any of its existing parents) resolving outside project.
+ * Policy: strict — build hard-fails before any delete attempt.
+ * Segment-safe: uses path.relative(root, out) only; no prefix startsWith.
+ */
+async function validateOutputPath(outDir: string, cwd: string): Promise<void> {
+  const cwdAbs = path.resolve(cwd);
+  let cwdReal: string;
+  try {
+    cwdReal = await fs.realpath(cwdAbs);
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`Cannot resolve project root: ${cwdAbs}. ${msg}`);
+  }
+
+  const outDirAbs = path.resolve(cwdAbs, outDir);
+  // Order: realpath → normalize → then case-fold for comparisons
+  const normalizedCwd = path.normalize(cwdReal);
+  const normalizedOut = path.normalize(outDirAbs);
+
+  // Segment-safe: use path.relative only (no prefix startsWith on full path). Cross-platform: relative()
+  // rarely returns absolute on Windows; startsWith("..") and path.isAbsolute(rel) cover escapes.
+  const relative = path.relative(normalizedCwd, normalizedOut);
+  if (relative.startsWith("..") || relative === ".." || path.isAbsolute(relative)) {
+    throw new Error(
+      `Output directory "${outDir}" resolves outside project root. Use a relative path within the project.`
+    );
+  }
+
+  // Reject: root filesystem (/, C:\, C:/) — early reject; real safety is "inside root" above
+  const rootPaths = ["/", "c:\\", "c:/"];
+  const outLower = normalizedOut.toLowerCase();
+  if (rootPaths.includes(outLower)) {
+    throw new Error(
+      `Output directory "${outDir}" resolves to root filesystem. This is not allowed for safety.`
+    );
+  }
+
+  // Reject: output dir equals project root (would delete entire project). Case-fold after normalize.
+  const cwdLower = normalizedCwd.toLowerCase();
+  if (outLower === cwdLower) {
+    throw new Error(
+      `Output directory "${outDir}" cannot be the project root. Use a subdirectory (e.g. dist-prerender).`
+    );
+  }
+
+  if (await fs.pathExists(outDirAbs)) {
+    // Path exists: resolve symlinks and ensure real path is inside root
+    let outDirReal: string;
+    try {
+      outDirReal = await fs.realpath(outDirAbs);
+    } catch {
+      outDirReal = outDirAbs;
+    }
+    const outDirRealNorm = path.normalize(outDirReal);
+    const relativeReal = path.relative(normalizedCwd, outDirRealNorm);
+    if (relativeReal.startsWith("..") || relativeReal === ".." || path.isAbsolute(relativeReal)) {
+      throw new Error(
+        `Output directory "${outDir}" resolves (via symlink) outside project root. Use a path that does not escape the project.`
+      );
+    }
+  } else {
+    // Path does not exist: walk up to nearest existing parent, realpath it, ensure it stays inside root.
+    // Guards e.g. outDir "dist-link/prerender-new" where dist-link is a symlink to /.
+    // If we never find an existing parent (or the only one is root), we must reject — do not treat as "fine."
+    let current = normalizedOut;
+    const rootDir = path.normalize(path.parse(normalizedCwd).root);
+    let foundParentInsideRoot = false;
+    while (current) {
+      if (await fs.pathExists(current)) {
+        let parentReal: string;
+        try {
+          parentReal = await fs.realpath(current);
+        } catch {
+          parentReal = current;
+        }
+        const parentRealNorm = path.normalize(parentReal);
+        // Nearest existing parent is filesystem root → outside project, reject
+        const parentLower = parentRealNorm.toLowerCase();
+        if (rootPaths.includes(parentLower)) {
+          throw new Error(
+            `Output directory "${outDir}" has a parent that resolves to filesystem root. Use a path inside the project.`
+          );
+        }
+        const relParent = path.relative(normalizedCwd, parentRealNorm);
+        if (relParent.startsWith("..") || relParent === ".." || path.isAbsolute(relParent)) {
+          throw new Error(
+            `Output directory "${outDir}" has a parent that resolves (via symlink) outside project root. Use a path that does not escape the project.`
+          );
+        }
+        foundParentInsideRoot = true;
+        break;
+      }
+      const parent = path.dirname(current);
+      if (parent === current) break;
+      current = parent;
+    }
+    if (!foundParentInsideRoot) {
+      // No existing parent found before hitting dirname loop stop (shouldn't happen on a normal FS)
+      throw new Error(
+        `Output directory "${outDir}" could not be validated: no existing parent path found. Use a path inside the project.`
+      );
+    }
+  }
+}
+
+export async function cmdBuild(cwd = process.cwd()) {
+  const cfg = await loadConfig(cwd);
+
+  // Validate output path before any destructive operations
+  await validateOutputPath(cfg.output.outDir, cwd);
+
+  const outDirAbs = path.join(cwd, cfg.output.outDir);
+
+  // Clean output (boring + deterministic)
+  await fs.remove(outDirAbs);
+  await fs.ensureDir(outDirAbs);
+
+  const docs = await loadAllMarkdownDocs(cfg, cwd);
+
+  if (docs.length === 0) {
+    throw new Error("No markdown documents found. Check content paths/patterns.");
+  }
+
+  // Generate pages (validate BEFORE writing)
+  for (const doc of docs) {
+    const pageDir = routeToOutDir(outDirAbs, doc.routePath);
+    await fs.ensureDir(pageDir);
+
+    const outFile = path.join(pageDir, "index.html");
+    const html = renderPageHtml(cfg, doc);
+
+    validatePrerenderHtml({
+      html,
+      outFile,
+      routePath: doc.routePath,
+      sourcePath: doc.sourcePath,
+    });
+
+    await fs.writeFile(outFile, html, "utf8");
+  }
+
+  // sitemap.xml
+  if (cfg.sitemap.enabled) {
+    const sitemapXml = generateSitemapXml(cfg, docs);
+    const sitemapPath = path.join(outDirAbs, cfg.sitemap.path.replace(/^\//, ""));
+    await fs.writeFile(sitemapPath, sitemapXml, "utf8");
+  }
+
+  // robots.txt
+  if (cfg.robots.enabled) {
+    const robotsTxt = generateRobotsTxt(cfg);
+    const robotsPath = path.join(outDirAbs, cfg.robots.path.replace(/^\//, ""));
+    await fs.writeFile(robotsPath, robotsTxt, "utf8");
+  }
+
+  // worker.js
+  if (cfg.worker.enabled) {
+    const workerJs = generateWorkerJs(cfg);
+    await fs.writeFile(path.join(outDirAbs, "worker.js"), workerJs, "utf8");
+  }
+
+  console.log(`Built ${docs.length} pages into ${cfg.output.outDir}/`);
+  console.log(
+    `Output includes: ${cfg.sitemap.enabled ? "sitemap.xml " : ""}${cfg.robots.enabled ? "robots.txt " : ""}${cfg.worker.enabled ? "worker.js" : ""}`
+  );
+}

package/src/commands/verify.ts

@@ -1,114 +1,233 @@
-import fs from "fs-extra";
-import path from "node:path";
-import { loadConfig } from "../core/loadConfig.js";
-
-function joinUrl(base: string, routePath: string): string {
-  const b = base.endsWith("/") ? base.slice(0, -1) : base;
-  const p = routePath.startsWith("/") ? routePath : `/${routePath}`;
-  return b + p;
-}
-
-async function findFirstIndexHtml(outDirAbs: string): Promise<string | null> {
-  const stack: string[] = [outDirAbs];
-
-  while (stack.length > 0) {
-    const current = stack.pop() as string;
-
-    let entries: fs.Dirent[];
-    try {
-      entries = await fs.readdir(current, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-
-    entries.sort((a, b) => a.name.localeCompare(b.name));
-
-    for (const entry of entries) {
-      const full = path.join(current, entry.name);
-
-      if (entry.isDirectory()) {
-        stack.push(full);
-        continue;
-      }
-
-      if (entry.isFile() && entry.name.toLowerCase() === "index.html") {
-        // Ignore index.html at the output root; prefer a routed page like
-        // <section>/<slug>/index.html (or deeper).
-        const rel = path.relative(outDirAbs, full);
-        const parts = rel.split(path.sep).filter(Boolean);
-        if (parts.length >= 2) return full;
-      }
-    }
-  }
-
-  return null;
-}
-
-function indexHtmlPathToRoute(outDirAbs: string, indexPathAbs: string): string {
-  const rel = path.relative(outDirAbs, indexPathAbs);
-  // rel: <section>/<slug>/index.html
-  const noFile = rel.replace(/index\.html$/i, "");
-  const normalized = noFile.split(path.sep).join("/").replace(/\/+$/, "");
-  return "/" + normalized.replace(/^\/+/, "");
-}
-
-export async function cmdVerify(cwd = process.cwd()) {
-  const cfg = await loadConfig(cwd);
-
-  const outDirAbs = path.join(cwd, cfg.output.outDir);
-  const exists = await fs.pathExists(outDirAbs);
-
-  if (!exists) {
-    console.log(`
-RenderShield verify
-
-No prerender output directory found: ${cfg.output.outDir}/
-
-Run:
-  node dist/cli.js build
-`);
-    return;
-  }
-
-  const firstIndex = await findFirstIndexHtml(outDirAbs);
-
-  if (!firstIndex) {
-    console.log(`
-RenderShield verify
-
-No prerendered pages found inside: ${cfg.output.outDir}/
-
-Run:
-  node dist/cli.js build
-`);
-    return;
-  }
-
-  const routePath = indexHtmlPathToRoute(outDirAbs, firstIndex);
-  const url = joinUrl(cfg.site.canonicalBase, routePath);
-
-  console.log(`
-RenderShield verify
-
-Using:
-  canonicalBase: ${cfg.site.canonicalBase}
-  routePath:     ${routePath}
-  output file:   ${path.relative(cwd, firstIndex)}
-
-Smoke tests:
-
-1) Human (usually SPA shell):
-  curl -s ${url} | grep -i "<title>"
-
-2) Bot (should see prerendered, route-specific title):
-  curl -s -H "User-Agent: Googlebot" ${url} | grep -i "<title>"
-
-3) Debug headers (Worker must be routed + proxy ON):
-  curl -I -H "User-Agent: GPTBot" ${url}
-
-Expected headers (if debugHeaders enabled):
-  X-Bot-Detected: true
-  X-Prerender: true
-  X-Final-Path: ${routePath.replace(/\/?$/, "/index.html")}
-`);
-}
+import fs from "fs-extra";
+import path from "node:path";
+import { loadConfig } from "../core/loadConfig.js";
+import { checkPrerenderContract } from "../core/validateOutput.js";
+
+function joinUrl(base: string, routePath: string): string {
+  const b = base.endsWith("/") ? base.slice(0, -1) : base;
+  const p = routePath.startsWith("/") ? routePath : `/${routePath}`;
+  return b + p;
+}
+
+async function findFirstIndexHtml(outDirAbs: string): Promise<string | null> {
+  const stack: string[] = [outDirAbs];
+
+  while (stack.length > 0) {
+    const current = stack.pop() as string;
+
+    let entries: fs.Dirent[];
+    try {
+      entries = await fs.readdir(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+
+    for (const entry of entries) {
+      const full = path.join(current, entry.name);
+
+      if (entry.isDirectory()) {
+        stack.push(full);
+        continue;
+      }
+
+      if (entry.isFile() && entry.name.toLowerCase() === "index.html") {
+        // Ignore index.html at the output root; prefer a routed page like
+        // <section>/<slug>/index.html (or deeper).
+        const rel = path.relative(outDirAbs, full);
+        const parts = rel.split(path.sep).filter(Boolean);
+        if (parts.length >= 2) return full;
+      }
+    }
+  }
+
+  return null;
+}
+
+function indexHtmlPathToRoute(outDirAbs: string, indexPathAbs: string): string {
+  const rel = path.relative(outDirAbs, indexPathAbs);
+  // rel: <section>/<slug>/index.html
+  const noFile = rel.replace(/index\.html$/i, "");
+  const normalized = noFile.split(path.sep).join("/").replace(/\/+$/, "");
+  return "/" + normalized.replace(/^\/+/, "");
+}
+
+const BOT_UA =
+  "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)";
+const HUMAN_UA =
+  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36";
+
+/** Heuristic: likely SPA shell if body has almost no visible content and no article. */
+function looksLikeSpaShell(html: string): { likely: boolean; reason?: string } {
+  const bodyMatch = html.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
+  const bodyHtml = bodyMatch ? bodyMatch[1] : html;
+  const noScript = bodyHtml
+    .replace(/<script[\s\S]*?<\/script>/gi, " ")
+    .replace(/<style[\s\S]*?<\/style>/gi, " ")
+    .replace(/<noscript[\s\S]*?<\/noscript>/gi, " ");
+  const text = noScript.replace(/<\/?[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+  if (text.length < 150) {
+    return { likely: true, reason: `Body text very short (${text.length} chars); likely app shell.` };
+  }
+  if (!/<article\b/i.test(html)) {
+    return { likely: true, reason: "No <article> present; may be SPA shell." };
+  }
+  const rootOnly = /<body[^>]*>\s*<div[^>]*id=["'](?:root|app|__next)["'][^>]*>\s*<\/div>\s*<\/body>/i.test(
+    html.replace(/\s+/g, " ")
+  );
+  if (rootOnly) {
+    return { likely: true, reason: "Single root div (e.g. #root, #app) with no content." };
+  }
+  return { likely: false };
+}
+
+export type VerifyProdOptions = { prodUrl: string };
+
+export async function cmdVerify(
+  cwd = process.cwd(),
+  options?: VerifyProdOptions
+) {
+  if (options?.prodUrl) {
+    await runVerifyProd(options.prodUrl);
+    return;
+  }
+
+  const cfg = await loadConfig(cwd);
+
+  const outDirAbs = path.join(cwd, cfg.output.outDir);
+  const exists = await fs.pathExists(outDirAbs);
+
+  if (!exists) {
+    console.log(`
+RenderShield verify
+
+No prerender output directory found: ${cfg.output.outDir}/
+
+Run:
+  node dist/cli.js build
+`);
+    return;
+  }
+
+  const firstIndex = await findFirstIndexHtml(outDirAbs);
+
+  if (!firstIndex) {
+    console.log(`
+RenderShield verify
+
+No prerendered pages found inside: ${cfg.output.outDir}/
+
+Run:
+  node dist/cli.js build
+`);
+    return;
+  }
+
+  const routePath = indexHtmlPathToRoute(outDirAbs, firstIndex);
+  const url = joinUrl(cfg.site.canonicalBase, routePath);
+
+  console.log(`
+RenderShield verify
+
+Using:
+  canonicalBase: ${cfg.site.canonicalBase}
+  routePath:     ${routePath}
+  output file:   ${path.relative(cwd, firstIndex)}
+
+Smoke tests:
+
+1) Human (usually SPA shell):
+  curl -s ${url} | grep -i "<title>"
+
+2) Bot (should see prerendered, route-specific title):
+  curl -s -H "User-Agent: Googlebot" ${url} | grep -i "<title>"
+
+3) Debug headers (Worker must be routed + proxy ON):
+  curl -I -H "User-Agent: GPTBot" ${url}
+
+Expected: x-rendershield: bot-hit (proves Worker served prerender to bot).
+If debugHeaders enabled: X-Bot-Detected, X-Prerender, X-Final-Path.
+`);
+}
+
+async function runVerifyProd(url: string): Promise<void> {
+  const normalizedUrl = url.startsWith("http") ? url : `https://${url}`;
+
+  let botHtml: string;
+  let humanHtml: string;
+  let botStatus: number;
+  let humanStatus: number;
+  let xRenderShield: string | null;
+
+  try {
+    const [botRes, humanRes] = await Promise.all([
+      fetch(normalizedUrl, {
+        headers: { "User-Agent": BOT_UA },
+        redirect: "follow",
+      }),
+      fetch(normalizedUrl, {
+        headers: { "User-Agent": HUMAN_UA },
+        redirect: "follow",
+      }),
+    ]);
+
+    botStatus = botRes.status;
+    humanStatus = humanRes.status;
+    xRenderShield = botRes.headers.get("x-rendershield");
+    botHtml = await botRes.text();
+    humanHtml = await humanRes.text();
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `RenderShield verify --prod: failed to fetch ${normalizedUrl}. ${msg}`
+    );
+  }
+
+  // Prove routing: Worker must set x-rendershield: bot-hit for bot requests. No inference.
+  const routingOk = xRenderShield === "bot-hit";
+  if (xRenderShield === "bot-fallback") {
+    throw new Error(
+      `RenderShield verify --prod: bot request received x-rendershield: bot-fallback. ` +
+        `Prerender origin returned non-200; Worker fell back to SPA. Fix deployment or origin so bots get prerendered HTML.`
+    );
+  }
+  if (!routingOk) {
+    throw new Error(
+      `RenderShield verify --prod: expected x-rendershield: bot-hit (proving Worker routed bot to prerender). ` +
+        `Got: ${xRenderShield ?? "(missing)"}. Ensure the Worker is deployed and bound to this route.`
+    );
+  }
+
+  const contract = checkPrerenderContract(botHtml, {
+    routePath: normalizedUrl,
+    outFile: normalizedUrl,
+  });
+
+  const humanSpa = looksLikeSpaShell(humanHtml);
+
+  // Report
+  console.log(`
+RenderShield verify --prod
+URL: ${normalizedUrl}
+
+Fetch:
+  Bot (Googlebot):   ${botStatus}  (${botHtml.length} bytes)  x-rendershield: ${xRenderShield ?? "(none)"}
+  Human (Chrome):    ${humanStatus}  (${humanHtml.length} bytes)
+
+Routing:  x-rendershield: bot-hit (Worker served prerendered HTML to bot)
+
+Bot contract (title, meta, canonical, OG, JSON-LD, article):
+  ${contract.ok ? "PASS — all required fields present." : "FAIL — missing or invalid:"}
+${contract.missing.length > 0 ? contract.missing.map((m) => `  - ${m}`).join("\n") : ""}
+
+Human response:
+  ${humanSpa.likely ? `Likely SPA shell: ${humanSpa.reason ?? "unknown"}` : "Has substantial content (not a minimal SPA shell)."}
+`);
+
+  if (!contract.ok) {
+    throw new Error(
+      `Production URL did not satisfy bot contract. Missing: ${contract.missing.join("; ")}`
+    );
+  }
+}