reqly-cli 0.2.2 → 0.3.0

package/README.md

@@ -25,6 +25,7 @@ Start a tunnel that forwards captured requests to your local server.
 reqly tunnel --port 3000
 reqly tunnel --port 8080 --bin my-webhook
 reqly tunnel --port 3000 --name "stripe hooks"
+reqly tunnel --port 3000 --passthrough
 ```
 
 | Option | Description | Default |
@@ -32,6 +33,7 @@ reqly tunnel --port 3000 --name "stripe hooks"
 | `--port <n>` | Local port to forward to | `3000` |
 | `--bin <slug>` | Bin slug to listen on | assigned by server |
 | `--name <s>` | Human-readable tunnel name | `cli-<port>` |
+| `--passthrough` | Reverse-proxy mode — relay your local server's real response back to the caller (serves HTML, redirects, etc., not just webhooks) | off |
 
 ### `reqly login`
 
@@ -56,11 +58,13 @@ Show version.
 ## How it works
 
 1. The CLI registers a tunnel with the Reqly server.
-2. It opens a Server-Sent Events (SSE) connection to receive incoming requests in real time.
+2. It polls the server for incoming requests (`GET /api/tunnel/poll`). Polling is used instead of streaming because it survives reverse proxies (Traefik, nginx) that buffer or drop long-lived connections.
 3. Each request is forwarded to your local server (`http://localhost:<port>`).
 4. The response from your local server is reported back to Reqly so you can inspect it in the dashboard.
 
-The connection auto-reconnects with exponential backoff if interrupted.
+In `--passthrough` mode, the caller is held open until your local server responds, and that real response is relayed back to them — so the public URL behaves like a reverse proxy (HTML pages, redirects, status codes), not just a webhook collector.
+
+The poll loop keeps running through transient network errors and resumes automatically once the server is reachable again.
 
 ## Configuration
 

package/bin/reqly.mjs

@@ -63,9 +63,11 @@ ${BOLD}Commands:${RESET}
   status     Show connection status and config info
 
 ${BOLD}Tunnel options:${RESET}
-  --port <n>   Local port to forward to (default: 3000)
-  --bin <slug> Bin slug to listen on (optional)
-  --name <s>   Human-readable tunnel name (optional)
+  --port <n>     Local port to forward to (default: 3000)
+  --bin <slug>   Bin slug to listen on (optional)
+  --name <s>     Human-readable tunnel name (optional)
+  --passthrough  Reverse-proxy mode: relay the local server's real response
+                 back to the caller (serves HTML/redirects, not just webhooks)
 
 ${BOLD}Global options:${RESET}
   --help       Show this help message
@@ -134,13 +136,16 @@ async function main() {
       const port = parseInt(getFlag("--port") || config.defaultPort, 10);
       const bin = getFlag("--bin");
       const name = getFlag("--name");
+      const url = getFlag("--url");
+      const token = getFlag("--token");
+      const passthrough = hasFlag("--passthrough");
 
       if (isNaN(port) || port < 1 || port > 65535) {
         console.log(`${RED}Invalid port number.${RESET} Use --port <1-65535>`);
         process.exit(1);
       }
 
-      await startTunnel({ port, bin, name });
+      await startTunnel({ port, bin, name, url, token, passthrough });
       break;
     }
 

package/lib/tunnel.mjs

@@ -1,14 +1,18 @@
 /**
- * SSE-based tunnel that receives webhook requests from Reqly and
+ * Polling-based tunnel that receives webhook requests from Reqly and
  * forwards them to a local dev server.
  *
+ * Polling is used instead of SSE because it survives reverse proxies
+ * (Traefik, nginx) that buffer or drop long-lived streaming connections.
+ *
  * Flow:
  *   1. POST /api/tunnel/register  → register this tunnel
- *   2. GET  /api/tunnel/connect   → SSE stream of incoming requests
- *   3. For each event: forward to localhost, then
+ *   2. GET  /api/tunnel/poll      → fetch captures newer than the cursor
+ *   3. For each capture: forward to localhost, then
  *      POST /api/tunnel/response  → report the response back
  *
- * Reconnects automatically with exponential backoff + jitter.
+ * The poll loop keeps running through transient errors; it logs after
+ * repeated failures rather than giving up.
  */
 
 import { loadConfig } from "./config.mjs";
@@ -22,11 +26,6 @@ const RED = "\x1b[31m";
 const CYAN = "\x1b[36m";
 const RESET = "\x1b[0m";
 
