@peaje/proxy 0.1.0

package/dist/express.cjs

@@ -0,0 +1,422 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/express.ts
+var express_exports = {};
+__export(express_exports, {
+  default: () => express_default,
+  peajeExpress: () => peajeExpress
+});
+module.exports = __toCommonJS(express_exports);
+var import_node_stream = require("stream");
+
+// ../shared/src/kit/rutas.ts
+var RUTAS_PROXY = [
+  { path: "/llms.txt", nota: "gu\xEDa para agentes (fusionada con la tuya)" },
+  { path: "/pricing.md", nota: "precios por endpoint" },
+  { path: "/auth.md", nota: 'c\xF3mo pagar (el "auth" ac\xE1 es el pago)' },
+  { path: "/agents.md", nota: "qu\xE9 es y cu\xE1ndo usarte" },
+  { path: "/openapi.json", nota: "discovery con precios" },
+  { path: "/mcp", nota: "MCP server con tools pagas, en TU dominio" },
+  { path: "/.well-known/mcp", nota: "el MCP tambi\xE9n ac\xE1: es donde lo buscan los auditores" },
+  { path: "/.well-known/ard.json", nota: "cat\xE1logo ARD (path can\xF3nico)" },
+  { path: "/.well-known/ai-catalog.json", nota: "cat\xE1logo ARD (alias legacy)" },
+  { path: "/.well-known/api-catalog", nota: "linkset RFC 9727" },
+  { path: "/.well-known/agent-card.json", nota: "agent card A2A" },
+  { path: "/.well-known/mcp/server-card.json", nota: "server card MCP" },
+  { path: "/discovery/resources", nota: "lista x402 Bazaar: lo que cobra 402 de verdad" },
+  { path: "/.well-known/ucp", nota: "perfil UCP: qu\xE9 sabe hacer tu negocio" },
+  { path: "/checkout_sessions", nota: "checkout ACP (el de OpenAI)" },
+  { path: "/agentic_commerce/delegate_payment", nota: "delegate payment ACP" },
+  { path: "/developers", nota: "portal de desarrolladores, renderizado con tus precios" },
+  { path: "/.well-known/peaje-indexnow.txt", nota: "clave IndexNow: avisa a Bing y Copilot cuando cambian precios" },
+  // Los auditores prueban /docs y /developers; el gateway redirige uno al otro.
+  { path: "/docs", nota: "alias del portal: los auditores prueban ambos" }
+];
+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 PEAJE_FETCH_HEADER = "x-peaje-fetch";
+
+// ../shared/src/kit/proxy-runtime.ts
+var PEAJE_ORIGIN_HEADER = "x-peaje-origin";
+function iguales(a, b) {
+  if (a.length !== b.length) return false;
+  let d = 0;
+  for (let i = 0; i < a.length; i++) d |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return d === 0;
+}
+function coincidePatron(patron, pathname) {
+  const p = patron.split("/").filter(Boolean);
+  const parts = segmentosCanonicos(pathname);
+  for (let i = 0; i < p.length; i++) {
+    const seg = p[i];
+    if (seg === "*") return true;
+    const v = parts[i];
+    if (v === void 0) return false;
+    if (seg.startsWith(":")) continue;
+    if (seg.toLowerCase() !== v.toLowerCase()) return false;
+  }
+  return p.length === parts.length;
+}
+function segmentosCanonicos(pathname) {
+  const out = [];
+  for (const crudo of pathname.split(/[\\/]+/)) {
+    if (!crudo) continue;
+    let seg = crudo;
+    try {
+      seg = decodeURIComponent(crudo);
+    } catch {
+    }
+    for (const s of seg.split(/[\\/]+/)) {
+      if (!s || s === ".") continue;
+      if (s === "..") out.pop();
+      else out.push(s);
+    }
+  }
+  return out;
+}
+var pathCanonico = (pathname) => `/${segmentosCanonicos(pathname).join("/")}`;
+function patronReenviable(patron) {
+  const segs = patron.split("/").filter(Boolean);
+  if (segs.length === 0) return false;
+  return !(segs.length === 1 && (segs[0] === "*" || segs[0].startsWith(":")));
+}
+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 ?? []
+  };
+  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
+      };
+    } catch {
+      cache = { ...cache, at: Date.now() };
+    } finally {
+      refrescando = null;
+    }
+  }
+  async function listas() {
+    const vencido = Date.now() - cache.at >= ttl;
+    if (vencido) {
+      refrescando ??= refrescar();
+      if (cache.at === 0) await refrescando;
+    }
+    return cache;
+  }
+  return {
+    /** 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));
+    },
+    /** Fuerza la carga del manifiesto (útil al arrancar o en tests). */
+    cargar: () => refrescando ??= refrescar(),
+    /**
+     * Decide si la request va al gateway. `method` y `pathname` de la request,
+     * `search` con el `?` incluido, y los headers para cortar bucles.
+     */
+    async decidir(input) {
+      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));
+      if (!fija && !prefijo && !patron) return null;
+      return { destino: `${base}${path}${input.search ?? ""}` };
+    }
+  };
+}
+
+// ../shared/src/index.ts
+var TEMPO = {
+  mainnet: {
+    chainId: 4217,
+    rpcUrl: "https://rpc.tempo.xyz",
+    explorerUrl: "https://explore.tempo.xyz"
+  },
+  testnet: {
+    chainId: 42431,
+    rpcUrl: "https://rpc.moderato.tempo.xyz",
+    explorerUrl: "https://explore.testnet.tempo.xyz"
+  }
+};
+var TOKENS = {
+  pathUsd: "0x20c0000000000000000000000000000000000000",
+  usdc: "0x20C000000000000000000000b9537d11c60E8b50"
+};
+var DEFAULT_CURRENCY = TOKENS.pathUsd;
+var NETWORKS = {
+  tempo: {
+    id: "tempo",
+    label: "Tempo",
+    token: TOKENS.pathUsd,
+    tokenSymbol: "pathUSD",
+    decimals: 6,
+    mainnet: TEMPO.mainnet,
+    testnet: TEMPO.testnet
+  },
+  arc: {
+    id: "arc",
+    label: "Arc",
+    // Interfaz ERC-20 del USDC nativo de Arc; el gas de la red se paga en ese mismo USDC.
+    token: "0x3600000000000000000000000000000000000000",
+    tokenSymbol: "USDC",
+    decimals: 6,
+    // Leído on-chain del contrato: name() = "USDC", version() = "2".
+    eip3009: { name: "USDC", version: "2" },
+    // Arc no publica direcciones de mainnet todavía (sept 2026).
+    mainnet: null,
+    testnet: {
+      chainId: 5042002,
+      rpcUrl: "https://rpc.testnet.arc.io",
+      explorerUrl: "https://testnet.arcscan.app"
+    }
+  },
+  arbitrum: {
+    id: "arbitrum",
+    label: "Arbitrum",
+    // USDC de Circle en Arbitrum Sepolia. En Arbitrum One vive en otra dirección,
+    // por eso mainnet queda en null hasta que el gateway opere allá.
+    token: "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d",
+    tokenSymbol: "USDC",
+    decimals: 6,
+    // Leído on-chain: name() = "USD Coin", version() = "2" (distinto al USDC de Arc).
+    eip3009: { name: "USD Coin", version: "2" },
+    mainnet: null,
+    testnet: {
+      chainId: 421614,
+      rpcUrl: "https://sepolia-rollup.arbitrum.io/rpc",
+      explorerUrl: "https://sepolia.arbiscan.io"
+    }
+  },
+  "arbitrum-usdg": {
+    id: "arbitrum-usdg",
+    label: "Arbitrum \xB7 USDG",
+    // Mismo contrato y misma cadena que el riel USDC: cambia el stablecoin.
+    // Un riel es (cadena, token), y el saldo del negocio se lleva por token.
+    token: "0xFFC95faa3d63Cde504a05B567C600B78C0b41892",
+    tokenSymbol: "USDG",
+    decimals: 6,
+    eip3009: { name: "Global Dollar", version: "1" },
+    mainnet: null,
+    testnet: {
+      chainId: 421614,
+      rpcUrl: "https://sepolia-rollup.arbitrum.io/rpc",
+      explorerUrl: "https://sepolia.arbiscan.io"
+    }
+  },
+  robinhood: {
+    id: "robinhood",
+    label: "Robinhood",
+    // USDG de Paxos en Robinhood Chain Testnet (el "USDC" de esa testnet es un
+    // mock sin EIP-3009). Leído on-chain: dominio "Global Dollar", versión "1".
+    token: "0x7E955252E15c84f5768B83c41a71F9eba181802F",
+    tokenSymbol: "USDG",
+    decimals: 6,
+    eip3009: { name: "Global Dollar", version: "1" },
+    mainnet: null,
+    testnet: {
+      chainId: 46630,
+      rpcUrl: "https://rpc.testnet.chain.robinhood.com",
+      explorerUrl: "https://explorer.testnet.chain.robinhood.com"
+    }
+  }
+};
+var NETWORK_IDS = Object.keys(NETWORKS);
+var CHAIN_LABELS = [
+  ...new Map(NETWORK_IDS.map((id) => [NETWORKS[id].testnet.chainId, NETWORKS[id].label.split(" \xB7 ")[0] ?? NETWORKS[id].label])).values()
+];
+var GATEWAY_RAILS = {
+  "gateway-arbitrum": {
+    id: "gateway-arbitrum",
+    label: "Arbitrum \xB7 Nanopayments",
+    chainId: 421614,
+    rpcUrl: "https://sepolia-rollup.arbitrum.io/rpc",
+    token: "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d",
+    decimals: 6,
+    verifyingContract: "0x0077777d7EBA4688BDeF3E311b846F25870A19B9",
+    facilitatorUrl: "https://gateway-api-testnet.circle.com/v1/x402",
+    sdkChain: "arbitrumSepolia",
+    explorerUrl: "https://sepolia.arbiscan.io"
+  },
+  "gateway-arc": {
+    id: "gateway-arc",
+    label: "Arc \xB7 Nanopayments",
+    chainId: 5042002,
+    rpcUrl: "https://rpc.testnet.arc.network",
+    token: "0x3600000000000000000000000000000000000000",
+    decimals: 6,
+    verifyingContract: "0x0077777d7EBA4688BDeF3E311b846F25870A19B9",
+    facilitatorUrl: "https://gateway-api-testnet.circle.com/v1/x402",
+    sdkChain: "arcTestnet",
+    explorerUrl: "https://testnet.arcscan.app"
+  }
+};
+var GATEWAY_RAIL_IDS = Object.keys(GATEWAY_RAILS);
+
+// src/index.ts
+var GATEWAY_POR_DEFECTO = "https://peaje-gateway.up.railway.app";
+function env(nombre) {
+  return typeof process !== "undefined" ? process.env?.[nombre] : void 0;
+}
+function baseDe({ slug, gateway }) {
+  const raiz = (gateway ?? env("PEAJE_GATEWAY_URL") ?? GATEWAY_POR_DEFECTO).replace(/\/+$/, "");
+  return `${raiz}/${slug}`;
+}
+var SALTO = ["host", "connection", "keep-alive", "proxy-connection", "transfer-encoding", "upgrade", "te", "trailer", "content-length"];
+var avisado = false;
+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: [] }
+  });
+  return {
+    base,
+    async decidir({ method, url, headers }) {
+      if (!secreto && !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.`
+            );
+          }
+        });
+      }
+      const d = await runtime.decidir({ method, pathname: url.pathname, search: url.search, headers });
+      return d?.destino ?? null;
+    },
+    async reenviar(destino, { method, url, headers, body }) {
+      const salida = new Headers(headers);
+      for (const h of SALTO) salida.delete(h);
+      const primero = (h) => headers.get(h)?.split(",")[0]?.trim() || null;
+      salida.set("x-forwarded-host", primero("x-forwarded-host") ?? url.host);
+      salida.set("x-forwarded-proto", primero("x-forwarded-proto") ?? url.protocol.replace(":", ""));
+      const sinBody = method === "GET" || method === "HEAD";
+      const res = await fetchImpl(destino, { method, headers: salida, body: sinBody ? null : body, redirect: "manual" });
+      const vuelta = new Headers(res.headers);
+      vuelta.delete("content-encoding");
+      vuelta.delete("content-length");
+      vuelta.delete("transfer-encoding");
+      vuelta.delete("connection");
+      return new Response(method === "HEAD" ? null : res.body, { status: res.status, statusText: res.statusText, headers: vuelta });
+    }
+  };
+}
+
+// src/express.ts
+function headersDe(req) {
+  const h = new Headers();
+  for (const [clave, valor] of Object.entries(req.headers)) {
+    if (valor === void 0) continue;
+    if (Array.isArray(valor)) for (const v of valor) h.append(clave, v);
+    else h.set(clave, valor);
+  }
+  return h;
+}
+function urlDe(req) {
+  const cifrado = req.socket?.encrypted;
+  const proto = req.protocol ?? (cifrado ? "https" : "http");
+  const host = req.headers.host ?? "localhost";
+  return new URL(req.originalUrl ?? req.url ?? "/", `${proto}://${host}`);
+}
+async function bodyDe(req) {
+  if (req.readableEnded || req._body) {
+    const b = req.body;
+    if (b === void 0 || b === null) return null;
+    if (typeof b === "string" || b instanceof Uint8Array) return b;
+    if (typeof b === "object" && Object.keys(b).length === 0) return null;
+    return JSON.stringify(b);
+  }
+  const partes = [];
+  for await (const parte of req) partes.push(typeof parte === "string" ? Buffer.from(parte) : parte);
+  return partes.length > 0 ? Buffer.concat(partes) : null;
+}
+async function enviar(res, respuesta) {
+  res.statusCode = respuesta.status;
+  if (respuesta.statusText) res.statusMessage = respuesta.statusText;
+  const cookies = respuesta.headers.getSetCookie?.() ?? [];
+  respuesta.headers.forEach((valor, clave) => {
+    if (clave === "set-cookie") return;
+    res.setHeader(clave, valor);
+  });
+  if (cookies.length > 0) res.setHeader("set-cookie", cookies);
+  if (!respuesta.body) {
+    res.end();
+    return;
+  }
+  await new Promise((resolve, reject) => {
+    const cuerpo = import_node_stream.Readable.fromWeb(respuesta.body);
+    cuerpo.on("error", reject);
+    res.on("finish", resolve);
+    res.on("close", resolve);
+    cuerpo.pipe(res);
+  });
+}
+function peajeExpress(opciones) {
+  const peaje = crearPeaje(opciones);
+  return (req, res, next) => {
+    const r = req;
+    const entrada = { method: (r.method ?? "GET").toUpperCase(), url: urlDe(r), headers: headersDe(r) };
+    peaje.decidir(entrada).then(async (destino) => {
+      if (!destino) return next();
+      const body = entrada.method === "GET" || entrada.method === "HEAD" ? null : await bodyDe(r);
+      await enviar(res, await peaje.reenviar(destino, { ...entrada, body }));
+    }).catch((e) => {
+      if (res.headersSent) {
+        res.destroy(e instanceof Error ? e : void 0);
+        return;
+      }
+      next(e);
+    });
+  };
+}
+var express_default = peajeExpress;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  peajeExpress
+});

