lunel-cli 0.1.34 → 0.1.36

package/dist/index.js

@@ -44,6 +44,14 @@ let activeControlWs = null;
 let activeDataWs = null;
 const activeTunnels = new Map();
 const PORT_SYNC_INTERVAL_MS = 30_000;
+const CLI_LOCAL_TCP_CONNECT_TIMEOUT_MS = 2_500;
+const PROXY_WS_CONNECT_TIMEOUT_MS = 12_000;
+const TUNNEL_SETUP_BUDGET_MS = 18_000;
+const PROXY_WS_CONNECT_RETRY_ATTEMPTS = 1;
+const PROXY_WS_RETRY_JITTER_MIN_MS = 200;
+const PROXY_WS_RETRY_JITTER_MAX_MS = 500;
+const PROXY_TUNNEL_LINGER_MS = 1_200;
+const LOOPBACK_HOSTS = ["127.0.0.1", "::1"];
 let portSyncTimer = null;
 let portScanInFlight = false;
 let lastDiscoveredPorts = [];
@@ -54,6 +62,55 @@ function redactSensitive(input) {
         .replace(/(password|token|authorization|resumeToken|x-manager-password)\s*[:=]\s*["']?[^"',\s}]+/gi, "$1=[redacted]")
         .replace(/[A-Za-z0-9+/=_-]{40,}/g, "[redacted_secret]");
 }
+function parseProxyControlFrame(raw) {
+    const text = typeof raw === "string" ? raw : Buffer.isBuffer(raw) ? raw.toString("utf-8") : null;
+    if (!text)
+        return null;
+    try {
+        const parsed = JSON.parse(text);
+        if (parsed?.v !== 1 || parsed?.t !== "proxy_ctrl")
+            return null;
+        if (parsed.action !== "fin" && parsed.action !== "rst")
+            return null;
+        return {
+            v: 1,
+            t: "proxy_ctrl",
+            action: parsed.action,
+            reason: typeof parsed.reason === "string" ? parsed.reason : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function sendProxyControl(tunnel, action, reason) {
+    if (tunnel.proxyWs.readyState !== WebSocket.OPEN)
+        return;
+    const frame = { v: 1, t: "proxy_ctrl", action, reason };
+    tunnel.proxyWs.send(JSON.stringify(frame));
+}
+function maybeFinalizeTunnel(tunnelId) {
+    const tunnel = activeTunnels.get(tunnelId);
+    if (!tunnel || tunnel.closing)
+        return;
+    if (!tunnel.localEnded || !tunnel.remoteEnded)
+        return;
+    if (tunnel.finalizeTimer)
+        return;
+    tunnel.finalizeTimer = setTimeout(() => {
+        const current = activeTunnels.get(tunnelId);
+        if (!current || current.closing)
+            return;
+        current.closing = true;
+        activeTunnels.delete(tunnelId);
+        if (!current.tcpSocket.destroyed) {
+            current.tcpSocket.destroy();
+        }
+        if (current.proxyWs.readyState === WebSocket.OPEN || current.proxyWs.readyState === WebSocket.CONNECTING) {
+            current.proxyWs.close();
+        }
+    }, PROXY_TUNNEL_LINGER_MS);
+}
 // Popular development server ports to scan on connect
 const DEV_PORTS = [
     1234, // Parcel
@@ -1634,20 +1691,36 @@ async function scanDevPorts() {
     const openPorts = [];
     const checks = SCAN_PORTS.map((port) => {
         return new Promise((resolve) => {
-            const socket = createConnection({ port, host: "127.0.0.1" });
-            socket.setTimeout(200);
-            socket.on("connect", () => {
-                openPorts.push(port);
-                socket.destroy();
-                resolve();
-            });
-            socket.on("timeout", () => {
-                socket.destroy();
-                resolve();
-            });
-            socket.on("error", () => {
-                resolve();
-            });
+            let finished = false;
+            let pending = LOOPBACK_HOSTS.length;
+            for (const host of LOOPBACK_HOSTS) {
+                const socket = createConnection({ port, host });
+                socket.setTimeout(200);
+                socket.on("connect", () => {
+                    if (finished)
+                        return;
+                    finished = true;
+                    openPorts.push(port);
+                    socket.destroy();
+                    resolve();
+                });
+                const onDone = () => {
+                    if (finished)
+                        return;
+                    pending -= 1;
+                    if (pending <= 0) {
+                        finished = true;
+                        resolve();
+                    }
+                };
+                socket.on("timeout", () => {
+                    socket.destroy();
+                    onDone();
+                });
+                socket.on("error", () => {
+                    onDone();
+                });
+            }
         });
     });
     await Promise.all(checks);
@@ -1698,53 +1771,132 @@ function startPortSync(ws) {
 async function handleProxyConnect(payload) {
     const tunnelId = payload.tunnelId;
     const port = payload.port;
+    const setupStartedAt = Date.now();
+    const getRemainingSetupMs = () => TUNNEL_SETUP_BUDGET_MS - (Date.now() - setupStartedAt);
     if (!tunnelId)
         throw Object.assign(new Error("tunnelId is required"), { code: "EINVAL" });
     if (!port)
         throw Object.assign(new Error("port is required"), { code: "EINVAL" });
     if (!currentSessionCode && !currentSessionPassword)
         throw Object.assign(new Error("no active session"), { code: "ENOENT" });
-    // 1. Open TCP connection to the local service
-    const tcpSocket = createConnection({ port, host: "127.0.0.1" });
-    await new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-            tcpSocket.destroy();
-            reject(Object.assign(new Error(`TCP connect timeout to localhost:${port}`), { code: "ETIMEOUT" }));
-        }, 5000);
-        tcpSocket.on("connect", () => {
-            clearTimeout(timeout);
-            resolve();
-        });
-        tcpSocket.on("error", (err) => {
-            clearTimeout(timeout);
-            reject(Object.assign(new Error(`TCP connect failed: ${err.message}`), { code: "ECONNREFUSED" }));
-        });
-    });
+    if (getRemainingSetupMs() <= 0) {
+        throw Object.assign(new Error("Tunnel setup timeout before start"), { code: "ETIMEOUT" });
+    }
+    // 1. Open TCP connection to the local service (dual-stack localhost fallback)
+    let tcpSocket = null;
+    let tcpConnectError = null;
+    for (const host of LOOPBACK_HOSTS) {
+        const remainingMs = getRemainingSetupMs();
+        if (remainingMs <= 0) {
+            throw Object.assign(new Error("Tunnel setup timeout before local TCP connect"), { code: "ETIMEOUT" });
+        }
+        const tcpConnectTimeoutMs = Math.min(CLI_LOCAL_TCP_CONNECT_TIMEOUT_MS, Math.max(250, remainingMs));
+        const candidate = createConnection({ port, host });
+        try {
+            await new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    candidate.destroy();
+                    reject(Object.assign(new Error(`TCP connect timeout to ${host}:${port}`), { code: "ETIMEOUT" }));
+                }, tcpConnectTimeoutMs);
+                candidate.on("connect", () => {
+                    clearTimeout(timeout);
+                    resolve();
+                });
+                candidate.on("error", (err) => {
+                    clearTimeout(timeout);
+                    reject(Object.assign(new Error(`TCP connect failed to ${host}:${port}: ${err.message}`), { code: "ECONNREFUSED" }));
+                });
+            });
+            tcpSocket = candidate;
+            break;
+        }
+        catch (error) {
+            tcpConnectError = error;
+            try {
+                candidate.destroy();
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    if (!tcpSocket) {
+        throw tcpConnectError || Object.assign(new Error(`TCP connect failed to localhost:${port}`), { code: "ECONNREFUSED" });
+    }
     // 2. Open proxy WebSocket to gateway
     const wsBase = activeGatewayUrl.replace(/^http/, "ws");
     const authQuery = currentSessionPassword
         ? `password=${encodeURIComponent(currentSessionPassword)}`
         : `code=${encodeURIComponent(currentSessionCode)}`;
     const proxyWsUrl = `${wsBase}/v1/ws/proxy?${authQuery}&tunnelId=${encodeURIComponent(tunnelId)}&role=cli`;
-    const proxyWs = new WebSocket(proxyWsUrl);
-    await new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-            proxyWs.close();
-            tcpSocket.destroy();
-            reject(Object.assign(new Error("Proxy WS connect timeout"), { code: "ETIMEOUT" }));
-        }, 5000);
-        proxyWs.on("open", () => {
-            clearTimeout(timeout);
-            resolve();
-        });
-        proxyWs.on("error", (err) => {
-            clearTimeout(timeout);
+    let proxyWs = null;
+    let lastProxyError = null;
+    for (let attempt = 0; attempt <= PROXY_WS_CONNECT_RETRY_ATTEMPTS; attempt++) {
+        const remainingMs = getRemainingSetupMs();
+        if (remainingMs <= 0) {
             tcpSocket.destroy();
-            reject(Object.assign(new Error(`Proxy WS failed: ${err.message}`), { code: "ECONNREFUSED" }));
-        });
-    });
+            throw Object.assign(new Error("Tunnel setup timeout while connecting proxy WS"), { code: "ETIMEOUT" });
+        }
+        const wsConnectTimeoutMs = Math.min(PROXY_WS_CONNECT_TIMEOUT_MS, Math.max(250, remainingMs));
+        const candidateWs = new WebSocket(proxyWsUrl);
+        try {
+            await new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    candidateWs.close();
+                    reject(Object.assign(new Error("Proxy WS connect timeout"), { code: "ETIMEOUT" }));
+                }, wsConnectTimeoutMs);
+                candidateWs.on("open", () => {
+                    clearTimeout(timeout);
+                    resolve();
+                });
+                candidateWs.on("error", (err) => {
+                    clearTimeout(timeout);
+                    reject(Object.assign(new Error(`Proxy WS failed: ${err.message}`), { code: "ECONNREFUSED" }));
+                });
+                candidateWs.on("close", () => {
+                    clearTimeout(timeout);
+                    reject(Object.assign(new Error("Proxy WS closed during connect"), { code: "ECONNRESET" }));
+                });
+            });
+            proxyWs = candidateWs;
+            break;
+        }
+        catch (error) {
+            lastProxyError = error;
+            try {
+                candidateWs.close();
+            }
+            catch {
+                // ignore
+            }
+            if (attempt >= PROXY_WS_CONNECT_RETRY_ATTEMPTS) {
+                break;
+            }
+            const jitterSpan = PROXY_WS_RETRY_JITTER_MAX_MS - PROXY_WS_RETRY_JITTER_MIN_MS;
+            const jitterMs = PROXY_WS_RETRY_JITTER_MIN_MS + Math.floor(Math.random() * (jitterSpan + 1));
+            if (getRemainingSetupMs() <= jitterMs) {
+                break;
+            }
+            await new Promise((resolve) => setTimeout(resolve, jitterMs));
+        }
+    }
+    if (!proxyWs) {
+        tcpSocket.destroy();
+        const err = lastProxyError || Object.assign(new Error("Proxy WS connect failed"), { code: "ECONNREFUSED" });
+        throw err;
+    }
     // 3. Store the tunnel
