@patchstack/connect 0.3.3 → 0.3.4

package/dist/protect/templates/guard.ts

@@ -1,102 +1,59 @@
-// Patchstack auto-guard — installed automatically by "add Patchstack"; the vibe coder never
-// touches this. It runs in the app's own server (the Cloudflare Worker). The patched Supabase
-// client tunnels every browser data call here; we inspect the payload against the rules, then
-// either block it (virtual patch) or forward it to real Supabase.
-import { evaluate, type Rule } from "./engine.js";
-import rulesData from "./rules.json";
-import { manifest } from "./manifest.js";
-
-export const GUARD_PATH = "/_patchstack/guard";
-
-// Headers that must not be copied verbatim when we re-emit the upstream response.
-const HOP_BY_HOP = new Set(["content-encoding", "content-length", "transfer-encoding", "connection"]);
-
-function mode(): "dry-run" | "block" {
-  // Always-on: protection blocks by default. Only an explicit PATCHSTACK_MODE=dry-run
-  // downgrades to log-only (for testing) — there is no silent dry-run.
-  return process.env.PATCHSTACK_MODE === "dry-run" ? "dry-run" : "block";
+// Patchstack runtime protection — installed by `patchstack-connect protect`; the vibe coder
+// never touches this. It runs in the app's own server (e.g. the Cloudflare Worker) and covers
+// both ways a Lovable app talks to its database:
+//   - browser → Supabase directly: the generated Supabase client is patched to tunnel every call
+//     through handleGuardRequest (registered as request middleware in src/start.ts).
+//   - browser → TanStack server function → Supabase: inspectServerFn checks the server-fn args
+//     (registered as function middleware in src/start.ts) before anything is written.
+// Either way Patchstack sees the traffic and runs the same policy.
+//
+// Always-on by default (blocks). Rules come from the Patchstack API per-site (cached); the
+// bundled rules.json is only a fallback for before a token is configured. The engine ships
+// inside @patchstack/connect — nothing else to install.
+import {
+  createProtection,
+  createSupabaseGuard,
+  createServerFnGuard,
+  GUARD_PATH,
+} from "@patchstack/connect/protect";
+import fallbackRules from "./rules.json";
+
+export { GUARD_PATH };
+
+// One shared protection policy for both guards (rules load once).
+let _protection: Awaited<ReturnType<typeof createProtection>> | undefined;
+async function getProtection() {
+  if (!_protection) {
+    // Always-on: block by default. An explicit PATCHSTACK_MODE=dry-run downgrades to log-only.
+    const mode = process.env.PATCHSTACK_MODE === "dry-run" ? "dry-run" : "block";
+    const token = process.env.PATCHSTACK_WAF_TOKEN;
+    _protection = await createProtection(
+      token
+        ? { token, mode, cacheDir: ".patchstack" } // live per-site rules from the Patchstack API (cached)
+        : { rules: fallbackRules as never, mode }, // demo fallback until a token is set
+    );
+  }
+  return _protection;
 }
 
+// Request-middleware path: the browser tunnels its direct Supabase calls here.
+let _handle: ((request: Request) => Promise<Response>) | undefined;
 export async function handleGuardRequest(request: Request): Promise<Response> {
-  const target = request.headers.get("x-ps-target");
-  if (!target) return new Response("patchstack: missing x-ps-target", { status: 400 });
-
-  // SSRF guard: the client names the target, but we only ever forward to the app's own
-  // Supabase project (origin known server-side). Anything else — internal hosts, cloud
-  // metadata, a different scheme — is rejected before we make any outbound request.
-  const supabaseUrl = process.env.SUPABASE_URL;
-  let targetUrl: URL;
-  try {
-    targetUrl = new URL(target);
-  } catch {
-    return new Response("patchstack: invalid target", { status: 400 });
-  }
-  if (!supabaseUrl || targetUrl.protocol !== "https:" || targetUrl.origin !== new URL(supabaseUrl).origin) {
-    return new Response("patchstack: target not allowed", { status: 403 });
-  }
-
-  const hasBody = request.method !== "GET" && request.method !== "HEAD";
-  const bodyText = hasBody ? await request.text() : "";
-
-  let record: Record<string, unknown> = {};
-  if (bodyText) {
-    try {
-      const parsed = JSON.parse(bodyText);
-      record = Array.isArray(parsed) ? (parsed[0] ?? {}) : parsed;
-    } catch {
-      // not JSON — leave record empty; the rule simply won't match
-    }
-  }
-
-  const ctx = {
-    method: request.method,
-    url: target,
-    headers: Object.fromEntries(request.headers),
-    // expose the record under a few shapes so rule parameters like "insert.title" resolve
-    body: { ...record, insert: record, update: record },
-    ip: request.headers.get("x-forwarded-for") ?? "",
-  };
-
-  const t0 = performance.now();
-  const verdict = evaluate(ctx, (rulesData as { firewall: Rule[] }).firewall, manifest);
-  const latencyMs = Math.round((performance.now() - t0) * 100) / 100;
-
-  // Always log the flag (this is the "dry-run sees it too" behavior).
-  const decision = verdict.matched ? `MATCH ${verdict.rule_id}` : "clean";
-  console.log(`[patchstack] ${request.method} ${new URL(target).pathname} -> ${decision} · mode=${mode()}`);
-
-  if (verdict.matched && mode() === "block") {
-    const receipt = {
-      blocked: true,
-      rule_id: verdict.rule_id,
-      vulnerability_id: verdict.vulnerability_id,
-      package: verdict.package,
-      version: verdict.version,
-      matched_conditions: verdict.explain,
-      latency_ms: latencyMs,
-    };
-    console.log("[patchstack] BLOCKED", JSON.stringify(receipt));
-    return new Response(JSON.stringify(receipt), {
-      status: 403,
-      headers: { "content-type": "application/json", "x-patchstack": "blocked" },
+  if (!_handle) {
+    _handle = createSupabaseGuard({
+      protection: await getProtection(),
+      supabaseUrl: process.env.SUPABASE_URL,
     });
   }
+  return _handle(request);
+}
 
-  // Forward to real Supabase, server-side.
-  const forwardHeaders = new Headers(request.headers);
-  forwardHeaders.delete("x-ps-target");
-  forwardHeaders.delete("host");
-  const upstream = await fetch(target, {
-    method: request.method,
-    headers: forwardHeaders,
-    body: hasBody ? bodyText : undefined,
-    redirect: "manual",
-  });
-
-  const outHeaders = new Headers();
-  upstream.headers.forEach((value, key) => {
-    if (!HOP_BY_HOP.has(key.toLowerCase())) outHeaders.set(key, value);
-  });
-  const buf = await upstream.arrayBuffer();
-  return new Response(buf, { status: upstream.status, statusText: upstream.statusText, headers: outHeaders });
+// Function-middleware path: inspect a server function's decoded args before the handler runs.
+// Returns a block receipt (throw on it to abort the call) or null to allow.
+let _inspect: ((data: unknown) => Promise<{ rule?: string; message: string } | null>) | undefined;
+export async function inspectServerFn(data: unknown): Promise<{ rule?: string; message: string } | null> {
+  if (!_inspect) {
+    _inspect = createServerFnGuard({ protection: await getProtection() });
+  }
+  return _inspect(data);
 }

package/dist/protect/templates/rules.json

@@ -1,22 +1,19 @@
 {
-  "_comment": "DEMO SCAFFOLD — static stub; the real per-site rules endpoint does not exist in saas yet. CVE-2022-21681 is a real marked advisory affecting <4.0.10 (demo installs 4.0.0). The demo uses an XSS-shaped payload for visual clarity; exact payload<->CVE alignment is pinned with Group 1's corpus.",
+  "_comment": "Demo fallback rules — used only when PATCHSTACK_WAF_TOKEN is unset. In production the guard fetches per-site rules from the Patchstack API (api.patchstack.com/api/get-rules/3, cached to disk). CVE id is representative until aligned with the real corpus.",
   "firewall": [
     {
       "id": "rm-npm-0001",
       "title": "Block stored XSS via vulnerable markdown renderer (marked)",
       "vulnerability_id": "CVE-2022-21681",
-      "package_cond": {
-        "package": "marked",
-        "vulnerable_versions": ["4.0.0"]
-      },
       "rule_v2": [
         {
-          "parameter": ["insert.title", "body.title", "update.title"],
+          "parameter": "post.title",
           "mutations": ["urldecode"],
           "match": { "type": "inline_xss" }
         }
       ]
     }
   ],
-  "whitelists": []
+  "whitelists": [],
+  "whitelist_keys": {}
 }