centaurus-cli 3.0.0 → 3.1.0

package/dist/utils/editor-utils.js

@@ -1,895 +1,790 @@
-import * as os from 'os';
-import { createRequire } from 'module';
-import { logError } from './logger.js';
-// 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
- */
+import * as os from "os";
+import { createRequire } from "module";
+import { logError } from "./logger.js";
+const require2 = createRequire(import.meta.url);
+const nodePty = require2("@homebridge/node-pty-prebuilt-multiarch");
 const INTERACTIVE_EDITORS = [
-    'vim', 'nvim', 'vi', 'nano', 'emacs', 'micro', 'helix', 'hx',
-    'pico', 'joe', 'ne', 'mcedit'
+  "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)
+  /^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;
+function isInteractiveEditorCommand(command) {
+  const trimmed = command.trim();
+  const parts = trimmed.split(/\s+/);
+  const baseCommand = parts[0].toLowerCase();
+  if (INTERACTIVE_EDITORS.includes(baseCommand)) {
+    return true;
+  }
+  for (const pattern of EDITOR_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      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;
+  }
+  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
+function isNanoEditor(command) {
+  const trimmed = command.trim();
+  const parts = trimmed.split(/\s+/);
+  let baseCommand = parts[0].toLowerCase();
+  if (baseCommand === "sudo" || baseCommand === "doas") {
+    baseCommand = parts[1]?.toLowerCase() || "";
+  }
+  return baseCommand === "nano" || baseCommand === "pico";
 }
-/**
- * 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;
+function getEditorName(command) {
+  const trimmed = command.trim();
+  const parts = trimmed.split(/\s+/);
+  let baseCommand = parts[0].toLowerCase();
+  if (baseCommand === "sudo" || baseCommand === "doas") {
+    baseCommand = parts[1]?.toLowerCase() || baseCommand;
+  }
+  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';
+  if (os.platform() !== "win32") {
+    return process.env.SHELL || "/bin/bash";
+  }
+  const gitBashPath = findGitBash();
+  if (gitBashPath) {
+    return gitBashPath;
+  }
+  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
-        }
+  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 = require2("fs");
+      if (fs.existsSync(bashPath)) {
+        return bashPath;
+      }
+    } catch {
     }
-    return null;
+  }
+  return null;
 }
-/**
- * Check if we should use bash-style arguments for the shell
- */
 function usesBashArgs(shell) {
-    return shell.includes('bash') || shell.includes('sh');
+  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('');
+  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
+  let isRunning = true;
+  const wasRaw = process.stdin.isRaw;
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+  process.stdin.resume();
+  const stdinHandler = (data) => {
+    if (isRunning) {
+      ptyProcess.write(data.toString());
+    }
+  };
+  process.stdin.on("data", stdinHandler);
+  ptyProcess.onData((data) => {
+    if (isRunning) {
+      process.stdout.write(data);
+    }
+  });
+  const resizeHandler = () => {
+    if (isRunning) {
+      const newCols = process.stdout.columns || 80;
+      const newRows = process.stdout.rows || 24;
+      try {
+        ptyProcess.resize(newCols, newRows);
+      } catch (e) {
+      }
+    }
+  };
+  process.stdout.on("resize", resizeHandler);
+  ptyProcess.onExit(({ exitCode }) => {
+    isRunning = false;
+    process.stdin.removeListener("data", stdinHandler);
+    process.stdout.removeListener("resize", resizeHandler);
     if (process.stdin.isTTY) {
-        process.stdin.setRawMode(true);
+      process.stdin.setRawMode(wasRaw ?? false);
     }
-    process.stdin.resume();
-    // Pipe stdin to PTY (user keys -> editor)
-    const stdinHandler = (data) => {
-        if (isRunning) {
-            ptyProcess.write(data.toString());
+    process.stdout.write(getTerminalResetSequences());
+    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) {
         }
-    };
-    process.stdin.on('data', stdinHandler);
-    // Pipe PTY output to stdout (editor display -> terminal)
-    ptyProcess.onData((data) => {
-        if (isRunning) {
-            process.stdout.write(data);
+      }
+    }
+  };
+}
+function runInteractiveEditor(command, cwd, onExit) {
+  const shell = getShellCommand();
+  const isWindows = os.platform() === "win32";
+  const isBash = usesBashArgs(shell);
+  const args = isBash ? ["-c", command] : isWindows ? ["-Command", command] : ["-c", command];
+  const cols = process.stdout.columns || 80;
+  const rows = process.stdout.rows || 24;
+  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);
+  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;
+  const wasRaw = process.stdin.isRaw;
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+  process.stdin.resume();
+  const stdinHandler = (data) => {
+    if (isRunning) {
+      ptyProcess.write(data.toString());
+    }
+  };
+  process.stdin.on("data", stdinHandler);
+  ptyProcess.onData((data) => {
+    if (isRunning) {
+      process.stdout.write(data);
+    }
+  });
+  const resizeHandler = () => {
+    if (isRunning) {
+      const newCols = process.stdout.columns || 80;
+      const newRows = process.stdout.rows || 24;
+      try {
+        ptyProcess.resize(newCols, newRows);
+      } catch (e) {
+      }
+    }
+  };
+  process.stdout.on("resize", resizeHandler);
+  ptyProcess.onExit(({ exitCode }) => {
+    isRunning = false;
+    process.stdin.removeListener("data", stdinHandler);
+    process.stdout.removeListener("resize", resizeHandler);
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(wasRaw ?? false);
+    }
+    process.stdout.write(getTerminalResetSequences());
+    setTimeout(() => {
+      onExit(exitCode);
+    }, 200);
+  });
+  return {
+    kill: () => {
+      if (isRunning) {
+        isRunning = false;
+        try {
+          ptyProcess.kill();
+        } catch (e) {
+        }
+      }
+    }
+  };
+}
+function runWSLEditor(distribution, command, cwd, onExit) {
+  const cols = process.stdout.columns || 80;
+  const rows = process.stdout.rows || 24;
+  const wslArgs = [
+    "-d",
+    distribution,
+    "--",
+    "bash",
+    "-c",
+    `cd "${cwd}" && ${command}`
+  ];
+  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 };
+}
+function runWSLCommand(distribution, command, cwd, onData, onExit, initialCols, initialRows) {
+  const cols = initialCols || process.stdout.columns || 80;
+  const rows = initialRows || process.stdout.rows || 24;
+  const wslArgs = [
+    "-d",
+    distribution,
+    "--",
+    "bash",
+    "-c",
+    `cd "${cwd}" && ${command}`
+  ];
+  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;
+  let hasExited = false;
+  const finalizeExit = (exitCode) => {
+    if (hasExited) return;
+    hasExited = true;
+    isRunning = false;
+    onExit(exitCode);
+  };
+  ptyProcess.onData((data) => {
+    if (isRunning) {
+      onData(data);
+    }
+  });
+  ptyProcess.onExit(({ exitCode }) => {
+    finalizeExit(exitCode);
+  });
+  return {
+    write: (data) => {
+      if (isRunning) {
+        ptyProcess.write(data);
+      }
+    },
+    kill: () => {
+      if (!isRunning || hasExited) {
+        return;
+      }
+      isRunning = false;
+      try {
+        ptyProcess.kill();
+      } catch (e) {
+      }
+      setTimeout(() => {
+        finalizeExit(130);
+      }, 150);
+    },
+    resize: (cols2, rows2) => {
+      if (isRunning) {
+        try {
+          ptyProcess.resize(cols2, rows2);
+        } catch (e) {
+        }
+      }
+    },
+    isRunning: () => isRunning
+  };
+}
+function runDockerCommand(containerId, command, cwd, onData, onExit, initialCols, initialRows) {
+  const cols = initialCols || process.stdout.columns || 80;
+  const rows = initialRows || process.stdout.rows || 24;
+  const dockerArgs = [
+    "exec",
+    "-it",
+    containerId,
+    "bash",
+    "-c",
+    `cd "${cwd}" && ${command}`
+  ];
+  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;
+  let hasExited = false;
+  const finalizeExit = (exitCode) => {
+    if (hasExited) return;
+    hasExited = true;
+    isRunning = false;
+    onExit(exitCode);
+  };
+  ptyProcess.onData((data) => {
+    if (isRunning) {
+      onData(data);
+    }
+  });
+  ptyProcess.onExit(({ exitCode }) => {
+    finalizeExit(exitCode);
+  });
+  return {
+    write: (data) => {
+      if (isRunning) {
+        ptyProcess.write(data);
+      }
+    },
+    kill: () => {
+      if (!isRunning || hasExited) {
+        return;
+      }
+      isRunning = false;
+      try {
+        ptyProcess.kill();
+      } catch (e) {
+      }
+      setTimeout(() => {
+        finalizeExit(130);
+      }, 150);
+    },
+    resize: (cols2, rows2) => {
+      if (isRunning) {
+        try {
+          ptyProcess.resize(cols2, rows2);
+        } catch (e) {
+        }
+      }
+    },
+    isRunning: () => isRunning
+  };
+}
+function runDockerEditor(containerId, command, cwd, onExit) {
+  const cols = process.stdout.columns || 80;
+  const rows = process.stdout.rows || 24;
+  const dockerArgs = [
+    "exec",
+    "-it",
+    containerId,
+    "bash",
+    "-c",
+    `cd "${cwd}" && ${command}`
+  ];
+  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 };
+}
+function runSSHEditor(sshClient, command, cwd, onExit) {
+  let isRunning = true;
+  let stream = null;
+  const wasRaw = process.stdin.isRaw;
+  const cols = process.stdout.columns || 80;
+  const rows = process.stdout.rows || 24;
+  sshClient.shell(
+    {
+      term: "xterm-256color",
+      cols,
+      rows
+    },
+    (err, shellStream) => {
+      if (err) {
+        logError("Failed to open SSH shell", err);
+        onExit(1);
+        return;
+      }
+      stream = shellStream;
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+      }
+      process.stdin.resume();
+      const stdinHandler = (data) => {
+        if (isRunning && stream) {
+          stream.write(data);
         }
-    });
-    // Handle terminal resize
-    const resizeHandler = () => {
+      };
+      process.stdin.on("data", stdinHandler);
+      stream.on("data", (data) => {
         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.write(data);
         }
-    };
-    process.stdout.on('resize', resizeHandler);
-    // Handle PTY exit
-    ptyProcess.onExit(({ exitCode }) => {
+      });
+      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) {
+          }
+        }
+      };
+      process.stdout.on("resize", resizeHandler);
+      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
+        process.stdin.removeListener("data", stdinHandler);
+        process.stdout.removeListener("resize", resizeHandler);
         if (process.stdin.isTTY) {
-            process.stdin.setRawMode(wasRaw ?? false);
+          process.stdin.setRawMode(wasRaw ?? false);
         }
