reqly-cli 0.2.3 → 0.3.1

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() {
@@ -162,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) {
@@ -183,8 +182,14 @@ async function registerTunnel(serverUrl, token, name, port, binSlug) {
 /**
  * Poll for new captures and forward them.
  * More reliable than SSE through reverse proxies (Traefik, nginx).
+ *
+ * The server's tunnel registry is in-memory with a short TTL, so after the
+ * laptop sleeps (poll loop frozen) or the server restarts, the tunnelId is
+ * forgotten and poll returns 404/401. When that happens we re-register via
+ * `reregister()` to get a fresh tunnelId and resume — so the tunnel
+ * self-heals instead of looping forever on a dead id.
  */
-async function pollForCaptures(serverUrl, token, tunnelId, localOrigin) {
+async function pollForCaptures({ serverUrl, token, tunnelId, localOrigin, pollIntervalMs = 1000, reregister }) {
   let aborted = false;
   let lastSeen = new Date().toISOString();
   let consecutiveErrors = 0;
@@ -210,6 +215,22 @@ async function pollForCaptures(serverUrl, token, tunnelId, localOrigin) {
         headers: { Authorization: `Bearer ${token}` },
       });
 
+      // 404 = server forgot this tunnel (sleep/restart); 401 = token re-auth
+      // needed. Either way, re-register to get a fresh tunnelId and resume.
+      if (res.status === 404 || res.status === 401) {
+        console.log(
+          `${DIM}[${timestamp()}]${RESET} ${YELLOW}Tunnel dropped (${res.status}) — reconnecting...${RESET}`
+        );
+        const fresh = await reregister();
+        tunnelId = fresh.tunnelId;
+        consecutiveErrors = 0;
+        console.log(
+          `${DIM}[${timestamp()}]${RESET} ${GREEN}Reconnected.${RESET} ${DIM}Listening for requests...${RESET}`
+        );
+        await new Promise((r) => setTimeout(r, pollIntervalMs));
+        continue;
+      }
+
       if (!res.ok) {
         throw new Error(`Poll failed (${res.status})`);
       }
@@ -244,7 +265,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) {
@@ -264,8 +287,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));
   }
 }
 
@@ -279,29 +301,57 @@ 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
-  let registration;
-  try {
-    process.stdout.write(`${DIM}Registering tunnel...${RESET}`);
-    registration = await registerTunnel(
+  // Re-register against the SAME bin slug each time so the public URL stays
+  // stable across reconnects. On the first call `bin` may be undefined (the
+  // server auto-creates a bin); afterwards we reuse the slug it returned.
+  let knownBinSlug = bin;
+  async function register() {
+    const reg = await registerTunnel(
       serverUrl,
       token,
       name || `cli-${port}`,
       port,
-      bin
+      knownBinSlug,
+      passthrough
     );
+    knownBinSlug = reg.binSlug;
+    return reg;
+  }
+
+  // Resilient re-register: keep retrying with backoff until the server is
+  // reachable again (e.g. it's still booting after a restart).
+  async function reregister() {
+    let delay = 1000;
+    for (;;) {
+      try {
+        return await register();
+      } catch (err) {
+        console.log(
+          `${DIM}[${timestamp()}]${RESET} ${YELLOW}Reconnect failed: ${err.message} — retrying in ${Math.round(delay / 1000)}s${RESET}`
+        );
+        await new Promise((r) => setTimeout(r, delay));
+        delay = Math.min(delay * 2, 30_000);
+      }
+    }
+  }
+
+  // 1. Register the tunnel
+  let registration;
+  try {
+    process.stdout.write(`${DIM}Registering tunnel...${RESET}`);
+    registration = await register();
     console.log(` ${GREEN}done${RESET}`);
   } catch (err) {
     console.log(` ${RED}failed${RESET}`);
@@ -315,7 +365,19 @@ 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,
+    pollIntervalMs: passthrough ? 250 : 1000,
+    reregister,
+  });
 }

package/package.json

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