-// ── Backoff settings ────────────────────────────────────────────────
-const BACKOFF_INITIAL_MS = 1000;
-const BACKOFF_MAX_MS = 60_000;
-const BACKOFF_FACTOR = 2;
-
 // ── Helpers ─────────────────────────────────────────────────────────
 
 function timestamp() {
@@ -76,11 +75,25 @@ async function forwardRequest(localOrigin, capture) {
 
   const start = Date.now();
 
+  // Clean headers — remove ones that break local forwarding
+  const cleanHeaders = {};
+  if (headers && typeof headers === "object") {
+    const skipHeaders = new Set(["host", "content-length", "transfer-encoding", "connection", "keep-alive", "upgrade", "http2-settings"]);
+    for (const [k, v] of Object.entries(headers)) {
+      if (!skipHeaders.has(k.toLowerCase())) {
+        cleanHeaders[k] = v;
+      }
+    }
+  }
+
+  // Don't send body for GET/HEAD
+  const hasBody = method && !["GET", "HEAD"].includes(method.toUpperCase());
+
   try {
     const res = await fetch(url, {
-      method: method || "POST",
-      headers: headers || {},
-      body: body != null ? (typeof body === "string" ? body : JSON.stringify(body)) : undefined,
+      method: method || "GET",
+      headers: cleanHeaders,
+      body: hasBody && body ? (typeof body === "string" ? body : JSON.stringify(body)) : undefined,
     });
 
     const resBody = await res.text();
@@ -148,14 +161,14 @@ function parseSSELine(line, current) {
  * Register this tunnel with the server.
  * Returns { tunnelId, binSlug, binUrl }.
  */
-async function registerTunnel(serverUrl, token, name, port, binSlug) {
+async function registerTunnel(serverUrl, token, name, port, binSlug, passthrough) {
   const res = await fetch(`${serverUrl}/api/tunnel/register`, {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
       Authorization: `Bearer ${token}`,
     },
-    body: JSON.stringify({ token, name, port, binSlug }),
+    body: JSON.stringify({ token, name, port, binSlug, passthrough: !!passthrough }),
   });
 
   if (!res.ok) {
@@ -170,7 +183,7 @@ async function registerTunnel(serverUrl, token, name, port, binSlug) {
  * Poll for new captures and forward them.
  * More reliable than SSE through reverse proxies (Traefik, nginx).
  */
-async function pollForCaptures(serverUrl, token, tunnelId, localOrigin) {
+async function pollForCaptures(serverUrl, token, tunnelId, localOrigin, pollIntervalMs = 1000) {
   let aborted = false;
   let lastSeen = new Date().toISOString();
   let consecutiveErrors = 0;
@@ -213,9 +226,14 @@ async function pollForCaptures(serverUrl, token, tunnelId, localOrigin) {
           try { headers = JSON.parse(headers); } catch { headers = {}; }
         }
 
-        const methodStr = (method || "POST").toUpperCase().padEnd(6);
+        // Compute local path for display
+        let displayPath = capture.path || "/";
+        const binMatch = displayPath.match(/^\/api\/bin\/[^/]+(\/.*)?$/);
+        if (binMatch) displayPath = binMatch[1] || "/";
+
+        const methodStr = (method || "GET").toUpperCase().padEnd(6);
         console.log(
-          `${DIM}[${timestamp()}]${RESET} ${CYAN}\u2192 ${methodStr}${RESET} ${path || "/"}`
+          `${DIM}[${timestamp()}]${RESET} ${CYAN}\u2192 ${methodStr}${RESET} ${displayPath}`
         );
 
         // Forward and report
@@ -225,7 +243,9 @@ async function pollForCaptures(serverUrl, token, tunnelId, localOrigin) {
           `${DIM}[${timestamp()}]${RESET} ${color}\u2190 ${result.status} ${result.statusText}${RESET} ${DIM}(${result.durationMs}ms)${RESET}`
         );
 
-        reportResponse(serverUrl, token, captureId, result).catch(() => {});
+        // Await the report so a passthrough request held open on the server
+        // is released as soon as possible (non-fatal if it fails).
+        await reportResponse(serverUrl, token, captureId, result).catch(() => {});
 
         // Update cursor
         if (capture.createdAt && capture.createdAt > lastSeen) {
@@ -245,8 +265,7 @@ async function pollForCaptures(serverUrl, token, tunnelId, localOrigin) {
     }
 
     if (aborted) return;
-    // Poll every 1 second
-    await new Promise((r) => setTimeout(r, 1000));
+    await new Promise((r) => setTimeout(r, pollIntervalMs));
   }
 }
 
@@ -260,16 +279,16 @@ async function pollForCaptures(serverUrl, token, tunnelId, localOrigin) {
  * @param {string} [opts.bin] - Bin slug to listen on (optional, server can assign)
  * @param {string} [opts.name] - Human-readable tunnel name
  */
-export async function startTunnel({ port, bin, name }) {
+export async function startTunnel({ port, bin, name, url, token: tokenOverride, passthrough }) {
   const config = loadConfig();
 
-  if (!config.token) {
-    console.log(`${RED}Not logged in.${RESET} Run ${BOLD}reqly login${RESET} first.`);
+  const serverUrl = url || config.url;
+  const token = tokenOverride || config.token;
+
+  if (!token) {
+    console.log(`${RED}Not logged in.${RESET} Run ${BOLD}reqly login${RESET} first, or pass ${BOLD}--token${RESET}.`);
     process.exit(1);
   }
-
-  const serverUrl = config.url;
-  const token = config.token;
   const localOrigin = `http://localhost:${port}`;
 
   // 1. Register the tunnel
@@ -281,7 +300,8 @@ export async function startTunnel({ port, bin, name }) {
       token,
       name || `cli-${port}`,
       port,
-      bin
+      bin,
+      passthrough
     );
     console.log(` ${GREEN}done${RESET}`);
   } catch (err) {
@@ -296,7 +316,18 @@ export async function startTunnel({ port, bin, name }) {
 
   // 2. Print banner
   printBanner(publicUrl, localOrigin, true);
+  if (passthrough) {
+    console.log(
+      `${DIM}[${timestamp()}]${RESET} ${CYAN}Passthrough mode${RESET} ${DIM}— relaying real responses (serves HTML/redirects)${RESET}`
+    );
+  }
 
-  // 3. Connect SSE and start forwarding
-  await pollForCaptures(serverUrl, token, tunnelId, localOrigin);
+  // 3. Start forwarding. Passthrough holds the caller open, so poll faster.
+  await pollForCaptures(
+    serverUrl,
+    token,
+    tunnelId,
+    localOrigin,
+    passthrough ? 250 : 1000
+  );
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "reqly-cli",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Reqly CLI — tunnel webhooks to your local dev server",
   "type": "module",
   "bin": {
-    "reqly": "./bin/reqly.mjs"
+    "reqly": "bin/reqly.mjs"
   },
   "files": [
     "bin/",