Upload 5 files

README.md

@@ -1,3 +1,130 @@
----
-license: mit
----
+# Shell MCP Server
+
+Terminal access for Claude with two security modes, plus SSH bridge for remote servers.
+
+## Features
+
+- **Local shell** with safe/dangerous command separation
+- **SSH Bridge** - GUI app for secure remote server access
+- **Full visibility** - see every command Claude runs
+- **Instant disconnect** - revoke access anytime
+
+## Components
+
+### 1. Shell MCP (`shell-mcp.dll`)
+Local Windows terminal access with configurable command allowlists.
+
+### 2. SSH Bridge (`ssh-bridge.exe`)
+WinForms app that:
+- You authenticate with password (never stored on disk)
+- Claude sends commands through it
+- You see all commands and output in real-time
+- Click Disconnect to revoke access instantly
+
+## Installation
+
+### Prerequisites
+- .NET 8.0 SDK
+- Windows 10/11
+
+### Build
+
+```bash
+git clone https://github.com/FreeOnlineUser/shell-mcp.git
+cd shell-mcp
+dotnet restore
+dotnet build ShellMcp.csproj
+dotnet build SshBridge.csproj
+```
+
+### Configure Claude Desktop
+
+Edit `%APPDATA%\Claude\claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "shell_safe": {
+      "command": "dotnet",
+      "args": ["C:\\path\\to\\shell-mcp.dll"],
+      "env": {
+        "SHELL_MCP_MODE": "safe",
+        "SHELL_MCP_START_DIR": "C:\\your\\workspace"
+      }
+    },
+    "shell_dangerous": {
+      "command": "dotnet",
+      "args": ["C:\\path\\to\\shell-mcp.dll"],
+      "env": {
+        "SHELL_MCP_MODE": "dangerous",
+        "SHELL_MCP_START_DIR": "C:\\your\\workspace"
+      }
+    }
+  }
+}
+```
+
+**Approval settings:**
+- `shell_safe` → "Allow always"
+- `shell_dangerous` → "Allow once" (asks every time)
+
+## Tools
+
+### Local Shell
+| Tool | Description |
+|------|-------------|
+| `Shell` | Execute a local command |
+| `Pwd` | Get current working directory |
+| `ShellInfo` | Show mode and allowed commands |
+| `ShellBatch` | Run multiple commands in sequence |
+
+### SSH (requires SSH Bridge running)
+| Tool | Description |
+|------|-------------|
+| `SshCommand` | Execute command on remote server |
+| `SshStatus` | Check if SSH Bridge is connected |
+
+## SSH Bridge Usage
+
+1. Run `ssh-bridge.exe`
+2. Enter host, username, and password
+3. Click **Connect**
+4. Window shows all commands Claude runs and their output
+5. Click **Disconnect** anytime to revoke access
+
+Password is held in memory only while connected - never written to disk.
+
+## Security Model
+
+### shell_safe (approve once)
+Read-only and build commands:
+- `dir`, `ls`, `type`, `cat`, `pwd`, `cd`
+- `git status`, `git log`, `git diff`, `git branch`
+- `dotnet build`, `dotnet run`, `dotnet test`
+- `npm install`, `npm run`, `npm test`
+
+### shell_dangerous (approve each time)
+Modifying commands:
+- `del`, `rm`, `rmdir`, `move`, `copy`, `mkdir`
+- `git push`, `git commit`, `git reset`
+- `taskkill`
+
+### Always blocked
+- `format`, `diskpart`, `regedit`
+- `net user`, `net localgroup`
+- `rm -rf /`, `del /s /q c:\`
+
+### SSH Bridge
+- You authenticate manually each session
+- You see every command in real-time
+- Disconnect button = instant revoke
+- No password persistence
+
+## Dependencies
+
+- [ModelContextProtocol](https://www.nuget.org/packages/ModelContextProtocol) - MCP SDK for .NET
+- [SSH.NET](https://www.nuget.org/packages/SSH.NET) - SSH client library
+
+## License
+
+MIT

ShellMcp.cs

@@ -0,0 +1,604 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.IO;
+using System.IO.Pipes;
+using System.Linq;
+using System.Text;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using ModelContextProtocol.Server;
+
+namespace ShellMcp
+{
+    public class Program
+    {
+        public static async Task Main(string[] args)
+        {
+            var mode = Environment.GetEnvironmentVariable("SHELL_MCP_MODE") ?? "safe";
+            ShellExecutor.Initialize(mode);
+
+            var builder = Host.CreateApplicationBuilder(args);
+            
+            builder.Logging.ClearProviders();
+            builder.Logging.AddConsole(options =>
+            {
+                options.LogToStandardErrorThreshold = LogLevel.Trace;
+            });
+            
+            builder.Services
+                .AddMcpServer()
+                .WithStdioServerTransport()
+                .WithToolsFromAssembly();
+            
+            await builder.Build().RunAsync();
+        }
+    }
+
+    // ===============================================
+    // SHELL EXECUTOR
+    // ===============================================
+
+    public static class ShellExecutor
+    {
+        private static string _currentDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
+        private static string _mode = "safe";
+        private static int _defaultTimeout = 30;
+
+        private static readonly HashSet<string> SafeCommands = new(StringComparer.OrdinalIgnoreCase)
+        {
+            "dir", "ls", "pwd", "cd", "tree",
+            "type", "cat", "head", "tail", "more", "less", "find", "findstr", "grep", "where", "which",
+            "echo", "date", "time", "whoami", "hostname", "ver",
+            "git status", "git log", "git diff", "git branch", "git remote", "git fetch", "git show", "git ls-files", "git stash list",
+            "dotnet build", "dotnet run", "dotnet test", "dotnet restore", "dotnet clean", "dotnet --version", "dotnet --list-sdks",
+            "npm install", "npm run", "npm test", "npm list", "npm --version", "npm ci", "npm audit",
+            "node --version", "yarn --version", "yarn install", "yarn build", "yarn test",
+            "cls", "clear", "help", "man",
+        };
+
+        private static readonly HashSet<string> DangerousCommands = new(StringComparer.OrdinalIgnoreCase)
+        {
+            "del", "rm", "rmdir", "rd", "erase",
+            "move", "mv", "rename", "ren",
+            "copy", "cp", "xcopy", "robocopy",
+            "mkdir", "md",
+            "git push", "git pull", "git merge", "git rebase", "git reset", "git clean", "git checkout", "git commit", "git add", "git rm", "git stash",
+            "taskkill", "kill", "shutdown", "restart",
+            "npm install -g", "npm uninstall", "dotnet tool install",
+        };
+
+        private static readonly HashSet<string> BlockedCommands = new(StringComparer.OrdinalIgnoreCase)
+        {
+            "format", "diskpart", "reg", "regedit", "net user", "net localgroup",
+            "powershell -enc", "cmd /c", "rm -rf /", "del /s /q c:\\",
+        };
+
+        public static void Initialize(string mode)
+        {
+            _mode = mode.ToLowerInvariant();
+            var startDir = Environment.GetEnvironmentVariable("SHELL_MCP_START_DIR");
+            if (!string.IsNullOrEmpty(startDir) && Directory.Exists(startDir))
+                _currentDirectory = startDir;
+
+            // Set SSH Bridge path from environment
+            var bridgePath = Environment.GetEnvironmentVariable("SSH_BRIDGE_PATH");
+            if (!string.IsNullOrEmpty(bridgePath))
+                SshBridgeClient.SetBridgePath(bridgePath);
+        }
+
+        public static string Mode => _mode;
+        public static string CurrentDirectory => _currentDirectory;
+
+        public static bool IsCommandAllowed(string command, out string reason)
+        {
+            reason = "";
+            string cmdLower = command.ToLowerInvariant().Trim();
+            string firstWord = cmdLower.Split(' ', StringSplitOptions.RemoveEmptyEntries).FirstOrDefault() ?? "";
+
+            foreach (var blocked in BlockedCommands)
+            {
+                if (cmdLower.Contains(blocked.ToLowerInvariant()))
+                {
+                    reason = $"Command '{blocked}' is blocked for safety";
+                    return false;
+                }
+            }
+
+            if (_mode == "safe")
+            {
+                bool isSafe = SafeCommands.Any(safe => 
+                    cmdLower.StartsWith(safe.ToLowerInvariant()) ||
+                    firstWord == safe.ToLowerInvariant().Split(' ')[0]);
+
+                if (!isSafe)
+                {
+                    reason = $"Command '{firstWord}' is not in the safe list. Use shell_dangerous for this operation.";
+                    return false;
+                }
+            }
+            else if (_mode == "dangerous")
+            {
+                bool isAllowed = SafeCommands.Any(safe => 
+                    cmdLower.StartsWith(safe.ToLowerInvariant()) ||
+                    firstWord == safe.ToLowerInvariant().Split(' ')[0]) ||
+                    DangerousCommands.Any(dangerous => 
+                    cmdLower.StartsWith(dangerous.ToLowerInvariant()) ||
+                    firstWord == dangerous.ToLowerInvariant().Split(' ')[0]);
+
+                if (!isAllowed)
+                {
+                    reason = $"Command '{firstWord}' is not recognized.";
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        public static CommandResult Execute(string command, int? timeoutSeconds = null)
+        {
+            var result = new CommandResult { Command = command };
+            int timeout = timeoutSeconds ?? _defaultTimeout;
+
+            try
+            {
+                if (command.Trim().StartsWith("cd ", StringComparison.OrdinalIgnoreCase) ||
+                    command.Trim().Equals("cd", StringComparison.OrdinalIgnoreCase))
+                {
+                    return HandleCd(command);
+                }
+
+                if (!IsCommandAllowed(command, out string reason))
+                {
+                    result.Success = false;
+                    result.Stderr = reason;
+                    result.ExitCode = -1;
+                    return result;
+                }
+
+                var psi = new ProcessStartInfo
+                {
+                    FileName = "cmd.exe",
+                    Arguments = $"/c {command}",
+                    WorkingDirectory = _currentDirectory,
+                    UseShellExecute = false,
+                    RedirectStandardOutput = true,
+                    RedirectStandardError = true,
+                    CreateNoWindow = true,
+                    StandardOutputEncoding = Encoding.UTF8,
+                    StandardErrorEncoding = Encoding.UTF8,
+                };
+
+                using var process = new Process { StartInfo = psi };
+                var stdout = new StringBuilder();
+                var stderr = new StringBuilder();
+
+                process.OutputDataReceived += (s, e) => { if (e.Data != null) stdout.AppendLine(e.Data); };
+                process.ErrorDataReceived += (s, e) => { if (e.Data != null) stderr.AppendLine(e.Data); };
+
+                var sw = Stopwatch.StartNew();
+                process.Start();
+                process.BeginOutputReadLine();
+                process.BeginErrorReadLine();
+
+                bool completed = process.WaitForExit(timeout * 1000);
+                sw.Stop();
+
+                if (!completed)
+                {
+                    try { process.Kill(entireProcessTree: true); } catch { }
+                    result.Success = false;
+                    result.Stderr = $"Command timed out after {timeout} seconds";
+                    result.ExitCode = -1;
+                    result.TimedOut = true;
+                }
+                else
+                {
+                    result.Success = process.ExitCode == 0;
+                    result.ExitCode = process.ExitCode;
+                    result.Stdout = stdout.ToString().TrimEnd();
+                    result.Stderr = stderr.ToString().TrimEnd();
+                }
+
+                result.ExecutionTimeMs = sw.ElapsedMilliseconds;
+                result.WorkingDirectory = _currentDirectory;
+            }
+            catch (Exception ex)
+            {
+                result.Success = false;
+                result.Stderr = $"Execution error: {ex.Message}";
+                result.ExitCode = -1;
+            }
+
+            return result;
+        }
+
+        private static CommandResult HandleCd(string command)
+        {
+            var result = new CommandResult { Command = command };
+            var parts = command.Trim().Split(' ', 2, StringSplitOptions.RemoveEmptyEntries);
+            
+            if (parts.Length == 1)
+            {
+                result.Success = true;
+                result.Stdout = _currentDirectory;
+                result.WorkingDirectory = _currentDirectory;
+                return result;
+            }
+
+            string targetPath = parts[1].Trim().Trim('"');
+            string newPath;
+
+            if (Path.IsPathRooted(targetPath))
+                newPath = targetPath;
+            else if (targetPath == "..")
+                newPath = Path.GetDirectoryName(_currentDirectory) ?? _currentDirectory;
+            else if (targetPath == "~")
+                newPath = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
+            else
+                newPath = Path.Combine(_currentDirectory, targetPath);
+
+            newPath = Path.GetFullPath(newPath);
+
+            if (Directory.Exists(newPath))
+            {
+                _currentDirectory = newPath;
+                result.Success = true;
+                result.Stdout = _currentDirectory;
+                result.WorkingDirectory = _currentDirectory;
+            }
+            else
+            {
+                result.Success = false;
+                result.Stderr = $"Directory not found: {newPath}";
+                result.ExitCode = 1;
+                result.WorkingDirectory = _currentDirectory;
+            }
+
+            return result;
+        }
+
+        public static string GetAllowedCommands()
+        {
+            var sb = new StringBuilder();
+            sb.AppendLine($"Mode: {_mode}");
+            sb.AppendLine();
+            sb.AppendLine("Safe commands (always allowed):");
+            foreach (var cmd in SafeCommands.OrderBy(c => c))
+                sb.AppendLine($"  - {cmd}");
+
+            if (_mode == "dangerous")
+            {
+                sb.AppendLine();
+                sb.AppendLine("Dangerous commands (available in this mode):");
+                foreach (var cmd in DangerousCommands.OrderBy(c => c))
+                    sb.AppendLine($"  - {cmd}");
+            }
+
+            sb.AppendLine();
+            sb.AppendLine("Blocked commands (never allowed):");
+            foreach (var cmd in BlockedCommands.OrderBy(c => c))
+                sb.AppendLine($"  - {cmd}");
+
+            return sb.ToString();
+        }
+    }
+
+    public class CommandResult
+    {
+        public string Command { get; set; } = "";
+        public bool Success { get; set; }
+        public string Stdout { get; set; } = "";
+        public string Stderr { get; set; } = "";
+        public int ExitCode { get; set; }
+        public long ExecutionTimeMs { get; set; }
+        public string WorkingDirectory { get; set; } = "";
+        public bool TimedOut { get; set; }
+
+        public override string ToString()
+        {
+            var sb = new StringBuilder();
+            if (!string.IsNullOrEmpty(Stdout))
+                sb.AppendLine(Stdout);
+            if (!string.IsNullOrEmpty(Stderr))
+            {
+                if (sb.Length > 0) sb.AppendLine();
+                sb.AppendLine($"[stderr] {Stderr}");
+            }
+            sb.AppendLine();
+            sb.AppendLine($"[exit: {ExitCode}] [time: {ExecutionTimeMs}ms] [cwd: {WorkingDirectory}]");
+            if (TimedOut)
+                sb.AppendLine("[TIMED OUT]");
+            return sb.ToString();
+        }
+    }
+
+    // ===============================================
+    // SSH BRIDGE CLIENT
+    // ===============================================
+
+    public static class SshBridgeClient
+    {
+        private const int PORT = 52718;
+
+        private static string? _bridgePath;
+
+        public static void SetBridgePath(string path)
+        {
+            _bridgePath = path;
+        }
+
+        public static string GetStatus()
+        {
+            try
+            {
+                return SendCommand("__STATUS__");
+            }
+            catch
+            {
+                return "DISCONNECTED";
+            }
+        }
+
+        public static bool LaunchBridge()
+        {
+            if (string.IsNullOrEmpty(_bridgePath) || !System.IO.File.Exists(_bridgePath))
+                return false;
+
+            try
+            {
+                System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo
+                {
+                    FileName = _bridgePath,
+                    UseShellExecute = true
+                });
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        public static bool IsBridgeRunning()
+        {
+            try
+            {
+                using var client = new System.Net.Sockets.TcpClient();
+                client.Connect("127.0.0.1", PORT);
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        public static string SendCommand(string command)
+        {
+            using var client = new System.Net.Sockets.TcpClient();
+            client.Connect("127.0.0.1", PORT);
+
+            using var stream = client.GetStream();
+            using var writer = new StreamWriter(stream, Encoding.UTF8) { AutoFlush = true };
+            using var reader = new StreamReader(stream, Encoding.UTF8);
+
+            writer.WriteLine(command);
+            var response = reader.ReadLine() ?? "No response";
+            // Decode newlines
+            return response.Replace("<<CRLF>>", "\r\n").Replace("<<LF>>", "\n");
+        }
+
+        public static string Prefill(string host, int port, string user, string? password = null)
+        {
+            var cmd = $"__PREFILL__:{host}:{port}:{user}";
+            if (!string.IsNullOrEmpty(password))
+                cmd += $":{password}";
+            return SendCommand(cmd);
+        }
+
+        public static string TriggerConnect()
+        {
+            return SendCommand("__CONNECT__");
+        }
+    }
+
+    // ===============================================
+    // MCP TOOLS
+    // ===============================================
+
+    [McpServerToolType]
+    public static class ShellTools
+    {
+        [McpServerTool, Description("Execute a shell command. Working directory persists across calls. Use 'cd' to navigate. Check 'shell_info' for allowed commands.")]
+        public static string Shell(
+            [Description("Command to execute")] string command,
+            [Description("Timeout in seconds (default: 30)")] int? timeout = null)
+        {
+            if (string.IsNullOrWhiteSpace(command))
+                return "Error: No command provided";
+
+            var result = ShellExecutor.Execute(command, timeout);
+            return result.Success ? result.ToString() : $"❌ Command failed:\n{result}";
+        }
+
+        [McpServerTool, Description("Get current working directory")]
+        public static string Pwd()
+        {
+            return ShellExecutor.CurrentDirectory;
+        }
+
+        [McpServerTool, Description("Show shell mode and list of allowed commands")]
+        public static string ShellInfo()
+        {
+            var sb = new StringBuilder();
+            sb.AppendLine($"Shell MCP - {ShellExecutor.Mode.ToUpperInvariant()} mode");
+            sb.AppendLine($"Current directory: {ShellExecutor.CurrentDirectory}");
+            sb.AppendLine();
+            sb.AppendLine(ShellExecutor.GetAllowedCommands());
+            return sb.ToString();
+        }
+
+        [McpServerTool, Description("Execute multiple commands in sequence. Stops on first failure unless continue_on_error is true.")]
+        public static string ShellBatch(
+            [Description("JSON array of commands: [\"cmd1\", \"cmd2\", ...]")] string commands_json,
+            [Description("Continue executing even if a command fails")] bool continue_on_error = false,
+            [Description("Timeout per command in seconds")] int? timeout = null)
+        {
+            try
+            {
+                var commands = JsonSerializer.Deserialize<List<string>>(commands_json);
+                if (commands == null || commands.Count == 0)
+                    return "Error: No commands provided";
+
+                var sb = new StringBuilder();
+                int succeeded = 0, failed = 0;
+
+                foreach (var cmd in commands)
+                {
+                    sb.AppendLine($"$ {cmd}");
+                    var result = ShellExecutor.Execute(cmd, timeout);
+                    sb.AppendLine(result.ToString());
+
+                    if (result.Success)
+                        succeeded++;
+                    else
+                    {
+                        failed++;
+                        if (!continue_on_error)
+                        {
+                            sb.AppendLine($"❌ Batch stopped. {succeeded} succeeded, {failed} failed, {commands.Count - succeeded - failed} skipped.");
+                            return sb.ToString();
+                        }
+                    }
+                }
+
+                sb.AppendLine($"✅ Batch complete: {succeeded} succeeded, {failed} failed");
+                return sb.ToString();
+            }
+            catch (Exception ex)
+            {
+                return $"Error parsing commands: {ex.Message}";
+            }
+        }
+
+        [McpServerTool, Description("Execute a command on a remote server via SSH Bridge. Requires SSH Bridge app to be running and connected.")]
+        public static string SshCommand(
+            [Description("Command to execute on the remote server")] string command)
+        {
+            if (string.IsNullOrWhiteSpace(command))
+                return "Error: No command provided";
+
+            try
+            {
+                // Check if bridge is running, launch if not
+                if (!SshBridgeClient.IsBridgeRunning())
+                {
+                    if (SshBridgeClient.LaunchBridge())
+                    {
+                        return "🚀 SSH Bridge launched!\n\nPlease:\n1. Enter host, user, and password in the window that just opened\n2. Click Connect\n3. Try this command again";
+                    }
+                    else
+                    {
+                        return "❌ SSH Bridge not running and could not auto-launch.\n\nPlease run ssh-bridge.exe manually, or set SSH_BRIDGE_PATH in your Claude config.";
+                    }
+                }
+
+                var status = SshBridgeClient.GetStatus();
+                if (status == "DISCONNECTED")
+                {
+                    return "⚠️ SSH Bridge is open but not connected.\n\nPlease:\n1. Enter host, user, and password\n2. Click Connect\n3. Try this command again";
+                }
+
+                var result = SshBridgeClient.SendCommand(command);
+                return $"📡 {status}\n\n{result}";
+            }
+            catch (Exception ex)
+            {
+                return $"❌ SSH error: {ex.Message}";
+            }
+        }
+
+        [McpServerTool, Description("Check if SSH Bridge is connected")]
+        public static string SshStatus()
+        {
+            try
+            {
+                if (!SshBridgeClient.IsBridgeRunning())
+                {
+                    return "❌ SSH Bridge not running";
+                }
+
+                var status = SshBridgeClient.GetStatus();
+                if (status.StartsWith("CONNECTED:"))
+                {
+                    return $"✅ {status.Replace("CONNECTED:", "Connected to ")}";
+                }
+                return "⚠️ SSH Bridge open but not connected";
+            }
+            catch
+            {
+                return "❌ SSH Bridge not running";
+            }
+        }
+
+        [McpServerTool, Description("Pre-fill SSH Bridge connection details. Launches SSH Bridge if not running, fills in host/port/user, optionally password. User must click Connect or you can call with auto_connect=true.")]
+        public static string SshPrefill(
+            [Description("SSH host/IP address")] string host,
+            [Description("SSH username")] string user,
+            [Description("SSH port (default: 22)")] int port = 22,
+            [Description("SSH password (optional - user can enter manually for security)")] string? password = null,
+            [Description("Automatically click Connect after prefilling")] bool auto_connect = false)
+        {
+            try
+            {
+                // Launch bridge if not running
+                if (!SshBridgeClient.IsBridgeRunning())
+                {
+                    if (!SshBridgeClient.LaunchBridge())
+                    {
+                        return "❌ Could not launch SSH Bridge. Set SSH_BRIDGE_PATH in your Claude config.";
+                    }
+                    // Wait for it to start
+                    Thread.Sleep(1000);
+                }
+
+                // Prefill the fields
+                var result = SshBridgeClient.Prefill(host, port, user, password);
+                if (result != "PREFILLED")
+                {
+                    return $"❌ Prefill failed: {result}";
+                }
+
+                if (auto_connect && !string.IsNullOrEmpty(password))
+                {
+                    Thread.Sleep(200);
+                    SshBridgeClient.TriggerConnect();
+                    Thread.Sleep(2000); // Wait for connection
+                    var status = SshBridgeClient.GetStatus();
+                    if (status.StartsWith("CONNECTED:"))
+                    {
+                        return $"✅ Connected to {user}@{host}:{port}";
+                    }
+                    return $"⚠️ Connection initiated. Status: {status}";
+                }
+
+                if (string.IsNullOrEmpty(password))
+                {
+                    return $"📝 SSH Bridge prefilled with {user}@{host}:{port}\n\nPlease enter password and click Connect.";
+                }
+                return $"📝 SSH Bridge prefilled with {user}@{host}:{port}\n\nClick Connect when ready.";
+            }
+            catch (Exception ex)
+            {
+                return $"❌ Error: {ex.Message}";
+            }
+        }
+    }
+}

ShellMcp.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>disable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <AssemblyName>shell-mcp</AssemblyName>
+    <RootNamespace>ShellMcp</RootNamespace>
+  </PropertyGroup>
+
+  <!-- Only compile ShellMcp.cs -->
+  <ItemGroup>
+    <Compile Remove="*.cs" />
+    <Compile Include="ShellMcp.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="ModelContextProtocol" Version="0.1.0-preview.10" />
+    <PackageReference Include="Microsoft.Extensions.Hosting" Version="8.0.0" />
+  </ItemGroup>
+
+</Project>

SshBridge.cs

@@ -0,0 +1,414 @@
+using System;
+using System.Drawing;
+using System.IO;
+using System.Net;
+using System.Net.Sockets;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows.Forms;
+using Renci.SshNet;
+
+namespace SshBridge
+{
+    public class Program
+    {
+        [STAThread]
+        public static void Main(string[] args)
+        {
+            Application.EnableVisualStyles();
+            Application.SetCompatibleTextRenderingDefault(false);
+            Application.Run(new SshBridgeForm());
+        }
+    }
+
+    public class SshBridgeForm : Form
+    {
+        private RichTextBox _outputBox = null!;
+        private TextBox _hostBox = null!;
+        private TextBox _portBox = null!;
+        private TextBox _userBox = null!;
+        private TextBox _passwordBox = null!;
+        private Button _connectButton = null!;
+        private Button _disconnectButton = null!;
+        private Label _statusLabel = null!;
+        private Panel _loginPanel = null!;
+        private Panel _sessionPanel = null!;
+
+        private Thread? _serverThread;
+        private CancellationTokenSource? _cts;
+        private SshClient? _sshClient;
+        private bool _isConnected;
+        private int _commandCount;
+        private string _currentHost = "";
+        private string _currentUser = "";
+
+        private const int PORT = 52718;
+
+        public SshBridgeForm()
+        {
+            InitializeComponents();
+            StartTcpServer();
+        }
+
+        private void InitializeComponents()
+        {
+            this.Text = "SSH Bridge for Claude";
+            this.Size = new Size(700, 500);
+            this.MinimumSize = new Size(500, 400);
+            this.StartPosition = FormStartPosition.CenterScreen;
+            this.FormBorderStyle = FormBorderStyle.Sizable;
+
+            // Login Panel
+            _loginPanel = new Panel
+            {
+                Dock = DockStyle.Fill,
+                Padding = new Padding(20),
+            };
+
+            var loginLayout = new TableLayoutPanel
+            {
+                Dock = DockStyle.Fill,
+                ColumnCount = 2,
+                RowCount = 6,
+                Padding = new Padding(50, 30, 50, 30),
+            };
+            loginLayout.ColumnStyles.Add(new ColumnStyle(SizeType.Absolute, 100));
+            loginLayout.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 100));
+            loginLayout.RowStyles.Add(new RowStyle(SizeType.Absolute, 40));
+            loginLayout.RowStyles.Add(new RowStyle(SizeType.Absolute, 40));
+            loginLayout.RowStyles.Add(new RowStyle(SizeType.Absolute, 40));
+            loginLayout.RowStyles.Add(new RowStyle(SizeType.Absolute, 40));
+            loginLayout.RowStyles.Add(new RowStyle(SizeType.Absolute, 50));
+            loginLayout.RowStyles.Add(new RowStyle(SizeType.Percent, 100));
+
+            loginLayout.Controls.Add(new Label { Text = "Host:", Anchor = AnchorStyles.Left, AutoSize = true }, 0, 0);
+            _hostBox = new TextBox { Dock = DockStyle.Fill, Text = "" };
+            loginLayout.Controls.Add(_hostBox, 1, 0);
+
+            loginLayout.Controls.Add(new Label { Text = "Port:", Anchor = AnchorStyles.Left, AutoSize = true }, 0, 1);
+            _portBox = new TextBox { Dock = DockStyle.Fill, Text = "22", Width = 80 };
+            loginLayout.Controls.Add(_portBox, 1, 1);
+
+            loginLayout.Controls.Add(new Label { Text = "User:", Anchor = AnchorStyles.Left, AutoSize = true }, 0, 2);
+            _userBox = new TextBox { Dock = DockStyle.Fill, Text = "" };
+            loginLayout.Controls.Add(_userBox, 1, 2);
+
+            loginLayout.Controls.Add(new Label { Text = "Password:", Anchor = AnchorStyles.Left, AutoSize = true }, 0, 3);
+            _passwordBox = new TextBox { Dock = DockStyle.Fill, UseSystemPasswordChar = true };
+            _passwordBox.KeyPress += (s, e) => { if (e.KeyChar == (char)Keys.Enter) Connect(); };
+            loginLayout.Controls.Add(_passwordBox, 1, 3);
+
+            _connectButton = new Button { Text = "Connect", Width = 100, Height = 35 };
+            _connectButton.Click += (s, e) => Connect();
+            var buttonPanel = new FlowLayoutPanel { Dock = DockStyle.Fill, FlowDirection = FlowDirection.LeftToRight };
+            buttonPanel.Controls.Add(_connectButton);
+            loginLayout.Controls.Add(buttonPanel, 1, 4);
+
+            _loginPanel.Controls.Add(loginLayout);
+
+            // Session Panel
+            _sessionPanel = new Panel
+            {
+                Dock = DockStyle.Fill,
+                Visible = false,
+            };
+
+            var topBar = new Panel
+            {
+                Dock = DockStyle.Top,
+                Height = 40,
+                BackColor = Color.FromArgb(45, 45, 48),
+                Padding = new Padding(10, 5, 10, 5),
+            };
+
+            _statusLabel = new Label
+            {
+                Text = "Disconnected",
+                ForeColor = Color.White,
+                AutoSize = true,
+                Location = new Point(10, 10),
+                Font = new Font("Segoe UI", 10),
+            };
+            topBar.Controls.Add(_statusLabel);
+
+            _disconnectButton = new Button
+            {
+                Text = "Disconnect",
+                ForeColor = Color.White,
+                BackColor = Color.FromArgb(180, 50, 50),
+                FlatStyle = FlatStyle.Flat,
+                Width = 90,
+                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);
+
+            _outputBox = new RichTextBox
+            {
+                Dock = DockStyle.Fill,
+                ReadOnly = true,
+                BackColor = Color.FromArgb(30, 30, 30),
+                ForeColor = Color.FromArgb(220, 220, 220),
+                Font = new Font("Consolas", 10),
+                WordWrap = false,
+            };
+
+            _sessionPanel.Controls.Add(_outputBox);
+            _sessionPanel.Controls.Add(topBar);
+
+            this.Controls.Add(_loginPanel);
+            this.Controls.Add(_sessionPanel);
+        }
+
+        private void Connect()
+        {
+            string host = _hostBox.Text.Trim();
+            string user = _userBox.Text.Trim();
+            string password = _passwordBox.Text;
+            int port = 22;
+            int.TryParse(_portBox.Text.Trim(), out port);
+            if (port <= 0 || port > 65535) port = 22;
+
+            if (string.IsNullOrEmpty(host) || string.IsNullOrEmpty(user) || string.IsNullOrEmpty(password))
+            {
+                MessageBox.Show("Please fill in all fields.", "Connection Error", MessageBoxButtons.OK, MessageBoxIcon.Warning);
+                return;
+            }
+
+            _connectButton.Enabled = false;
+            _connectButton.Text = "Connecting...";
+
+            Task.Run(() =>
+            {
+                try
+                {
+                    _sshClient = new SshClient(host, port, user, password);
+                    _sshClient.ConnectionInfo.Timeout = TimeSpan.FromSeconds(10);
+                    _sshClient.Connect();
+
+                    if (_sshClient.IsConnected)
+                    {
+                        _currentHost = host;
+                        _currentUser = user;
+                        _commandCount = 0;
+
+                        this.Invoke(() =>
+                        {
+                            _passwordBox.Clear();
+                            OnConnected();
+                        });
+                    }
+                    else
+                    {
+                        throw new Exception("Connection failed");
+                    }
+                }
+                catch (Exception ex)
+                {
+                    this.Invoke(() =>
+                    {
+                        MessageBox.Show($"Connection failed:\n{ex.Message}", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
+                        _connectButton.Enabled = true;
+                        _connectButton.Text = "Connect";
+                    });
+                }
+            });
+        }
+
+        private void OnConnected()
+        {
+            _isConnected = true;
+            _loginPanel.Visible = false;
+            _sessionPanel.Visible = true;
+            _statusLabel.Text = $"Connected to {_currentUser}@{_currentHost}";
+            _outputBox.Clear();
+            AppendOutput($"=== Connected to {_currentUser}@{_currentHost} ===", Color.LimeGreen);
+        }
+
+        private void Disconnect()
+        {
+            _isConnected = false;
+
+            try
+            {
+                _sshClient?.Disconnect();
+                _sshClient?.Dispose();
+            }
+            catch { }
+
+            _sshClient = null;
+            _currentHost = "";
+            _currentUser = "";
+
+            _loginPanel.Visible = true;
+            _sessionPanel.Visible = false;
+            _connectButton.Enabled = true;
+            _connectButton.Text = "Connect";
+            _statusLabel.Text = "Disconnected";
+        }
+
+        private void AppendOutput(string? text, Color? color = null)
+        {
+            if (string.IsNullOrEmpty(text)) return;
+            
+            if (_outputBox.InvokeRequired)
+            {
+                _outputBox.Invoke(() => AppendOutput(text, color));
+                return;
+            }
+
+            // Normalize line endings to Windows style
+            var normalized = text.Replace("\r\n", "\n").Replace("\r", "\n").Replace("\n", "\r\n");
+            
+            _outputBox.SelectionStart = _outputBox.TextLength;
+            _outputBox.SelectionLength = 0;
+            _outputBox.SelectionColor = color ?? Color.FromArgb(220, 220, 220);
+            _outputBox.AppendText(normalized + "\r\n");
+            _outputBox.SelectionColor = _outputBox.ForeColor;
+            _outputBox.ScrollToCaret();
+        }
+
+        public string ExecuteCommand(string command)
+        {
+            if (!_isConnected || _sshClient == null || !_sshClient.IsConnected)
+            {
+                return "ERROR: Not connected. Open SSH Bridge and connect first.";
+            }
+
+            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 output = result.Trim();
+                if (!string.IsNullOrEmpty(error))
+                {
+                    output += "\n[stderr] " + error.Trim();
+                }
+
+                if (string.IsNullOrEmpty(output))
+                {
+                    output = "(no output)";
+                }
+
+                AppendOutput(output);
+                
+                return output;
+            }
+            catch (Exception ex)
+            {
+                var error = $"ERROR: {ex.Message}";
+                AppendOutput(error, Color.Red);
+                return error;
+            }
+        }
+
+        private void StartTcpServer()
+        {
+            _cts = new CancellationTokenSource();
+            _serverThread = new Thread(() => TcpServerLoop(_cts.Token))
+            {
+                IsBackground = true,
+                Name = "SshBridge TCP Server"
+            };
+            _serverThread.Start();
+        }
+
+        private void TcpServerLoop(CancellationToken ct)
+        {
+            var listener = new TcpListener(IPAddress.Loopback, PORT);
+            listener.Start();
+
+            while (!ct.IsCancellationRequested)
+            {
+                try
+                {
+                    if (!listener.Pending())
+                    {
+                        Thread.Sleep(50);
+                        continue;
+                    }
+
+                    using var client = listener.AcceptTcpClient();
+                    using var stream = client.GetStream();
+                    using var reader = new StreamReader(stream, Encoding.UTF8);
+                    using var writer = new StreamWriter(stream, Encoding.UTF8) { AutoFlush = true };
+
+                    string? command = reader.ReadLine();
+                    if (!string.IsNullOrEmpty(command))
+                    {
+                        string response;
+                        if (command == "__STATUS__")
+                        {
+                            response = _isConnected ? $"CONNECTED:{_currentUser}@{_currentHost}" : "DISCONNECTED";
+                        }
+                        else if (command.StartsWith("__PREFILL__:"))
+                        {
+                            // Format: __PREFILL__:host:port:user:password
+                            // Password is optional - if not provided, user must enter it
+                            var parts = command.Substring(12).Split(':', 4);
+                            if (parts.Length >= 3)
+                            {
+                                this.Invoke(() =>
+                                {
+                                    _hostBox.Text = parts[0];
+                                    _portBox.Text = parts[1];
+                                    _userBox.Text = parts[2];
+                                    if (parts.Length >= 4 && !string.IsNullOrEmpty(parts[3]))
+                                    {
+                                        _passwordBox.Text = parts[3];
+                                    }
+                                    _passwordBox.Focus();
+                                    this.Activate();
+                                    this.BringToFront();
+                                });
+                                response = "PREFILLED";
+                            }
+                            else
+                            {
+                                response = "ERROR: Invalid prefill format. Use __PREFILL__:host:port:user[:password]";
+                            }
+                        }
+                        else if (command == "__CONNECT__")
+                        {
+                            // Trigger connect if fields are filled
+                            this.Invoke(() => Connect());
+                            response = "CONNECTING";
+                        }
+                        else
+                        {
+                            response = ExecuteCommand(command);
+                        }
+                        // Encode newlines so they survive the single-line protocol
+                        response = response.Replace("\r\n", "<<CRLF>>").Replace("\n", "<<LF>>");
+                        writer.WriteLine(response);
+                    }
+                }
+                catch (Exception)
+                {
+                    // Ignore errors
+                }
+            }
+
+            listener.Stop();
+        }
+
+        protected override void OnFormClosing(FormClosingEventArgs e)
+        {
+            _cts?.Cancel();
+            Disconnect();
+            base.OnFormClosing(e);
+        }
+    }
+}

SshBridge.csproj

@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>WinExe</OutputType>
+    <TargetFramework>net8.0-windows</TargetFramework>
+    <UseWindowsForms>true</UseWindowsForms>
+    <ImplicitUsings>disable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <AssemblyName>ssh-bridge</AssemblyName>
+    <RootNamespace>SshBridge</RootNamespace>
+  </PropertyGroup>
+
+  <!-- Only compile SshBridge.cs -->
+  <ItemGroup>
+    <Compile Remove="*.cs" />
+    <Compile Include="SshBridge.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="SSH.NET" Version="2024.2.0" />
+  </ItemGroup>
+
+</Project>