lunel-cli 0.1.13 → 0.1.16

package/dist/index.js

@@ -1,216 +1,80 @@
 #!/usr/bin/env node
 import { WebSocket } from "ws";
 import qrcode from "qrcode-terminal";
+import { createOpencode } from "@opencode-ai/sdk";
 import Ignore from "ignore";
 const ignore = Ignore.default;
 import * as fs from "fs/promises";
-import * as fsSync from "fs";
 import * as path from "path";
 import * as os from "os";
 import { spawn, execSync } from "child_process";
-import * as pty from "node-pty";
-import { createServer } from "net";
-import { fileURLToPath } from "url";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+import { createServer, createConnection } from "net";
 const PROXY_URL = process.env.LUNEL_PROXY_URL || "https://gateway.lunel.dev";
-const VERSION = JSON.parse(fsSync.readFileSync(path.join(__dirname, "../package.json"), "utf-8")).version;
+import { createRequire } from "module";
+const __require = createRequire(import.meta.url);
+const VERSION = __require("../package.json").version;
 // 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;
+// OpenCode client
+let opencodeClient = 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
 // ============================================================================
@@ -674,78 +538,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)}`;
-    console.log(`[Terminal] Spawning PTY shell: ${shell} (${cols}x${rows}) in ${ROOT_DIR}`);
-    // Create ANSI parser for terminal state
-    const parser = new AnsiParser(cols, rows);
-    // Spawn PTY with node-pty
-    const ptyProcess = pty.spawn(shell, [], {
-        name: 'xterm-256color',
-        cols,
-        rows,
+    const proc = spawn(shell, [], {
         cwd: ROOT_DIR,
-        env: process.env,
-    });
-    console.log(`[Terminal] PTY spawned with PID: ${ptyProcess.pid}`);
-    terminals.set(terminalId, {
-        ptyProcess,
-        shell,
-        cols,
-        rows,
-        buffer: parser.getState().buffer,
-        cursorX: 0,
-        cursorY: 0,
-        parser,
+        env: {
+            ...process.env,
+            TERM: "xterm-256color",
+            COLUMNS: cols.toString(),
+            LINES: rows.toString(),
+        },
+        stdio: ["pipe", "pipe", "pipe"],
     });
-    // Process output and send grid state
-    ptyProcess.onData((data) => {
-        parser.write(data);
-        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));
         }
-    });
-    ptyProcess.onExit(({ exitCode }) => {
-        console.log(`[Terminal] PTY exited with code: ${exitCode}`);
+    };
+    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 = {
@@ -753,12 +576,12 @@ function handleTerminalSpawn(payload) {
                 id: `evt-${Date.now()}`,
                 ns: "terminal",
                 action: "exit",
-                payload: { terminalId, code: exitCode },
+                payload: { terminalId, code },
             };
             dataChannel.send(JSON.stringify(msg));
         }
     });
-    return { terminalId, shell, cols, rows };
+    return { terminalId };
 }
 function handleTerminalWrite(payload) {
     const terminalId = payload.terminalId;
@@ -767,10 +590,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.ptyProcess.write(data);
+    proc.stdin?.write(data);
     return {};
 }
 function handleTerminalResize(payload) {
@@ -779,27 +602,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 PTY (sends SIGWINCH)
-    session.ptyProcess.resize(cols, rows);
-    // Resize parser buffer
-    session.parser.resize(cols, rows);
-    session.cols = cols;
-    session.rows = rows;
+    // 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.ptyProcess.kill();
+    proc.kill();
     terminals.delete(terminalId);
     return {};
 }
@@ -809,7 +626,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", "ai", "proxy"],
         platform: os.platform(),
         rootDir: ROOT_DIR,
         hostname: os.hostname(),
@@ -1273,6 +1090,267 @@ async function handleHttpRequest(payload) {
     }
 }
 // ============================================================================
+// AI Handlers (OpenCode SDK)
+// ============================================================================
+async function handleAiCreateSession(payload) {
+    const title = payload.title || undefined;
+    const response = await opencodeClient.session.create({ body: { title } });
+    return { session: response.data };
+}
+async function handleAiListSessions() {
+    const response = await opencodeClient.session.list();
+    return { sessions: response.data };
+}
+async function handleAiGetSession(payload) {
+    const id = payload.id;
+    const response = await opencodeClient.session.get({ path: { id } });
+    return { session: response.data };
+}
+async function handleAiDeleteSession(payload) {
+    const id = payload.id;
+    await opencodeClient.session.delete({ path: { id } });
+    return {};
+}
+async function handleAiGetMessages(payload) {
+    const id = payload.id;
+    const response = await opencodeClient.session.messages({ path: { id } });
+    return { messages: response.data };
+}
+async function handleAiPrompt(payload) {
+    const sessionId = payload.sessionId;
+    const text = payload.text;
+    const model = payload.model;
+    // Fire and forget — results stream via SSE events forwarded on data channel
+    opencodeClient.session.prompt({
+        path: { id: sessionId },
+        body: {
+            parts: [{ type: "text", text }],
+            ...(model ? { model } : {}),
+        },
+    }).catch((err) => {
+        if (dataChannel && dataChannel.readyState === WebSocket.OPEN) {
+            dataChannel.send(JSON.stringify({
+                v: 1,
+                id: `evt-${Date.now()}`,
+                ns: "ai",
+                action: "event",
+                payload: {
+                    type: "prompt_error",
+                    properties: { sessionId, error: err.message },
+                },
+            }));
+        }
+    });
+    return { ack: true };
+}
+async function handleAiAbort(payload) {
+    const id = payload.sessionId;
+    await opencodeClient.session.abort({ path: { id } });
+    return {};
+}
+async function handleAiAgents() {
+    const response = await opencodeClient.app.agents();
+    return { agents: response.data };
+}
+async function handleAiProviders() {
+    const response = await opencodeClient.config.providers();
+    return { providers: response.data };
+}
+async function handleAiSetAuth(payload) {
+    const providerId = payload.providerId;
+    const key = payload.key;
+    await opencodeClient.auth.set({
+        path: { id: providerId },
+        body: { type: "api", key },
+    });
+    return {};
+}
+async function handleAiCommand(payload) {
+    const sessionId = payload.sessionId;
+    const command = payload.command;
+    const args = payload.arguments || "";
+    const response = await opencodeClient.session.command({
+        path: { id: sessionId },
+        body: { command, arguments: args },
+    });
+    return { result: response.data };
+}
+async function handleAiRevert(payload) {
+    const sessionId = payload.sessionId;
+    const messageId = payload.messageId;
+    await opencodeClient.session.revert({
+        path: { id: sessionId },
+        body: { messageID: messageId },
+    });
+    return {};
+}
+async function handleAiUnrevert(payload) {
+    const sessionId = payload.sessionId;
+    await opencodeClient.session.unrevert({ path: { id: sessionId } });
+    return {};
+}
+async function handleAiShare(payload) {
+    const sessionId = payload.sessionId;
+    const response = await opencodeClient.session.share({ path: { id: sessionId } });
+    return { share: response.data };
+}
+async function handleAiPermissionReply(payload) {
+    const permissionId = payload.permissionId;
+    const sessionId = payload.sessionId;
+    const approved = payload.approved;
+    await opencodeClient.postSessionIdPermissionsPermissionId({
+        path: { id: sessionId, permissionID: permissionId },
+        body: { response: approved ? "once" : "reject" },
+    });
+    return {};
+}
+// SSE event forwarding from OpenCode to mobile app
+async function subscribeToOpenCodeEvents(client) {
+    try {
+        const events = await client.event.subscribe();
+        for await (const event of events.stream) {
+            if (dataChannel && dataChannel.readyState === WebSocket.OPEN) {
+                const msg = {
+                    v: 1,
+                    id: `evt-${Date.now()}-${Math.random().toString(36).substring(2, 6)}`,
+                    ns: "ai",
+                    action: "event",
+                    payload: {
+                        type: event.type,
+                        properties: event.properties,
+                    },
+                };
+                dataChannel.send(JSON.stringify(msg));
+            }
+        }
+    }
+    catch (err) {
+        console.error("OpenCode event stream error:", err);
+        setTimeout(() => subscribeToOpenCodeEvents(client), 3000);
+    }
+}
+// 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) {
@@ -1460,6 +1538,66 @@ async function processMessage(message) {
                         throw Object.assign(new Error(`Unknown action: ${ns}.${action}`), { code: "EINVAL" });
                 }
                 break;
+            case "ai":
+                switch (action) {
+                    case "prompt":
+                        result = await handleAiPrompt(payload);
+                        break;
+                    case "createSession":
+                        result = await handleAiCreateSession(payload);
+                        break;
+                    case "listSessions":
+                        result = await handleAiListSessions();
+                        break;
+                    case "getSession":
+                        result = await handleAiGetSession(payload);
+                        break;
+                    case "deleteSession":
+                        result = await handleAiDeleteSession(payload);
+                        break;
+                    case "getMessages":
+                        result = await handleAiGetMessages(payload);
+                        break;
+                    case "abort":
+                        result = await handleAiAbort(payload);
+                        break;
+                    case "agents":
+                        result = await handleAiAgents();
+                        break;
+                    case "providers":
+                        result = await handleAiProviders();
+                        break;
+                    case "setAuth":
+                        result = await handleAiSetAuth(payload);
+                        break;
+                    case "command":
+                        result = await handleAiCommand(payload);
+                        break;
+                    case "revert":
+                        result = await handleAiRevert(payload);
+                        break;
+                    case "unrevert":
+                        result = await handleAiUnrevert(payload);
+                        break;
+                    case "share":
+                        result = await handleAiShare(payload);
+                        break;
+                    case "permission":
+                        result = await handleAiPermissionReply(payload);
+                        break;
+                    default:
+                        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" });
         }
@@ -1506,6 +1644,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}`;
@@ -1537,6 +1676,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") {
@@ -1555,6 +1711,7 @@ function connectWebSocket(code) {
     });
     controlWs.on("close", (code, reason) => {
         console.log(`\nControl channel disconnected (${code}: ${reason.toString()})`);
+        cleanupAllTunnels();
         dataWs.close();
         process.exit(0);
     });
