lunel-cli 0.1.12 → 0.1.15

package/dist/index.js

@@ -7,205 +7,69 @@ import * as fs from "fs/promises";
 import * as path from "path";
 import * as os from "os";
 import { spawn, execSync } from "child_process";
-import { createServer } from "net";
+import { createServer, createConnection } from "net";
 const PROXY_URL = process.env.LUNEL_PROXY_URL || "https://gateway.lunel.dev";
-const VERSION = "0.1.11";
+const VERSION = "0.1.3";
 // Root directory - sandbox all file operations to this
 const ROOT_DIR = process.cwd();
-// Simple ANSI parser for terminal state
-class AnsiParser {
-    buffer;
-    cursorX = 0;
-    cursorY = 0;
-    cols;
-    rows;
-    currentFg = '#ffffff';
-    currentBg = '#000000';
-    scrollbackBuffer = [];
-    // ANSI color codes to hex
-    colors = {
-        0: '#000000', 1: '#cc0000', 2: '#4e9a06', 3: '#c4a000',
-        4: '#3465a4', 5: '#75507b', 6: '#06989a', 7: '#d3d7cf',
-        8: '#555753', 9: '#ef2929', 10: '#8ae234', 11: '#fce94f',
-        12: '#729fcf', 13: '#ad7fa8', 14: '#34e2e2', 15: '#eeeeec',
-    };
-    constructor(cols, rows) {
-        this.cols = cols;
-        this.rows = rows;
-        this.buffer = this.createEmptyBuffer();
-    }
-    createEmptyBuffer() {
-        return Array.from({ length: this.rows }, () => Array.from({ length: this.cols }, () => ({
-            char: ' ',
-            fg: '#ffffff',
-            bg: '#000000',
-        })));
-    }
-    scrollUp() {
-        // Move first line to scrollback
-        this.scrollbackBuffer.push(this.buffer.shift());
-        // Keep scrollback limited
-        if (this.scrollbackBuffer.length > 1000) {
-            this.scrollbackBuffer.shift();
-        }
-        // Add new empty line at bottom
-        this.buffer.push(Array.from({ length: this.cols }, () => ({
-            char: ' ',
-            fg: '#ffffff',
-            bg: '#000000',
-        })));
-    }
-    write(data) {
-        let i = 0;
-        while (i < data.length) {
-            const char = data[i];
-            // Check for escape sequence
-            if (char === '\x1b' && data[i + 1] === '[') {
-                // Parse CSI sequence
-                let j = i + 2;
-                let params = '';
-                while (j < data.length && /[0-9;]/.test(data[j])) {
-                    params += data[j];
-                    j++;
-                }
-                const cmd = data[j];
-                i = j + 1;
-                this.handleCSI(params, cmd);
-                continue;
-            }
-            // Handle special characters
-            if (char === '\n') {
-                this.cursorY++;
-                if (this.cursorY >= this.rows) {
-                    this.scrollUp();
-                    this.cursorY = this.rows - 1;
-                }
-                i++;
-                continue;
-            }
-            if (char === '\r') {
-                this.cursorX = 0;
-                i++;
-                continue;
-            }
-            if (char === '\b') {
-                if (this.cursorX > 0)
-                    this.cursorX--;
-                i++;
-                continue;
-            }
-            if (char === '\t') {
-                this.cursorX = Math.min(this.cols - 1, (Math.floor(this.cursorX / 8) + 1) * 8);
-                i++;
-                continue;
-            }
-            if (char === '\x07') { // Bell
-                i++;
-                continue;
-            }
-            // Skip other control characters
-            if (char.charCodeAt(0) < 32) {
-                i++;
-                continue;
-            }
-            // Regular character
-            if (this.cursorX >= this.cols) {
-                this.cursorX = 0;
-                this.cursorY++;
-                if (this.cursorY >= this.rows) {
-                    this.scrollUp();
-                    this.cursorY = this.rows - 1;
-                }
-            }
-            if (this.cursorY >= 0 && this.cursorY < this.rows &&
-                this.cursorX >= 0 && this.cursorX < this.cols) {
-                this.buffer[this.cursorY][this.cursorX] = {
-                    char,
-                    fg: this.currentFg,
-                    bg: this.currentBg,
-                };
-            }
-            this.cursorX++;
-            i++;
-        }
-    }
-    handleCSI(params, cmd) {
-        const args = params.split(';').map(p => parseInt(p) || 0);
-        switch (cmd) {
-            case 'A': // Cursor up
-                this.cursorY = Math.max(0, this.cursorY - (args[0] || 1));
-                break;
-            case 'B': // Cursor down
-                this.cursorY = Math.min(this.rows - 1, this.cursorY + (args[0] || 1));
-                break;
-            case 'C': // Cursor forward
-                this.cursorX = Math.min(this.cols - 1, this.cursorX + (args[0] || 1));
-                break;
-            case 'D': // Cursor back
-                this.cursorX = Math.max(0, this.cursorX - (args[0] || 1));
-                break;
-            case 'H': // Cursor position
-            case 'f':
-                this.cursorY = Math.min(this.rows - 1, Math.max(0, (args[0] || 1) - 1));
-                this.cursorX = Math.min(this.cols - 1, Math.max(0, (args[1] || 1) - 1));
-                break;
-            case 'J': // Erase display
-                if (args[0] === 2) {
-                    this.buffer = this.createEmptyBuffer();
-                    this.cursorX = 0;
-                    this.cursorY = 0;
-                }
-                break;
-            case 'K': // Erase line
-                for (let x = this.cursorX; x < this.cols; x++) {
-                    this.buffer[this.cursorY][x] = { char: ' ', fg: this.currentFg, bg: this.currentBg };
-                }
-                break;
-            case 'm': // SGR - Select Graphic Rendition
-                for (const arg of args) {
-                    if (arg === 0) {
-                        this.currentFg = '#ffffff';
-                        this.currentBg = '#000000';
-                    }
-                    else if (arg >= 30 && arg <= 37) {
-                        this.currentFg = this.colors[arg - 30] || '#ffffff';
-                    }
-                    else if (arg >= 40 && arg <= 47) {
-                        this.currentBg = this.colors[arg - 40] || '#000000';
-                    }
-                    else if (arg >= 90 && arg <= 97) {
-                        this.currentFg = this.colors[arg - 90 + 8] || '#ffffff';
-                    }
-                    else if (arg >= 100 && arg <= 107) {
-                        this.currentBg = this.colors[arg - 100 + 8] || '#000000';
-                    }
-                }
-                break;
-        }
-    }
-    resize(cols, rows) {
-        const newBuffer = Array.from({ length: rows }, (_, y) => Array.from({ length: cols }, (_, x) => (y < this.rows && x < this.cols) ? this.buffer[y][x] : { char: ' ', fg: '#ffffff', bg: '#000000' }));
-        this.cols = cols;
-        this.rows = rows;
-        this.buffer = newBuffer;
-        this.cursorX = Math.min(this.cursorX, cols - 1);
-        this.cursorY = Math.min(this.cursorY, rows - 1);
-    }
-    getState() {
-        return {
-            buffer: this.buffer,
-            cursorX: this.cursorX,
-            cursorY: this.cursorY,
-            cols: this.cols,
-            rows: this.rows,
-        };
-    }
-}
+// Terminal sessions
 const terminals = new Map();
 const processes = new Map();
 const processOutputBuffers = new Map();
 // CPU usage tracking
 let lastCpuInfo = null;
