@peaje/proxy 0.1.2 → 0.2.1

package/dist/index.cjs

@@ -56,9 +56,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) {
@@ -67,6 +112,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);
@@ -103,50 +180,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.
@@ -155,14 +259,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 ?? ""}` };
     }
@@ -307,6 +415,24 @@ 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 _reiniciarAviso() {
   avisado = false;
 }
@@ -315,24 +441,14 @@ function crearPeaje(opciones) {
   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;
@@ -340,6 +456,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);
@@ -353,16 +470,26 @@ 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;
     }
   };
 }
 function peajeFetch(opciones) {
   const peaje = crearPeaje(opciones);
-  return async (request) => {
+  return async (request, waitUntil) => {
     const url = new URL(request.url);
     const entrada = { method: request.method.toUpperCase(), url, headers: request.headers };
     const destino = await peaje.decidir(entrada);
-    if (!destino) return null;
+    if (!destino) {
+      const lectura = peaje.reportarLectura(entrada);
+      if (lectura) {
+        if (waitUntil) waitUntil(lectura);
+        else void lectura;
+      }
+      return null;
+    }
     const body = entrada.method === "GET" || entrada.method === "HEAD" ? null : await request.arrayBuffer();
     return peaje.reenviar(destino, { ...entrada, body });
   };

package/dist/index.d.cts

@@ -10,6 +10,19 @@ type OpcionesPeaje = {
     secret?: string;
     /** URL pública del gateway. Por defecto `PEAJE_GATEWAY_URL` o la de producción. */
     gateway?: string;
+    /**
+     * Prefijos bajo los que viven tus rutas de API con precio. Una ruta del
+     * dashboard fuera de ellos cobra solo en la URL del gateway, no en tu
+     * dominio. Por defecto `['/api/', '/v1/']`. La raíz y los paths reservados
+     * (`/login`, `/auth`, `/api/auth`, `/_next`...) nunca se aceptan.
+     */
+    apiPrefixes?: string[];
+    /**
+     * Avisarle al gateway cuando un bot de IA lee una página de la app, para el
+     * registro de visitas. Solo viajan la ruta (sin query) y el user-agent del
+     * bot. Por defecto `true`.
+     */
+    reportBotVisits?: boolean;
     /** Para tests o runtimes sin fetch global. */
     fetch?: typeof fetch;
 };
@@ -32,15 +45,23 @@ type Peaje = {
     reenviar(destino: string, entrada: EntradaDecision & {
         body: BodyInit | null;
     }): Promise<Response>;
+    /**
+     * Para una request que no fue al gateway: si es un bot de IA leyendo una
+     * página, se lo avisa al gateway y devuelve la promesa del aviso (para
+     * `waitUntil`). Null si no hay nada que avisar. Nunca lanza.
+     */
+    reportarLectura(entrada: EntradaDecision): Promise<void> | null;
 };
 declare function baseDe({ slug, gateway }: Pick<OpcionesPeaje, 'slug' | 'gateway'>): string;
 /** Solo para tests: vuelve a permitir el aviso de secreto faltante. */
 declare function _reiniciarAviso(): void;
 declare function crearPeaje(opciones: OpcionesPeaje): Peaje;
-type PeajeFetch = (request: Request) => Promise<Response | null>;
+type PeajeFetch = (request: Request, waitUntil?: (promesa: Promise<unknown>) => void) => Promise<Response | null>;
 /**
  * `(request) => Response | null`. Null: la request no es de Peaje y la
- * atiende la app. El body se lee (en memoria) solo si va al gateway.
+ * atiende la app. El body se lee (en memoria) solo si va al gateway. Con
+ * `waitUntil` (Workers, Vercel), el aviso de lectura de un bot corre ahí;
+ * sin él, al costado.
  */
 declare function peajeFetch(opciones: OpcionesPeaje): PeajeFetch;
 

package/dist/index.d.ts

@@ -10,6 +10,19 @@ type OpcionesPeaje = {
     secret?: string;
     /** URL pública del gateway. Por defecto `PEAJE_GATEWAY_URL` o la de producción. */
     gateway?: string;
+    /**
+     * Prefijos bajo los que viven tus rutas de API con precio. Una ruta del
+     * dashboard fuera de ellos cobra solo en la URL del gateway, no en tu
+     * dominio. Por defecto `['/api/', '/v1/']`. La raíz y los paths reservados
+     * (`/login`, `/auth`, `/api/auth`, `/_next`...) nunca se aceptan.
+     */
+    apiPrefixes?: string[];
+    /**
+     * Avisarle al gateway cuando un bot de IA lee una página de la app, para el
+     * registro de visitas. Solo viajan la ruta (sin query) y el user-agent del
+     * bot. Por defecto `true`.
+     */
+    reportBotVisits?: boolean;
     /** Para tests o runtimes sin fetch global. */
     fetch?: typeof fetch;
 };
@@ -32,15 +45,23 @@ type Peaje = {
     reenviar(destino: string, entrada: EntradaDecision & {
         body: BodyInit | null;
     }): Promise<Response>;
+    /**
+     * Para una request que no fue al gateway: si es un bot de IA leyendo una
+     * página, se lo avisa al gateway y devuelve la promesa del aviso (para
+     * `waitUntil`). Null si no hay nada que avisar. Nunca lanza.
+     */
+    reportarLectura(entrada: EntradaDecision): Promise<void> | null;
 };
 declare function baseDe({ slug, gateway }: Pick<OpcionesPeaje, 'slug' | 'gateway'>): string;
 /** Solo para tests: vuelve a permitir el aviso de secreto faltante. */
 declare function _reiniciarAviso(): void;
 declare function crearPeaje(opciones: OpcionesPeaje): Peaje;
-type PeajeFetch = (request: Request) => Promise<Response | null>;
+type PeajeFetch = (request: Request, waitUntil?: (promesa: Promise<unknown>) => void) => Promise<Response | null>;
 /**
  * `(request) => Response | null`. Null: la request no es de Peaje y la
- * atiende la app. El body se lee (en memoria) solo si va al gateway.
+ * atiende la app. El body se lee (en memoria) solo si va al gateway. Con
+ * `waitUntil` (Workers, Vercel), el aviso de lectura de un bot corre ahí;
+ * sin él, al costado.
  */
 declare function peajeFetch(opciones: OpcionesPeaje): PeajeFetch;
 

package/dist/index.js

@@ -5,7 +5,7 @@ import {
   crearPeaje,
   peajeFetch,
   src_default
-} from "./chunk-IU5YMR4J.js";
+} from "./chunk-SWB3HJVY.js";
 export {
   GATEWAY_POR_DEFECTO,
   _reiniciarAviso,