Upload SshBridge.cs with huggingface_hub

SshBridge.cs

@@ -1,9 +1,12 @@
 using System;
+using System.Collections.Generic;
 using System.Drawing;
 using System.IO;
+using System.Linq;
 using System.Net;
 using System.Net.Sockets;
 using System.Text;
+using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Windows.Forms;
@@ -38,12 +41,33 @@ namespace SshBridge
         private Thread? _serverThread;
         private CancellationTokenSource? _cts;
         private SshClient? _sshClient;
+        private ShellStream? _shellStream;
         private bool _isConnected;
         private int _commandCount;
         private string _currentHost = "";
         private string _currentUser = "";
+        private string _promptPattern = "";
+        private readonly object _shellLock = new object();
+        
+        // UI state
+        private bool _stayOnTop;
+        private bool _penLifted;
+        private bool _allowSudo;
+        private bool _isRunning;
+        private string _storedPassword = "";
+        private Button _stayOnTopButton = null!;
+        private Button _penButton = null!;
+        private Button _sudoButton = null!;
+        private System.Windows.Forms.Timer _runningTimer = null!;
+        private int _runningDots;
 
         private const int PORT = 52718;
+        private const int MAX_OUTPUT_BYTES = 500 * 1024; // 500KB limit for MCP
+        private const int MAX_OUTPUT_LINES = 150; // Keep last N lines for large output
+        private const int DEFAULT_TIMEOUT_MS = 30000;
+        
+        private int _nextCommandTimeoutMs = DEFAULT_TIMEOUT_MS; // Configurable per-command
+        private Dictionary<string, int> _spawnedProcesses = new(); // Track background processes
 
         public SshBridgeForm()
         {
@@ -142,10 +166,48 @@ namespace SshBridge
                 Height = 28,
                 Anchor = AnchorStyles.Right,
             };
-            _disconnectButton.Location = new Point(topBar.Width - _disconnectButton.Width - 10, 6);
             _disconnectButton.Click += (s, e) => Disconnect();
             topBar.Controls.Add(_disconnectButton);
-            topBar.Resize += (s, e) => _disconnectButton.Location = new Point(topBar.Width - _disconnectButton.Width - 10, 6);
+
+            _penButton = new Button
+            {
+                Text = "✏️ Lift Pen",
+                ForeColor = Color.White,
+                BackColor = Color.FromArgb(70, 130, 180),
+                FlatStyle = FlatStyle.Flat,
+                Width = 100,
+                Height = 28,
+            };
+            _penButton.Click += (s, e) => TogglePen();
+            topBar.Controls.Add(_penButton);
+
+            _stayOnTopButton = new Button
+            {
+                Text = "📌 Pin",
+                ForeColor = Color.White,
+                BackColor = Color.FromArgb(80, 80, 85),
+                FlatStyle = FlatStyle.Flat,
+                Width = 70,
+                Height = 28,
+            };
+            _stayOnTopButton.Click += (s, e) => ToggleStayOnTop();
+            topBar.Controls.Add(_stayOnTopButton);
+
+            _sudoButton = new Button
+            {
+                Text = "🔓 Sudo",
+                ForeColor = Color.White,
+                BackColor = Color.FromArgb(80, 80, 85),
+                FlatStyle = FlatStyle.Flat,
+                Width = 80,
+                Height = 28,
+            };
+            _sudoButton.Click += (s, e) => ToggleSudo();
+            topBar.Controls.Add(_sudoButton);
+
+            // Position buttons from right edge
+            topBar.Resize += (s, e) => RepositionTopBarButtons();
+            this.Load += (s, e) => RepositionTopBarButtons();
 
             _outputBox = new RichTextBox
             {
@@ -157,11 +219,45 @@ namespace SshBridge
                 WordWrap = false,
             };
 
+            // Right-click context menu
+            var contextMenu = new ContextMenuStrip();
+            var copyItem = new ToolStripMenuItem("Copy", null, (s, e) =>
+            {
+                if (_outputBox.SelectionLength > 0)
+                    Clipboard.SetText(_outputBox.SelectedText);
+            });
+            var copyAllItem = new ToolStripMenuItem("Copy All", null, (s, e) =>
+            {
+                if (!string.IsNullOrEmpty(_outputBox.Text))
+                    Clipboard.SetText(_outputBox.Text);
+            });
+            var clearItem = new ToolStripMenuItem("Clear", null, (s, e) =>
+            {
+                _outputBox.Clear();
+            });
+            contextMenu.Items.Add(copyItem);
+            contextMenu.Items.Add(copyAllItem);
+            contextMenu.Items.AddRange(new ToolStripItem[] { new ToolStripSeparator(), clearItem });
+            _outputBox.ContextMenuStrip = contextMenu;
+
             _sessionPanel.Controls.Add(_outputBox);
             _sessionPanel.Controls.Add(topBar);
 
             this.Controls.Add(_loginPanel);
             this.Controls.Add(_sessionPanel);