-    activeTunnels.set(tunnelId, { tunnelId, port, tcpSocket, proxyWs });
+    activeTunnels.set(tunnelId, {
+        tunnelId,
+        port,
+        tcpSocket,
+        proxyWs,
+        localEnded: false,
+        remoteEnded: false,
+        finSent: false,
+        finalizeTimer: null,
+        closing: false,
+    });
     // 4. Pipe: TCP data -> proxy WS (as binary)
     tcpSocket.on("data", (chunk) => {
         if (proxyWs.readyState === WebSocket.OPEN) {
@@ -1753,18 +1905,70 @@ async function handleProxyConnect(payload) {
     });
     // 5. Pipe: proxy WS -> TCP socket (as binary)
     proxyWs.on("message", (data) => {
+        const control = parseProxyControlFrame(data);
+        if (control) {
+            const tunnel = activeTunnels.get(tunnelId);
+            if (!tunnel || tunnel.closing)
+                return;
+            if (control.action === "fin") {
+                tunnel.remoteEnded = true;
+                if (!tcpSocket.destroyed) {
+                    tcpSocket.end();
+                }
+                maybeFinalizeTunnel(tunnelId);
+            }
+            else {
+                tunnel.closing = true;
+                activeTunnels.delete(tunnelId);
+                if (!tcpSocket.destroyed) {
+                    tcpSocket.destroy();
+                }
+                if (proxyWs.readyState === WebSocket.OPEN || proxyWs.readyState === WebSocket.CONNECTING) {
+                    proxyWs.close();
+                }
+            }
+            return;
+        }
         if (!tcpSocket.destroyed) {
-            tcpSocket.write(data);
+            const chunk = Buffer.isBuffer(data)
+                ? data
+                : typeof data === "string"
+                    ? Buffer.from(data)
+                    : Array.isArray(data)
+                        ? Buffer.concat(data)
+                        : Buffer.from(data);
+            tcpSocket.write(chunk);
         }
     });
-    // 6. Close cascade: TCP closes -> close WS
-    tcpSocket.on("close", () => {
-        activeTunnels.delete(tunnelId);
-        if (proxyWs.readyState === WebSocket.OPEN || proxyWs.readyState === WebSocket.CONNECTING) {
-            proxyWs.close();
+    const markLocalEnded = () => {
+        const tunnel = activeTunnels.get(tunnelId);
+        if (!tunnel || tunnel.closing)
+            return;
+        tunnel.localEnded = true;
+        if (!tunnel.finSent) {
+            tunnel.finSent = true;
+            sendProxyControl(tunnel, "fin");
         }
+        maybeFinalizeTunnel(tunnelId);
+    };
+    // 6. Half-close handling
+    tcpSocket.on("end", () => {
+        markLocalEnded();
+    });
+    tcpSocket.on("close", () => {
+        markLocalEnded();
     });
     tcpSocket.on("error", () => {
+        const tunnel = activeTunnels.get(tunnelId);
+        if (tunnel && !tunnel.finSent) {
+            sendProxyControl(tunnel, "rst", "tcp_error");
+        }
+        if (tunnel) {
+            tunnel.closing = true;
+            if (tunnel.finalizeTimer) {
+                clearTimeout(tunnel.finalizeTimer);
+            }
+        }
         activeTunnels.delete(tunnelId);
         if (proxyWs.readyState === WebSocket.OPEN || proxyWs.readyState === WebSocket.CONNECTING) {
             proxyWs.close();
@@ -1772,12 +1976,26 @@ async function handleProxyConnect(payload) {
     });
     // 7. Close cascade: WS closes -> close TCP
     proxyWs.on("close", () => {
+        const tunnel = activeTunnels.get(tunnelId);
+        if (tunnel) {
+            tunnel.closing = true;
+            if (tunnel.finalizeTimer) {
+                clearTimeout(tunnel.finalizeTimer);
+            }
+        }
         activeTunnels.delete(tunnelId);
         if (!tcpSocket.destroyed) {
             tcpSocket.destroy();
         }
     });
     proxyWs.on("error", () => {
+        const tunnel = activeTunnels.get(tunnelId);
+        if (tunnel) {
+            tunnel.closing = true;
+            if (tunnel.finalizeTimer) {
+                clearTimeout(tunnel.finalizeTimer);
+            }
+        }
         activeTunnels.delete(tunnelId);
         if (!tcpSocket.destroyed) {
             tcpSocket.destroy();
@@ -1787,6 +2005,9 @@ async function handleProxyConnect(payload) {
 }
 function cleanupAllTunnels() {
     for (const [, tunnel] of activeTunnels) {
+        if (tunnel.finalizeTimer) {
+            clearTimeout(tunnel.finalizeTimer);
+        }
         tunnel.tcpSocket.destroy();
         if (tunnel.proxyWs.readyState === WebSocket.OPEN) {
             tunnel.proxyWs.close();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lunel-cli",
-  "version": "0.1.34",
+  "version": "0.1.36",
   "author": [
     {
       "name": "Soham Bharambe",