centaurus-cli 2.7.3 → 2.8.1

package/dist/utils/editor-utils.js

@@ -0,0 +1,712 @@
+import * as os from 'os';
+import { createRequire } from 'module';
+// Use createRequire for ESM compatibility with native modules
+const require = createRequire(import.meta.url);
+const nodePty = require('@homebridge/node-pty-prebuilt-multiarch');
+/**
+ * List of interactive editor commands that require full terminal control
+ */
+const INTERACTIVE_EDITORS = [
+    'vim', 'nvim', 'vi', 'nano', 'emacs', 'micro', 'helix', 'hx',
+    'pico', 'joe', 'ne', 'mcedit'
+];
+/**
+ * Patterns that indicate an editor will be opened
+ */
+const EDITOR_PATTERNS = [
+    /^git\s+rebase\s+-i/, // git rebase -i (interactive)
+    /^crontab\s+-e/, // crontab -e (opens editor)
+    /^visudo/, // visudo (opens editor)
+    /^vipw/, // vipw (opens editor)
+    /^sudoedit/, // sudoedit (opens editor)
+];
+/**
+ * Check if a command is an interactive editor that needs full terminal control
+ */
+export function isInteractiveEditorCommand(command) {
+    const trimmed = command.trim();
+    const parts = trimmed.split(/\s+/);
+    const baseCommand = parts[0].toLowerCase();
+    // Direct editor commands
+    if (INTERACTIVE_EDITORS.includes(baseCommand)) {
+        return true;
+    }
+    // Check patterns
+    for (const pattern of EDITOR_PATTERNS) {
+        if (pattern.test(trimmed)) {
+            return true;
+        }
+    }
+    // Handle sudo/doas prefix
+    if (baseCommand === 'sudo' || baseCommand === 'doas') {
+        const actualCommand = parts.slice(1).join(' ');
+        return isInteractiveEditorCommand(actualCommand);
+    }
+    return false;
+}
+/**
+ * Check if the command is specifically for nano editor (the only remote-supported editor currently)
+ */
+export function isNanoEditor(command) {
+    const trimmed = command.trim();
+    const parts = trimmed.split(/\s+/);
+    let baseCommand = parts[0].toLowerCase();
+    // Handle sudo/doas prefix
+    if (baseCommand === 'sudo' || baseCommand === 'doas') {
+        baseCommand = parts[1]?.toLowerCase() || '';
+    }
+    return baseCommand === 'nano' || baseCommand === 'pico'; // pico is often aliased to nano
+}
+/**
+ * Get the display name of an editor command for user-friendly messages
+ */
+export function getEditorName(command) {
+    const trimmed = command.trim();
+    const parts = trimmed.split(/\s+/);
+    let baseCommand = parts[0].toLowerCase();
+    // Handle sudo/doas prefix
+    if (baseCommand === 'sudo' || baseCommand === 'doas') {
+        baseCommand = parts[1]?.toLowerCase() || baseCommand;
+    }
+    // Map to display names
+    const displayNames = {
+        'vim': 'Vim',
+        'nvim': 'Neovim',
+        'vi': 'Vi',
+        'nano': 'Nano',
+        'emacs': 'Emacs',
+        'micro': 'Micro',
+        'helix': 'Helix',
+        'hx': 'Helix',
+        'pico': 'Pico',
+        'joe': 'Joe',
+        'ne': 'Ne',
+        'mcedit': 'Midnight Commander Editor',
+    };
+    return displayNames[baseCommand] || baseCommand;
+}
+/**
+ * Get the shell command for the current platform.
+ * On Windows, prefers Git Bash if available for better terminal emulation.
+ */
+function getShellCommand() {
+    if (os.platform() !== 'win32') {
+        return process.env.SHELL || '/bin/bash';
+    }
+    // On Windows, try to find Git Bash for better terminal emulation
+    const gitBashPath = findGitBash();
+    if (gitBashPath) {
+        return gitBashPath;
+    }
+    // Fallback to PowerShell
+    return 'powershell.exe';
+}
+/**
+ * Find Git Bash on Windows. Returns null if not found.
+ * Git Bash provides proper Unix terminal emulation for editors like nano.
+ */
+function findGitBash() {
+    const possiblePaths = [
+        'C:\\Program Files\\Git\\bin\\bash.exe',
+        'C:\\Program Files (x86)\\Git\\bin\\bash.exe',
+        process.env.PROGRAMFILES ? `${process.env.PROGRAMFILES}\\Git\\bin\\bash.exe` : null,
+        process.env['PROGRAMFILES(X86)'] ? `${process.env['PROGRAMFILES(X86)']}\\Git\\bin\\bash.exe` : null,
+        // User-specific installation
+        process.env.LOCALAPPDATA ? `${process.env.LOCALAPPDATA}\\Programs\\Git\\bin\\bash.exe` : null,
+    ].filter(Boolean);
+    for (const bashPath of possiblePaths) {
+        try {
+            const fs = require('fs');
+            if (fs.existsSync(bashPath)) {
+                return bashPath;
+            }
+        }
+        catch {
+            // Continue to next path
+        }
+    }
+    return null;
+}
+/**
+ * Check if we should use bash-style arguments for the shell
+ */
+function usesBashArgs(shell) {
+    return shell.includes('bash') || shell.includes('sh');
+}
+/**
+ * Common terminal reset sequences for cleanup after editor exits
+ */
+function getTerminalResetSequences() {
+    return [
+        '\x1b[?1049l', // Exit alternate screen buffer
+        '\x1b[?25l', // HIDE cursor (let Ink show it in the right place)
+        '\x1b[0m', // Reset text attributes (colors, bold, etc.)
+        '\x1b[?1000l', // Disable mouse tracking (X10)
+        '\x1b[?1002l', // Disable mouse button tracking
+        '\x1b[?1003l', // Disable mouse any-event tracking
+        '\x1b[?1006l', // Disable SGR mouse mode
+        '\x1b[?2004l', // Disable bracketed paste mode
+        '\x1b[?1u', // Disable CSI u mode (extended key reporting) - some terminals
+        '\x1b[>4;0m', // Disable modifyOtherKeys mode
+        '\x1b[?66l', // Disable application keypad mode
+        '\x1b[?1l', // Disable cursor keys application mode
+        '\x1bc', // Full terminal reset (RIS - Reset to Initial State)
+        '\x1b[?25l', // Hide cursor again after reset (reset shows it)
+    ].join('');
+}
+/**
+ * Common setup for interactive editor: raw stdin mode and handlers
+ */
+function setupInteractiveMode(ptyProcess, onExit) {
+    let isRunning = true;
+    // Save original stdin settings
+    const wasRaw = process.stdin.isRaw;
+    // Set stdin to raw mode for direct key passthrough
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+    // Pipe stdin to PTY (user keys -> editor)
+    const stdinHandler = (data) => {
+        if (isRunning) {
+            ptyProcess.write(data.toString());
+        }
+    };
+    process.stdin.on('data', stdinHandler);
+    // Pipe PTY output to stdout (editor display -> terminal)
+    ptyProcess.onData((data) => {
+        if (isRunning) {
+            process.stdout.write(data);
+        }
+    });
+    // Handle terminal resize
+    const resizeHandler = () => {
+        if (isRunning) {
+            const newCols = process.stdout.columns || 80;
+            const newRows = process.stdout.rows || 24;
+            try {
+                ptyProcess.resize(newCols, newRows);
+            }
+            catch (e) {
+                // Ignore resize errors
+            }
+        }
+    };
+    process.stdout.on('resize', resizeHandler);
+    // Handle PTY exit
+    ptyProcess.onExit(({ exitCode }) => {
+        isRunning = false;
+        // CRITICAL: Remove our stdin handler FIRST
+        process.stdin.removeListener('data', stdinHandler);
+        process.stdout.removeListener('resize', resizeHandler);
+        // Restore stdin to original raw mode setting
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(wasRaw ?? false);
+        }
+        // COMPREHENSIVE TERMINAL RESET
+        process.stdout.write(getTerminalResetSequences());
+        // Give terminal time to process reset sequences
+        setTimeout(() => {
+            onExit(exitCode);
+        }, 200);
+    });
+    return {
+        cleanup: () => {
+            process.stdin.removeListener('data', stdinHandler);
+            process.stdout.removeListener('resize', resizeHandler);
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(wasRaw ?? false);
+            }
+        },
+        kill: () => {
+            if (isRunning) {
+                isRunning = false;
+                try {
+                    ptyProcess.kill();
+                }
+                catch (e) {
+                    // Ignore kill errors
+                }
+            }
+        }
+    };
+}
+/**
+ * Run an interactive editor with full terminal control (LOCAL mode).
+ * This function:
+ * 1. Clears the screen and enters alternate screen buffer
+ * 2. Spawns a PTY process
+ * 3. Pipes stdin directly to the PTY (raw mode)
+ * 4. Pipes PTY output directly to stdout
+ * 5. Handles cleanup on exit
+ *
+ * Uses alternate screen buffer to prevent chat history from showing through.
+ */
+export function runInteractiveEditor(command, cwd, onExit) {
+    const shell = getShellCommand();
+    const isWindows = os.platform() === 'win32';
+    // Use bash-style args for Git Bash, PowerShell-style only if falling back to PowerShell
+    const isBash = usesBashArgs(shell);
+    const args = isBash ? ['-c', command] : (isWindows ? ['-Command', command] : ['-c', command]);
+    // Get terminal dimensions
+    const cols = process.stdout.columns || 80;
+    const rows = process.stdout.rows || 24;
+    // Enter alternate screen buffer and clear screen to hide chat history
+    // This combined with cygwin terminal type provides proper display on Windows
+    const enterAlternateBuffer = [
+        '\x1b[?1049h', // Enter alternate screen buffer
+        '\x1b[2J', // Clear entire screen
+        '\x1b[H', // Move cursor to home position
+    ].join('');
+    process.stdout.write(enterAlternateBuffer);
+    // Spawn PTY process - use 'cygwin' terminal type on Windows for better compatibility
+    // 'xterm-256color' can cause issues with some Windows terminal configurations
+    const ptyProcess = nodePty.spawn(shell, args, {
+        name: isWindows ? 'cygwin' : 'xterm-256color',
+        cols,
+        rows,
+        cwd,
+        env: {
+            ...process.env,
+            // Use cygwin TERM on Windows for better nano compatibility
+            TERM: isWindows ? 'cygwin' : 'xterm-256color',
+            COLORTERM: 'truecolor',
+        },
+    });
+    let isRunning = true;
+    // Save original stdin settings
+    const wasRaw = process.stdin.isRaw;
+    // Set stdin to raw mode for direct key passthrough
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+    // Pipe stdin to PTY (user keys -> editor)
+    const stdinHandler = (data) => {
+        if (isRunning) {
+            ptyProcess.write(data.toString());
+        }
+    };
+    process.stdin.on('data', stdinHandler);
+    // Pipe PTY output to stdout (editor display -> terminal)
+    ptyProcess.onData((data) => {
+        if (isRunning) {
+            process.stdout.write(data);
+        }
+    });
+    // Handle terminal resize
+    const resizeHandler = () => {
+        if (isRunning) {
+            const newCols = process.stdout.columns || 80;
+            const newRows = process.stdout.rows || 24;
+            try {
+                ptyProcess.resize(newCols, newRows);
+            }
+            catch (e) {
+                // Ignore resize errors
+            }
+        }
+    };
+    process.stdout.on('resize', resizeHandler);
+    // Handle PTY exit
+    ptyProcess.onExit(({ exitCode }) => {
+        isRunning = false;
+        // CRITICAL: Remove our stdin handler FIRST
+        process.stdin.removeListener('data', stdinHandler);
+        process.stdout.removeListener('resize', resizeHandler);
+        // Restore stdin to original raw mode setting
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(wasRaw ?? false);
+        }
+        // COMPREHENSIVE TERMINAL RESET
+        process.stdout.write(getTerminalResetSequences());
+        // Give terminal time to process reset sequences
+        setTimeout(() => {
+            onExit(exitCode);
+        }, 200);
+    });
+    return {
+        kill: () => {
+            if (isRunning) {
+                isRunning = false;
+                try {
+                    ptyProcess.kill();
+                }
+                catch (e) {
+                    // Ignore kill errors
+                }
+            }
+        }
+    };
+}
+/**
+ * Run an interactive editor in WSL session via node-pty.
+ * Uses wsl.exe to execute the editor command in the specified distribution.
+ */
+export function runWSLEditor(distribution, command, cwd, onExit) {
+    // Get terminal dimensions
+    const cols = process.stdout.columns || 80;
+    const rows = process.stdout.rows || 24;
+    // Build WSL command - cd to directory and run editor
+    // wsl.exe -d <distro> -- bash -c "cd <path> && <command>"
+    const wslArgs = [
+        '-d', distribution,
+        '--',
+        'bash', '-c',
+        `cd "${cwd}" && ${command}`
+    ];
+    // Spawn PTY process with wsl.exe
+    const ptyProcess = nodePty.spawn('wsl.exe', wslArgs, {
+        name: 'xterm-256color',
+        cols,
+        rows,
+        cwd: process.cwd(), // Use current Windows cwd
+        env: {
+            ...process.env,
+            TERM: 'xterm-256color',
+            COLORTERM: 'truecolor',
+        },
+    });
+    const { kill } = setupInteractiveMode(ptyProcess, onExit);
+    return { kill };
+}
+/**
+ * Run a command in WSL session via node-pty with streaming output.
+ * Unlike runWSLEditor, this doesn't take over the terminal - it streams output to a callback.
+ * This is essential for sudo commands that need TTY for password prompts.
+ */
+export function runWSLCommand(distribution, command, cwd, onData, onExit) {
+    // Get terminal dimensions
+    const cols = process.stdout.columns || 80;
+    const rows = process.stdout.rows || 24;
+    // Build WSL command - cd to directory and run command
+    const wslArgs = [
+        '-d', distribution,
+        '--',
+        'bash', '-c',
+        `cd "${cwd}" && ${command}`
+    ];
+    // Spawn PTY process with wsl.exe
+    const ptyProcess = nodePty.spawn('wsl.exe', wslArgs, {
+        name: 'xterm-256color',
+        cols,
+        rows,
+        cwd: process.cwd(),
+        env: {
+            ...process.env,
+            TERM: 'xterm-256color',
+            COLORTERM: 'truecolor',
+        },
+    });
+    let isRunning = true;
+    // Stream output to callback
+    ptyProcess.onData((data) => {
+        if (isRunning) {
+            onData(data);
+        }
+    });
+    // Handle exit
+    ptyProcess.onExit(({ exitCode }) => {
+        isRunning = false;
+        onExit(exitCode);
+    });
+    return {
+        write: (data) => {
+            if (isRunning) {
+                ptyProcess.write(data);
+            }
+        },
+        kill: () => {
+            if (isRunning) {
+                isRunning = false;
+                try {
+                    ptyProcess.kill();
+                }
+                catch (e) {
+                    // Ignore kill errors
+                }
+            }
+        },
+        resize: (cols, rows) => {
+            if (isRunning) {
+                try {
+                    ptyProcess.resize(cols, rows);
+                }
+                catch (e) {
+                    // Ignore resize errors
+                }
+            }
+        },
+        isRunning: () => isRunning
+    };
+}
+/**
+ * Run a command in Docker container via node-pty with streaming output.
+ * Unlike runDockerEditor, this doesn't take over the terminal - it streams output to a callback.
+ * This is essential for sudo commands that need TTY for password prompts.
+ */
+export function runDockerCommand(containerId, command, cwd, onData, onExit) {
+    // Get terminal dimensions
+    const cols = process.stdout.columns || 80;
+    const rows = process.stdout.rows || 24;
+    // Build docker exec command
+    const dockerArgs = [
+        'exec',
+        '-it',
+        containerId,
+        'bash', '-c',
+        `cd "${cwd}" && ${command}`
+    ];
+    // Spawn PTY process with docker
+    const ptyProcess = nodePty.spawn('docker', dockerArgs, {
+        name: 'xterm-256color',
+        cols,
+        rows,
+        cwd: process.cwd(),
+        env: {
+            ...process.env,
+            TERM: 'xterm-256color',
+            COLORTERM: 'truecolor',
+        },
+    });
+    let isRunning = true;
+    // Stream output to callback
+    ptyProcess.onData((data) => {
+        if (isRunning) {
+            onData(data);
+        }
+    });
+    // Handle exit
+    ptyProcess.onExit(({ exitCode }) => {
+        isRunning = false;
+        onExit(exitCode);
+    });
+    return {
+        write: (data) => {
+            if (isRunning) {
+                ptyProcess.write(data);
+            }
+        },
+        kill: () => {
+            if (isRunning) {
+                isRunning = false;
+                try {
+                    ptyProcess.kill();
+                }
+                catch (e) {
+                    // Ignore kill errors
+                }
+            }
+        },
+        resize: (cols, rows) => {
+            if (isRunning) {
+                try {
+                    ptyProcess.resize(cols, rows);
+                }
+                catch (e) {
+                    // Ignore resize errors
+                }
+            }
+        },
+        isRunning: () => isRunning
+    };
+}
+/**
+ * Run an interactive editor in Docker container via node-pty.
+ * Uses docker exec -it to execute the editor command in the container.
+ */
+export function runDockerEditor(containerId, command, cwd, onExit) {
+    // Get terminal dimensions
+    const cols = process.stdout.columns || 80;
+    const rows = process.stdout.rows || 24;
+    // Build docker exec command
+    // docker exec -it <container> bash -c "cd <path> && <command>"
+    const dockerArgs = [
+        'exec',
+        '-it',
+        containerId,
+        'bash', '-c',
+        `cd "${cwd}" && ${command}`
+    ];
+    // Spawn PTY process with docker
+    const ptyProcess = nodePty.spawn('docker', dockerArgs, {
+        name: 'xterm-256color',
+        cols,
+        rows,
+        cwd: process.cwd(),
+        env: {
+            ...process.env,
+            TERM: 'xterm-256color',
+            COLORTERM: 'truecolor',
+        },
+    });
+    const { kill } = setupInteractiveMode(ptyProcess, onExit);
+    return { kill };
+}
+/**
+ * Run an interactive editor in SSH session via ssh2's interactive shell.
+ * This is more complex as we need to use the ssh2 client's shell() method
+ * instead of exec() to get a proper interactive PTY.
+ */
+export function runSSHEditor(sshClient, // ssh2 Client
+command, cwd, onExit) {
+    let isRunning = true;
+    let stream = null;
+    // Save original stdin settings
+    const wasRaw = process.stdin.isRaw;
+    // Get terminal dimensions
+    const cols = process.stdout.columns || 80;
+    const rows = process.stdout.rows || 24;
+    // Request an interactive shell from the SSH server
+    sshClient.shell({
+        term: 'xterm-256color',
+        cols,
+        rows,
+    }, (err, shellStream) => {
+        if (err) {
+            console.error('Failed to open SSH shell:', err.message);
+            onExit(1);
+            return;
+        }
+        stream = shellStream;
+        // Set stdin to raw mode for direct key passthrough
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        // Pipe stdin to SSH stream (user keys -> remote shell)
+        const stdinHandler = (data) => {
+            if (isRunning && stream) {
+                stream.write(data);
+            }
+        };
+        process.stdin.on('data', stdinHandler);
+        // Pipe SSH stream output to stdout (remote -> terminal)
+        stream.on('data', (data) => {
+            if (isRunning) {
+                process.stdout.write(data);
+            }
+        });
+        // Handle terminal resize
+        const resizeHandler = () => {
+            if (isRunning && stream) {
+                const newCols = process.stdout.columns || 80;
+                const newRows = process.stdout.rows || 24;
+                try {
+                    stream.setWindow(newRows, newCols, 0, 0);
+                }
+                catch (e) {
+                    // Ignore resize errors
+                }
+            }
+        };
+        process.stdout.on('resize', resizeHandler);
+        // Handle stream close
+        stream.on('close', () => {
+            isRunning = false;
+            // CRITICAL: Remove our stdin handler FIRST
+            process.stdin.removeListener('data', stdinHandler);
+            process.stdout.removeListener('resize', resizeHandler);
+            // Restore stdin to original raw mode setting
+            if (process.stdin.isTTY) {
+                process.stdin.setRawMode(wasRaw ?? false);
+            }
+            // COMPREHENSIVE TERMINAL RESET
+            process.stdout.write(getTerminalResetSequences());
+            // Give terminal time to process reset sequences
+            setTimeout(() => {
+                onExit(0);
+            }, 200);
+        });
+        // Send the command to the shell: cd to directory and run editor
+        // Note: We send the command with exit so shell closes after editor exits
+        stream.write(`cd "${cwd}" && ${command}; exit\n`);
+    });
+    return {
+        kill: () => {
+            if (isRunning) {
+                isRunning = false;
+                if (stream) {
+                    try {
+                        stream.close();
+                    }
+                    catch (e) {
+                        // Ignore close errors
+                    }
+                }
+            }
+        }
+    };
+}
+/**
+ * Run a command in SSH session via ssh2's interactive shell with streaming output.
+ * Unlike runSSHEditor, this doesn't take over the terminal - it streams output to a callback.
+ * This is essential for sudo commands that need TTY for password prompts.
+ */
+export function runSSHCommand(sshClient, // ssh2 Client
+command, cwd, onData, onExit) {
+    let isRunning = true;
+    let stream = null;
+    // Get terminal dimensions
+    const cols = process.stdout.columns || 80;
+    const rows = process.stdout.rows || 24;
+    // Request an interactive shell from the SSH server
+    sshClient.shell({
+        term: 'xterm-256color',
+        cols,
+        rows,
+    }, (err, shellStream) => {
+        if (err) {
+            console.error('Failed to open SSH shell:', err.message);
+            onExit(1);
+            return;
+        }
+        stream = shellStream;
+        // Stream output to callback (instead of process.stdout)
+        stream.on('data', (data) => {
+            if (isRunning) {
+                onData(data.toString());
+            }
+        });
+        // Handle stream close
+        stream.on('close', () => {
+            isRunning = false;
+            onExit(0);
+        });
+        // Send the command to the shell: cd to directory and run command
+        // Note: We send the command with exit so shell closes after command exits
+        stream.write(`cd "${cwd}" && ${command}; exit\n`);
+    });
+    return {
+        write: (data) => {
+            if (isRunning && stream) {
+                stream.write(data);
+            }
+        },
+        kill: () => {
+            if (isRunning) {
+                isRunning = false;
+                if (stream) {
+                    try {
+                        stream.close();
+                    }
+                    catch (e) {
+                        // Ignore close errors
+                    }
+                }
+            }
+        },
+        resize: (cols, rows) => {
+            if (isRunning && stream) {
+                try {
+                    stream.setWindow(rows, cols, 0, 0);
+                }
+                catch (e) {
+                    // Ignore resize errors
+                }
+            }
+        },
+        isRunning: () => isRunning
+    };
+}
+//# sourceMappingURL=editor-utils.js.map