@peaje/proxy 0.1.2 → 0.2.1

package/dist/vercel.cjs

@@ -52,9 +52,54 @@ var RUTAS_DINAMICAS = [
   { path: "/r/:slug", prefijo: "/r/", nota: "links con precio: el 402 en tu dominio" },
   { path: "/checkout_sessions/:id", prefijo: "/checkout_sessions/", nota: "leer una sesi\xF3n de checkout ACP" }
 ];
+var PREFIJOS_API_POR_DEFECTO = ["/api/", "/v1/"];
+var PATHS_RESERVADOS = [
+  "/",
+  "/login",
+  "/logout",
+  "/signin",
+  "/signout",
+  "/signup",
+  "/sign-in",
+  "/sign-out",
+  "/sign-up",
+  "/register",
+  "/auth",
+  "/oauth",
+  "/session",
+  "/account",
+  "/admin",
+  "/dashboard",
+  "/_next",
+  "/_vercel",
+  "/api/auth",
+  "/static",
+  "/assets",
+  "/favicon.ico",
+  "/robots.txt",
+  "/sitemap.xml"
+];
 var PEAJE_FETCH_HEADER = "x-peaje-fetch";
 var PEAJE_HOST_HEADER = "x-peaje-forwarded-host";
 
+// ../shared/src/kit/bots.ts
+var BOTS_DE_VISITA = [
+  { patron: /OAI-SearchBot/i, tipo: "openai-searchbot" },
+  { patron: /PerplexityBot/i, tipo: "perplexitybot" },
+  { patron: /Googlebot/i, tipo: "googlebot" },
+  { patron: /ClaudeBot|anthropic-ai/i, tipo: "claudebot" },
+  { patron: /GPTBot/i, tipo: "gptbot" }
+];
+function tipoDeBot(ua) {
+  if (!ua) return null;
+  for (const b of BOTS_DE_VISITA) if (b.patron.test(ua)) return b.tipo;
+  return null;
+}
+var PEAJE_VERIFICADOR_HEADER = "x-peaje-verificador";
+var NO_ES_PAGINA = /\.(png|jpe?g|gif|webp|avif|svg|ico|css|m?js|map|woff2?|ttf|otf|eot|mp4|webm|mp3|wav)$/i;
+var MAX_PATH_LECTURA = 500;
+var MAX_UA_LECTURA = 300;
+
 // ../shared/src/kit/proxy-runtime.ts
 var PEAJE_ORIGIN_HEADER = "x-peaje-origin";
 function iguales(a, b) {
@@ -63,6 +108,38 @@ function iguales(a, b) {
   for (let i = 0; i < a.length; i++) d |= a.charCodeAt(i) ^ b.charCodeAt(i);
   return d === 0;
 }
+var HEADERS_NO_REENVIADOS = ["cookie"];
+function esReservado(path) {
+  const canon = pathCanonico(path).toLowerCase();
+  return PATHS_RESERVADOS.some((r) => r === "/" ? canon === "/" : canon === r || canon.startsWith(`${r}/`));
+}
+function prefijosApiValidos(prefijos = PREFIJOS_API_POR_DEFECTO) {
+  const out = [];
+  for (const crudo of prefijos) {
+    const segs = segmentosCanonicos(String(crudo ?? "")).map((s) => s.toLowerCase());
+    if (segs.length === 0) continue;
+    const path = `/${segs.join("/")}`;
+    if (esReservado(path)) continue;
+    if (!out.includes(`${path}/`)) out.push(`${path}/`);
+  }
+  return out;
+}
+function patronPermitido(patron, prefijos) {
+  if (!patronReenviable(patron)) return false;
+  const segs = patron.split("/").filter(Boolean);
+  const literal = (s) => s !== "*" && !s.startsWith(":");
+  const bajoPrefijo = prefijos.some((pre) => {
+    const ps = pre.split("/").filter(Boolean);
+    return segs.length > ps.length && ps.every((s, i) => literal(segs[i]) && segs[i].toLowerCase() === s);
+  });
+  if (!bajoPrefijo) return false;
+  const literales = [];
+  for (const s of segs) {
+    if (!literal(s)) break;
+    literales.push(s);
+  }
+  return !esReservado(`/${literales.join("/")}`);
+}
 function coincidePatron(patron, pathname) {
   const p = patron.split("/").filter(Boolean);
   const parts = segmentosCanonicos(pathname);
@@ -99,50 +176,77 @@ function patronReenviable(patron) {
   if (segs.length === 0) return false;
   return !(segs.length === 1 && (segs[0] === "*" || segs[0].startsWith(":")));
 }
+function lecturaDeBot(input) {
+  const method = input.method.toUpperCase();
+  if (method !== "GET" && method !== "HEAD") return null;
+  const h = input.headers;
+  if (h.has(PEAJE_ORIGIN_HEADER) || h.has(PEAJE_FETCH_HEADER) || h.has(PEAJE_VERIFICADOR_HEADER)) return null;
+  const ua = h.get("user-agent");
+  if (!ua || !tipoDeBot(ua)) return null;
+  const path = input.pathname;
+  if (!path.startsWith("/") || path.startsWith("/_next/") || path.startsWith("/_vercel/") || NO_ES_PAGINA.test(path)) return null;
+  return { path: path.slice(0, MAX_PATH_LECTURA), method, userAgent: ua.slice(0, MAX_UA_LECTURA) };
+}
 function crearProxyRuntime(opciones) {
   const base = opciones.base.replace(/\/+$/, "");
   const ttl = opciones.ttlMs ?? 6e4;
   const fetchImpl = opciones.fetchImpl ?? fetch;
-  let cache = {
-    at: 0,
-    rutas: opciones.respaldo?.rutas ?? [],
-    prefijos: opciones.respaldo?.prefijos ?? [],
-    patrones: opciones.respaldo?.patrones ?? []
-  };
+  const rutas = [...opciones.fijas?.rutas ?? RUTAS_PROXY.map((r) => r.path)];
+  const prefijos = [...opciones.fijas?.prefijos ?? RUTAS_DINAMICAS.map((r) => r.prefijo)];
+  const prefijosApi = prefijosApiValidos(opciones.prefijosApi ?? PREFIJOS_API_POR_DEFECTO);
+  let cache = { at: 0, patrones: [] };
   let refrescando = null;
   async function refrescar() {
     try {
       const res = await fetchImpl(`${base}/kit/manifest.json`, { signal: AbortSignal.timeout(5e3) });
       if (!res.ok) throw new Error(String(res.status));
       const m = await res.json();
-      cache = {
-        at: Date.now(),
-        rutas: Array.isArray(m.rutas) ? m.rutas : cache.rutas,
-        prefijos: Array.isArray(m.prefijos) ? m.prefijos : cache.prefijos,
-        patrones: Array.isArray(m.patrones) ? m.patrones : cache.patrones
-      };
+      const patrones2 = Array.isArray(m.patrones) ? m.patrones.filter((p) => typeof p?.method === "string" && typeof p?.path === "string") : cache.patrones;
+      cache = { at: Date.now(), patrones: patrones2 };
     } catch {
       cache = { ...cache, at: Date.now() };
     } finally {
       refrescando = null;
     }
   }
-  async function listas() {
+  async function patrones() {
     const vencido = Date.now() - cache.at >= ttl;
     if (vencido) {
       refrescando ??= refrescar();
       if (cache.at === 0) await refrescando;
     }
-    return cache;
+    return cache.patrones;
   }
   return {
+    /** Los prefijos de API efectivos, normalizados (para los avisos). */
+    prefijosApi,
     /** Rutas de API con precio que este sitio no puede cobrar por falta de secreto. */
     async sinSecreto() {
       if (opciones.secreto) return [];
-      return (await listas()).patrones.filter((p) => patronReenviable(p.path));
+      return (await patrones()).filter((p) => patronPermitido(p.path, prefijosApi));
+    },
+    /** Rutas de API con precio que no se reenvían por caer fuera de `prefijosApi` o en un path reservado. */
+    async fueraDePrefijos() {
+      return (await patrones()).filter((p) => patronReenviable(p.path) && !patronPermitido(p.path, prefijosApi));
     },
     /** Fuerza la carga del manifiesto (útil al arrancar o en tests). */
     cargar: () => refrescando ??= refrescar(),
+    /**
+     * Si la request es un bot leyendo una página del sitio, le avisa al
+     * gateway y devuelve la promesa del aviso (para `waitUntil`); si no, null.
+     * El aviso nunca lanza ni demora la página: 3 s de tope y se descarta la
+     * respuesta.
+     */
+    reportarLectura(input) {
+      const lectura = lecturaDeBot(input);
+      if (!lectura) return null;
+      return fetchImpl(`${base}/kit/visita`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(lectura),
+        signal: AbortSignal.timeout(3e3)
+      }).then((res) => res.body?.cancel()).catch(() => void 0);
+    },
     /**
      * Decide si la request va al gateway. `method` y `pathname` de la request,
      * `search` con el `?` incluido, y los headers para cortar bucles.
@@ -151,14 +255,18 @@ function crearProxyRuntime(opciones) {
       const secreto = opciones.secreto || null;
       const prueba = input.headers.get(PEAJE_ORIGIN_HEADER);
       if (secreto && prueba && iguales(prueba, secreto)) return null;
-      const { rutas, prefijos, patrones } = await listas();
       const path = input.pathname;
       const canon = pathCanonico(path).toLowerCase();
       const esFetchDePeaje = input.headers.get(PEAJE_FETCH_HEADER) !== null;
       const fija = (rutas.includes(path) || rutas.some((r) => r.toLowerCase() === canon)) && !(canon === "/llms.txt" && esFetchDePeaje);
       const prefijo = prefijos.some((p) => path.startsWith(p) || canon.startsWith(p.toLowerCase()));
-      const method = input.method.toUpperCase();
-      const patron = secreto !== null && patrones.some((p) => p.method.toUpperCase() === method && patronReenviable(p.path) && coincidePatron(p.path, path));
+      let patron = false;
+      if (!fija && !prefijo && secreto !== null && !esReservado(path) && prefijosApi.some((pre) => canon.startsWith(pre))) {
+        const method = input.method.toUpperCase();
+        patron = (await patrones()).some(
+          (p) => p.method.toUpperCase() === method && patronPermitido(p.path, prefijosApi) && coincidePatron(p.path, path)
+        );
+      }
       if (!fija && !prefijo && !patron) return null;
       return { destino: `${base}${path}${input.search ?? ""}` };
     }
@@ -303,29 +411,37 @@ function baseDe({ slug, gateway }) {
 }
 var SALTO = ["host", "connection", "keep-alive", "proxy-connection", "transfer-encoding", "upgrade", "te", "trailer", "content-length"];
 var avisado = false;
+function avisar(runtime, conSecreto) {
+  if (!conSecreto) {
+    void runtime.sinSecreto().then((faltan) => {
+      if (faltan.length > 0) {
+        console.warn(
+          `[peaje] ${faltan.length} priced API route(s) are not charged on this domain because PEAJE_ORIGIN_SECRET is not set: ${faltan.map((p) => `${p.method} ${p.path}`).join(", ")}. Copy it from the Kit page of your Peaje dashboard into your hosting environment variables.`
+        );
+      }
+    });
+  }
+  void runtime.fueraDePrefijos().then((fuera) => {
+    if (fuera.length > 0) {
+      console.warn(
+        `[peaje] ${fuera.length} priced API route(s) are outside apiPrefixes (${runtime.prefijosApi.join(", ") || "none"}) or on a reserved path, so they are charged only at the gateway URL, not on this domain: ${fuera.map((p) => `${p.method} ${p.path}`).join(", ")}. A route under a prefix of its own (/weather/:city) is charged here once that prefix is in the apiPrefixes option; a single path at the root or a reserved path never is.`
+      );
+    }
+  });
+}
 function crearPeaje(opciones) {
   if (!opciones?.slug) throw new Error("@peaje/proxy: `slug` is required (the business slug from your Peaje dashboard).");
   const base = baseDe(opciones);
   const secreto = opciones.secret ?? env("PEAJE_ORIGIN_SECRET") ?? null;
   const fetchImpl = opciones.fetch ?? ((...a) => fetch(...a));
-  const runtime = crearProxyRuntime({
-    base,
-    secreto,
-    fetchImpl,
-    respaldo: { rutas: RUTAS_PROXY.map((x) => x.path), prefijos: RUTAS_DINAMICAS.map((x) => x.prefijo), patrones: [] }
-  });
+  const runtime = crearProxyRuntime({ base, secreto, fetchImpl, prefijosApi: opciones.apiPrefixes ?? PREFIJOS_API_POR_DEFECTO });
+  const reportar = opciones.reportBotVisits !== false;
   return {
     base,
     async decidir({ method, url, headers }) {
-      if (!secreto && !avisado) {
+      if (!avisado) {
         avisado = true;
-        void runtime.sinSecreto().then((faltan) => {
-          if (faltan.length > 0) {
-            console.warn(
-              `[peaje] ${faltan.length} priced API route(s) are not charged on this domain because PEAJE_ORIGIN_SECRET is not set: ${faltan.map((p) => `${p.method} ${p.path}`).join(", ")}. Copy it from the Kit page of your Peaje dashboard into your hosting environment variables.`
-            );
-          }
-        });
+        avisar(runtime, Boolean(secreto));
       }
       const d = await runtime.decidir({ method, pathname: url.pathname, search: url.search, headers });
       return d?.destino ?? null;
@@ -333,6 +449,7 @@ function crearPeaje(opciones) {
     async reenviar(destino, { method, url, headers, body }) {
       const salida = new Headers(headers);
       for (const h of SALTO) salida.delete(h);
+      for (const h of HEADERS_NO_REENVIADOS) salida.delete(h);
       const primero = (h) => headers.get(h)?.split(",")[0]?.trim() || null;
       const host = primero("x-forwarded-host") ?? url.host;
       salida.set("x-forwarded-host", host);
@@ -346,6 +463,9 @@ function crearPeaje(opciones) {
       vuelta.delete("transfer-encoding");
       vuelta.delete("connection");
       return new Response(method === "HEAD" ? null : res.body, { status: res.status, statusText: res.statusText, headers: vuelta });
+    },
+    reportarLectura({ method, url, headers }) {
+      return reportar ? runtime.reportarLectura({ method, pathname: url.pathname, headers }) : null;
     }
   };
 }
@@ -371,11 +491,17 @@ function peajeVercel(opciones, siguiente) {
     const destino = await peaje.decidir(entrada);
     if (destino) {
       const headers = new Headers(request.headers);
+      for (const h of HEADERS_NO_REENVIADOS) headers.delete(h);
       headers.set("x-forwarded-host", url.host);
       headers.set(PEAJE_HOST_HEADER, url.host);
       headers.set("x-forwarded-proto", url.protocol.replace(":", ""));
       return respuestaMiddleware({ "x-middleware-rewrite": destino }, headers);
     }
+    const lectura = peaje.reportarLectura(entrada);
+    if (lectura) {
+      if (context?.waitUntil) context.waitUntil(lectura);
+      else void lectura;
+    }
     const propia = siguiente ? await siguiente(request, context) : void 0;
     return propia ?? respuestaMiddleware({ "x-middleware-next": "1" });
   };

package/dist/vercel.js

@@ -1,7 +1,8 @@
 import {
+  HEADERS_NO_REENVIADOS,
   PEAJE_HOST_HEADER,
   crearPeaje
-} from "./chunk-IU5YMR4J.js";
+} from "./chunk-SWB3HJVY.js";
 
 // src/vercel.ts
 function respuestaMiddleware(control, requestHeaders) {
@@ -24,11 +25,17 @@ function peajeVercel(opciones, siguiente) {
     const destino = await peaje.decidir(entrada);
     if (destino) {
       const headers = new Headers(request.headers);
+      for (const h of HEADERS_NO_REENVIADOS) headers.delete(h);
       headers.set("x-forwarded-host", url.host);
       headers.set(PEAJE_HOST_HEADER, url.host);
       headers.set("x-forwarded-proto", url.protocol.replace(":", ""));
       return respuestaMiddleware({ "x-middleware-rewrite": destino }, headers);
     }
+    const lectura = peaje.reportarLectura(entrada);
+    if (lectura) {
+      if (context?.waitUntil) context.waitUntil(lectura);
+      else void lectura;
+    }
     const propia = siguiente ? await siguiente(request, context) : void 0;
     return propia ?? respuestaMiddleware({ "x-middleware-next": "1" });
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peaje/proxy",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "description": "Peaje for any server: answer HTTP 402 (MPP, x402) for your priced API routes on your own domain. Fetch handler plus Express, Hono and Vercel Routing Middleware adapters.",
   "license": "MIT",
   "repository": {
@@ -8,10 +8,13 @@
     "url": "git+https://github.com/sandragcarrillo/peaje.git",
     "directory": "packages/peaje-proxy"
   },
+  "homepage": "https://github.com/sandragcarrillo/peaje/tree/main/packages/peaje-proxy#readme",
+  "bugs": "https://github.com/sandragcarrillo/peaje/issues",
   "type": "module",
   "sideEffects": false,
   "files": [
-    "dist"
+    "dist",
+    "LICENSE"
   ],
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",