+
+            // Timer for running indicator
+            _runningTimer = new System.Windows.Forms.Timer { Interval = 400 };
+            _runningTimer.Tick += (s, e) =>
+            {
+                if (_isRunning)
+                {
+                    _runningDots = (_runningDots + 1) % 4;
+                    var dots = new string('.', _runningDots);
+                    _statusLabel.Text = $"⚡ Running{dots}";
+                    _statusLabel.ForeColor = Color.Yellow;
+                }
+            };
         }
 
         private void Connect()
@@ -196,10 +292,27 @@ namespace SshBridge
                         _currentUser = user;
                         _commandCount = 0;
 
+                        // Create persistent shell stream
+                        _shellStream = _sshClient.CreateShellStream("xterm", 200, 50, 800, 600, 65536);
+                        
+                        // Wait for initial prompt and detect the pattern
+                        Thread.Sleep(500);
+                        var initial = ReadAvailable();
+                        _promptPattern = DetectPrompt(initial, user);
+
                         this.Invoke(() =>
                         {
+                            _storedPassword = _passwordBox.Text;
                             _passwordBox.Clear();
                             OnConnected();
+                            if (!string.IsNullOrEmpty(initial))
+                            {
+                                var cleaned = StripAnsiCodes(initial).Trim();
+                                if (!string.IsNullOrEmpty(cleaned))
+                                {
+                                    AppendOutput(cleaned, Color.Gray);
+                                }
+                            }
                         });
                     }
                     else
@@ -232,23 +345,102 @@ namespace SshBridge
         private void Disconnect()
         {
             _isConnected = false;
+            _penLifted = false;
+            _allowSudo = false;
+            _storedPassword = "";
 
             try
             {
+                _shellStream?.Dispose();
                 _sshClient?.Disconnect();
                 _sshClient?.Dispose();
             }
             catch { }
 
+            _shellStream = null;
             _sshClient = null;
             _currentHost = "";
             _currentUser = "";
+            _promptPattern = "";
 
             _loginPanel.Visible = true;
             _sessionPanel.Visible = false;
             _connectButton.Enabled = true;
             _connectButton.Text = "Connect";
             _statusLabel.Text = "Disconnected";
+            UpdatePenButton();
+            UpdateSudoButton();
+        }
+
+        private void RepositionTopBarButtons()
+        {
+            int rightEdge = _sessionPanel.Width - 10;
+            _disconnectButton.Location = new Point(rightEdge - _disconnectButton.Width, 6);
+            _penButton.Location = new Point(_disconnectButton.Left - _penButton.Width - 5, 6);
+            _stayOnTopButton.Location = new Point(_penButton.Left - _stayOnTopButton.Width - 5, 6);
+            _sudoButton.Location = new Point(_stayOnTopButton.Left - _sudoButton.Width - 5, 6);
+        }
+
+        private void ToggleStayOnTop()
+        {
+            _stayOnTop = !_stayOnTop;
+            this.TopMost = _stayOnTop;
+            _stayOnTopButton.BackColor = _stayOnTop 
+                ? Color.FromArgb(60, 140, 60)  // Green when active
+                : Color.FromArgb(80, 80, 85);  // Gray when inactive
+            _stayOnTopButton.Text = _stayOnTop ? "📌 Pinned" : "📌 Pin";
+        }
+
+        private void TogglePen()
+        {
+            _penLifted = !_penLifted;
+            UpdatePenButton();
+            
+            if (_penLifted)
+            {
+                AppendOutput("=== PEN LIFTED - Claude paused ===", Color.Orange);
+            }
+            else
+            {
+                AppendOutput("=== PEN DOWN - Claude resumed ===", Color.LimeGreen);
+            }
+        }
+
+        private void UpdatePenButton()
+        {
+            _penButton.BackColor = _penLifted 
+                ? Color.FromArgb(200, 120, 50)  // Orange when lifted
+                : Color.FromArgb(70, 130, 180); // Blue when down
+            _penButton.Text = _penLifted ? "✏️ Pen Up!" : "✏️ Lift Pen";
+        }
+
+        private void ToggleSudo()
+        {
+            if (string.IsNullOrEmpty(_storedPassword))
+            {
+                MessageBox.Show("No password stored. Reconnect to enable sudo.", "Sudo", MessageBoxButtons.OK, MessageBoxIcon.Warning);
+                return;
+            }
+            
+            _allowSudo = !_allowSudo;
+            UpdateSudoButton();
+            
+            if (_allowSudo)
+            {
+                AppendOutput("=== SUDO ENABLED - Password will auto-send ===", Color.FromArgb(180, 100, 255));
+            }
+            else
+            {
+                AppendOutput("=== SUDO DISABLED ===", Color.Gray);
+            }
+        }
+
+        private void UpdateSudoButton()
+        {
+            _sudoButton.BackColor = _allowSudo 
+                ? Color.FromArgb(140, 80, 200)  // Purple when enabled
+                : Color.FromArgb(80, 80, 85);   // Gray when disabled
+            _sudoButton.Text = _allowSudo ? "🔐 Sudo On" : "🔓 Sudo";
         }
 
         private void AppendOutput(string? text, Color? color = null)
