lunel-cli 0.1.7 → 0.1.9

package/dist/index.js

@@ -12,6 +12,195 @@ const PROXY_URL = process.env.LUNEL_PROXY_URL || "https://gateway.lunel.dev";
 const VERSION = "0.1.6";
 // 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,
+        };
+    }
+}
 const terminals = new Map();
 const processes = new Map();
 const processOutputBuffers = new Map();
@@ -480,6 +669,8 @@ async function handleGitDiscard(payload) {
 // ============================================================================
 let dataChannel = null;
 function handleTerminalSpawn(payload) {
+    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'
@@ -511,30 +702,72 @@ function handleTerminalSpawn(payload) {
             cleanEnv[key] = value;
         }
     }
-    cleanEnv['TERM'] = 'dumb'; // Simple terminal - no escape codes
-    // Spawn shell process
-    const proc = spawn(shell, ['-i'], {
-        cwd: ROOT_DIR,
-        env: cleanEnv,
-        stdio: ['pipe', 'pipe', 'pipe'],
+    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}`);
+    if (isWindows) {
+        proc = spawn(shell, [], {
+            cwd: ROOT_DIR,
+            env: cleanEnv,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            shell: true,
+        });
+    }
+    else {
+        // Unix: spawn shell with interactive flag
+        proc = spawn(shell, ['-i'], {
+            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,
     });
-    terminals.set(terminalId, { proc, shell });
-    // Stream output to app
-    const sendOutput = (data) => {
+    // Process output and send grid state
+    const processOutput = (data) => {
+        const str = data.toString();
+        parser.write(str);
+        const state = parser.getState();
         if (dataChannel && dataChannel.readyState === WebSocket.OPEN) {
             const msg = {
                 v: 1,
                 id: `evt-${Date.now()}`,
                 ns: "terminal",
-                action: "output",
-                payload: { terminalId, data: data.toString() },
+                action: "state",
+                payload: {
+                    terminalId,
+                    buffer: state.buffer,
+                    cursorX: state.cursorX,
+                    cursorY: state.cursorY,
+                    cols: state.cols,
+                    rows: state.rows,
+                },
             };
             dataChannel.send(JSON.stringify(msg));
         }
     };
-    proc.stdout?.on('data', sendOutput);
-    proc.stderr?.on('data', sendOutput);
+    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}`);
         terminals.delete(terminalId);
         if (dataChannel && dataChannel.readyState === WebSocket.OPEN) {
             const msg = {
@@ -547,7 +780,28 @@ function handleTerminalSpawn(payload) {
             dataChannel.send(JSON.stringify(msg));
         }
     });
-    return { terminalId, shell };
+    // 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 };
 }
 function handleTerminalWrite(payload) {
     const terminalId = payload.terminalId;
@@ -563,7 +817,41 @@ function handleTerminalWrite(payload) {
     return {};
 }
 function handleTerminalResize(payload) {
-    // No-op for simple terminal - resize not supported without PTY
+    const terminalId = payload.terminalId;
+    const cols = payload.cols;
+    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)
+        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));
+    }
     return {};
 }
 function handleTerminalKill(payload) {
@@ -573,7 +861,7 @@ function handleTerminalKill(payload) {
     const session = terminals.get(terminalId);
     if (!session)
         throw Object.assign(new Error("Terminal not found"), { code: "ENOTERM" });
-    session.proc.kill();
+    session.proc.kill('SIGKILL');
     terminals.delete(terminalId);
     return {};
 }

package/package.json

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