@patchstack/connect 0.3.11 → 0.3.13

package/dist/protect/templates/guard.ts

@@ -5,7 +5,9 @@
 //     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.
+// Either way Patchstack sees the traffic and runs the same policy. It also screens the app's own
+// OUTBOUND calls for SSRF (egress: true wraps the global fetch) — blocking requests to internal /
+// cloud-metadata addresses while allowing the app's own Supabase project.
 //
 // 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
@@ -18,6 +20,9 @@ import {
 } from "@patchstack/connect/protect";
 import fallbackRules from "./rules.json";
 
+// Baked by `patchstack-connect protect` from .patchstackrc.json (empty if the app isn't scanned yet).
+const PS_SITE_UUID = "__PATCHSTACK_SITE_UUID__";
+
 export { GUARD_PATH };
 
 // One shared protection policy for both guards (rules load once).
@@ -27,10 +32,22 @@ async function getProtection() {
     // 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;
+    const siteUuid = PS_SITE_UUID.startsWith("__") ? process.env.PATCHSTACK_SITE_UUID : PS_SITE_UUID;
+    // Egress SSRF screening: block the app's outbound calls to internal / metadata addresses,
+    // but never its own Supabase project.
+    let allowHosts: string[] = [];
+    try {
+      if (process.env.SUPABASE_URL) allowHosts = [new URL(process.env.SUPABASE_URL).host];
+    } catch {
+      /* ignore a malformed SUPABASE_URL — just don't add an allow entry */
+    }
+    const common = { mode, egress: true, allowHosts };
     _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
+      siteUuid
+        ? { ...common, siteUuid, rules: fallbackRules as never, cacheDir: ".patchstack" } // live per-site rules; bundled = offline fallback
+        : token
+          ? { ...common, token, cacheDir: ".patchstack" } // live per-site WAF rules from the Patchstack API (cached)
+          : { ...common, rules: fallbackRules as never }, // demo fallback until a site UUID / token is set
     );
   }
   return _protection;
@@ -57,3 +74,18 @@ export async function inspectServerFn(data: unknown): Promise<{ rule?: string; m
   }
   return _inspect(data);
 }
+
+// Response phase: redact leaked secrets / PII (private keys, cloud keys, JWTs, DB URLs, …) from an
+// outgoing response before it leaves the server. Applied to the SSR / non-tunnel response in
+// src/start.ts (the browser→Supabase tunnel screens its own forwarded response). Only acts on a
+// web Response (text/JSON/HTML) — anything else, or any error, passes through untouched (fail-open,
+// never breaks a response).
+export async function screenResponse(response: unknown): Promise<unknown> {
+  try {
+    if (!(response instanceof Response)) return response;
+    const protection = await getProtection();
+    return protection.screenResponse ? await protection.screenResponse(response) : response;
+  } catch {
+    return response; // fail open
+  }
+}

package/dist/protect/templates/rules.json