@@ -274,44 +466,490 @@ namespace SshBridge
 
         public string ExecuteCommand(string command)
         {
-            if (!_isConnected || _sshClient == null || !_sshClient.IsConnected)
+            if (!_isConnected || _sshClient == null || !_sshClient.IsConnected || _shellStream == null)
             {
                 return "ERROR: Not connected. Open SSH Bridge and connect first.";
             }
 
+            lock (_shellLock)
+            {
+                try
+                {
+                    _commandCount++;
+                    SetRunning(true);
+                    
+                    // Clear any pending output
+                    ReadAvailable();
+                    
+                    // Block interactive commands that would break the shell
+                    if (IsBlockedCommand(command, out string blockReason))
+                    {
+                        AppendOutput($"> {command}", Color.Gray);
+                        AppendOutput($"[BLOCKED - Interactive command]\n{blockReason}", Color.Red);
+                        return $"BLOCKED: Interactive command not supported.\n{blockReason}";
+                    }
+                    
+                    // Block sudo commands if sudo not enabled - BEFORE sending
+                    if (command.TrimStart().StartsWith("sudo") && !_allowSudo)
+                    {
+                        AppendOutput($"> {command}", Color.White);
+                        AppendOutput("[SUDO BLOCKED - Command not sent. Enable sudo button to allow.]", Color.Red);
+                        return "SUDO_BLOCKED: Sudo commands are disabled. Click the Sudo button to enable.";
+                    }
+                    
+                    // Send command
+                    _shellStream.WriteLine(command);
+                    
+                    // Wait for output and prompt
+                    var output = WaitForPrompt(_nextCommandTimeoutMs);
+                    _nextCommandTimeoutMs = DEFAULT_TIMEOUT_MS; // Reset after use
+                    
+                    // Handle sudo password prompt (only runs if sudo IS enabled)
+                    if (command.TrimStart().StartsWith("sudo") && IsSudoPrompt(output))
+                    {
+                        AppendOutput("[sudo password auto-sent]", Color.FromArgb(180, 100, 255));
+                        _shellStream.WriteLine(_storedPassword);
+                        var sudoOutput = WaitForPrompt(30000);
+                        output += sudoOutput;
+                    }
+
+                    
+                    // Clean up output - remove the echoed command and prompt
+                    output = CleanOutput(output, command);
+                    
+                    if (string.IsNullOrEmpty(output))
+                    {
+                        output = "(no output)";
+                    }
+
+                    // Tail large output - keep last N lines
+                    var lines = output.Split('\n');
+                    string returnOutput;
+                    if (lines.Length > MAX_OUTPUT_LINES)
+                    {
+                        var tailLines = lines.Skip(lines.Length - MAX_OUTPUT_LINES).ToArray();
+                        returnOutput = $"[... {lines.Length - MAX_OUTPUT_LINES} lines truncated ...]\n" + string.Join("\n", tailLines);
+                    }
+                    else
+                    {
+                        returnOutput = output;
+                    }
+                    
+                    // Output already displayed in real-time by WaitForPrompt
+                    if (lines.Length > MAX_OUTPUT_LINES)
+                    {
+                        AppendOutput($"[Returned last {MAX_OUTPUT_LINES} of {lines.Length} lines to Claude]", Color.Gray);
+                    }
+                    
+                    // Final size check
+                    if (Encoding.UTF8.GetByteCount(returnOutput) > MAX_OUTPUT_BYTES)
+                    {
+                        returnOutput = TruncateToBytes(returnOutput, MAX_OUTPUT_BYTES);
+                        returnOutput += $"\n\n[OUTPUT TRUNCATED - exceeded 500KB limit]";
+                    }
+                    
+                    return returnOutput;
+                }
+                catch (Exception ex)
+                {
+                    var error = $"ERROR: {ex.Message}";
+                    AppendOutput(error, Color.Red);
+                    return error;
+                }
+                finally
+                {
+                    SetRunning(false);
+                }
+            }
+        }
+
+        private void SetRunning(bool running)
+        {
+            _isRunning = running;
+            if (this.InvokeRequired)
+            {
+                this.Invoke(() => SetRunning(running));
+                return;
+            }
+            
+            if (running)
+            {
+                _runningDots = 0;
+                _runningTimer.Start();
+            }
+            else
+            {
+                _runningTimer.Stop();
+                _statusLabel.Text = $"Connected to {_currentUser}@{_currentHost}";
+                _statusLabel.ForeColor = Color.White;
+            }
+        }
+
+        private static string TruncateToBytes(string text, int maxBytes)
+        {
+            if (string.IsNullOrEmpty(text)) return text;
+            var bytes = Encoding.UTF8.GetBytes(text);
+            if (bytes.Length <= maxBytes) return text;
+            
+            // Find a safe cut point (don't break UTF-8 sequences)
+            int cutPoint = maxBytes;
+            while (cutPoint > 0 && (bytes[cutPoint] & 0xC0) == 0x80)
+                cutPoint--;
+            
+            return Encoding.UTF8.GetString(bytes, 0, cutPoint);
+        }
+
+        private bool IsProcessRunning(int pid)
+        {
+            if (pid <= 0) return false;
             try
             {
-                _commandCount++;
-                this.Invoke(() => _statusLabel.Text = $"Connected to {_currentUser}@{_currentHost} ({_commandCount} commands)");
-                
-                AppendOutput($"> {command}", Color.Cyan);
-                
-                using var cmd = _sshClient.CreateCommand(command);
-                cmd.CommandTimeout = TimeSpan.FromSeconds(30);
-                var result = cmd.Execute();
-                var error = cmd.Error;
+                var proc = System.Diagnostics.Process.GetProcessById(pid);
+                return !proc.HasExited;
+            }
+            catch
+            {
+                return false;
+            }
+        }
 
