reqly-cli 0.1.0 → 0.2.0

package/lib/tunnel.mjs

@@ -159,18 +159,16 @@ async function registerTunnel(serverUrl, token, name, port, binSlug) {
 }
 
 /**
- * Connect to the SSE stream and process incoming requests.
- * Handles reconnection with exponential backoff.
+ * Poll for new captures and forward them.
+ * More reliable than SSE through reverse proxies (Traefik, nginx).
  */
-async function connectSSE(serverUrl, token, tunnelId, localOrigin) {
-  let backoff = BACKOFF_INITIAL_MS;
+async function pollForCaptures(serverUrl, token, tunnelId, localOrigin) {
   let aborted = false;
-  let controller;
+  let lastSeen = new Date().toISOString();
+  let consecutiveErrors = 0;
 
-  // Clean shutdown
   function shutdown() {
     aborted = true;
-    if (controller) controller.abort();
     console.log();
     console.log(`${DIM}[${timestamp()}]${RESET} Tunnel closed.`);
     process.exit(0);
@@ -178,112 +176,72 @@ async function connectSSE(serverUrl, token, tunnelId, localOrigin) {
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
 
-  while (!aborted) {
-    controller = new AbortController();
+  console.log(
+    `${DIM}[${timestamp()}]${RESET} ${GREEN}Listening for requests...${RESET}`
+  );
 
+  while (!aborted) {
     try {
-      const sseUrl = `${serverUrl}/api/tunnel/connect?token=${encodeURIComponent(token)}&tunnelId=${encodeURIComponent(tunnelId)}`;
+      const pollUrl = `${serverUrl}/api/tunnel/poll?token=${encodeURIComponent(token)}&tunnelId=${encodeURIComponent(tunnelId)}&since=${encodeURIComponent(lastSeen)}`;
 
-      const res = await fetch(sseUrl, {
-        headers: { Accept: "text/event-stream" },
-        signal: controller.signal,
+      const res = await fetch(pollUrl, {
+        headers: { Authorization: `Bearer ${token}` },
       });
 
       if (!res.ok) {
-        throw new Error(`SSE connection failed (${res.status})`);
+        throw new Error(`Poll failed (${res.status})`);
       }
 
-      // Reset backoff on successful connection
-      backoff = BACKOFF_INITIAL_MS;
-      console.log(
-        `${DIM}[${timestamp()}]${RESET} ${GREEN}Connected to tunnel stream${RESET}`
-      );
-
-      // Read the SSE stream line by line
-      const reader = res.body.getReader();
-      const decoder = new TextDecoder();
-      let buffer = "";
-      let current = {};
-
-      while (true) {
-        const { value, done } = await reader.read();
-        if (done) break;
-
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
-        buffer = lines.pop(); // keep incomplete line in buffer
-
-        for (const line of lines) {
-          if (line === "") {
-            // Empty line = end of event
-            if (current.data) {
-              handleEvent(current, serverUrl, token, localOrigin);
-            }
-            current = {};
-          } else {
-            parseSSELine(line, current);
-          }
+      consecutiveErrors = 0;
+      const data = await res.json();
+
+      for (const capture of data.captures || []) {
+        const { captureId, method, path } = capture;
+        if (!captureId) continue;
+
+        // Parse headers if they're a string
+        let headers = capture.headers;
+        if (typeof headers === "string") {
+          try { headers = JSON.parse(headers); } catch { headers = {}; }
         }
-      }
 
-      // Stream ended normally — server closed the connection
-      console.log(
-        `${DIM}[${timestamp()}]${RESET} ${YELLOW}Stream ended, reconnecting...${RESET}`
-      );
+        const methodStr = (method || "POST").toUpperCase().padEnd(6);
+        console.log(
+          `${DIM}[${timestamp()}]${RESET} ${CYAN}\u2192 ${methodStr}${RESET} ${path || "/"}`
+        );
+
+        // Forward and report
+        const result = await forwardRequest(localOrigin, { ...capture, headers });
+        const color = result.status < 400 ? GREEN : RED;
+        console.log(
+          `${DIM}[${timestamp()}]${RESET} ${color}\u2190 ${result.status} ${result.statusText}${RESET} ${DIM}(${result.durationMs}ms)${RESET}`
+        );
+
+        reportResponse(serverUrl, token, captureId, result).catch(() => {});
+
+        // Update cursor
+        if (capture.createdAt && capture.createdAt > lastSeen) {
+          lastSeen = capture.createdAt;
+        }
+      }
     } catch (err) {
       if (aborted) return;
-      console.log(
-        `${DIM}[${timestamp()}]${RESET} ${RED}Connection error: ${err.message}${RESET}`
-      );
+      consecutiveErrors++;
+      if (consecutiveErrors <= 3) {
+        // Silent for first few errors
+      } else if (consecutiveErrors % 10 === 0) {
+        console.log(
+          `${DIM}[${timestamp()}]${RESET} ${RED}Poll error: ${err.message}${RESET}`
+        );
+      }
     }
 
     if (aborted) return;
-
-    // Exponential backoff with jitter
-    const jitter = Math.random() * backoff * 0.3;
-    const delay = Math.min(backoff + jitter, BACKOFF_MAX_MS);
-    console.log(
-      `${DIM}[${timestamp()}]${RESET} ${YELLOW}Reconnecting in ${(delay / 1000).toFixed(1)}s...${RESET}`
-    );
-    await new Promise((r) => setTimeout(r, delay));
-    backoff = Math.min(backoff * BACKOFF_FACTOR, BACKOFF_MAX_MS);
+    // Poll every 1 second
+    await new Promise((r) => setTimeout(r, 1000));
   }
 }
 
-/**
- * Handle a single SSE event: forward the request and report back.
- */
-function handleEvent(event, serverUrl, token, localOrigin) {
-  // We only care about "request" events
-  if (event.event && event.event !== "request" && event.event !== "message") {
-    return;
-  }
-
-  let payload;
-  try {
-    payload = JSON.parse(event.data);
-  } catch {
-    return; // ignore malformed events (e.g. heartbeat pings)
-  }
-
-  const { captureId, method, path } = payload;
-  if (!captureId) return;
-
-  const methodStr = (method || "POST").toUpperCase().padEnd(6);
-  console.log(
-    `${DIM}[${timestamp()}]${RESET} ${CYAN}\u2192 ${methodStr}${RESET} ${path || "/"}`
-  );
-
-  // Fire-and-forget: forward + report (don't block the event loop)
-  forwardRequest(localOrigin, payload).then((result) => {
-    const color = result.status < 400 ? GREEN : RED;
-    console.log(
-      `${DIM}[${timestamp()}]${RESET} ${color}\u2190 ${result.status} ${result.statusText}${RESET} ${DIM}(${result.durationMs}ms)${RESET}`
-    );
-    return reportResponse(serverUrl, token, captureId, result);
-  });
-}
-
 // ── Public API ──────────────────────────────────────────────────────
 
 /**
@@ -332,5 +290,5 @@ export async function startTunnel({ port, bin, name }) {
   printBanner(publicUrl, localOrigin, true);
 
   // 3. Connect SSE and start forwarding
-  await connectSSE(serverUrl, token, tunnelId, localOrigin);
+  await pollForCaptures(serverUrl, token, tunnelId, localOrigin);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reqly-cli",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Reqly CLI — tunnel webhooks to your local dev server",
   "type": "module",
   "bin": {