-        // COMPREHENSIVE TERMINAL RESET
         process.stdout.write(getTerminalResetSequences());
-        // Give terminal time to process reset sequences
         setTimeout(() => {
-            onExit(exitCode);
+          onExit(0);
         }, 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
-                }
-            }
+      });
+      stream.write(`cd "${cwd}" && ${command}; exit
+`);
+    }
+  );
+  return {
+    kill: () => {
+      if (isRunning) {
+        isRunning = false;
+        if (stream) {
+          try {
+            stream.close();
+          } catch (e) {
+          }
         }
-    };
+      }
+    }
+  };
 }
-/**
- * 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) {
+function runNestedDockerSSHEditor(sshClient, containerId, command, cwd, onExit) {
+  let isRunning = true;
+  let stream = null;
+  const wasRaw = process.stdin.isRaw;
+  const cols = process.stdout.columns || 80;
+  const rows = process.stdout.rows || 24;
+  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);
+  sshClient.shell(
+    {
+      term: "xterm-256color",
+      cols,
+      rows
+    },
+    (err, shellStream) => {
+      if (err) {
+        logError("Failed to open SSH shell for nested Docker editor", err);
+        onExit(1);
+        return;
+      }
+      stream = shellStream;
+      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.resume();
+      const stdinHandler = (data) => {
+        if (isRunning && stream) {
+          stream.write(data);
         }
-    };
-    process.stdin.on('data', stdinHandler);
-    // Pipe PTY output to stdout (editor display -> terminal)
-    ptyProcess.onData((data) => {
+      };
+      process.stdin.on("data", stdinHandler);
+      stream.on("data", (data) => {
         if (isRunning) {
-            process.stdout.write(data);
+          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
-            }
+      });
+      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) {
+          }
         }
-    };
-    process.stdout.on('resize', resizeHandler);
-    // Handle PTY exit
-    ptyProcess.onExit(({ exitCode }) => {
+      };
+      process.stdout.on("resize", resizeHandler);
+      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
+        process.stdin.removeListener("data", stdinHandler);
+        process.stdout.removeListener("resize", resizeHandler);
         if (process.stdin.isTTY) {
-            process.stdin.setRawMode(wasRaw ?? false);
+          process.stdin.setRawMode(wasRaw ?? false);
         }
-        // COMPREHENSIVE TERMINAL RESET
         process.stdout.write(getTerminalResetSequences());
-        // Give terminal time to process reset sequences
         setTimeout(() => {
-            onExit(exitCode);
+          onExit(0);
         }, 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, initialCols, initialRows) {
-    // Get terminal dimensions - use provided values or fall back to process.stdout
-    // Constrained dimensions help with proper escape sequence handling in UI display
-    const cols = initialCols || process.stdout.columns || 80;
-    const rows = initialRows || 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 }) => {
+      });
+      const escapedCwd = cwd.replace(/"/g, '\\"');
+      const escapedCommand = command.replace(/"/g, '\\"');
+      const dockerExecCommand = `docker exec -it ${containerId} bash -c "cd \\"${escapedCwd}\\" && ${escapedCommand}"; exit
+`;
+      stream.write(dockerExecCommand);
+    }
+  );
+  return {
+    kill: () => {
+      if (isRunning) {
         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, initialCols, initialRows) {
-    // Get terminal dimensions - use provided values or fall back to process.stdout
-    // Constrained dimensions help with proper escape sequence handling in UI display
-    const cols = initialCols || process.stdout.columns || 80;
-    const rows = initialRows || 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);
+        if (stream) {
+          try {
+            stream.close();
+          } catch (e) {
+          }
         }
-    });
-    // 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',
+function runSSHCommand(sshClient, command, cwd, onData, onExit, initialCols, initialRows) {
+  let isRunning = true;
+  let stream = null;
+  let hasExited = false;
+  let killRequested = false;
+  const finalizeExit = (exitCode) => {
+    if (hasExited) return;
+    hasExited = true;
+    isRunning = false;
+    onExit(exitCode);
+  };
+  const cols = initialCols || process.stdout.columns || 80;
+  const rows = initialRows || process.stdout.rows || 24;
+  const fullCommand = `cd "${cwd}" && ${command}`;
+  sshClient.exec(
+    fullCommand,
+    {
+      pty: {
+        term: "xterm-256color",
         cols,
         rows,
-    }, (err, shellStream) => {
-        if (err) {
-            logError('Failed to open SSH shell', err);
-            onExit(1);
-            return;
-        }
-        stream = shellStream;
-        // Set stdin to raw mode for direct key passthrough
-        if (process.stdin.isTTY) {
-            process.stdin.setRawMode(true);
+        modes: {
+          ECHO: 0
+          // Disable echo to prevent duplicate output
         }
-        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
-                    }
-                }
-            }
+      }
+    },
+    (err, execStream) => {
+      if (err) {
+        logError("Failed to execute SSH command", err);
+        finalizeExit(1);
+        return;
+      }
+      stream = execStream;
+      if (killRequested) {
+        try {
+          stream.close();
+        } catch (e) {
         }
-    };
-}
-/**
- * Run an interactive editor in a Docker container that is accessed through SSH.
- * This routes the docker exec command through the SSH session to properly access
- * the remote Docker daemon instead of trying to use local Docker.
- */
-export function runNestedDockerSSHEditor(sshClient, // ssh2 Client from parent SSH context
-containerId, 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;
-    // Enter alternate screen buffer and clear screen to hide chat history
-    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);
-    // Request an interactive shell from the SSH server
-    sshClient.shell({
-        term: 'xterm-256color',
-        cols,
-        rows,
-    }, (err, shellStream) => {
-        if (err) {
-            logError('Failed to open SSH shell for nested Docker editor', err);
-            onExit(1);
-            return;
+        finalizeExit(130);
+        return;
+      }
+      stream.on("data", (data) => {
+        if (isRunning) {
+          onData(data.toString());
         }
-        stream = shellStream;
-        // Set stdin to raw mode for direct key passthrough
-        if (process.stdin.isTTY) {
-            process.stdin.setRawMode(true);
+      });
+      stream.on("close", (code) => {
+        finalizeExit(code || 0);
+      });
+    }
+  );
+  return {
+    write: (data) => {
+      if (isRunning && stream) {
+        stream.write(data);
+      }
+    },
+    kill: () => {
+      if (!isRunning || hasExited) {
+        return;
+      }
+      killRequested = true;
+      isRunning = false;
+      if (stream) {
+        try {
+          stream.close();
+        } catch (e) {
         }
-        process.stdin.resume();
-        // Pipe stdin to SSH stream (user keys -> remote shell -> docker)
-        const stdinHandler = (data) => {
-            if (isRunning && stream) {
-                stream.write(data);
-            }
-        };
-        process.stdin.on('data', stdinHandler);
-        // Pipe SSH stream output to stdout (docker -> remote shell -> 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);
-        });
-        // Build the docker exec command to run via SSH shell
-        // Use docker exec -it for interactive TTY, cd to cwd, run command, then exit
-        const escapedCwd = cwd.replace(/"/g, '\\"');
-        const escapedCommand = command.replace(/"/g, '\\"');
-        const dockerExecCommand = `docker exec -it ${containerId} bash -c "cd \\"${escapedCwd}\\" && ${escapedCommand}"; exit\n`;
-        stream.write(dockerExecCommand);
-    });
-    return {
-        kill: () => {
-            if (isRunning) {
-                isRunning = false;
-                if (stream) {
-                    try {
-                        stream.close();
-                    }
-                    catch (e) {
-                        // Ignore close errors
-                    }
-                }
-            }
+      }
+      setTimeout(() => {
+        finalizeExit(130);
+      }, 150);
+    },
+    resize: (cols2, rows2) => {
+      if (isRunning && stream) {
+        try {
+          stream.setWindow(rows2, cols2, 0, 0);
+        } catch (e) {
         }
-    };
+      }
+    },
+    isRunning: () => isRunning
+  };
 }