-                var output = result.Trim();
-                if (!string.IsNullOrEmpty(error))
+        private void SendAbort()
+        {
+            if (_shellStream != null && _isConnected)
+            {
+                try
                 {
-                    output += "\n[stderr] " + error.Trim();
+                    _shellStream.Write("\x03"); // Ctrl+C
+                    Thread.Sleep(100);
+                    _shellStream.Write("\x03"); // Send twice for stubborn processes
+                    AppendOutput("[ABORT SIGNAL SENT - Ctrl+C]", Color.Orange);
                 }
+                catch { }
+            }
+        }
 
-                if (string.IsNullOrEmpty(output))
+        private string ReadAvailable()
+        {
+            if (_shellStream == null) return "";
+            
+            var sb = new StringBuilder();
+            while (_shellStream.DataAvailable)
+            {
+                var buffer = new byte[4096];
+                var read = _shellStream.Read(buffer, 0, buffer.Length);
+                if (read > 0)
                 {
-                    output = "(no output)";
+                    sb.Append(Encoding.UTF8.GetString(buffer, 0, read));
                 }
+            }
+            return sb.ToString();
+        }
 
-                AppendOutput(output);
+        private string WaitForPrompt(int timeoutMs)
+        {
+            if (_shellStream == null) return "";
+            
+            var sb = new StringBuilder();
+            var sw = System.Diagnostics.Stopwatch.StartNew();
+            var lastDataTime = sw.ElapsedMilliseconds;
+            
+            // Minimum wait time to ensure we get all output
+            const int minWaitMs = 300;
+            const int quietTimeMs = 150;
+            
+            while (sw.ElapsedMilliseconds < timeoutMs)
+            {
+                // Check for pen-lift interrupt - abort immediately
+                if (_penLifted)
+                {
+                    try { _shellStream.Write("\x03"); } catch { } // Send Ctrl+C
+                    Thread.Sleep(200);
+                    sb.Append(ReadAvailable()); // Grab remaining output
+                    sb.Append("\n[ABORTED BY USER - Pen lifted]");
+                    AppendOutput("[Command aborted - Pen lifted]", Color.Orange);
+                    return sb.ToString();
+                }
                 
-                return output;
+                if (_shellStream.DataAvailable)
+                {
+                    var buffer = new byte[4096];
+                    var read = _shellStream.Read(buffer, 0, buffer.Length);
+                    if (read > 0)
+                    {
+                        var chunk = Encoding.UTF8.GetString(buffer, 0, read);
+                        sb.Append(chunk);
+                        lastDataTime = sw.ElapsedMilliseconds;
+                        
+                        // Real-time display update
+                        var cleaned = StripAnsiCodes(chunk);
+                        if (!string.IsNullOrEmpty(cleaned))
+                        {
+                            AppendOutput(cleaned, Color.FromArgb(180, 180, 180));
+                        }
+                    }
+                }
+                else
+                {
+                    // Only check for prompt after minimum wait AND data stops flowing
+                    if (sw.ElapsedMilliseconds > minWaitMs && 
+                        sw.ElapsedMilliseconds - lastDataTime > quietTimeMs)
+                    {
+                        var current = sb.ToString();
+                        if (LooksLikePrompt(current))
+                        {
+                            break;
+                        }
+                    }
+                    Thread.Sleep(5); // Fast polling for responsive terminal
+                }
+            }
+            
+            return sb.ToString();
+        }
+
+        private bool LooksLikePrompt(string text)
+        {
+            if (string.IsNullOrEmpty(text)) return false;
+            
+            // Normalize line endings and get last non-empty line
+            var normalized = text.Replace("\r\n", "\n").Replace("\r", "\n");
+            var lines = normalized.Split('\n');
+            
+            // Find last non-empty line
+            string lastLine = "";
+            for (int i = lines.Length - 1; i >= 0; i--)
+            {
+                var trimmed = lines[i].Trim();
+                if (!string.IsNullOrEmpty(trimmed))
+                {
+                    lastLine = trimmed;
+                    break;
+                }
+            }
+            
+            if (string.IsNullOrEmpty(lastLine)) return false;
+            
+            // Known prompt pattern from connection (most reliable)
+            if (!string.IsNullOrEmpty(_promptPattern) && lastLine.Contains(_promptPattern)) return true;
+            
+            // Linux/Unix prompts: user@host patterns ending with $ or #
+            if ((lastLine.EndsWith("$") || lastLine.EndsWith("#")) && lastLine.Contains("@")) return true;
+            
+            // Windows cmd prompt: ends with > and contains drive letter or path
+            if (lastLine.EndsWith(">") && (lastLine.Contains(":\\") || lastLine.Contains(":/"))) return true;
+            
+            // PowerShell prompt
+            if (lastLine.EndsWith("PS>") || lastLine.EndsWith("PS >")) return true;
+            
+            return false;
+        }
+
+        private bool IsSudoPrompt(string text)
+        {
+            if (string.IsNullOrEmpty(text)) return false;
+            
+            // Only check the last line - prevents false matches on buffer history
+            var lines = text.Split('\n');
+            var lastLine = lines[lines.Length - 1].Trim().ToLowerInvariant();
+            
+            // Match password prompts
+            if (lastLine.EndsWith("password:")) return true;
+            if (lastLine.Contains("[sudo]") && lastLine.Contains("password")) return true;
+            if (Regex.IsMatch(lastLine, @"password for \w+:")) return true;
+            
+            return false;
+        }
+
+        private bool IsBlockedCommand(string command, out string reason)
+        {
+            var trimmed = command.Trim();
+            var parts = trimmed.Split(' ', StringSplitOptions.RemoveEmptyEntries);
+            var firstWord = parts.FirstOrDefault()?.ToLowerInvariant() ?? "";
+            var fullLower = trimmed.ToLowerInvariant();
+            
+            reason = "";
+            
+            switch (firstWord)
+            {
+                // Editors - always blocked (no non-interactive mode)
+                case "nano":
+                case "vim":
+                case "vi":
+                case "nvim":
+                case "emacs":
+                case "pico":
+                case "joe":
+                case "mcedit":
+                    reason = "Interactive editors not supported. Use:\n" +
+                             "• echo \"content\" > file.txt (create/overwrite)\n" +
+                             "• echo \"more\" >> file.txt (append)\n" +
+                             "• cat << 'EOF' > file.txt (multi-line)\n" +
+                             "• sed -i 's/old/new/g' file.txt (find/replace)";
+                    return true;
+                    
+                // Pagers - always blocked
+                case "less":
+                case "more":
+                    reason = "Use 'cat', 'head -n 100', or 'tail -n 100' instead.";
+                    return true;
+                    
+                // TUI monitors - allow batch mode
+                case "top":
+                    if (!fullLower.Contains("-b"))
+                    {
+                        reason = "Use 'top -b -n 1' for batch mode, or 'ps aux' instead.";
+                        return true;
+                    }
+                    break;
+                case "htop":
+                case "btop":
+                case "atop":
+                case "nmon":
+                case "glances":
+                    reason = "Use 'ps aux', 'free -h', 'df -h', or 'top -b -n 1' instead.";
+                    return true;
+                    
+                // Databases - allow with query flags
+                case "mysql":
+                    if (!fullLower.Contains("-e"))
+                    {
+                        reason = "Use 'mysql -e \"SELECT...\"' for non-interactive query.";
+                        return true;
+                    }
+                    break;
+                case "psql":
+                    if (!fullLower.Contains("-c"))
+                    {
+                        reason = "Use 'psql -c \"SELECT...\"' for non-interactive query.";
+                        return true;
+                    }
+                    break;
+                case "mongo":
+                case "mongosh":
+                    if (!fullLower.Contains("--eval"))
+                    {
+                        reason = "Use 'mongosh --eval \"db.collection.find()\"' for non-interactive.";
+                        return true;
+                    }
+                    break;
+                case "redis-cli":
+                    if (parts.Length == 1)
+                    {
+                        reason = "Add command: 'redis-cli GET key' or 'redis-cli INFO'.";
+                        return true;
+                    }
+                    break;
+                case "sqlite3":
+                    if (!fullLower.Contains("-cmd") && !trimmed.Contains("\""))
+                    {
+                        reason = "Use 'sqlite3 db.sqlite \"SELECT...\"' for non-interactive.";
+                        return true;
+                    }
+                    break;
+                    
+                // Terminal multiplexers - always blocked
+                case "tmux":
+                case "screen":
+                case "byobu":
+                    reason = "Terminal multiplexers not supported in this shell.";
+                    return true;
+                    
+                // File managers - always blocked
+                case "mc":
+                case "ranger":
+                case "nnn":
+                    reason = "Use 'ls -la', 'find', or 'tree' instead.";
+                    return true;
+                    
+                // Nested shells - block unless -c flag
+                case "bash":
+                case "zsh":
+                case "fish":
+                case "sh":
+                case "csh":
+                case "tcsh":
+                    if (!fullLower.Contains("-c"))
+                    {
+                        reason = "Nested shells not supported. Use 'bash -c \"command\"' for one-offs.";
+                        return true;
+                    }
+                    break;
+                    
+                // SSH/remote - always blocked
+                case "ssh":
+                case "telnet":
+                    reason = "Nested SSH not supported. Disconnect and connect to the other server.";
+                    return true;
+                    
+                // Man pages - always blocked
+                case "man":
+                case "info":
+                    reason = "Use 'command --help' or search online.";
+                    return true;
+                    
+                // FTP - always blocked
+                case "ftp":
+                case "sftp":
+                    reason = "Interactive FTP not supported. Use 'scp' or 'curl' instead.";
+                    return true;
             }
-            catch (Exception ex)
+            
+            return false;
+        }
+
+        private string DetectPrompt(string initialOutput, string user)
+        {
+            if (string.IsNullOrEmpty(initialOutput)) return ">";
+            
+            var lines = initialOutput.Split('\n');
+            var lastLine = lines[^1].Trim();
+            
+            // Return the last line as the prompt pattern
+            if (lastLine.EndsWith(">") || lastLine.EndsWith("$") || lastLine.EndsWith("#"))
             {
-                var error = $"ERROR: {ex.Message}";
-                AppendOutput(error, Color.Red);
-                return error;
+                return lastLine;
             }
+            
+            return ">";
+        }
+
+        private string CleanOutput(string output, string command)
+        {
+            if (string.IsNullOrEmpty(output)) return "";
+            
+            // Strip ANSI escape codes and normalize line endings
+            var cleaned = StripAnsiCodes(output);
+            // Convert all line endings to \n only
+            cleaned = cleaned.Replace("\r\n", "\n").Replace("\r", "\n");
+            return cleaned.Trim();
+        }
+
+        private static string StripAnsiCodes(string text)
+        {
+            if (string.IsNullOrEmpty(text)) return text;
+            
+            // Remove ANSI escape sequences:
+            // CSI sequences: ESC [ ... final_byte
+            // OSC sequences: ESC ] ... BEL or ESC \
+            // Simple escapes: ESC followed by single char
+            
+            var result = text;
+            
+            // CSI sequences (ESC [ or 0x9B followed by parameters and final byte)
+            result = Regex.Replace(result, @"\x1B\[[0-9;?]*[A-Za-z]", "");
+            result = Regex.Replace(result, @"\x1B\[[0-9;?]*[ -/]*[@-~]", "");
+            
+            // OSC sequences (ESC ] ... BEL or ST)
+            result = Regex.Replace(result, @"\x1B\][^\x07\x1B]*(\x07|\x1B\\)?", "");
+            
+            // Other escape sequences
+            result = Regex.Replace(result, @"\x1B[()][AB012]", "");  // Character set selection
+            result = Regex.Replace(result, @"\x1B[@-_]", "");        // C1 control codes
+            
+            // Clean up any remaining escape chars and control chars (except newline, tab, CR)
+            result = Regex.Replace(result, @"[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]", "");
+            
+            return result;
         }
 
         private void StartTcpServer()
