lunel-cli 0.1.28 → 0.1.30

package/dist/index.js

@@ -11,7 +11,8 @@ import * as os from "os";
 import { spawn, execSync } from "child_process";
 import { createServer, createConnection } from "net";
 import { createInterface } from "readline";
-const PROXY_URL = process.env.LUNEL_PROXY_URL || "https://gateway.lunel.dev";
+const DEFAULT_PROXY_URL = process.env.LUNEL_PROXY_URL || "https://gateway.lunel.dev";
+const MANAGER_URL = process.env.LUNEL_MANAGER_URL || "https://manager.lunel.dev";
 import { createRequire } from "module";
 const __require = createRequire(import.meta.url);
 const VERSION = __require("../package.json").version;
@@ -30,6 +31,13 @@ let lastCpuInfo = null;
 let opencodeClient = null;
 // Proxy tunnel management
 let currentSessionCode = null;
+let currentSessionPassword = null;
+let currentPrimaryGateway = DEFAULT_PROXY_URL;
+let currentBackupGateway = null;
+let activeGatewayUrl = DEFAULT_PROXY_URL;
+let shuttingDown = false;
+let activeControlWs = null;
+let activeDataWs = null;
 const activeTunnels = new Map();
 // Popular development server ports to scan on connect
 const DEV_PORTS = [
@@ -1433,7 +1441,7 @@ async function handleProxyConnect(payload) {
         throw Object.assign(new Error("tunnelId is required"), { code: "EINVAL" });
     if (!port)
         throw Object.assign(new Error("port is required"), { code: "EINVAL" });
-    if (!currentSessionCode)
+    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" });
@@ -1452,8 +1460,11 @@ async function handleProxyConnect(payload) {
         });
     });
     // 2. Open proxy WebSocket to gateway