+// Proxy tunnel management
+let currentSessionCode = null;
+const activeTunnels = new Map();
+// Popular development server ports to scan on connect
+const DEV_PORTS = [
+    1234, // Parcel
+    1313, // Hugo
+    2000, // Deno (alt)
+    3000, // Next.js / CRA / Remix / Express
+    3001, // Next.js (alt)
+    3002, // Dev server (alt)
+    3003, // Dev server (alt)
+    3333, // AdonisJS / Nitro
+    4000, // Gatsby / Redwood
+    4200, // Angular CLI
+    4321, // Astro
+    4173, // Vite preview
+    4444, // Selenium
+    4567, // Sinatra
+    5000, // Flask / Sails.js
+    5001, // Flask (alt)
+    5173, // Vite
+    5174, // Vite (alt)
+    5175, // Vite (alt)
+    5500, // Live Server (VS Code)
+    5555, // Prisma Studio
+    6006, // Storybook
+    7000, // Hapi
+    7070, // Dev server
+    7777, // Dev server
+    8000, // Django / Laravel / Gatsby
+    8001, // Django (alt)
+    8008, // Dev server
+    8010, // Dev server
+    8080, // Vue CLI / Webpack Dev Server / Spring Boot
+    8081, // Metro Bundler
+    8082, // Dev server (alt)
+    8100, // Ionic
+    8200, // Vault
+    8443, // HTTPS dev server
+    8787, // Wrangler (Cloudflare Workers)
+    8888, // Jupyter Notebook
+    8899, // Dev server
+    9000, // PHP / SonarQube
+    9090, // Prometheus / Cockpit
+    9200, // Elasticsearch
+    9229, // Node.js debugger
+    9292, // Rack (Ruby)
+    10000, // Webmin
+    19006, // Expo web
+    24678, // Vite HMR WebSocket
+];
 // ============================================================================
 // Path Safety
 // ============================================================================
