groove-dev 0.16.2 → 0.16.4

package/node_modules/@groove-dev/daemon/src/index.js

@@ -174,13 +174,16 @@ export class Daemon {
               break;
             // Terminal
             case 'terminal:spawn': {
-              const id = this.terminalManager.spawn(ws, { cwd: msg.cwd });
+              const id = this.terminalManager.spawn(ws, { cwd: msg.cwd, cols: msg.cols, rows: msg.rows });
               ws.send(JSON.stringify({ type: 'terminal:spawned', id }));
               break;
             }
             case 'terminal:input':
               if (msg.id && msg.data) this.terminalManager.write(msg.id, msg.data);
               break;
+            case 'terminal:resize':
+              if (msg.id && msg.rows && msg.cols) this.terminalManager.resize(msg.id, msg.rows, msg.cols);
+              break;
             case 'terminal:kill':
               if (msg.id) this.terminalManager.kill(msg.id);
               break;

package/node_modules/@groove-dev/daemon/src/terminal-pty.js

@@ -1,38 +1,116 @@
 // GROOVE — Terminal PTY Manager (shell sessions over WebSocket)
 // FSL-1.1-Apache-2.0 — see LICENSE
 
-import { spawn } from 'child_process';
+import { spawn, execFileSync } from 'child_process';
 import { existsSync } from 'fs';
 
-/**
- * Manages interactive shell sessions for the GUI terminal.
- * Uses child_process.spawn with pipe stdio + TERM=xterm-256color
- * so most CLI tools produce colored output.
- */
+// Python helper that creates a real PTY and relays I/O through stdin/stdout pipes.
+// The shell sees a genuine TTY — prompts, colors, line editing, tab completion all work.
+const PTY_HELPER = `
+import pty, os, sys, select, signal, struct, fcntl, termios, errno
+
+master, slave = pty.openpty()
+
+cols = int(os.environ.get('COLS', '120'))
+rows = int(os.environ.get('ROWS', '30'))
+fcntl.ioctl(slave, termios.TIOCSWINSZ, struct.pack('HHHH', rows, cols, 0, 0))
+
+pid = os.fork()
+if pid == 0:
+    os.setsid()
+    fcntl.ioctl(slave, termios.TIOCSCTTY, 0)
+    os.dup2(slave, 0)
+    os.dup2(slave, 1)
+    os.dup2(slave, 2)
+    os.close(master)
+    os.close(slave)
+    shell = os.environ.get('GROOVE_SHELL', os.environ.get('SHELL', '/bin/bash'))
+    os.execvp(shell, [shell, '-l'])
+
+os.close(slave)
+
+def resize(sig, frame):
+    pass
+signal.signal(signal.SIGWINCH, resize)
+
+flags = fcntl.fcntl(0, fcntl.F_GETFL)
+fcntl.fcntl(0, fcntl.F_SETFL, flags | os.O_NONBLOCK)
+
+try:
+    while True:
+        rlist = select.select([0, master], [], [], 0.05)[0]
+        if 0 in rlist:
+            try:
+                data = os.read(0, 4096)
+                if not data: break
+                # Resize command: ESC ] 7 ; <rows> ; <cols> BEL
+                if b'\\x1b]7;' in data:
+                    idx = data.index(b'\\x1b]7;')
+                    end = data.index(b'\\x07', idx)
+                    params = data[idx+4:end].decode().split(';')
+                    if len(params) == 2:
+                        r, c = int(params[0]), int(params[1])
+                        fcntl.ioctl(master, termios.TIOCSWINSZ, struct.pack('HHHH', r, c, 0, 0))
+                        os.kill(pid, signal.SIGWINCH)
+                    rest = data[:idx] + data[end+1:]
+                    if rest:
+                        os.write(master, rest)
+                else:
+                    os.write(master, data)
+            except OSError as e:
+                if e.errno != errno.EAGAIN: break
+        if master in rlist:
+            try:
+                data = os.read(master, 4096)
+                if not data: break
+                sys.stdout.buffer.write(data)
+                sys.stdout.buffer.flush()
+            except OSError: break
+        # Check child
+        try:
+            p, status = os.waitpid(pid, os.WNOHANG)
+            if p != 0: break
+        except ChildProcessError: break
+except: pass
+finally:
+    try: os.kill(pid, signal.SIGTERM)
+    except: pass
+`.trim();
+
 export class TerminalManager {
   constructor(daemon) {
     this.daemon = daemon;
-    this.sessions = new Map(); // sessionId → { proc, ws }
+    this.sessions = new Map();
     this.counter = 0;
+    this._python = this._findPython();
   }
 
-  /**
-   * Spawn a new shell session connected to a specific WebSocket client.
-   */
   spawn(ws, options = {}) {
     const id = `term-${++this.counter}`;
     const shell = this._detectShell();
     const cwd = options.cwd || this.daemon.projectDir;
+    const cols = options.cols || 120;
+    const rows = options.rows || 30;
+
+    if (!this._python) {
+      ws.send(JSON.stringify({
+        type: 'terminal:output', id,
+        data: '\r\n\x1b[31mTerminal requires Python 3 (python3 not found in PATH)\x1b[0m\r\n',
+      }));
+      ws.send(JSON.stringify({ type: 'terminal:exit', id, code: 1 }));
+      return id;
+    }
 
-    const proc = spawn(shell, ['-l'], {
+    const proc = spawn(this._python, ['-u', '-c', PTY_HELPER], {
       cwd,
       env: {
         ...process.env,
         TERM: 'xterm-256color',
         COLORTERM: 'truecolor',
         LANG: process.env.LANG || 'en_US.UTF-8',
-        // Remove NODE_CHANNEL_FD to prevent child confusion
-        NODE_CHANNEL_FD: undefined,
+        GROOVE_SHELL: shell,
+        COLS: String(cols),
+        ROWS: String(rows),
       },
       stdio: ['pipe', 'pipe', 'pipe'],
     });
@@ -40,14 +118,12 @@ export class TerminalManager {
     const session = { proc, ws, id };
     this.sessions.set(id, session);
 
-    // Relay stdout → WS
     proc.stdout.on('data', (data) => {
       if (ws.readyState === 1) {
         ws.send(JSON.stringify({ type: 'terminal:output', id, data: data.toString('utf8') }));
       }
     });
 
-    // Relay stderr → WS (merge with stdout)
     proc.stderr.on('data', (data) => {
       if (ws.readyState === 1) {
         ws.send(JSON.stringify({ type: 'terminal:output', id, data: data.toString('utf8') }));
@@ -71,18 +147,19 @@ export class TerminalManager {
     return id;
   }
 
-  /**
-   * Write input to a terminal session.
-   */
   write(id, data) {
     const session = this.sessions.get(id);
     if (!session || !session.proc.stdin.writable) return;
     session.proc.stdin.write(data);
   }
 
-  /**
-   * Kill a terminal session.
-   */
+  resize(id, rows, cols) {
+    const session = this.sessions.get(id);
+    if (!session || !session.proc.stdin.writable) return;
+    // Send resize command via the custom escape sequence
+    session.proc.stdin.write(`\x1b]7;${rows};${cols}\x07`);
+  }
+
   kill(id) {
     const session = this.sessions.get(id);
     if (!session) return;
@@ -95,18 +172,12 @@ export class TerminalManager {
     this.sessions.delete(id);
   }
 
-  /**
-   * Kill all sessions (daemon shutdown).
-   */
   killAll() {
     for (const [id] of this.sessions) {
       this.kill(id);
     }
   }
 
-  /**
-   * Clean up sessions for a disconnected WS client.
-   */
   cleanupClient(ws) {
     for (const [id, session] of this.sessions) {
       if (session.ws === ws) {
@@ -116,14 +187,20 @@ export class TerminalManager {
   }
 
   _detectShell() {
-    // Prefer user's shell, fall back to common ones
-    if (process.env.SHELL && existsSync(process.env.SHELL)) {
-      return process.env.SHELL;
-    }
-    const candidates = ['/bin/zsh', '/bin/bash', '/bin/sh'];
-    for (const sh of candidates) {
+    if (process.env.SHELL && existsSync(process.env.SHELL)) return process.env.SHELL;
+    for (const sh of ['/bin/zsh', '/bin/bash', '/bin/sh']) {
       if (existsSync(sh)) return sh;
     }
     return 'sh';
   }
+
+  _findPython() {
+    for (const cmd of ['python3', 'python']) {
+      try {
+        const v = execFileSync(cmd, ['--version'], { encoding: 'utf8', timeout: 3000 }).trim();
+        if (v.startsWith('Python 3')) return cmd;
+      } catch { /* not found */ }
+    }
+    return null;
+  }
 }