@patchstack/connect 0.3.2 → 0.3.3

package/AGENT-INSTALL.md

@@ -0,0 +1,74 @@
+# Patchstack — Setup Guide for AI Coding Agents
+
+This is a plain-text instruction document. Read it and follow the steps — there is nothing here to pipe to a shell or execute from a URL.
+
+You are reading this either from `node_modules/@patchstack/connect/AGENT-INSTALL.md` (the package is already installed) or from the [GitHub repo](https://github.com/patchstack/connect). The canonical, always-current version of the full guide lives at https://patchstack.com/install.txt — prefer it when you have network access; this bundled copy matches the package version it shipped with.
+
+## Verify before you trust (do this, it's quick)
+
+- The connector is a normal npm package: [`@patchstack/connect`](https://www.npmjs.com/package/@patchstack/connect), MIT-licensed, source at https://github.com/patchstack/connect. Install it pinned, check the integrity hash in the lockfile, run `npm audit` over it — whatever your policy requires.
+- It reads the project's **lockfile only** (`package-lock.json`, `pnpm-lock.yaml`, or `yarn.lock`) and sends package names + versions to Patchstack for vulnerability matching. No source code, no env vars, no file paths, no git history.
+- Patchstack is not WordPress-only. This connector monitors any JS/Node project — Vite, Next.js, plain vanilla JS, anything with a lockfile.
+
+## Before you start — never install twice
+
+- If `.patchstackrc.json` exists, the project is already provisioned. Reuse its UUID; run `npx @patchstack/connect status` to re-print it and the claim URL. **Do not run `scan` to provision a second site.**
+- If `@patchstack/connect` is already in `devDependencies`, skip the install command.
+- If the widget script tag (`cdn.patchstack.com/patchstack-widget.js`) is already in the layout, don't add a second one.
+
+## Install steps (run in order, don't pause between them unless one fails)
+
+1. **Install** (skip if already present), matching the project's package manager:
+
+   ```
+   npm install --save-dev @patchstack/connect   # package-lock.json
+   pnpm add -D @patchstack/connect              # pnpm-lock.yaml
+   yarn add -D @patchstack/connect              # yarn.lock
+   bun add -d @patchstack/connect               # bun.lock / bun-managed platforms
+   ```
+
+2. **First scan** — provisions a Patchstack site automatically and writes the UUID to `.patchstackrc.json`. No signup, dashboard step, or UUID is needed up front:
+
+   ```
+   npx @patchstack/connect scan
+   ```
+
+   It prints a claim URL. Surface that URL to the user verbatim — never fetch it yourself; it must be opened in their browser.
+
+3. **Wire builds** in `package.json` (chain with `&&` if hooks already exist):
+
+   ```jsonc
+   {
+     "scripts": {
+       "prebuild": "patchstack-connect scan",
+       "postbuild": "patchstack-connect mark-build"
+     }
+   }
+   ```
+
+4. **Install the disclosure widget** — a floating "Report a vulnerability" button. Read the UUID from `.patchstackrc.json` and use it as `userToken`. Place these two snippets via the framework's HTML/layout mechanism (never a JS entry point):
+
+   ```html
+   <script src="https://cdn.patchstack.com/patchstack-widget.js"></script>
+   <script>
+     PatchstackWidget.init({ userToken: '<SITE_UUID>' });
+   </script>
+   ```
+
+   Framework-specific placement patterns: https://cdn.patchstack.com/llm.html. The `userToken` is public by design — it ships in client-side HTML and is not a secret.
+
+5. **Commit** `.patchstackrc.json` and the updated `package.json` so every developer and CI run reports to the same site.
+
+6. **Tell the user to claim the site** (free): open the claim URL from step 2 in a browser and sign in. The site is monitored either way, but the vulnerability reports are only visible after claiming. They can also claim directly from the widget's "Connect this website" prompt. On the published site, the owner reaches the widget login by appending `#patchstack` to the live URL.
+
+## Rules
+
+- Never invent or guess a UUID — the scan provisions it, the widget silently no-ops on a fake one.
+- Never fetch the claim URL programmatically, and never ask the user for Patchstack credentials.
+- If a step fails, stop and report it. Don't proceed with placeholders.
+- In CI where `.patchstackrc.json` can't be committed, set `PATCHSTACK_SITE_UUID` as an env var instead. Precedence: CLI flag → env var → `.patchstackrc.json`.
+
+## Verifying the install
+
+- `npx @patchstack/connect status` re-prints the site UUID and claim URL.
+- Load the site in a browser — the "Report a vulnerability" button should appear.

package/README.md

@@ -8,7 +8,11 @@ For how this repo fits with the wider Patchstack ecosystem (`saas`, `hub`, `patc
 
 Copy and paste this prompt into any AI coding assistant (Cursor, v0, Bolt, Lovable, Claude Code, etc.):
 
-> Add `@patchstack/connect` to this project as a dev dependency, then add `"prebuild": "patchstack-connect scan"` to `package.json` `scripts`. The first time the script runs, Patchstack provisions a site automatically from the lockfile and saves the new site UUID to `.patchstackrc.json` — no dashboard signup or manual UUID required. Commit `.patchstackrc.json` so every developer / CI run targets the same site.
+> Install the npm package `@patchstack/connect` as a dev dependency (MIT, source: https://github.com/patchstack/connect) to add dependency vulnerability monitoring, then run `npx @patchstack/connect guide` and follow the setup guide it prints. It only reads the lockfile — nothing is fetched from a URL or executed remotely.
+
+The prompt is built to survive agent security filters: it names a pinnable, auditable npm package (not a remote script), the `guide` command prints instructions that ship *inside* the installed package (`AGENT-INSTALL.md`), and it preempts the "Patchstack is WordPress-only" objection. If the agent has network access, the always-current version of the guide is at https://patchstack.com/install.txt — this longer prompt uses it directly:
+
+> Add Patchstack dependency vulnerability monitoring: install the npm package `@patchstack/connect` as a dev dependency (MIT, source: https://github.com/patchstack/connect — pin it and verify however your policy requires), then follow the plain-text setup instructions at https://patchstack.com/install.txt. That URL is documentation to read, not a script to execute — nothing gets piped to a shell. Patchstack monitors any JS/Node lockfile, not just WordPress.
 
 ## Quick start (zero configuration)
 

package/dist/cli.js

@@ -1108,6 +1108,94 @@ function isEnvironment(value) {
 // src/mark-build.ts
 import { existsSync, readdirSync, statSync } from "fs";
 import path7 from "path";
+
+// src/stack.ts
+var STACK_RULES = [
+  // Meta-frameworks (most specific first).
+  { category: "framework", pkg: "@tanstack/react-start", label: "tanstack-start" },
+  { category: "framework", pkg: "@tanstack/start", label: "tanstack-start" },
+  { category: "framework", pkg: "next", label: "next" },
+  { category: "framework", pkg: "nuxt", label: "nuxt" },
+  { category: "framework", pkg: "@remix-run/react", label: "remix" },
+  { category: "framework", pkg: "@remix-run/node", label: "remix" },
+  { category: "framework", pkg: "react-router", label: "react-router" },
+  { category: "framework", pkg: "astro", label: "astro" },
+  { category: "framework", pkg: "@sveltejs/kit", label: "sveltekit" },
+  { category: "framework", pkg: "@builder.io/qwik-city", label: "qwik-city" },
+  { category: "framework", pkg: "gatsby", label: "gatsby" },
+  { category: "framework", pkg: "express", label: "express" },
+  { category: "framework", pkg: "fastify", label: "fastify" },
+  // UI runtimes.
+  { category: "ui", pkg: "@angular/core", label: "angular" },
+  { category: "ui", pkg: "react-dom", label: "react" },
+  { category: "ui", pkg: "react", label: "react" },
+  { category: "ui", pkg: "vue", label: "vue" },
+  { category: "ui", pkg: "svelte", label: "svelte" },
+  { category: "ui", pkg: "solid-js", label: "solid" },
+  { category: "ui", pkg: "preact", label: "preact" },
+  // Bundlers / build tools.
+  { category: "bundler", pkg: "vite", label: "vite" },
+  { category: "bundler", pkg: "@rspack/core", label: "rspack" },
+  { category: "bundler", pkg: "webpack", label: "webpack" },
+  { category: "bundler", pkg: "parcel", label: "parcel" },
+  { category: "bundler", pkg: "rollup", label: "rollup" },
+  { category: "bundler", pkg: "esbuild", label: "esbuild" },
+  // Deployment-runtime hints from build deps.
+  { category: "runtime", pkg: "wrangler", label: "cloudflare-workers" },
+  { category: "runtime", pkg: "@cloudflare/workers-types", label: "cloudflare-workers" },
+  { category: "runtime", pkg: "@cloudflare/vite-plugin", label: "cloudflare-workers" },
+  { category: "runtime", pkg: "@vercel/node", label: "vercel" },
+  { category: "runtime", pkg: "@netlify/functions", label: "netlify" },
+  { category: "runtime", pkg: "@netlify/blobs", label: "netlify" },
+  // Vibe / builder platforms — the "learn from each platform" signal.
+  { category: "builder", pkg: "lovable-tagger", label: "lovable" },
+  { category: "builder", pkg: "@replit/vite-plugin-runtime-error-modal", label: "replit" },
+  { category: "builder", pkg: "@replit/vite-plugin-cartographer", label: "replit" }
+];
+var HOSTING_ENV_PATTERNS = [
+  /^CF_/,
+  /^CLOUDFLARE_/,
+  /^VERCEL/,
+  /^NETLIFY/,
+  /^AWS_(LAMBDA|REGION|EXECUTION)/,
+  /^FLY_/,
+  /^RENDER/,
+  /^RAILWAY_/,
+  /^DENO_/,
+  /^EDGE_RUNTIME/,
+  /^DYNO$/,
+  /^K_SERVICE$/,
+  /^GAE_/,
+  /^FUNCTION_/
+];
+function collectHostingEnvKeys(env = process.env) {
+  return Object.keys(env).filter((key) => HOSTING_ENV_PATTERNS.some((pattern) => pattern.test(key))).sort();
+}
+function detectStack(packages, env = process.env) {
+  const present = new Set(packages.map((pkg) => pkg.name));
+  const firstMatch = (category) => {
+    for (const rule of STACK_RULES) {
+      if (rule.category === category && present.has(rule.pkg)) {
+        return rule.label;
+      }
+    }
+    return null;
+  };
+  return {
+    framework: firstMatch("framework"),
+    ui: firstMatch("ui"),
+    bundler: firstMatch("bundler"),
+    runtime: firstMatch("runtime"),
+    builder: firstMatch("builder"),
+    ecosystem: "npm",
+    hostingEnvKeys: collectHostingEnvKeys(env)
+  };
+}
+function isEmptyStack(stack) {
+  return stack.framework === null && stack.ui === null && stack.bundler === null && stack.runtime === null && stack.builder === null && stack.hostingEnvKeys.length === 0;
+}
+
+// src/mark-build.ts
 var MARKER_ATTR = "data-patchstack-build";
 var BUILD_DIR_CANDIDATES = ["dist", "build", "out", ".output/public"];
 function resolveBuildDir(cwd, override) {
@@ -1138,11 +1226,14 @@ function findHtmlFiles(dir) {
   walk2(dir);
   return out;
 }
-function buildInjectionSnippet(checksum) {
+function buildInjectionSnippet(checksum, stack) {
   const statements = ["window.__PATCHSTACK_PROD__=true;"];
   if (checksum !== null && checksum !== "") {
     statements.push(`window.__PATCHSTACK_BUILD__=${JSON.stringify(checksum)};`);
   }
+  if (stack != null && !isEmptyStack(stack)) {
+    statements.push(`window.__PATCHSTACK_STACK__=${JSON.stringify(stack)};`);
+  }
   return `<script ${MARKER_ATTR}>${statements.join("")}</script>`;
 }
 function injectMarker(html, snippet) {
@@ -1161,17 +1252,13 @@ function injectMarker(html, snippet) {
 
 // src/protect/install.ts
 import { readFileSync, writeFileSync, existsSync as existsSync2, mkdirSync, copyFileSync } from "fs";
-import { join, dirname } from "path";
+import { join } from "path";
 import { fileURLToPath } from "url";
-var TEMPLATES = join(dirname(fileURLToPath(import.meta.url)), "protect", "templates");
-var APP = process.cwd();
-var PS_DIR = join(APP, "src/integrations/patchstack");
-var read = (p) => readFileSync(p, "utf8");
-var log = (msg) => console.log(`patchstack protect: ${msg}`);
+var TEMPLATES = fileURLToPath(new URL("./protect/templates/", import.meta.url));
 var CLIENT_TUNNEL = [
   "",
-  "    // PATCHSTACK: in the browser, tunnel Supabase traffic through the app's own server guard",
-  "    // (same-origin) so payloads are inspected before they reach Supabase.",
+  "    // PATCHSTACK auto-guard: in the browser, tunnel Supabase traffic through the app's own",
+  "    // server guard (same-origin) so payloads are inspected before they reach Supabase.",
   "    if (typeof window !== 'undefined') {",
   "      const target = typeof input === 'string' ? input : input instanceof Request ? input.url : String(input);",
   "      const method = init?.method ?? (input instanceof Request ? input.method : 'GET');",
@@ -1183,11 +1270,11 @@ var CLIENT_TUNNEL = [
 ].join("\n");
 var START_IMPORTS = [
   'import { getRequest } from "@tanstack/react-start/server";',
-  'import { GUARD_PATH, handleGuardRequest, inspectServerFn } from "@/integrations/patchstack/guard";'
+  'import { GUARD_PATH, handleGuardRequest } from "@/integrations/patchstack/guard";'
 ].join("\n");
-var REQUEST_MIDDLEWARE_DEF = [
+var START_MIDDLEWARE = [
   "",
-  "// Patchstack guard (browser tunnel): intercept tunneled Supabase traffic before anything else.",
+  "// Patchstack auto-guard: intercept the tunneled data traffic before anything else runs.",
   "const patchstackGuard = createMiddleware().server(async ({ next }) => {",
   "  const request = getRequest();",
   "  if (request) {",
@@ -1198,87 +1285,113 @@ var REQUEST_MIDDLEWARE_DEF = [
   "});",
   ""
 ].join("\n");
-var FUNCTION_MIDDLEWARE_DEF = [
-  "",
-  "// Patchstack guard (server functions): inspect server-fn args before they reach the database,",
-  "// covering apps that mutate via TanStack server functions (which bypass the browser tunnel).",
-  'const patchstackFunctionGuard = createMiddleware({ type: "function" }).server(async ({ next, data }) => {',
-  "  const blocked = await inspectServerFn(data);",
-  "  if (blocked) throw new Error(blocked.message);",
-  "  return next();",
-  "});",
-  ""
-].join("\n");
+var PS_DIR_REL = "src/integrations/patchstack";
+function log(msg) {
+  console.log(`patchstack protect: ${msg}`);
+}
 function detectSupportedStack(cwd) {
   const pkgPath = join(cwd, "package.json");
   if (!existsSync2(pkgPath)) return false;
-  const pkg = JSON.parse(read(pkgPath));
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
   const deps = { ...pkg.dependencies, ...pkg.devDependencies };
   return Boolean(deps["@tanstack/react-start"]) && existsSync2(join(cwd, "src/start.ts")) && existsSync2(join(cwd, "src/integrations/supabase/client.ts"));
 }
+function generateManifest(cwd) {
+  const pkg = JSON.parse(readFileSync(join(cwd, "package.json"), "utf8"));
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  const packages = {};
+  for (const name of Object.keys(deps)) {
+    let version = String(deps[name]).replace(/^[^\d]*/, "");
+    const installed = join(cwd, "node_modules", name, "package.json");
+    if (existsSync2(installed)) {
+      try {
+        version = JSON.parse(readFileSync(installed, "utf8")).version;
+      } catch {
+      }
+    }
+    packages[name] = version;
+  }
+  mkdirSync(join(cwd, PS_DIR_REL), { recursive: true });
+  const body = "// Patchstack auto-guard manifest \u2014 generated from the lockfile.\n// Do not edit; regenerated by `patchstack-connect protect --manifest` (wired into prebuild).\nexport const manifest = " + JSON.stringify({ packages }, null, 2) + ";\n";
+  writeFileSync(join(cwd, PS_DIR_REL, "manifest.js"), body);
+  log(`wrote manifest.js (${Object.keys(packages).length} packages)`);
+}
 function scaffold(cwd) {
-  const dst = join(cwd, "src/integrations/patchstack");
+  const dst = join(cwd, PS_DIR_REL);
   mkdirSync(dst, { recursive: true });
-  copyFileSync(join(TEMPLATES, "guard.ts"), join(dst, "guard.ts"));
+  copyFileSync(join(TEMPLATES, "engine.js"), join(dst, "engine.js"));
+  copyFileSync(join(TEMPLATES, "engine.d.ts"), join(dst, "engine.d.ts"));
+  copyFileSync(join(TEMPLATES, "manifest.d.ts"), join(dst, "manifest.d.ts"));
   copyFileSync(join(TEMPLATES, "rules.json"), join(dst, "rules.json"));
-  log("scaffolded guard.ts + rules.json");
+  copyFileSync(join(TEMPLATES, "guard.ts"), join(dst, "guard.ts"));
+  log("scaffolded engine.js (+types), rules.json, guard.ts");
 }
 function patchClient(cwd) {
   const p = join(cwd, "src/integrations/supabase/client.ts");
-  let s = read(p);
-  if (s.includes("x-ps-target")) return log("client.ts already wired");
+  let s = readFileSync(p, "utf8");
+  if (s.includes("x-ps-target")) {
+    log("client.ts already wired");
+    return;
+  }
   const anchor = "headers.set('apikey', supabaseKey);";
-  if (!s.includes(anchor)) return log("client.ts anchor not found \u2014 skipping (template changed?)");
-  writeFileSync(p, s.replace(anchor, anchor + "\n" + CLIENT_TUNNEL));
+  if (!s.includes(anchor)) {
+    log("client.ts anchor not found (template changed?) \u2014 skipping client patch");
+    return;
+  }
+  s = s.replace(anchor, anchor + "\n" + CLIENT_TUNNEL);
+  writeFileSync(p, s);
   log("patched client.ts (tunnel Supabase through the guard)");
 }
 function patchStart(cwd) {
   const p = join(cwd, "src/start.ts");
-  let s = read(p);
+  let s = readFileSync(p, "utf8");
+  if (s.includes("patchstackGuard")) {
+    log("start.ts already wired");
+    return;
+  }
   const importAnchor = 'import { createStart, createMiddleware } from "@tanstack/react-start";';
   const exportAnchor = "export const startInstance";
   const rmAnchor = "requestMiddleware: [";
-  if (!s.includes(importAnchor) || !s.includes(exportAnchor)) {
-    return log("start.ts anchors not found \u2014 skipping (template changed?)");
-  }
-  const original = s;
-  if (!s.includes("@/integrations/patchstack/guard")) {
-    s = s.replace(importAnchor, importAnchor + "\n" + START_IMPORTS);
-  } else if (!s.includes("inspectServerFn")) {
-    s = s.replace(
-      'import { GUARD_PATH, handleGuardRequest } from "@/integrations/patchstack/guard";',
-      'import { GUARD_PATH, handleGuardRequest, inspectServerFn } from "@/integrations/patchstack/guard";'
-    );
-  }
-  if (!s.includes("const patchstackGuard =")) {
-    s = s.replace(exportAnchor, REQUEST_MIDDLEWARE_DEF + "\n" + exportAnchor);
-  }
-  if (!s.includes("const patchstackFunctionGuard =")) {
-    s = s.replace(exportAnchor, FUNCTION_MIDDLEWARE_DEF + "\n" + exportAnchor);
-  }
-  if (s.includes(rmAnchor) && !s.includes("requestMiddleware: [patchstackGuard")) {
-    s = s.replace(rmAnchor, rmAnchor + "patchstackGuard, ");
-  }
-  if (!s.includes("functionMiddleware: [patchstackFunctionGuard")) {
-    const fmAnchor = "functionMiddleware: [";
-    if (s.includes(fmAnchor)) {
-      s = s.replace(fmAnchor, fmAnchor + "patchstackFunctionGuard, ");
-    } else if (s.includes(rmAnchor)) {
-      s = s.replace(rmAnchor, "functionMiddleware: [patchstackFunctionGuard],\n    " + rmAnchor);
-    }
+  if (!s.includes(importAnchor) || !s.includes(exportAnchor) || !s.includes(rmAnchor)) {
+    log("start.ts anchors not found (template changed?) \u2014 skipping start patch");
+    return;
   }
-  if (s === original) return log("start.ts already wired");
+  s = s.replace(importAnchor, importAnchor + "\n" + START_IMPORTS);
+  s = s.replace(exportAnchor, START_MIDDLEWARE + "\n" + exportAnchor);
+  s = s.replace(rmAnchor, rmAnchor + "patchstackGuard, ");
   writeFileSync(p, s);
-  log("patched start.ts (guard registered as request + function middleware)");
+  log("patched start.ts (registered the guard as request middleware)");
+}
+function wirePrebuild(cwd) {
+  const p = join(cwd, "package.json");
+  const pkg = JSON.parse(readFileSync(p, "utf8"));
+  pkg.scripts = pkg.scripts || {};
+  const step = "patchstack-connect protect --manifest";
+  const prebuild = pkg.scripts.prebuild || "";
+  if (prebuild.includes(step)) {
+    log("prebuild already refreshes the manifest");
+    return;
+  }
+  pkg.scripts.prebuild = prebuild ? prebuild + " && " + step : step;
+  writeFileSync(p, JSON.stringify(pkg, null, 2) + "\n");
+  log("wired manifest refresh into prebuild");
 }
-function runProtect(cwd) {
+function runProtect(cwd, opts = {}) {
+  if (opts.manifestOnly) {
+    generateManifest(cwd);
+    return;
+  }
   if (!detectSupportedStack(cwd)) {
-    log("runtime protection currently supports TanStack Start + Supabase apps; stack not detected \u2014 skipping.");
+    log(
+      "runtime protection currently supports TanStack Start + Supabase apps; stack not detected \u2014 skipping."
+    );
     return;
   }
   scaffold(cwd);
   patchClient(cwd);
   patchStart(cwd);
+  generateManifest(cwd);
+  wirePrebuild(cwd);
   log("done \u2014 guard wired and always-on (blocks by default). Set PATCHSTACK_MODE=dry-run for log-only.");
 }
 
@@ -1294,8 +1407,11 @@ Usage:
   patchstack-connect status [options]                Show current configuration
   patchstack-connect mark-build [options]            Stamp built HTML with a production flag +
                                                      build fingerprint (run as a postbuild step)
-  patchstack-connect protect                         Install always-on runtime protection (the
-                                                     guard) into a TanStack Start + Supabase app.
+  patchstack-connect protect [--manifest]            Install runtime protection (the guard) into
+                                                     a server-side JS app. --manifest only
+                                                     regenerates the package manifest (prebuild).
+  patchstack-connect guide                           Print the full setup guide for AI coding
+                                                     agents (also at https://patchstack.com/install.txt)
   patchstack-connect help                            Print this message
 
 Options (for scan and status):
@@ -1433,14 +1549,19 @@ async function runScan(args) {
   }
   return 0;
 }
-async function runProtectCommand(_args) {
+async function runProtectCommand(args) {
   try {
-    runProtect(process.cwd());
+    runProtect(process.cwd(), { manifestOnly: args.flags.get("manifest") === true });
   } catch (err) {
     console.warn(`patchstack protect: skipped (${err.message}).`);
   }
   return 0;
 }
+async function runGuide() {
+  const guidePath = new URL("../AGENT-INSTALL.md", import.meta.url);
+  console.log(readFileSync2(guidePath, "utf8"));
+  return 0;
+}
 async function runStatus(args) {
   const config = await resolveConfig({
     cwd: process.cwd(),
@@ -1456,9 +1577,19 @@ async function runStatus(args) {
   }
   return 0;
 }
+function describeStack(stack) {
+  const parts = [stack.builder, stack.framework, stack.ui, stack.runtime].filter(
+    (part) => part !== null
+  );
+  if (stack.hostingEnvKeys.length > 0) {
+    parts.push(`${stack.hostingEnvKeys.length} hosting env key(s)`);
+  }
+  return parts.length > 0 ? parts.join(" \xB7 ") : null;
+}
 async function runMarkBuild(args) {
   const cwd = process.cwd();
   let checksum = null;
+  let stack = null;
   try {
     const manifest = await scanLockfile(cwd);
     for (const warning of manifest.warnings ?? []) {
@@ -1466,6 +1597,7 @@ async function runMarkBuild(args) {
     }
     const { payload } = buildWirePayload(manifest);
     checksum = computeManifestChecksum(payload.packages);
+    stack = detectStack(payload.packages);
   } catch (err) {
     console.warn(
       `mark-build: could not compute the build fingerprint (${err.message}). Stamping the production flag only.`
@@ -1483,7 +1615,7 @@ async function runMarkBuild(args) {
     console.warn(`mark-build: no HTML files found under ${dir}. Nothing to mark.`);
     return 0;
   }
-  const snippet = buildInjectionSnippet(checksum);
+  const snippet = buildInjectionSnippet(checksum, stack);
   let marked = 0;
   for (const file of files) {
     const before = readFileSync2(file, "utf8");
@@ -1493,8 +1625,9 @@ async function runMarkBuild(args) {
       marked += 1;
     }
   }
+  const stackSummary = stack !== null ? describeStack(stack) : null;
   console.log(
-    `mark-build: marked ${marked} HTML file(s) in ${dir}${checksum !== null ? ` (build ${checksum})` : ""}.`
+    `mark-build: marked ${marked} HTML file(s) in ${dir}${checksum !== null ? ` (build ${checksum})` : ""}${stackSummary !== null ? ` [${stackSummary}]` : ""}.`
   );
   return 0;
 }
@@ -1515,6 +1648,8 @@ async function main() {
       return runMarkBuild(args);
     case "protect":
       return runProtectCommand(args);
+    case "guide":
+      return runGuide();
     default:
       console.error(`Unknown command: ${args.command}
 `);