@@ -669,122 +533,37 @@ async function handleGitDiscard(payload) {
 // ============================================================================
 let dataChannel = null;
 function handleTerminalSpawn(payload) {
+    const shell = payload.shell || process.env.SHELL || "/bin/sh";
     const cols = payload.cols || 80;
     const rows = payload.rows || 24;
-    // Find a working shell
-    let shell = payload.shell || process.env.SHELL || '';
-    const possibleShells = os.platform() === 'win32'
-        ? ['powershell.exe', 'cmd.exe']
-        : [shell, '/bin/zsh', '/bin/bash', '/bin/sh'].filter(Boolean);
-    shell = '';
-    for (const candidate of possibleShells) {
-        if (!candidate)
-            continue;
-        try {
-            if (os.platform() !== 'win32') {
-                execSync(`test -x "${candidate}"`, { stdio: 'ignore' });
-            }
-            shell = candidate;
-            break;
-        }
-        catch {
-            // Try next
-        }
-    }
-    if (!shell) {
-        throw Object.assign(new Error('No valid shell found'), { code: 'ENOSHELL' });
-    }
     const terminalId = `term-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
-    // Clean environment
-    const cleanEnv = {};
-    for (const [key, value] of Object.entries(process.env)) {
-        if (value !== undefined) {
-            cleanEnv[key] = value;
-        }
-    }
-    cleanEnv['TERM'] = 'xterm-256color';
-    cleanEnv['COLUMNS'] = cols.toString();
-    cleanEnv['LINES'] = rows.toString();
-    // Create ANSI parser for terminal state
-    const parser = new AnsiParser(cols, rows);
-    // Spawn shell directly with interactive flag
-    let proc;
-    const isWindows = os.platform() === 'win32';
-    console.log(`[Terminal] Spawning shell: ${shell} in ${ROOT_DIR}`);
-    // Force a simple prompt and disable fancy terminal features
-    cleanEnv['PS1'] = '$ ';
-    cleanEnv['PROMPT'] = '$ ';
-    cleanEnv['TERM'] = 'dumb';
-    if (isWindows) {
-        proc = spawn(shell, [], {
-            cwd: ROOT_DIR,
-            env: cleanEnv,
-            stdio: ['pipe', 'pipe', 'pipe'],
-            shell: true,
-        });
-    }
-    else {
-        // Spawn shell with flags to disable rc files and work non-interactively
-        const shellName = path.basename(shell);
-        let args = [];
-        if (shellName === 'zsh') {
-            // -f: no rc files, -s: read from stdin
-            args = ['-f', '-s'];
-        }
-        else if (shellName === 'bash') {
-            // --norc --noprofile: no rc files, -s: read from stdin
-            args = ['--norc', '--noprofile', '-s'];
-        }
-        else {
-            args = ['-s'];
-        }
-        proc = spawn(shell, args, {
-            cwd: ROOT_DIR,
-            env: cleanEnv,
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-    }
-    console.log(`[Terminal] Spawned with PID: ${proc.pid}`);
-    terminals.set(terminalId, {
-        proc,
-        shell,
-        cols,
-        rows,
-        buffer: parser.getState().buffer,
-        cursorX: 0,
-        cursorY: 0,
-        parser,
+    const proc = spawn(shell, [], {
+        cwd: ROOT_DIR,
+        env: {
+            ...process.env,
+            TERM: "xterm-256color",
+            COLUMNS: cols.toString(),
+            LINES: rows.toString(),
+        },
+        stdio: ["pipe", "pipe", "pipe"],
     });
-    // Process output and send grid state
-    const processOutput = (data) => {
-        const str = data.toString();
-        parser.write(str);
-        const state = parser.getState();
+    terminals.set(terminalId, proc);
+    // Stream output to app via data channel
+    const sendOutput = (data) => {
         if (dataChannel && dataChannel.readyState === WebSocket.OPEN) {
             const msg = {
                 v: 1,
                 id: `evt-${Date.now()}`,
                 ns: "terminal",
-                action: "state",
-                payload: {
-                    terminalId,
-                    buffer: state.buffer,
-                    cursorX: state.cursorX,
-                    cursorY: state.cursorY,
-                    cols: state.cols,
-                    rows: state.rows,
-                },
+                action: "output",
+                payload: { terminalId, data: data.toString() },
             };
             dataChannel.send(JSON.stringify(msg));
         }
     };
-    proc.stdout?.on('data', processOutput);
-    proc.stderr?.on('data', processOutput);
-    proc.on('error', (err) => {
-        console.error(`[Terminal] Process error:`, err);
-    });
-    proc.on('close', (code) => {
-        console.log(`[Terminal] Process closed with code: ${code}`);
+    proc.stdout?.on("data", sendOutput);
+    proc.stderr?.on("data", sendOutput);
+    proc.on("close", (code) => {
         terminals.delete(terminalId);
         if (dataChannel && dataChannel.readyState === WebSocket.OPEN) {
             const msg = {
@@ -792,33 +571,12 @@ function handleTerminalSpawn(payload) {
                 id: `evt-${Date.now()}`,
                 ns: "terminal",
                 action: "exit",
-                payload: { terminalId, code: code || 0 },
+                payload: { terminalId, code },
             };
             dataChannel.send(JSON.stringify(msg));
         }
     });
-    // Send initial state
-    setTimeout(() => {
-        const state = parser.getState();
-        if (dataChannel && dataChannel.readyState === WebSocket.OPEN) {
-            const msg = {
-                v: 1,
-                id: `evt-${Date.now()}`,
-                ns: "terminal",
-                action: "state",
-                payload: {
-                    terminalId,
-                    buffer: state.buffer,
-                    cursorX: state.cursorX,
-                    cursorY: state.cursorY,
-                    cols: state.cols,
-                    rows: state.rows,
-                },
-            };
-            dataChannel.send(JSON.stringify(msg));
-        }
-    }, 100);
-    return { terminalId, shell, cols, rows };
+    return { terminalId };
 }
 function handleTerminalWrite(payload) {
     const terminalId = payload.terminalId;
@@ -827,10 +585,10 @@ function handleTerminalWrite(payload) {
         throw Object.assign(new Error("terminalId is required"), { code: "EINVAL" });
     if (typeof data !== "string")
         throw Object.assign(new Error("data is required"), { code: "EINVAL" });
-    const session = terminals.get(terminalId);
-    if (!session)
+    const proc = terminals.get(terminalId);
+    if (!proc)
         throw Object.assign(new Error("Terminal not found"), { code: "ENOTERM" });
-    session.proc.stdin?.write(data);
+    proc.stdin?.write(data);
     return {};
 }
 function handleTerminalResize(payload) {
@@ -839,46 +597,21 @@ function handleTerminalResize(payload) {
     const rows = payload.rows;
     if (!terminalId)
         throw Object.assign(new Error("terminalId is required"), { code: "EINVAL" });
-    if (!cols || !rows)
-        throw Object.assign(new Error("cols and rows are required"), { code: "EINVAL" });
-    const session = terminals.get(terminalId);
-    if (!session)
+    const proc = terminals.get(terminalId);
+    if (!proc)
         throw Object.assign(new Error("Terminal not found"), { code: "ENOTERM" });
-    // Resize parser buffer
-    session.parser.resize(cols, rows);
-    session.cols = cols;
-    session.rows = rows;
-    // Send SIGWINCH to process (resize signal) - won't work without real PTY
-    // But we update our internal state
-    // Send updated state
-    const state = session.parser.getState();
-    if (dataChannel && dataChannel.readyState === WebSocket.OPEN) {
-        const msg = {
-            v: 1,
-            id: `evt-${Date.now()}`,
-            ns: "terminal",
-            action: "state",
-            payload: {
-                terminalId,
-                buffer: state.buffer,
-                cursorX: state.cursorX,
-                cursorY: state.cursorY,
-                cols: state.cols,
-                rows: state.rows,
-            },
-        };
-        dataChannel.send(JSON.stringify(msg));
-    }
+    // Note: For proper PTY resize, you'd need node-pty
+    // This is a simplified version
     return {};
 }
 function handleTerminalKill(payload) {
     const terminalId = payload.terminalId;
     if (!terminalId)
         throw Object.assign(new Error("terminalId is required"), { code: "EINVAL" });
-    const session = terminals.get(terminalId);
-    if (!session)
+    const proc = terminals.get(terminalId);
+    if (!proc)
         throw Object.assign(new Error("Terminal not found"), { code: "ENOTERM" });
-    session.proc.kill('SIGKILL');
+    proc.kill();
     terminals.delete(terminalId);
     return {};
 }
@@ -888,7 +621,7 @@ function handleTerminalKill(payload) {
 function handleSystemCapabilities() {
     return {
         version: VERSION,
-        namespaces: ["fs", "git", "terminal", "processes", "ports", "monitor", "http"],
+        namespaces: ["fs", "git", "terminal", "processes", "ports", "monitor", "http", "proxy"],
         platform: os.platform(),
         rootDir: ROOT_DIR,
         hostname: os.hostname(),
@@ -1352,6 +1085,128 @@ async function handleHttpRequest(payload) {
     }
 }
 // ============================================================================
+// Proxy Handlers
+// ============================================================================
+async function scanDevPorts() {
+    const openPorts = [];
+    const checks = DEV_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();
+            });
+        });
+    });
+    await Promise.all(checks);
+    return openPorts.sort((a, b) => a - b);
+}
+async function handleProxyConnect(payload) {
+    const tunnelId = payload.tunnelId;
+    const port = payload.port;
+    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)
+        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" }));
+        });
+    });
+    // 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 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);
+            tcpSocket.destroy();
+            reject(Object.assign(new Error(`Proxy WS failed: ${err.message}`), { code: "ECONNREFUSED" }));
+        });
+    });
+    // 3. Store the tunnel
+    activeTunnels.set(tunnelId, { tunnelId, port, tcpSocket, proxyWs });
+    // 4. Pipe: TCP data -> proxy WS (as binary)
+    tcpSocket.on("data", (chunk) => {
+        if (proxyWs.readyState === WebSocket.OPEN) {
+            proxyWs.send(chunk);
+        }
+    });
+    // 5. Pipe: proxy WS -> TCP socket (as binary)
+    proxyWs.on("message", (data) => {
+        if (!tcpSocket.destroyed) {
+            tcpSocket.write(data);
+        }
+    });
+    // 6. Close cascade: TCP closes -> close WS
+    tcpSocket.on("close", () => {
+        activeTunnels.delete(tunnelId);
+        if (proxyWs.readyState === WebSocket.OPEN || proxyWs.readyState === WebSocket.CONNECTING) {
+            proxyWs.close();
+        }
+    });
+    tcpSocket.on("error", () => {
+        activeTunnels.delete(tunnelId);
+        if (proxyWs.readyState === WebSocket.OPEN || proxyWs.readyState === WebSocket.CONNECTING) {
+            proxyWs.close();
+        }
+    });
+    // 7. Close cascade: WS closes -> close TCP
+    proxyWs.on("close", () => {
+        activeTunnels.delete(tunnelId);
+        if (!tcpSocket.destroyed) {
+            tcpSocket.destroy();
+        }
+    });
+    proxyWs.on("error", () => {
+        activeTunnels.delete(tunnelId);
+        if (!tcpSocket.destroyed) {
+            tcpSocket.destroy();
+        }
+    });
+    return { tunnelId, port };
+}
+function cleanupAllTunnels() {
+    for (const [, tunnel] of activeTunnels) {
+        tunnel.tcpSocket.destroy();
+        if (tunnel.proxyWs.readyState === WebSocket.OPEN) {
+            tunnel.proxyWs.close();
+        }
+    }
+    activeTunnels.clear();
+}
+// ============================================================================
 // Message Router
 // ============================================================================
 async function processMessage(message) {
@@ -1539,6 +1394,15 @@ async function processMessage(message) {
                         throw Object.assign(new Error(`Unknown action: ${ns}.${action}`), { code: "EINVAL" });
                 }
                 break;
+            case "proxy":
+                switch (action) {
+                    case "connect":
+                        result = await handleProxyConnect(payload);
+                        break;
+                    default:
+                        throw Object.assign(new Error(`Unknown action: ${ns}.${action}`), { code: "EINVAL" });
+                }
+                break;
             default:
                 throw Object.assign(new Error(`Unknown namespace: ${ns}`), { code: "EINVAL" });
         }
@@ -1585,6 +1449,7 @@ function displayQR(code) {
     });
 }
 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}`;
@@ -1616,6 +1481,23 @@ function connectWebSocket(code) {
             }
             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(", ")}`);
+                    }
+                    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") {
@@ -1634,6 +1516,7 @@ function connectWebSocket(code) {
     });
     controlWs.on("close", (code, reason) => {
         console.log(`\nControl channel disconnected (${code}: ${reason.toString()})`);
+        cleanupAllTunnels();
         dataWs.close();
         process.exit(0);
     });
@@ -1664,6 +1547,7 @@ function connectWebSocket(code) {
     });
     dataWs.on("close", (code, reason) => {
         console.log(`\nData channel disconnected (${code}: ${reason.toString()})`);
+        cleanupAllTunnels();
         controlWs.close();
         process.exit(0);
     });
@@ -1674,8 +1558,8 @@ function connectWebSocket(code) {
     process.on("SIGINT", () => {
         console.log("\nShutting down...");
         // Kill all terminals
-        for (const [id, session] of terminals) {
-            session.proc.kill();
+        for (const [id, proc] of terminals) {
+            proc.kill();
         }
         terminals.clear();
         // Kill all managed processes
@@ -1684,6 +1568,7 @@ function connectWebSocket(code) {
         }
         processes.clear();
         processOutputBuffers.clear();
+        cleanupAllTunnels();
         controlWs.close();
         dataWs.close();
         process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lunel-cli",
-  "version": "0.1.12",
+  "version": "0.1.15",
   "author": [
     {
       "name": "Soham Bharambe",
@@ -27,8 +27,7 @@
   "dependencies": {
     "ignore": "^6.0.2",
     "qrcode-terminal": "^0.12.0",
-    "ws": "^8.18.0",
-    "@xterm/headless": "^5.5.0"
+    "ws": "^8.18.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",