forge-remote 0.1.0

package/src/tunnel-manager.js

@@ -0,0 +1,201 @@
+import { spawn, execSync } from "child_process";
+import * as log from "./logger.js";
+
+/**
+ * Manages localhost tunnels for dev server previews.
+ *
+ * Prefers `cloudflared` (no splash page, more reliable) and falls back
+ * to `localtunnel` if cloudflared is not installed.
+ */
+
+const activeTunnels = new Map(); // sessionId → { process, port, url }
+
+// Detect which tunnel binary is available (checked once at startup).
+let tunnelBackend = "none";
+try {
+  execSync("which cloudflared", { stdio: "pipe" });
+  tunnelBackend = "cloudflared";
+  log.info("Tunnel backend: cloudflared");
+} catch {
+  try {
+    execSync("which npx", { stdio: "pipe" });
+    tunnelBackend = "localtunnel";
+    log.info(
+      "Tunnel backend: localtunnel (install cloudflared for better experience)",
+    );
+  } catch {
+    log.warn("No tunnel backend available — live preview will not work");
+  }
+}
+
+/**
+ * Start a tunnel for a localhost port.
+ * Returns the public tunnel URL, or null on failure.
+ */
+export async function startTunnel(sessionId, port) {
+  if (tunnelBackend === "none") {
+    log.warn("No tunnel backend available — skipping tunnel creation");
+    return null;
+  }
+
+  // Don't create duplicate tunnels for the same session+port.
+  const existing = activeTunnels.get(sessionId);
+  if (existing && existing.port === port) {
+    log.info(
+      `Tunnel already active for session ${sessionId.slice(0, 8)} on port ${port}`,
+    );
+    return existing.url;
+  }
+
+  // Stop any previous tunnel for this session.
+  if (existing) {
+    await stopTunnel(sessionId);
+  }
+
+  log.info(`Starting ${tunnelBackend} tunnel for localhost:${port}...`);
+
+  if (tunnelBackend === "cloudflared") {
+    return startCloudflaredTunnel(sessionId, port);
+  }
+  return startLocaltunnel(sessionId, port);
+}
+
+// ---------------------------------------------------------------------------
+// Cloudflared (preferred — no splash page)
+// ---------------------------------------------------------------------------
+
+function startCloudflaredTunnel(sessionId, port) {
+  return new Promise((resolve) => {
+    const proc = spawn(
+      "cloudflared",
+      ["tunnel", "--url", `http://localhost:${port}`],
+      { stdio: ["pipe", "pipe", "pipe"] },
+    );
+
+    let url = null;
+    let stderrBuf = "";
+
+    const timeout = setTimeout(() => {
+      if (!url) {
+        log.warn(
+          `cloudflared tunnel startup timed out after 30s for port ${port}`,
+        );
+        proc.kill("SIGTERM");
+        resolve(null);
+      }
+    }, 30_000);
+
+    // cloudflared prints the URL to stderr, not stdout.
+    proc.stderr.on("data", (data) => {
+      stderrBuf += data.toString();
+      // Matches: https://some-random-name.trycloudflare.com
+      const match = stderrBuf.match(
+        /https:\/\/[a-z0-9-]+\.trycloudflare\.com/i,
+      );
+      if (match && !url) {
+        url = match[0].trim();
+        clearTimeout(timeout);
+        activeTunnels.set(sessionId, { process: proc, port, url });
+        log.success(`Tunnel active: localhost:${port} → ${url}`);
+        resolve(url);
+      }
+    });
+
+    proc.on("error", (err) => {
+      clearTimeout(timeout);
+      log.error(`cloudflared failed to start: ${err.message}`);
+      resolve(null);
+    });
+
+    proc.on("close", (code) => {
+      clearTimeout(timeout);
+      activeTunnels.delete(sessionId);
+      if (code !== 0 && code !== null) {
+        log.warn(`cloudflared process exited with code ${code}`);
+      }
+      if (!url) resolve(null);
+    });
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Localtunnel (fallback)
+// ---------------------------------------------------------------------------
+
+function startLocaltunnel(sessionId, port) {
+  return new Promise((resolve) => {
+    const proc = spawn("npx", ["localtunnel", "--port", String(port)], {
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    let url = null;
+    let stdoutBuf = "";
+
+    const timeout = setTimeout(() => {
+      if (!url) {
+        log.warn(`localtunnel startup timed out after 30s for port ${port}`);
+        proc.kill("SIGTERM");
+        resolve(null);
+      }
+    }, 30_000);
+
+    proc.stdout.on("data", (data) => {
+      stdoutBuf += data.toString();
+      // localtunnel outputs: "your url is: https://xyz.loca.lt"
+      const match = stdoutBuf.match(/your url is:\s*(https?:\/\/\S+)/i);
+      if (match && !url) {
+        url = match[1].trim();
+        clearTimeout(timeout);
+
+        activeTunnels.set(sessionId, { process: proc, port, url });
+        log.success(`Tunnel active: localhost:${port} → ${url}`);
+        resolve(url);
+      }
+    });
+
+    proc.stderr.on("data", (data) => {
+      const msg = data.toString().trim();
+      if (msg) log.warn(`[tunnel] ${msg}`);
+    });
+
+    proc.on("error", (err) => {
+      clearTimeout(timeout);
+      log.error(`localtunnel failed to start: ${err.message}`);
+      resolve(null);
+    });
+
+    proc.on("close", (code) => {
+      clearTimeout(timeout);
+      activeTunnels.delete(sessionId);
+      if (code !== 0 && code !== null) {
+        log.warn(`localtunnel process exited with code ${code}`);
+      }
+      if (!url) resolve(null);
+    });
+  });
+}
+
+/**
+ * Stop the tunnel for a session.
+ */
+export async function stopTunnel(sessionId) {
+  const tunnel = activeTunnels.get(sessionId);
+  if (!tunnel) return;
+
+  log.info(
+    `Stopping tunnel for session ${sessionId.slice(0, 8)} (port ${tunnel.port})`,
+  );
+  tunnel.process.kill("SIGTERM");
+  activeTunnels.delete(sessionId);
+}
+
+/**
+ * Stop all active tunnels (relay shutdown cleanup).
+ */
+export async function stopAllTunnels() {
+  for (const [sessionId, tunnel] of activeTunnels) {
+    log.info(`Cleanup: stopping tunnel for ${sessionId.slice(0, 8)}`);
+    tunnel.process.kill("SIGTERM");
+  }
+  activeTunnels.clear();
+}