@@ -353,6 +991,193 @@ namespace SshBridge
                         {
                             response = _isConnected ? $"CONNECTED:{_currentUser}@{_currentHost}" : "DISCONNECTED";
                         }
+                        else if (command == "__PEN_STATUS__")
+                        {
+                            response = _penLifted ? "PEN_LIFTED" : "PEN_DOWN";
+                        }
+                        else if (command == "__PEN_DOWN__")
+                        {
+                            if (_penLifted)
+                            {
+                                this.Invoke(() => TogglePen());
+                                response = "PEN_LOWERED";
+                            }
+                            else
+                            {
+                                response = "PEN_ALREADY_DOWN";
+                            }
+                        }
+                        else if (command == "__ABORT__")
+                        {
+                            SendAbort();
+                            response = _isRunning ? "ABORT_SENT" : "NO_COMMAND_RUNNING";
+                        }
+                        else if (command == "__IS_RUNNING__")
+                        {
+                            response = _isRunning ? "RUNNING" : "IDLE";
+                        }
+                        else if (command.StartsWith("__TIMEOUT__:"))
+                        {
+                            var secStr = command.Substring(12);
+                            if (int.TryParse(secStr, out int seconds) && seconds > 0 && seconds <= 3600)
+                            {
+                                _nextCommandTimeoutMs = seconds * 1000;
+                                response = $"TIMEOUT_SET:{seconds}s";
+                                AppendOutput($"[Timeout set to {seconds}s for next command]", Color.Cyan);
+                            }
+                            else
+                            {
+                                response = "ERROR: Invalid timeout (1-3600 seconds)";
+                            }
+                        }
+                        else if (command.StartsWith("__KILL_PORT__:"))
+                        {
+                            var portStr = command.Substring(14);
+                            if (int.TryParse(portStr, out int portNum) && portNum > 0 && portNum <= 65535)
+                            {
+                                // Execute netstat to find PID, then taskkill
+                                var killCmd = $"for /f \"tokens=5\" %a in ('netstat -ano ^| findstr :{portNum} ^| findstr LISTENING') do @taskkill /PID %a /F 2>nul & echo Killed PID %a";
+                                response = ExecuteCommand(killCmd);
+                            }
+                            else
+                            {
+                                response = "ERROR: Invalid port number";
+                            }
+                        }
+                        else if (command.StartsWith("__WRITE_FILE__:"))
+                        {
+                            // Format: __WRITE_FILE__:C:\path\file.txt|content
+                            // Uses | as delimiter since it's not valid in Windows paths
+                            // Use <<LF>> for newlines, <<CR>> for carriage returns
+                            var rest = command.Substring(15);
+                            var pipeIdx = rest.IndexOf('|');
+                            if (pipeIdx > 0)
+                            {
+                                var path = rest.Substring(0, pipeIdx);
+                                var content = rest.Substring(pipeIdx + 1)
+                                    .Replace("<<CRLF>>", "\r\n")
+                                    .Replace("<<LF>>", "\r\n")   // Convert to Windows line endings
+                                    .Replace("<<CR>>", "\r");
+                                try
+                                {
+                                    // Base64 encode to avoid ALL escaping issues
+                                    var base64 = Convert.ToBase64String(Encoding.UTF8.GetBytes(content));
+                                    var psCmd = $"[System.IO.File]::WriteAllText('{path}', [System.Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('{base64}')))";
+                                    ExecuteCommand($"powershell -Command \"{psCmd}\"");
+                                    response = $"WRITTEN:{path} ({content.Length} chars)";
+                                    AppendOutput($"[Wrote {content.Length} chars to {path}]", Color.Green);
+                                }
+                                catch (Exception ex)
+                                {
+                                    response = $"ERROR: {ex.Message}";
+                                }
+                            }
+                            else
+                            {
+                                response = "ERROR: Use __WRITE_FILE__:path|content (use <<LF>> for newlines)";
+                            }
+                        }
+                        else if (command.StartsWith("__APPEND_FILE__:"))
+                        {
+                            // Format: __APPEND_FILE__:C:\path\file.txt|content
+                            var rest = command.Substring(16);
+                            var pipeIdx = rest.IndexOf('|');
+                            if (pipeIdx > 0)
+                            {
+                                var path = rest.Substring(0, pipeIdx);
+                                var content = rest.Substring(pipeIdx + 1)
+                                    .Replace("<<CRLF>>", "\r\n")
+                                    .Replace("<<LF>>", "\r\n")
+                                    .Replace("<<CR>>", "\r");
+                                try
+                                {
+                                    // Base64 encode to avoid ALL escaping issues
+                                    var base64 = Convert.ToBase64String(Encoding.UTF8.GetBytes(content));
+                                    var psCmd = $"[System.IO.File]::AppendAllText('{path}', [System.Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('{base64}')))";
+                                    ExecuteCommand($"powershell -Command \"{psCmd}\"");
+                                    response = $"APPENDED:{path} ({content.Length} chars)";
+                                    AppendOutput($"[Appended {content.Length} chars to {path}]", Color.Green);
+                                }
+                                catch (Exception ex)
+                                {
+                                    response = $"ERROR: {ex.Message}";
+                                }
+                            }
+                            else
+                            {
+                                response = "ERROR: Use __APPEND_FILE__:path|content (use <<LF>> for newlines)";
+                            }
+                        }
+                        else if (command.StartsWith("__SPAWN__:"))
+                        {
+                            // Format: __SPAWN__:name:command
+                            var rest = command.Substring(10);
+                            var colonIdx = rest.IndexOf(':');
+                            if (colonIdx > 0)
+                            {
+                                var name = rest.Substring(0, colonIdx);
+                                var spawnCmd = rest.Substring(colonIdx + 1);
+                                // Run in background, capture PID via PowerShell
+                                var psCmd = $"$p = Start-Process -FilePath cmd -ArgumentList '/c {spawnCmd.Replace("'", "''")}' -PassThru -WindowStyle Hidden; $p.Id";
+                                var pidResult = ExecuteCommand($"powershell -Command \"{psCmd}\"");
+                                if (int.TryParse(pidResult.Trim().Split('\n').Last().Trim(), out int pid))
+                                {
+                                    _spawnedProcesses[name] = pid;
+                                    response = $"SPAWNED:{name}:PID={pid}";
+                                }
+                                else
+                                {
+                                    response = $"SPAWN_STARTED:{name} (PID unknown)";
+                                }
+                            }
+                            else
+                            {
+                                response = "ERROR: Use __SPAWN__:name:command";
+                            }
+                        }
+                        else if (command == "__LIST_SPAWNED__")
+                        {
+                            if (_spawnedProcesses.Count == 0)
+                            {
+                                response = "NO_SPAWNED_PROCESSES";
+                            }
+                            else
+                            {
+                                var sb = new StringBuilder();
+                                foreach (var kvp in _spawnedProcesses)
+                                {
+                                    // Check if still running
+                                    var checkCmd = $"tasklist /FI \"PID eq {kvp.Value}\" /NH 2>nul | findstr {kvp.Value}";
+                                    var checkResult = ExecuteCommand(checkCmd);
+                                    var status = checkResult.Contains(kvp.Value.ToString()) ? "RUNNING" : "STOPPED";
+                                    sb.AppendLine($"{kvp.Key}: PID={kvp.Value} ({status})");
+                                }
+                                response = sb.ToString().TrimEnd();
+                            }
+                        }
+                        else if (command == "__TAIL__")
+                        {
+                            // Get last 50 lines from the output textbox
+                            string text = "";
+                            this.Invoke(() => text = _outputBox.Text);
+                            var lines = text.Split('\n');
+                            var tail = lines.Skip(Math.Max(0, lines.Length - 50)).ToArray();
+                            response = string.Join("\n", tail);
+                        }
+                        else if (command.StartsWith("__KILL_SPAWNED__:"))
+                        {
+                            var name = command.Substring(17);
+                            if (_spawnedProcesses.TryGetValue(name, out int pid))
+                            {
+                                ExecuteCommand($"taskkill /PID {pid} /F /T 2>nul");
+                                _spawnedProcesses.Remove(name);
+                                response = $"KILLED:{name}:PID={pid}";
+                            }
+                            else
+                            {
+                                response = $"ERROR: No spawned process named '{name}'";
+                            }
+                        }
                         else if (command.StartsWith("__PREFILL__:"))
                         {
                             // Format: __PREFILL__:host:port:user:password
@@ -386,12 +1211,19 @@ namespace SshBridge
                             this.Invoke(() => Connect());
                             response = "CONNECTING";
                         }
+                        else if (_penLifted)
+                        {
+                            // Block command execution when pen is lifted
+                            AppendOutput($"> {command}", Color.Gray);
+                            AppendOutput("[BLOCKED - Pen lifted by user]", Color.Orange);
+                            response = "PEN_LIFTED: User has paused command execution. Use SshPenDown to resume, or wait for user to click 'Lift Pen' button again.";
+                        }
                         else
                         {
                             response = ExecuteCommand(command);
                         }
                         // Encode newlines so they survive the single-line protocol
-                        response = response.Replace("\r\n", "<<CRLF>>").Replace("\n", "<<LF>>");
+                        response = response.Replace("\r\n", "<<CRLF>>").Replace("\n", "<<LF>>").Replace("\r", "<<CR>>");
                         writer.WriteLine(response);
                     }
                 }