lunel-cli 0.1.29 → 0.1.31

package/dist/index.js

@@ -11,7 +11,9 @@ 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";
+const CLI_ARGS = process.argv.slice(2);
 import { createRequire } from "module";
 const __require = createRequire(import.meta.url);
 const VERSION = __require("../package.json").version;
@@ -30,7 +32,18 @@ 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();
+const PORT_SYNC_INTERVAL_MS = 30_000;
+let portSyncTimer = null;
+let portScanInFlight = false;
+let lastDiscoveredPorts = [];
 // Popular development server ports to scan on connect
 const DEV_PORTS = [
     1234, // Parcel
@@ -80,6 +93,44 @@ const DEV_PORTS = [
     19006, // Expo web
     24678, // Vite HMR WebSocket
 ];
+function parseExtraPortsFromArgs(args) {
+    const values = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg.startsWith("--extra-ports=")) {
+            values.push(arg.slice("--extra-ports=".length));
+            continue;
+        }
+        if (arg === "--extra-ports" && i + 1 < args.length) {
+            values.push(args[i + 1]);
+            i++;
+        }
+    }
+    const parsed = new Set();
+    for (const value of values) {
+        for (const piece of value.split(",")) {
+            const trimmed = piece.trim();
+            if (!trimmed)
+                continue;
+            const num = Number(trimmed);
+            if (!Number.isInteger(num) || num < 1 || num > 65535)
+                continue;
+            parsed.add(num);
+        }
+    }
+    return Array.from(parsed).sort((a, b) => a - b);
+}
+const EXTRA_PORTS = parseExtraPortsFromArgs(CLI_ARGS);
+const SCAN_PORTS = Array.from(new Set([...DEV_PORTS, ...EXTRA_PORTS])).sort((a, b) => a - b);
+function samePortSet(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}
 // ============================================================================
 // Path Safety
 // ============================================================================
@@ -1405,7 +1456,7 @@ async function subscribeToOpenCodeEvents(client) {
 // ============================================================================
 async function scanDevPorts() {
     const openPorts = [];
-    const checks = DEV_PORTS.map((port) => {
+    const checks = SCAN_PORTS.map((port) => {
         return new Promise((resolve) => {
             const socket = createConnection({ port, host: "127.0.0.1" });
             socket.setTimeout(200);
@@ -1426,6 +1477,48 @@ async function scanDevPorts() {
     await Promise.all(checks);
     return openPorts.sort((a, b) => a - b);
 }
+async function publishDiscoveredPorts(ws, force = false) {
+    if (portScanInFlight)
+        return;
+    if (ws.readyState !== WebSocket.OPEN)
+        return;
+    portScanInFlight = true;
+    try {
+        const openPorts = await scanDevPorts();
+        if (!force && samePortSet(openPorts, lastDiscoveredPorts)) {
+            return;
+        }
+        lastDiscoveredPorts = openPorts;
+        ws.send(JSON.stringify({
+            v: 1,
+            id: `evt-${Date.now()}`,
+            ns: "proxy",
+            action: "ports_discovered",
+            payload: { ports: openPorts },
+        }));
+        console.log(`[proxy] ports updated (${openPorts.length}): ${openPorts.join(", ") || "-"}`);
+    }
+    catch (err) {
+        console.error("Port scan failed:", err);
+    }
+    finally {
+        portScanInFlight = false;
+    }
+}
+function stopPortSync() {
+    if (portSyncTimer) {
+        clearInterval(portSyncTimer);
+        portSyncTimer = null;
+    }
+    portScanInFlight = false;
+}
+function startPortSync(ws) {
+    stopPortSync();
+    void publishDiscoveredPorts(ws, true);
+    portSyncTimer = setInterval(() => {
+        void publishDiscoveredPorts(ws, false);
+    }, PORT_SYNC_INTERVAL_MS);
+}
 async function handleProxyConnect(payload) {
     const tunnelId = payload.tunnelId;
     const port = payload.port;
@@ -1433,7 +1526,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 +1545,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(() => {
@@ -1808,160 +1904,251 @@ 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 createSessionFromManager() {
+    const response = await fetch(`${MANAGER_URL}/v1/session`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
     });
     if (!response.ok) {
-        throw new Error(`Failed to create session: ${response.status}`);
+        throw new Error(`Failed to create session from manager: ${response.status}`);
     }
-    const data = (await response.json());
-    return data.code;
+    return (await response.json());
 }
-function displayQR(code) {
+function displayQR(primaryGateway, backupGateway, code) {
     console.log("\n");
     qrcode.generate(code, { 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...");
+    stopPortSync();
+    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();
                     }
-                    if (controlWs.readyState === WebSocket.OPEN) {
-                        controlWs.send(JSON.stringify({
-                            v: 1,
-                            id: `evt-${Date.now()}`,
-                            ns: "proxy",
-                            action: "ports_discovered",
-                            payload: { ports: openPorts },
-                        }));
+                };
+                const handleClose = (reason) => {
+                    if (closeHandled || shuttingDown)
+                        return;
+                    closeHandled = true;
+                    closeReason = reason;
+                    stopPortSync();
+                    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");
+                                startPortSync(controlWs);
+                                return;
+                            }
+                            if (message.type === "peer_disconnected") {
+                                console.log("App disconnected. Waiting for reconnect window.\n");
+                                stopPortSync();
+                                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));
+                        }
+                    }
+                    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);
     console.log("=".repeat(20) + "\n");
+    if (EXTRA_PORTS.length > 0) {
+        console.log(`Extra ports enabled: ${EXTRA_PORTS.join(", ")}`);
+    }
     try {
         // Generate auth credentials (like CodeNomad does)
         const opencodeUsername = "lunel";
@@ -1989,9 +2176,14 @@ async function main() {
         console.log("OpenCode ready.\n");
         // Subscribe to OpenCode events
         subscribeToOpenCodeEvents(client);
-        const code = await createSession();
-        displayQR(code);
-        connectWebSocket(code);
+        const session = await createSessionFromManager();
+        currentPrimaryGateway = normalizeGatewayUrl(session.primary);
+        currentBackupGateway = session.backup ? normalizeGatewayUrl(session.backup) : null;
+        currentSessionPassword = session.password;
+        activeGatewayUrl = currentPrimaryGateway;
+        currentSessionCode = session.code;
+        displayQR(currentPrimaryGateway, currentBackupGateway, session.code);
+        await connectWebSocket();
     }
     catch (error) {
         if (error instanceof Error) {
@@ -2005,4 +2197,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.29",
+  "version": "0.1.31",
   "author": [
     {
       "name": "Soham Bharambe",