-/**
- * Run a command in SSH session via ssh2's exec with PTY for streaming output.
- * Uses exec() with PTY option instead of shell() to avoid login banners and command echo.
- * This reuses the existing SSH connection so password is not required for each command.
- */
-export function runSSHCommand(sshClient, // ssh2 Client
-command, cwd, onData, onExit, initialCols, initialRows) {
-    let isRunning = true;
-    let stream = null;
-    // Get terminal dimensions - use provided values or fall back to process.stdout
-    // Constrained dimensions help with proper escape sequence handling in UI display
-    const cols = initialCols || process.stdout.columns || 80;
-    const rows = initialRows || process.stdout.rows || 24;
-    // Build the full command with cd
-    const fullCommand = `cd "${cwd}" && ${command}`;
-    // Use exec() with PTY option instead of shell()
-    // This runs a single command with PTY support but without login shell overhead
-    // IMPORTANT: Disable ECHO mode to prevent output duplication
-    sshClient.exec(fullCommand, {
-        pty: {
-            term: 'xterm-256color',
-            cols,
-            rows,
-            modes: {
-                ECHO: 0 // Disable echo to prevent duplicate output
-            }
-        }
-    }, (err, execStream) => {
-        if (err) {
-            logError('Failed to execute SSH command', err);
-            onExit(1);
-            return;
+function runLocalPty(command, cwd, onData, onExit, initialCols, initialRows) {
+  const cols = initialCols || process.stdout.columns || 80;
+  const rows = initialRows || process.stdout.rows || 24;
+  const shell = getShellCommand();
+  const isWindows = os.platform() === "win32";
+  const isBash = usesBashArgs(shell);
+  const shellArgs = isBash ? ["-c", command] : isWindows ? ["-Command", command] : ["-c", command];
+  const ptyProcess = nodePty.spawn(shell, shellArgs, {
+    name: isWindows ? "cygwin" : "xterm-256color",
+    // cygwin for Windows compatibility
+    cols,
+    rows,
+    cwd,
+    env: {
+      ...process.env,
+      TERM: isWindows ? "cygwin" : "xterm-256color",
+      COLORTERM: "truecolor"
+    }
+  });
+  let isRunning = true;
+  ptyProcess.onData((data) => {
+    if (isRunning) {
+      onData(data);
+    }
+  });
+  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) {
         }
-        stream = execStream;
-        // Stream output to callback
-        // Note: In PTY mode, stdout and stderr are merged into a single stream
-        stream.on('data', (data) => {
-            if (isRunning) {
-                onData(data.toString());
-            }
-        });
-        // Handle stream close with exit code
-        stream.on('close', (code) => {
-            isRunning = false;
-            onExit(code || 0);
-        });
-    });
-    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
-    };
-}
-/**
- * Run a command in a local PTY.
- * Useful for executing commands that are either local or wrapped (e.g., `wsl ...` or `ssh ...`).
- */
-export function runLocalPty(command, cwd, onData, onExit, initialCols, initialRows) {
-    // Get terminal dimensions - use provided values or fall back to process.stdout
-    const cols = initialCols || process.stdout.columns || 80;
-    const rows = initialRows || process.stdout.rows || 24;
-    const shell = getShellCommand();
-    const isWindows = os.platform() === 'win32';
-    // Use bash-style args for Git Bash
-    const isBash = usesBashArgs(shell);
-    const shellArgs = isBash ? ['-c', command] : (isWindows ? ['-Command', command] : ['-c', command]);
-    // Spawn PTY process
-    const ptyProcess = nodePty.spawn(shell, shellArgs, {
-        name: isWindows ? 'cygwin' : 'xterm-256color', // cygwin for Windows compatibility
-        cols,
-        rows,
-        cwd,
-        env: {
-            ...process.env,
-            TERM: isWindows ? 'cygwin' : 'xterm-256color',
-            COLORTERM: 'truecolor',
-        },
-    });
-    let isRunning = true;
-    // Stream output to callback
-    ptyProcess.onData((data) => {
-        if (isRunning) {
-            onData(data);
+      }
+    },
+    resize: (cols2, rows2) => {
+      if (isRunning) {
+        try {
+          ptyProcess.resize(cols2, rows2);
+        } catch (e) {
         }
-    });
-    // 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
-    };
+      }
+    },
+    isRunning: () => isRunning
+  };
 }
+export {
+  getEditorName,
+  isInteractiveEditorCommand,
+  isNanoEditor,
+  runDockerCommand,
+  runDockerEditor,
+  runInteractiveEditor,
+  runLocalPty,
+  runNestedDockerSSHEditor,
+  runSSHCommand,
+  runSSHEditor,
+  runWSLCommand,
+  runWSLEditor
+};
 //# sourceMappingURL=editor-utils.js.map