package/dist/express.d.cts

@@ -0,0 +1,19 @@
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { OpcionesPeaje } from './index.cjs';
+
+/**
+ * `@peaje/proxy/express`: middleware de Express (4 y 5) o Connect.
+ *
+ *   import { peajeExpress } from '@peaje/proxy/express'
+ *   app.use(peajeExpress({ slug: 'mi-negocio' }))
+ *
+ * Va antes de los body parsers (`express.json()`) y de las rutas: el body de
+ * una request de Peaje se reenvía crudo al gateway, y el de las demás no se
+ * toca. Si igual corre después de un parser, reenvía `req.body` serializado.
+ */
+
+type Next = (err?: unknown) => void;
+type MiddlewareExpress = (req: IncomingMessage, res: ServerResponse, next: Next) => void;
+declare function peajeExpress(opciones: OpcionesPeaje): MiddlewareExpress;
+
+export { type MiddlewareExpress, OpcionesPeaje, peajeExpress as default, peajeExpress };

package/dist/express.d.ts

@@ -0,0 +1,19 @@
+import { IncomingMessage, ServerResponse } from 'node:http';
+import { OpcionesPeaje } from './index.js';
+
+/**
+ * `@peaje/proxy/express`: middleware de Express (4 y 5) o Connect.
+ *
+ *   import { peajeExpress } from '@peaje/proxy/express'
+ *   app.use(peajeExpress({ slug: 'mi-negocio' }))
+ *
+ * Va antes de los body parsers (`express.json()`) y de las rutas: el body de
+ * una request de Peaje se reenvía crudo al gateway, y el de las demás no se
+ * toca. Si igual corre después de un parser, reenvía `req.body` serializado.
+ */
+
+type Next = (err?: unknown) => void;
+type MiddlewareExpress = (req: IncomingMessage, res: ServerResponse, next: Next) => void;
+declare function peajeExpress(opciones: OpcionesPeaje): MiddlewareExpress;
+
+export { type MiddlewareExpress, OpcionesPeaje, peajeExpress as default, peajeExpress };

