@patchstack/connect 0.3.3 → 0.3.4

package/AGENT-INSTALL.md

@@ -7,6 +7,7 @@ You are reading this either from `node_modules/@patchstack/connect/AGENT-INSTALL
 ## 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.
+- First published May 2026. If the package is absent from your training data, `npm view @patchstack/connect` (read-only) shows the live registry record.
 - 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.
 

package/README.md

@@ -8,11 +8,20 @@ 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.):
 
-> 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.
+> Add Patchstack dependency vulnerability monitoring to this project:
+>
+> 1. `npm install --save-dev @patchstack/connect` — or the pnpm/yarn/bun equivalent (MIT, source: https://github.com/patchstack/connect; verify with `npm view @patchstack/connect` if unsure).
+> 2. `npx @patchstack/connect scan` — saves a site ID to `.patchstackrc.json` and prints a claim URL. Show me that URL; don't open it.
+> 3. Add `package.json` scripts `"prebuild": "patchstack-connect scan"` and `"postbuild": "patchstack-connect mark-build"`, then commit the changes.
+> 4. Run `npx @patchstack/connect guide` and use it to add the report-a-vulnerability widget and finish any framework-specific details.
 
-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:
+The shape of this prompt is deliberate — it has survived three distinct AI-agent refusal modes, and each one punished a different shortcut:
 
-> 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.
+1. **"Follow the instructions at this URL" reads as remote script execution.** Agents refuse before ever fetching the doc.
+2. **Agents whose training predates May 2026 assert the package doesn't exist.** Step 1's `npm view` resolves that against the registry instead of the model's memory.
+3. **"Install the package, then follow the instructions it ships" reads as handing control to the package author** — structurally the same as prompt injection — and preemptive reassurance language ("it's safe, don't be suspicious, note your knowledge cutoff") is itself flagged as a manipulation signal.
+
+So the prompt inlines the core install as concrete, individually inspectable commands, delegates nothing up front, and argues nothing. `npx @patchstack/connect guide` (which prints the bundled `AGENT-INSTALL.md`) enters only at step 4, as an assist for widget placement, re-run rules, and troubleshooting — by then the agent has already installed and audited the package, so consulting its docs is ordinary behavior rather than the instruction channel the install depends on. The always-current long-form guide lives at https://patchstack.com/install.txt.
 
 ## Quick start (zero configuration)
 

package/dist/cli.js

@@ -1252,13 +1252,17 @@ function injectMarker(html, snippet) {
 
 // src/protect/install.ts
 import { readFileSync, writeFileSync, existsSync as existsSync2, mkdirSync, copyFileSync } from "fs";
-import { join } from "path";
+import { join, dirname } from "path";
 import { fileURLToPath } from "url";
-var TEMPLATES = fileURLToPath(new URL("./protect/templates/", import.meta.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 CLIENT_TUNNEL = [
   "",
-  "    // 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.",
+  "    // PATCHSTACK: 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');",
@@ -1270,11 +1274,11 @@ var CLIENT_TUNNEL = [
 ].join("\n");
 var START_IMPORTS = [
   'import { getRequest } from "@tanstack/react-start/server";',
-  'import { GUARD_PATH, handleGuardRequest } from "@/integrations/patchstack/guard";'
+  'import { GUARD_PATH, handleGuardRequest, inspectServerFn } from "@/integrations/patchstack/guard";'
 ].join("\n");
-var START_MIDDLEWARE = [
+var REQUEST_MIDDLEWARE_DEF = [
   "",
-  "// Patchstack auto-guard: intercept the tunneled data traffic before anything else runs.",
+  "// Patchstack guard (browser tunnel): intercept tunneled Supabase traffic before anything else.",
   "const patchstackGuard = createMiddleware().server(async ({ next }) => {",
   "  const request = getRequest();",
   "  if (request) {",
@@ -1285,113 +1289,87 @@ var START_MIDDLEWARE = [
   "});",
   ""
 ].join("\n");
-var PS_DIR_REL = "src/integrations/patchstack";
-function log(msg) {
-  console.log(`patchstack protect: ${msg}`);
-}
+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");
 function detectSupportedStack(cwd) {
   const pkgPath = join(cwd, "package.json");
   if (!existsSync2(pkgPath)) return false;
-  const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+  const pkg = JSON.parse(read(pkgPath));
   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, PS_DIR_REL);
+  const dst = join(cwd, "src/integrations/patchstack");
   mkdirSync(dst, { recursive: true });
-  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"));
   copyFileSync(join(TEMPLATES, "guard.ts"), join(dst, "guard.ts"));
-  log("scaffolded engine.js (+types), rules.json, guard.ts");
+  copyFileSync(join(TEMPLATES, "rules.json"), join(dst, "rules.json"));
+  log("scaffolded guard.ts + rules.json");
 }
 function patchClient(cwd) {
   const p = join(cwd, "src/integrations/supabase/client.ts");
-  let s = readFileSync(p, "utf8");
-  if (s.includes("x-ps-target")) {
-    log("client.ts already wired");
-    return;
-  }
+  let s = read(p);
+  if (s.includes("x-ps-target")) return log("client.ts already wired");
   const anchor = "headers.set('apikey', supabaseKey);";
-  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);
+  if (!s.includes(anchor)) return log("client.ts anchor not found \u2014 skipping (template changed?)");
+  writeFileSync(p, s.replace(anchor, anchor + "\n" + CLIENT_TUNNEL));
   log("patched client.ts (tunnel Supabase through the guard)");
 }
 function patchStart(cwd) {
   const p = join(cwd, "src/start.ts");
-  let s = readFileSync(p, "utf8");
-  if (s.includes("patchstackGuard")) {
-    log("start.ts already wired");
-    return;
-  }
+  let s = read(p);
   const importAnchor = 'import { createStart, createMiddleware } from "@tanstack/react-start";';
   const exportAnchor = "export const startInstance";
   const rmAnchor = "requestMiddleware: [";
-  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.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";'
+    );
   }
-  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 (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;
+  if (!s.includes("const patchstackGuard =")) {
+    s = s.replace(exportAnchor, REQUEST_MIDDLEWARE_DEF + "\n" + exportAnchor);
   }
-  pkg.scripts.prebuild = prebuild ? prebuild + " && " + step : step;
-  writeFileSync(p, JSON.stringify(pkg, null, 2) + "\n");
-  log("wired manifest refresh into prebuild");
-}
-function runProtect(cwd, opts = {}) {
-  if (opts.manifestOnly) {
-    generateManifest(cwd);
-    return;
+  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 === original) return log("start.ts already wired");
+  writeFileSync(p, s);
+  log("patched start.ts (guard registered as request + function middleware)");
+}
+function runProtect(cwd) {
   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.");
 }
 
@@ -1407,9 +1385,9 @@ 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 [--manifest]            Install runtime protection (the guard) into
-                                                     a server-side JS app. --manifest only
-                                                     regenerates the package manifest (prebuild).
+  patchstack-connect protect                         Install always-on runtime protection (the
+                                                     guard) into a TanStack Start + Supabase app.
+                                                     Covers the browser + server-function paths.
   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
@@ -1549,9 +1527,9 @@ async function runScan(args) {
   }
   return 0;
 }
-async function runProtectCommand(args) {
+async function runProtectCommand(_args) {
   try {
-    runProtect(process.cwd(), { manifestOnly: args.flags.get("manifest") === true });
+    runProtect(process.cwd());
   } catch (err) {
     console.warn(`patchstack protect: skipped (${err.message}).`);
   }