lunel-cli 0.1.15 → 0.1.17

package/dist/index.js

@@ -1,6 +1,7 @@
 #!/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";
@@ -8,16 +9,24 @@ import * as path from "path";
 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 VERSION = "0.1.3";
+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();
-// Terminal sessions
-const terminals = new Map();
+// Terminal sessions (managed by Rust PTY binary)
+const terminals = new Set();
+// PTY binary process
+let ptyProcess = null;
+const ptyPendingSpawns = 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();
@@ -529,53 +538,113 @@ async function handleGitDiscard(payload) {
     return {};
 }
 // ============================================================================
-// Terminal Handlers
+// Terminal Handlers (delegates to Rust PTY binary)
 // ============================================================================
 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;
-    const terminalId = `term-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
-    const proc = spawn(shell, [], {
+function getPtyBinaryPath() {
+    // TODO: Switch to GitHub releases download for production
+    return path.join(os.homedir(), "lunel-pty");
+}
+function ensurePtyProcess() {
+    if (ptyProcess && ptyProcess.exitCode === null)
+        return;
+    const binPath = getPtyBinaryPath();
+    ptyProcess = spawn(binPath, [], {
         cwd: ROOT_DIR,
-        env: {
-            ...process.env,
-            TERM: "xterm-256color",
-            COLUMNS: cols.toString(),
-            LINES: rows.toString(),
-        },
         stdio: ["pipe", "pipe", "pipe"],
     });
-    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: "output",
-                payload: { terminalId, data: data.toString() },
-            };
-            dataChannel.send(JSON.stringify(msg));
+    ptyProcess.stderr?.on("data", (data) => {
+        console.error("[pty]", data.toString().trim());
+    });
+    ptyProcess.on("exit", (code) => {
+        console.log(`[pty] PTY process exited with code ${code}`);
+        ptyProcess = null;
+        // Reject all pending spawns
+        for (const [id, pending] of ptyPendingSpawns) {
+            pending.reject(new Error("PTY process exited"));
         }
-    };
-    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 = {
-                v: 1,
-                id: `evt-${Date.now()}`,
-                ns: "terminal",
-                action: "exit",
-                payload: { terminalId, code },
-            };
-            dataChannel.send(JSON.stringify(msg));
+        ptyPendingSpawns.clear();
+    });
+    // Parse stdout line by line for events from the Rust binary
+    const rl = createInterface({ input: ptyProcess.stdout });
+    rl.on("line", (line) => {
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (event.event === "spawned") {
+            const pending = ptyPendingSpawns.get(event.id);
+            if (pending) {
+                pending.resolve();
+                ptyPendingSpawns.delete(event.id);
+            }
+        }
+        else if (event.event === "state") {
+            // Forward screen state to app via data channel
+            if (dataChannel && dataChannel.readyState === WebSocket.OPEN) {
+                const msg = {
+                    v: 1,
+                    id: `evt-${Date.now()}`,
+                    ns: "terminal",
+                    action: "state",
+                    payload: {
+                        terminalId: event.id,
+                        buffer: event.buffer,
+                        cursorX: event.cursorX,
+                        cursorY: event.cursorY,
+                        cols: event.cols,
+                        rows: event.rows,
+                    },
+                };
+                dataChannel.send(JSON.stringify(msg));
+            }
+        }
+        else if (event.event === "exit") {
+            terminals.delete(event.id);
+            if (dataChannel && dataChannel.readyState === WebSocket.OPEN) {
+                const msg = {
+                    v: 1,
+                    id: `evt-${Date.now()}`,
+                    ns: "terminal",
+                    action: "exit",
+                    payload: { terminalId: event.id, code: event.code },
+                };
+                dataChannel.send(JSON.stringify(msg));
+            }
+        }
+        else if (event.event === "error") {
+            console.error(`[pty] Error for ${event.id}: ${event.message}`);
         }
     });
+}
+function sendToPty(cmd) {
+    if (!ptyProcess || !ptyProcess.stdin) {
+        throw Object.assign(new Error("PTY process not running"), { code: "ENOPTY" });
+    }
+    ptyProcess.stdin.write(JSON.stringify(cmd) + "\n");
+}
+async function handleTerminalSpawn(payload) {
+    ensurePtyProcess();
+    const shell = payload.shell || process.env.SHELL || "/bin/sh";
+    const cols = payload.cols || 80;
+    const rows = payload.rows || 24;
+    const terminalId = `term-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+    // Wait for the Rust binary to confirm spawn
+    const spawnPromise = new Promise((resolve, reject) => {
+        ptyPendingSpawns.set(terminalId, { resolve, reject });
+        setTimeout(() => {
+            if (ptyPendingSpawns.has(terminalId)) {
+                ptyPendingSpawns.delete(terminalId);
+                reject(new Error("Spawn timed out"));
+            }
+        }, 10000);
+    });
+    sendToPty({ cmd: "spawn", id: terminalId, shell, cols, rows });
+    await spawnPromise;
+    terminals.add(terminalId);
     return { terminalId };
 }
 function handleTerminalWrite(payload) {
@@ -585,10 +654,9 @@ 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 proc = terminals.get(terminalId);
-    if (!proc)
+    if (!terminals.has(terminalId))
         throw Object.assign(new Error("Terminal not found"), { code: "ENOTERM" });
-    proc.stdin?.write(data);
+    sendToPty({ cmd: "write", id: terminalId, data });
     return {};
 }
 function handleTerminalResize(payload) {
@@ -597,21 +665,18 @@ function handleTerminalResize(payload) {
     const rows = payload.rows;
     if (!terminalId)
         throw Object.assign(new Error("terminalId is required"), { code: "EINVAL" });
-    const proc = terminals.get(terminalId);
-    if (!proc)
+    if (!terminals.has(terminalId))
         throw Object.assign(new Error("Terminal not found"), { code: "ENOTERM" });
-    // Note: For proper PTY resize, you'd need node-pty
-    // This is a simplified version
+    sendToPty({ cmd: "resize", id: terminalId, cols, rows });
     return {};
 }
 function handleTerminalKill(payload) {
     const terminalId = payload.terminalId;
     if (!terminalId)
         throw Object.assign(new Error("terminalId is required"), { code: "EINVAL" });
-    const proc = terminals.get(terminalId);
-    if (!proc)
+    if (!terminals.has(terminalId))
         throw Object.assign(new Error("Terminal not found"), { code: "ENOTERM" });
-    proc.kill();
+    sendToPty({ cmd: "kill", id: terminalId });
     terminals.delete(terminalId);
     return {};
 }
@@ -621,7 +686,7 @@ function handleTerminalKill(payload) {
 function handleSystemCapabilities() {
     return {
         version: VERSION,
-        namespaces: ["fs", "git", "terminal", "processes", "ports", "monitor", "http", "proxy"],
+        namespaces: ["fs", "git", "terminal", "processes", "ports", "monitor", "http", "ai", "proxy"],
         platform: os.platform(),
         rootDir: ROOT_DIR,
         hostname: os.hostname(),
@@ -1085,6 +1150,145 @@ 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() {
@@ -1313,7 +1517,7 @@ async function processMessage(message) {
             case "terminal":
                 switch (action) {
                     case "spawn":
-                        result = handleTerminalSpawn(payload);
+                        result = await handleTerminalSpawn(payload);
                         break;
                     case "write":
                         result = handleTerminalWrite(payload);
@@ -1394,6 +1598,57 @@ 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":
@@ -1557,9 +1812,10 @@ function connectWebSocket(code) {
     // Handle graceful shutdown
     process.on("SIGINT", () => {
         console.log("\nShutting down...");
-        // Kill all terminals
-        for (const [id, proc] of terminals) {
-            proc.kill();
+        // Kill PTY process (kills all terminals)
+        if (ptyProcess) {
+            ptyProcess.kill();
+            ptyProcess = null;
         }
         terminals.clear();
         // Kill all managed processes
@@ -1578,6 +1834,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.15",
+  "version": "0.1.17",
   "author": [
     {
       "name": "Soham Bharambe",
@@ -17,7 +17,8 @@
     "lunel-cli": "./dist/index.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "bin"
   ],
   "scripts": {
     "build": "tsc",
@@ -25,6 +26,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
+    "@opencode-ai/sdk": "^1.1.56",
     "ignore": "^6.0.2",
     "qrcode-terminal": "^0.12.0",
     "ws": "^8.18.0"