package/dist/express.js

@@ -0,0 +1,77 @@
+import {
+  crearPeaje
+} from "./chunk-BYMBIN6F.js";
+
+// src/express.ts
+import { Readable } from "stream";
+function headersDe(req) {
+  const h = new Headers();
+  for (const [clave, valor] of Object.entries(req.headers)) {
+    if (valor === void 0) continue;
+    if (Array.isArray(valor)) for (const v of valor) h.append(clave, v);
+    else h.set(clave, valor);
+  }
+  return h;
+}
+function urlDe(req) {
+  const cifrado = req.socket?.encrypted;
+  const proto = req.protocol ?? (cifrado ? "https" : "http");
+  const host = req.headers.host ?? "localhost";
+  return new URL(req.originalUrl ?? req.url ?? "/", `${proto}://${host}`);
+}
+async function bodyDe(req) {
+  if (req.readableEnded || req._body) {
+    const b = req.body;
+    if (b === void 0 || b === null) return null;
+    if (typeof b === "string" || b instanceof Uint8Array) return b;
+    if (typeof b === "object" && Object.keys(b).length === 0) return null;
+    return JSON.stringify(b);
+  }
+  const partes = [];
+  for await (const parte of req) partes.push(typeof parte === "string" ? Buffer.from(parte) : parte);
+  return partes.length > 0 ? Buffer.concat(partes) : null;
+}
+async function enviar(res, respuesta) {
+  res.statusCode = respuesta.status;
+  if (respuesta.statusText) res.statusMessage = respuesta.statusText;
+  const cookies = respuesta.headers.getSetCookie?.() ?? [];
+  respuesta.headers.forEach((valor, clave) => {
+    if (clave === "set-cookie") return;
+    res.setHeader(clave, valor);
+  });
+  if (cookies.length > 0) res.setHeader("set-cookie", cookies);
+  if (!respuesta.body) {
+    res.end();
+    return;
+  }
+  await new Promise((resolve, reject) => {
+    const cuerpo = Readable.fromWeb(respuesta.body);
+    cuerpo.on("error", reject);
+    res.on("finish", resolve);
+    res.on("close", resolve);
+    cuerpo.pipe(res);
+  });
+}
+function peajeExpress(opciones) {
+  const peaje = crearPeaje(opciones);
+  return (req, res, next) => {
+    const r = req;
+    const entrada = { method: (r.method ?? "GET").toUpperCase(), url: urlDe(r), headers: headersDe(r) };
+    peaje.decidir(entrada).then(async (destino) => {
+      if (!destino) return next();
+      const body = entrada.method === "GET" || entrada.method === "HEAD" ? null : await bodyDe(r);
+      await enviar(res, await peaje.reenviar(destino, { ...entrada, body }));
+    }).catch((e) => {
+      if (res.headersSent) {
+        res.destroy(e instanceof Error ? e : void 0);
+        return;
+      }
+      next(e);
+    });
+  };
+}
+var express_default = peajeExpress;
+export {
+  express_default as default,
+  peajeExpress
+};