-    const wsBase = PROXY_URL.replace(/^http/, "ws");
-    const proxyWsUrl = `${wsBase}/v1/ws/proxy?code=${currentSessionCode}&tunnelId=${tunnelId}&role=cli`;
+    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(() => {
@@ -1539,6 +1550,19 @@ async function processMessage(message) {
             error: { code: "EPROTO", message: `Unsupported protocol version: ${v}` },
         };
     }
+    // Validate required fields
+    if (!ns || !action) {
+        console.warn("[router] Ignoring message with missing ns/action:", JSON.stringify(message).substring(0, 300));
+        return {
+            v: 1,
+            id,
+            ns,
+            action,
+            ok: false,
+            payload: {},
+            error: { code: "EINVAL", message: `Missing namespace or action` },
+        };
+    }
     try {
         let result;
         switch (ns) {
@@ -1795,11 +1819,35 @@ async function processMessage(message) {
         };
     }
 }
-// ============================================================================
-// WebSocket Connection
-// ============================================================================
-async function createSession() {
-    const response = await fetch(`${PROXY_URL}/v1/session`, {
+function normalizeGatewayUrl(input) {
+    if (/^https?:\/\//.test(input))
+        return input.replace(/\/+$/, "");
+    return `https://${input}`.replace(/\/+$/, "");
+}
+async function discoverGateways() {
+    try {
+        const response = await fetch(`${MANAGER_URL}/v1/gateways`, {
+            method: "GET",
+            headers: { "Content-Type": "application/json" },
+        });
+        if (!response.ok) {
+            throw new Error(`manager returned ${response.status}`);
+        }
+        const data = (await response.json());
+        const gateways = (data.gateways || []).map((x) => normalizeGatewayUrl(x)).filter(Boolean);
+        const primary = data.primary ? normalizeGatewayUrl(data.primary) : gateways[0];
+        const backup = data.backup ? normalizeGatewayUrl(data.backup) : gateways[1] || null;
+        if (!primary)
+            throw new Error("manager returned no healthy gateways");
+        return { primary, backup };
+    }
+    catch (err) {
+        console.warn(`[manager] gateway discovery failed, using default: ${err.message}`);
+        return { primary: DEFAULT_PROXY_URL, backup: null };
+    }
+}
+async function createSession(gatewayUrl) {
+    const response = await fetch(`${gatewayUrl}/v1/session`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
     });
@@ -1809,142 +1857,244 @@ async function createSession() {
     const data = (await response.json());
     return data.code;
 }
-function displayQR(code) {
+function displayQR(primaryGateway, backupGateway, code) {
+    const qrPayload = backupGateway
+        ? `${primaryGateway},${backupGateway},${code}`
+        : `${primaryGateway},${code}`;
     console.log("\n");
-    qrcode.generate(code, { small: true }, (qr) => {
+    qrcode.generate(qrPayload, { small: true }, (qr) => {
         console.log(qr);
         console.log(`\n  Session code: ${code}\n`);
+        console.log(`  Primary gateway: ${primaryGateway}`);
+        if (backupGateway) {
+            console.log(`  Backup gateway: ${backupGateway}`);
+        }
         console.log(`  Root directory: ${ROOT_DIR}\n`);
         console.log("  Scan the QR code with the Lunel app to connect.");
         console.log("  Press Ctrl+C to exit.\n");
     });
 }
-function connectWebSocket(code) {
-    currentSessionCode = code;
-    const wsBase = PROXY_URL.replace(/^http/, "ws");
-    const controlUrl = `${wsBase}/v1/ws/cli/control?code=${code}`;
-    const dataUrl = `${wsBase}/v1/ws/cli/data?code=${code}`;
-    console.log("Connecting to proxy...");
-    // Control channel
-    const controlWs = new WebSocket(controlUrl);
-    let controlConnected = false;
-    // Data channel
-    const dataWs = new WebSocket(dataUrl);
-    let dataConnected = false;
-    // Store data channel reference for terminal output
-    dataChannel = dataWs;
-    function checkFullyConnected() {
-        if (controlConnected && dataConnected) {
-            console.log("Connected to proxy (control + data channels). Waiting for app...\n");
+function buildWsUrl(gatewayUrl, role, channel) {
+    const wsBase = gatewayUrl.replace(/^http/, "ws");
+    const query = new URLSearchParams();
+    if (currentSessionPassword) {
+        query.set("password", currentSessionPassword);
+    }
+    else if (currentSessionCode) {
+        query.set("code", currentSessionCode);
+        if (currentBackupGateway) {
+            query.set("backup", currentBackupGateway);
         }
     }
-    // Control channel handlers
-    controlWs.on("open", () => {
-        controlConnected = true;
-        checkFullyConnected();
-    });
-    controlWs.on("message", async (data) => {
+    else {
+        throw new Error("missing code/password for websocket connect");
+    }
+    return `${wsBase}/v1/ws/${role}/${channel}?${query.toString()}`;
+}
+function gracefulShutdown() {
+    shuttingDown = true;
+    console.log("\nShutting down...");
+    if (ptyProcess) {
+        ptyProcess.kill();
+        ptyProcess = null;
+    }
+    terminals.clear();
+    for (const [pid, managedProc] of processes) {
+        managedProc.proc.kill();
+    }
+    processes.clear();
+    processOutputBuffers.clear();
+    cleanupAllTunnels();
+    if (activeControlWs && (activeControlWs.readyState === WebSocket.OPEN || activeControlWs.readyState === WebSocket.CONNECTING)) {
+        activeControlWs.close();
+    }
+    if (activeDataWs && (activeDataWs.readyState === WebSocket.OPEN || activeDataWs.readyState === WebSocket.CONNECTING)) {
+        activeDataWs.close();
+    }
+    process.exit(0);
+}
+async function connectWebSocket() {
+    const gateways = currentBackupGateway ? [currentPrimaryGateway, currentBackupGateway] : [currentPrimaryGateway];
+    const uniqueGateways = Array.from(new Set(gateways));
+    for (const gatewayUrl of uniqueGateways) {
         try {
-            const message = JSON.parse(data.toString());
-            // Handle system messages
-            if (message.type === "connected") {
-                return;
-            }
-            if (message.type === "peer_connected") {
-                console.log("App connected!\n");
-                // Scan dev ports and notify app
-                scanDevPorts().then((openPorts) => {
-                    if (openPorts.length > 0) {
-                        console.log(`Found ${openPorts.length} open dev port(s): ${openPorts.join(", ")}`);
+            await new Promise((resolve, reject) => {
+                activeGatewayUrl = gatewayUrl;
+                const controlUrl = buildWsUrl(gatewayUrl, "cli", "control");
+                const dataUrl = buildWsUrl(gatewayUrl, "cli", "data");
+                console.log(`Connecting to gateway ${gatewayUrl}...`);
+                const controlWs = new WebSocket(controlUrl);
+                const dataWs = new WebSocket(dataUrl);
+                activeControlWs = controlWs;
+                activeDataWs = dataWs;
+                dataChannel = dataWs;
+                let controlConnected = false;
+                let dataConnected = false;
+                let settled = false;
+                let closeHandled = false;
+                let closeReason = "";
+                const failConnection = (reason) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    reject(new Error(reason));
+                };
+                const checkFullyConnected = () => {
+                    if (controlConnected && dataConnected && !settled) {
+                        settled = true;
+                        console.log("Connected to gateway (control + data channels).\n");
+                        resolve();
+                    }
+                };
+                const handleClose = (reason) => {
+                    if (closeHandled || shuttingDown)
+                        return;
+                    closeHandled = true;
+                    closeReason = reason;
+                    cleanupAllTunnels();
+                    setTimeout(() => {
+                        if (shuttingDown)
+                            return;
+                        void handleConnectionDrop(closeReason);
+                    }, 50);
+                };
+                controlWs.on("open", () => {
+                    controlConnected = true;
+                    checkFullyConnected();
+                });
+                controlWs.on("message", async (data) => {
+                    try {
+                        const message = JSON.parse(data.toString());
+                        if ("type" in message) {
+                            if (message.type === "connected")
+                                return;
+                            if (message.type === "session_password" && message.password) {
+                                currentSessionPassword = message.password;
+                                console.log("[session] received reconnect password");
+                                return;
+                            }
+                            if (message.type === "peer_connected") {
+                                console.log("App connected!\n");
+                                scanDevPorts().then((openPorts) => {
+                                    if (openPorts.length > 0) {
+                                        console.log(`Found ${openPorts.length} open dev port(s): ${openPorts.join(", ")}`);
+                                    }
+                                    if (controlWs.readyState === WebSocket.OPEN) {
+                                        controlWs.send(JSON.stringify({
+                                            v: 1,
+                                            id: `evt-${Date.now()}`,
+                                            ns: "proxy",
+                                            action: "ports_discovered",
+                                            payload: { ports: openPorts },
+                                        }));
+                                    }
+                                }).catch((err) => {
+                                    console.error("Port scan failed:", err);
+                                });
+                                return;
+                            }
+                            if (message.type === "peer_disconnected") {
+                                console.log("App disconnected. Waiting for reconnect window.\n");
+                                return;
+                            }
+                            if (message.type === "app_disconnected") {
+                                if (message.reconnectDeadline) {
+                                    console.log(`[session] app disconnected, waiting until ${new Date(message.reconnectDeadline).toISOString()}`);
+                                }
+                                return;
+                            }
+                            if (message.type === "close_connection") {
+                                console.log(`[session] closed by gateway: ${message.reason || "expired"}`);
+                                gracefulShutdown();
+                                return;
+                            }
+                        }
+                        if (message.v === 1) {
+                            const response = await processMessage(message);
+                            controlWs.send(JSON.stringify(response));
+                        }
                     }
-                    if (controlWs.readyState === WebSocket.OPEN) {
-                        controlWs.send(JSON.stringify({
-                            v: 1,
-                            id: `evt-${Date.now()}`,
-                            ns: "proxy",
-                            action: "ports_discovered",
-                            payload: { ports: openPorts },
-                        }));
+                    catch (error) {
+                        console.error("Error processing control message:", error);
                     }
-                }).catch((err) => {
-                    console.error("Port scan failed:", err);
                 });
-                return;
-            }
-            if (message.type === "peer_disconnected") {
-                console.log("App disconnected.\n");
-                return;
-            }
-            // Handle v1 protocol messages
-            if (message.v === 1) {
-                const response = await processMessage(message);
-                controlWs.send(JSON.stringify(response));
-            }
-        }
-        catch (error) {
-            console.error("Error processing control message:", error);
-        }
-    });
-    controlWs.on("close", (code, reason) => {
-        console.log(`\nControl channel disconnected (${code}: ${reason.toString()})`);
-        cleanupAllTunnels();
-        dataWs.close();
-        process.exit(0);
-    });
-    controlWs.on("error", (error) => {
-        console.error("Control WebSocket error:", error.message);
-    });
-    // Data channel handlers
-    dataWs.on("open", () => {
-        dataConnected = true;
-        checkFullyConnected();
-    });
-    dataWs.on("message", async (data) => {
-        try {
-            const message = JSON.parse(data.toString());
-            // Handle system messages
-            if (message.type === "connected") {
-                return;
-            }
-            // Handle v1 protocol messages
-            if (message.v === 1) {
-                const response = await processMessage(message);
-                dataWs.send(JSON.stringify(response));
-            }
-        }
-        catch (error) {
-            console.error("Error processing data message:", error);
-        }
-    });
-    dataWs.on("close", (code, reason) => {
-        console.log(`\nData channel disconnected (${code}: ${reason.toString()})`);
-        cleanupAllTunnels();
-        controlWs.close();
-        process.exit(0);
-    });
-    dataWs.on("error", (error) => {
-        console.error("Data WebSocket error:", error.message);
-    });
-    // Handle graceful shutdown
-    process.on("SIGINT", () => {
-        console.log("\nShutting down...");
-        // Kill PTY process (kills all terminals)
-        if (ptyProcess) {
-            ptyProcess.kill();
-            ptyProcess = null;
+                controlWs.on("close", (code, reason) => {
+                    if (!settled) {
+                        failConnection(`control close before ready (${code}: ${reason.toString()})`);
+                        return;
+                    }
+                    handleClose(`control closed (${code}: ${reason.toString()})`);
+                });
+                controlWs.on("error", (error) => {
+                    if (!settled) {
+                        failConnection(`control ws error: ${error.message}`);
+                        return;
+                    }
+                    console.error("Control WebSocket error:", error.message);
+                });
+                dataWs.on("open", () => {
+                    dataConnected = true;
+                    checkFullyConnected();
+                });
+                dataWs.on("message", async (data) => {
+                    try {
+                        const message = JSON.parse(data.toString());
+                        if (message.type === "connected")
+                            return;
+                        if (message.v === 1) {
+                            const response = await processMessage(message);
+                            dataWs.send(JSON.stringify(response));
+                        }
+                    }
+                    catch (error) {
+                        console.error("Error processing data message:", error);
+                    }
+                });
+                dataWs.on("close", (code, reason) => {
+                    if (!settled) {
+                        failConnection(`data close before ready (${code}: ${reason.toString()})`);
+                        return;
+                    }
+                    handleClose(`data closed (${code}: ${reason.toString()})`);
+                });
+                dataWs.on("error", (error) => {
+                    if (!settled) {
+                        failConnection(`data ws error: ${error.message}`);
+                        return;
+                    }
+                    console.error("Data WebSocket error:", error.message);
+                });
+                setTimeout(() => {
+                    if (!settled) {
+                        failConnection("connection timeout");
+                    }
+                }, 10000);
+            });
+            return;
         }
-        terminals.clear();
-        // Kill all managed processes
-        for (const [pid, managedProc] of processes) {
-            managedProc.proc.kill();
+        catch (err) {
+            console.error(`[gateway] failed ${gatewayUrl}: ${err.message}`);
         }
-        processes.clear();
-        processOutputBuffers.clear();
-        cleanupAllTunnels();
-        controlWs.close();
-        dataWs.close();
-        process.exit(0);
-    });
+    }
+    throw new Error("unable to connect to any gateway");
+}
+async function handleConnectionDrop(reason) {
+    if (shuttingDown)
+        return;
+    console.log(`\nDisconnected: ${reason}`);
+    if (!currentSessionPassword) {
+        console.error("No reconnect password available. Exiting.");
+        gracefulShutdown();
+        return;
+    }
+    try {
+        await connectWebSocket();
+        console.log(`[reconnect] connected via ${activeGatewayUrl}`);
+    }
+    catch (err) {
+        console.error(`[reconnect] failed on all gateways: ${err.message}`);
+        gracefulShutdown();
+    }
 }
 async function main() {
     console.log("Lunel CLI v" + VERSION);
@@ -1976,9 +2126,14 @@ async function main() {
         console.log("OpenCode ready.\n");
         // Subscribe to OpenCode events
         subscribeToOpenCodeEvents(client);
-        const code = await createSession();
-        displayQR(code);
-        connectWebSocket(code);
+        const gateways = await discoverGateways();
+        currentPrimaryGateway = gateways.primary;
+        currentBackupGateway = gateways.backup;
+        activeGatewayUrl = currentPrimaryGateway;
+        const code = await createSession(currentPrimaryGateway);
+        currentSessionCode = code;
+        displayQR(currentPrimaryGateway, currentBackupGateway, code);
+        await connectWebSocket();
     }
     catch (error) {
         if (error instanceof Error) {
@@ -1992,4 +2147,6 @@ async function main() {
         process.exit(1);
     }
 }
+process.on("SIGINT", gracefulShutdown);
+process.on("SIGTERM", gracefulShutdown);
 main();

package/package.json

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