@@ -1585,6 +1742,7 @@ function connectWebSocket(code) {
     });
     dataWs.on("close", (code, reason) => {
         console.log(`\nData channel disconnected (${code}: ${reason.toString()})`);
+        cleanupAllTunnels();
         controlWs.close();
         process.exit(0);
     });
@@ -1595,8 +1753,8 @@ function connectWebSocket(code) {
     process.on("SIGINT", () => {
         console.log("\nShutting down...");
         // Kill all terminals
-        for (const [id, session] of terminals) {
-            session.ptyProcess.kill();
+        for (const [id, proc] of terminals) {
+            proc.kill();
         }
         terminals.clear();
         // Kill all managed processes
@@ -1605,6 +1763,7 @@ function connectWebSocket(code) {
         }
         processes.clear();
         processOutputBuffers.clear();
+        cleanupAllTunnels();
         controlWs.close();
         dataWs.close();
         process.exit(0);
@@ -1614,6 +1773,13 @@ async function main() {
     console.log("Lunel CLI v" + VERSION);
     console.log("=".repeat(20) + "\n");
     try {
+        // Start OpenCode server + client
+        console.log("Starting OpenCode...");
+        const { client } = await createOpencode();
+        opencodeClient = client;
+        console.log("OpenCode ready.\n");
+        // Subscribe to OpenCode events
+        subscribeToOpenCodeEvents(client);
         const code = await createSession();
         displayQR(code);
         connectWebSocket(code);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lunel-cli",
-  "version": "0.1.13",
+  "version": "0.1.16",
   "author": [
     {
       "name": "Soham Bharambe",
@@ -25,9 +25,8 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@xterm/headless": "^5.5.0",
+    "@opencode-ai/sdk": "^1.1.56",
     "ignore": "^6.0.2",
-    "node-pty": "^1.1.0",
     "qrcode-terminal": "^0.12.0",
     "ws": "^8.18.0"
   },