agent402-tollbooth 0.3.0 → 0.3.1

package/dashboard.js

@@ -43,10 +43,15 @@ const cards=[
 async function tick(){
   try{
     const s=await (await fetch("/__tollbooth/stats",{cache:"no-store"})).json();
+    // Counters are always numbers — coerce, never trust raw JSON from the
+    // configured stats endpoint (a compromised collector with httpStatsSink
+    // could otherwise inject HTML through this innerHTML sink).
     document.getElementById("grid").innerHTML=cards.map(function(c){
       var k=c[0],label=c[1],acc=c[2];
-      if(k==="wouldCharge" && !(s.wouldCharge>0) && !s.observe) return "";
-      return '<div class="card"><div class="k">'+label+'</div><div class="v '+(acc||"")+'">'+(s[k]??0)+'</div></div>';
+      if(k==="wouldCharge" && !(Number(s.wouldCharge)>0) && !s.observe) return "";
+      var v=Number(s[k]); if(!Number.isFinite(v)) v=0;
+      var lbl=String(label).replace(/[&<>"']/g,function(ch){return({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'})[ch];});
+      return '<div class="card"><div class="k">'+lbl+'</div><div class="v '+(acc||"")+'">'+v+'</div></div>';
     }).join("");
     var botish=(s.charged||0)+(s.wouldCharge||0);
     var pct=s.requests?Math.round((botish/s.requests)*100):0;

package/edge.js

@@ -146,7 +146,12 @@ export function createEdgeTollbooth(config = {}) {
   const mem = memorySink();
   const sink = statsSink || mem;
   const writeThrough = statsSink && statsSink !== mem;
-  const incr = (k, n = 1) => { mem.incr(k, n); if (writeThrough) sink.incr(k, n); };
+  // Stats must never break a request path — a buggy custom sink can throw
+  // synchronously; we shrug and continue.
+  const incr = (k, n = 1) => {
+    try { mem.incr(k, n); } catch { /* ignore */ }
+    if (writeThrough) { try { sink.incr(k, n); } catch { /* ignore */ } }
+  };
 
   const looksHuman = (request) => {
     const ua = request.headers.get("user-agent") || "";
@@ -195,6 +200,8 @@ export function createEdgeTollbooth(config = {}) {
   gate.observe = observe;
   gate.stats = () => ({ ...mem.snapshot(), observe });
   gate.snapshot = async () => ({ ...(await sink.snapshot()), observe });
-  gate.flush = () => Promise.resolve(sink.flush && sink.flush());
+  // flush() is typically wired to ctx.waitUntil — swallow errors so a sink
+  // outage can't surface as an unhandled rejection after the response.
+  gate.flush = async () => { try { if (sink.flush) await sink.flush(); } catch { /* ignore */ } };
   return gate;
 }

package/index.js

@@ -96,7 +96,12 @@ export function createTollbooth(config = {}) {
   const mem = memorySink();
   const sink = statsSink || mem;
   const writeThrough = statsSink && statsSink !== mem;
-  const incr = (k, n = 1) => { mem.incr(k, n); if (writeThrough) sink.incr(k, n); };
+  // Never let a buggy custom sink throw inside the request path — stats are
+  // non-critical and must not be able to break a payment decision.
+  const incr = (k, n = 1) => {
+    try { mem.incr(k, n); } catch { /* ignore */ }
+    if (writeThrough) { try { sink.incr(k, n); } catch { /* ignore */ } }
+  };
 
   const looksHuman = (req) => {
     const ua = req.headers["user-agent"] || "";
@@ -190,7 +195,10 @@ export function createTollbooth(config = {}) {
   // .stats() is sync (in-process mirror). .snapshot() is async (durable sink).
   tollbooth.stats = () => ({ ...mem.snapshot(), difficultyNow: difficultyNow(), observe });
   tollbooth.snapshot = async () => ({ ...(await sink.snapshot()), difficultyNow: difficultyNow(), observe });
-  tollbooth.flush = () => Promise.resolve(sink.flush && sink.flush());
+  // Swallow flush errors — flush() is typically wired to ctx.waitUntil on the
+  // edge; an unhandled rejection there pollutes logs without affecting the
+  // already-sent response.
+  tollbooth.flush = async () => { try { if (sink.flush) await sink.flush(); } catch { /* ignore */ } };
   return tollbooth;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent402-tollbooth",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Open-source, self-hostable x402 pay-per-crawl tollbooth: charge AI bots per request (USDC via x402, or free proof-of-work) while humans browse free. Drop-in Express middleware or reverse proxy — no Cloudflare, no Stripe, no signup.",
   "type": "module",
   "main": "index.js",

package/sinks.js

@@ -16,14 +16,24 @@
 // Want strong consistency on Cloudflare? Back it with a Durable Object that
 // implements the same { incr, snapshot } interface and pass it as `statsSink`.
 
-const ZERO = () => ({
-  requests: 0,
-  freeAllowed: 0,
-  wouldCharge: 0,
-  charged: 0,
-  powSolved: 0,
-  x402Paid: 0,
-});
+const KNOWN_FIELDS = ["requests", "freeAllowed", "wouldCharge", "charged", "powSolved", "x402Paid"];
+const ZERO = () => Object.fromEntries(KNOWN_FIELDS.map((k) => [k, 0]));
+
+// Filter an untrusted JSON blob (KV value or HTTP collector response) to only
+// the known numeric counters. Prevents a compromised store from injecting
+// arbitrary keys or non-numeric values that downstream renderers (e.g.
+// dashboard.js) might treat as HTML. Defense in depth — the dashboard also
+// coerces, but trim at the boundary.
+const sanitize = (obj) => {
+  const out = ZERO();
+  if (!obj || typeof obj !== "object") return out;
+  for (const k of KNOWN_FIELDS) {
+    const v = Number(obj[k]);
+    if (Number.isFinite(v) && v >= 0) out[k] = v;
+  }
+  if (typeof obj.since === "string" && obj.since.length < 64) out.since = obj.since;
+  return out;
+};
 
 /** In-process counter. Synchronous; loses state on restart. */
 export function memorySink() {
@@ -77,9 +87,11 @@ export function kvStatsSink(kv, { bucket = "default", ttlSeconds = 60 * 60 * 24
           if (!raw) continue;
           let obj; try { obj = JSON.parse(raw); } catch { continue; }
           if (typeof obj._ts === "number" && obj._ts < oldest) oldest = obj._ts;
-          for (const [k, n] of Object.entries(obj)) {
-            if (k === "_ts") continue;
-            if (typeof n === "number") result[k] = (result[k] || 0) + n;
+          // Whitelist + numeric coerce: a misconfigured (or compromised) KV
+          // entry can't smuggle arbitrary keys or strings into the snapshot.
+          for (const k of KNOWN_FIELDS) {
+            const v = Number(obj[k]);
+            if (Number.isFinite(v) && v >= 0) result[k] = (result[k] || 0) + v;
           }
         }
         cursor = page.cursor;
@@ -140,8 +152,10 @@ export function httpStatsSink(url, { token, batchMs = 2000, fetchImpl } = {}) {
           signal: AbortSignal.timeout(5000),
         });
         if (!r.ok) return ZERO();
-        const j = await r.json();
-        return { ...ZERO(), ...j };
+        // Sanitize at the trust boundary — a compromised or misconfigured
+        // collector cannot inject non-numeric values or extra keys that the
+        // dashboard would render as HTML.
+        return sanitize(await r.json());
       } catch { return ZERO(); }
     },
   };

package/worker.js

@@ -16,6 +16,17 @@
 import { createEdgeTollbooth, kvStatsSink } from "./edge.js";
 import { dashboardHtml } from "./dashboard.js";
 
+// Constant-time string compare — Cloudflare Workers don't ship node:crypto's
+// timingSafeEqual. Short-circuiting `===` on a secret token leaks length and
+// prefix bits to a sufficiently patient attacker; this doesn't.
+function constEq(a, b) {
+  a = String(a || ""); b = String(b || "");
+  if (a.length !== b.length) return false;
+  let r = 0;
+  for (let i = 0; i < a.length; i++) r |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return r === 0;
+}
+
 const kvStore = (kv) => ({
   // Best-effort atomic claim. KV has no native compare-and-set, so this is
   // get-then-put (eventually consistent); for strict single-use, back it with a
@@ -61,10 +72,13 @@ export default {
       return new Response(dashboardHtml(), { headers: { "content-type": "text/html; charset=utf-8" } });
     }
     if (u.pathname === "/__tollbooth/stats") {
-      // Optional bearer-token gate — share with your monitoring caller.
+      // Optional bearer-token gate — share with your monitoring caller. We
+      // recommend setting this in any prod deploy: without it, anyone on the
+      // internet can read aggregate counts (no per-request data, but still
+      // potentially sensitive competitive info).
       if (env.TOLLBOOTH_STATS_TOKEN) {
         const got = (request.headers.get("authorization") || "").replace(/^Bearer\s+/i, "");
-        if (got !== env.TOLLBOOTH_STATS_TOKEN) return new Response("unauthorized", { status: 401 });
+        if (!constEq(got, env.TOLLBOOTH_STATS_TOKEN)) return new Response("unauthorized", { status: 401 });
       }
       const snap = await gate.snapshot();
       return new Response(JSON.stringify(snap), { headers: { "content-type": "application/json" } });