@@ -1,17 +1,44 @@
 {
-  "_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.",
+  "_comment": "Starter fallback rules — used ONLY when PATCHSTACK_WAF_TOKEN is unset. The guard blocks by default, so these are deliberately HIGH-PRECISION signatures (structural markers legitimate traffic doesn't carry) to avoid false positives before a token is configured. Once a token is set the guard fetches the per-site, version-scoped corpus from the Patchstack API (api.patchstack.com/api/get-rules/3, cached to disk) and this file is no longer used. For a broad, many-class DEMONSTRATION (SQLi/XSS/XXE/SSRF/PII/…), seed this file from examples/protect/demo-rules.json — see that folder's README.",
   "firewall": [
     {
-      "id": "rm-npm-0001",
-      "title": "Block stored XSS via vulnerable markdown renderer (marked)",
-      "vulnerability_id": "CVE-2022-21681",
+      "id": "ps-fallback-proto-pollution",
+      "title": "Prototype pollution in request body",
+      "category": "prototype-pollution",
       "rule_v2": [
+        { "parameter": "raw", "mutations": ["urldecode"], "match": { "type": "contains", "value": "__proto__" } },
         {
-          "parameter": "post.title",
-          "mutations": ["urldecode"],
-          "match": { "type": "inline_xss" }
+          "parameter": "rules",
+          "rules": [
+            { "parameter": "raw", "mutations": ["urldecode"], "match": { "type": "contains", "value": "constructor" }, "inclusive": true },
+            { "parameter": "raw", "mutations": ["urldecode"], "match": { "type": "contains", "value": "prototype" }, "inclusive": true }
+          ]
         }
       ]
+    },
+    {
+      "id": "ps-fallback-path-traversal",
+      "title": "Path traversal in a file/path parameter",
+      "category": "lfi",
+      "rule_v2": [
+        { "parameter": ["get.file", "post.file", "raw.file", "get.path", "post.path"], "mutations": ["urldecode"], "match": { "type": "contains", "value": ".." } }
+      ]
+    },
+    {
+      "id": "ps-fallback-ssrf-internal",
+      "title": "SSRF via a url parameter pointing at an internal/metadata address",
+      "category": "ssrf",
+      "rule_v2": [
+        { "parameter": ["get.url", "post.url", "raw.url"], "mutations": ["urldecode"], "match": { "type": "regex", "value": "/localhost|127\\.0\\.0\\.1|169\\.254\\.169\\.254|::1|metadata\\.google/i" } }
+      ]
+    },
+    {
+      "id": "ps-fallback-xss",
+      "title": "Stored/reflected XSS in a text field",
+      "category": "xss",
+      "rule_v2": [
+        { "parameter": ["post.title", "post.comment", "post.body"], "mutations": ["urldecode", "htmlentitydecode"], "match": { "type": "regex", "value": "/<script\\b|onerror\\s*=|javascript:/i" } }
+      ]
     }
   ],
   "whitelists": [],

package/dist/protect.cjs

@@ -21,6 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var runtime_exports = {};
 __export(runtime_exports, {
   GUARD_PATH: () => GUARD_PATH,
+  PulseRuleClient: () => PulseRuleClient,
   createProtection: () => createProtection,
   createServerFnGuard: () => createServerFnGuard,
   createSupabaseGuard: () => createSupabaseGuard
@@ -928,6 +929,64 @@ var RuleEngine = class {
   }
 };
 
+// src/protect/engine/pulse-client.js
+var DEFAULT_BASE_URL2 = "https://api.patchstack.com/monitor/pulse";
+var DEFAULT_CACHE_TTL2 = 3e5;
+var PulseRuleClient = class {
+  #siteUuid;
+  #baseUrl;
+  #cacheTtl;
+  #cache = null;
+  #cacheTime = null;
+  constructor({ siteUuid, baseUrl, cacheTtl } = {}) {
+    this.#siteUuid = siteUuid ?? process.env.PATCHSTACK_SITE_UUID;
+    this.#baseUrl = baseUrl ?? process.env.PATCHSTACK_PULSE_RULES_URL ?? DEFAULT_BASE_URL2;
+    this.#cacheTtl = cacheTtl ?? DEFAULT_CACHE_TTL2;
+    if (!this.#siteUuid) {
+      throw new Error("Patchstack site UUID is required. Pass { siteUuid } or set PATCHSTACK_SITE_UUID.");
+    }
+  }
+  async getRules() {
+    const now = Date.now();
+    if (this.#cache && this.#cacheTime && now - this.#cacheTime < this.#cacheTtl) {
+      return this.#cache;
+    }
+    const url = `${this.#baseUrl}/rules/${encodeURIComponent(this.#siteUuid)}`;
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: { Accept: "application/json" },
+        signal: AbortSignal.timeout(3e4)
+      });
+      if (!response.ok) {
+        return { success: false, error: `API returned ${response.status}`, firewall: [], whitelists: [], whitelist_keys: {} };
+      }
+      const data = await response.json();
+      const result = {
+        success: true,
+        firewall: Array.isArray(data.firewall) ? data.firewall : [],
+        whitelists: Array.isArray(data.whitelists) ? data.whitelists : [],
+        whitelist_keys: data.whitelist_keys ?? {}
+      };
+      this.#cache = result;
+      this.#cacheTime = now;
+      return result;
+    } catch (err) {
+      return {
+        success: false,
+        error: err.name === "TimeoutError" ? "Request timed out" : err.message,
+        firewall: [],
+        whitelists: [],
+        whitelist_keys: {}
+      };
+    }
+  }
+  clearCache() {
+    this.#cache = null;
+    this.#cacheTime = null;
+  }
+};
+
 // src/protect/engine/fetch.js
 async function fromFetchRequest(request) {
   const url = new URL(request.url);
@@ -1550,8 +1609,25 @@ function leakResponse() {
   });
 }
 async function resolveRules(options) {
-  if (options.rules) {
-    return normalizeBundle(options.rules);
+  if (options.siteUuid) {
+    const client = new PulseRuleClient({ siteUuid: options.siteUuid, baseUrl: options.pulseRulesUrl });
+    const res = await client.getRules();
+    if (res.success) {
+      const bundle = normalizeBundle(res);
+      cacheWrite(options.cacheDir, bundle);
+      return bundle;
+    }
+    const cached = cacheRead(options.cacheDir);
+    if (cached) {
+      options.onError?.(new Error(`pulse rule fetch failed (${res.error}); using cached bundle`));
+      return normalizeBundle(cached);
+    }
+    if (options.rules) {
+      options.onError?.(new Error(`pulse rule fetch failed (${res.error}); using bundled fallback`));
+      return normalizeBundle(options.rules);
+    }
+    options.onError?.(new Error(`pulse rule fetch failed (${res.error}); no cache \u2014 running with no rules`));
+    return emptyBundle();
   }
   if (options.token) {
     const client = new PatchstackRuleClient({ token: options.token, baseUrl: options.baseUrl });
@@ -1569,6 +1645,9 @@ async function resolveRules(options) {
     options.onError?.(new Error(`rule fetch failed (${res.error}); no cache \u2014 running with no rules`));
     return emptyBundle();
   }
+  if (options.rules) {
+    return normalizeBundle(options.rules);
+  }
   return emptyBundle();
 }
 function normalizeBundle(b) {
@@ -1620,6 +1699,7 @@ function defaultOnDetect({ phase, mode, category, rule, message }) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   GUARD_PATH,
+  PulseRuleClient,
   createProtection,
   createServerFnGuard,
   createSupabaseGuard