ssh-mcp 1.1.0 → 1.2.2

package/README.md

@@ -67,7 +67,7 @@
 
 ## Client Setup
 
-You can configure Claude Desktop to use this MCP Server.
+You can configure your IDE or LLM like Cursor, Windsurf, Claude Desktop to use this MCP Server.
 
 **Required Parameters:**
 - `host`: Hostname or IP of the Linux or Windows server
@@ -103,6 +103,62 @@ You can configure Claude Desktop to use this MCP Server.
 }
 ```
 
+### Claude Code
+
+You can add this MCP server to Claude Code using the `claude mcp add` command. This is the recommended method for Claude Code.
+
+**Basic Installation:**
+
+```bash
+claude mcp add --transport stdio ssh-mcp -- npx -y ssh-mcp -- --host=YOUR_HOST --user=YOUR_USER --password=YOUR_PASSWORD
+```
+
+**Installation Examples:**
+
+**With Password Authentication:**
+```bash
+claude mcp add --transport stdio ssh-mcp -- npx -y ssh-mcp -- --host=192.168.1.100 --port=22 --user=admin --password=your_password
+```
+
+**With SSH Key Authentication:**
+```bash
+claude mcp add --transport stdio ssh-mcp -- npx -y ssh-mcp -- --host=example.com --user=root --key=/path/to/private/key
+```
+
+**With Custom Timeout and No Character Limit:**
+```bash
+claude mcp add --transport stdio ssh-mcp -- npx -y ssh-mcp -- --host=192.168.1.100 --user=admin --password=your_password --timeout=120000 --maxChars=none
+```
+
+**Installation Scopes:**
+
+You can specify the scope when adding the server:
+
+- **Local scope** (default): For personal use in the current project
+  ```bash
+  claude mcp add --transport stdio ssh-mcp --scope local -- npx -y ssh-mcp -- --host=YOUR_HOST --user=YOUR_USER --password=YOUR_PASSWORD
+  ```
+
+- **Project scope**: Share with your team via `.mcp.json` file
+  ```bash
+  claude mcp add --transport stdio ssh-mcp --scope project -- npx -y ssh-mcp -- --host=YOUR_HOST --user=YOUR_USER --password=YOUR_PASSWORD
+  ```
+
+- **User scope**: Available across all your projects
+  ```bash
+  claude mcp add --transport stdio ssh-mcp --scope user -- npx -y ssh-mcp -- --host=YOUR_HOST --user=YOUR_USER --password=YOUR_PASSWORD
+  ```
+
+
+**Verify Installation:**
+
+After adding the server, restart Claude Code and ask Cascade to execute a command:
+```
+"Can you run 'ls -la' on the remote server?"
+```
+
+For more information about MCP in Claude Code, see the [official documentation](https://docs.claude.com/en/docs/claude-code/mcp).
+
 ## Testing
 
 You can use the [MCP Inspector](https://modelcontextprotocol.io/docs/tools/inspector) for visual debugging of this MCP Server.

package/build/index.js

@@ -80,9 +80,86 @@ export function escapeCommandForShell(command) {
     // Replace single quotes with escaped single quotes
     return command.replace(/'/g, "'\"'\"'");
 }
+// SSH Connection Manager to maintain persistent connection
+export class SSHConnectionManager {
+    conn = null;
+    sshConfig = null;
+    isConnecting = false;
+    connectionPromise = null;
+    constructor(config) {
+        this.sshConfig = config;
+    }
+    async connect() {
+        if (this.conn && this.isConnected()) {
+            return; // Already connected
+        }
+        if (this.isConnecting && this.connectionPromise) {
+            return this.connectionPromise; // Wait for ongoing connection
+        }
+        this.isConnecting = true;
+        this.connectionPromise = new Promise((resolve, reject) => {
+            this.conn = new SSHClient();
+            const timeoutId = setTimeout(() => {
+                this.conn?.end();
+                this.conn = null;
+                this.isConnecting = false;
+                this.connectionPromise = null;
+                reject(new McpError(ErrorCode.InternalError, 'SSH connection timeout'));
+            }, 30000); // 30 seconds connection timeout
+            this.conn.on('ready', () => {
+                clearTimeout(timeoutId);
+                this.isConnecting = false;
+                console.error('SSH connection established');
+                resolve();
+            });
+            this.conn.on('error', (err) => {
+                clearTimeout(timeoutId);
+                this.conn = null;
+                this.isConnecting = false;
+                this.connectionPromise = null;
+                reject(new McpError(ErrorCode.InternalError, `SSH connection error: ${err.message}`));
+            });
+            this.conn.on('end', () => {
+                console.error('SSH connection ended');
+                this.conn = null;
+                this.isConnecting = false;
+                this.connectionPromise = null;
+            });
+            this.conn.on('close', () => {
+                console.error('SSH connection closed');
+                this.conn = null;
+                this.isConnecting = false;
+                this.connectionPromise = null;
+            });
+            this.conn.connect(this.sshConfig);
+        });
+        return this.connectionPromise;
+    }
+    isConnected() {
+        return this.conn !== null && this.conn._sock && !this.conn._sock.destroyed;
+    }
+    async ensureConnected() {
+        if (!this.isConnected()) {
+            await this.connect();
+        }
+    }
+    getConnection() {
+        if (!this.conn) {
+            throw new McpError(ErrorCode.InternalError, 'SSH connection not established');
+        }
+        return this.conn;
+    }
+    close() {
+        if (this.conn) {
+            this.conn.end();
+            this.conn = null;
+        }
+    }
+}
+let connectionManager = null;
 const server = new McpServer({
     name: 'SSH MCP Server',
-    version: '1.0.9',
+    version: '1.2.2',
     capabilities: {
         resources: {},
         tools: {},
@@ -93,20 +170,26 @@ server.tool("exec", "Execute a shell command on the remote SSH server and return
 }, async ({ command }) => {
     // Sanitize command input
     const sanitizedCommand = sanitizeCommand(command);
-    const sshConfig = {
-        host: HOST,
-        port: PORT,
-        username: USER,
-    };
     try {
-        if (PASSWORD) {
-            sshConfig.password = PASSWORD;
-        }
-        else if (KEY) {
-            const fs = await import('fs/promises');
-            sshConfig.privateKey = await fs.readFile(KEY, 'utf8');
+        // Initialize connection manager if not already done
+        if (!connectionManager) {
+            const sshConfig = {
+                host: HOST,
+                port: PORT,
+                username: USER,
+            };
+            if (PASSWORD) {
+                sshConfig.password = PASSWORD;
+            }
+            else if (KEY) {
+                const fs = await import('fs/promises');
+                sshConfig.privateKey = await fs.readFile(KEY, 'utf8');
+            }
+            connectionManager = new SSHConnectionManager(sshConfig);
         }
-        const result = await execSshCommand(sshConfig, sanitizedCommand);
+        // Ensure connection is active (reconnect if needed)
+        await connectionManager.ensureConnected();
+        const result = await execSshCommandWithConnection(connectionManager, sanitizedCommand);
         return result;
     }
     catch (err) {
@@ -116,6 +199,71 @@ server.tool("exec", "Execute a shell command on the remote SSH server and return
         throw new McpError(ErrorCode.InternalError, `Unexpected error: ${err?.message || err}`);
     }
 });
+// New function that uses persistent connection
+export async function execSshCommandWithConnection(manager, command) {
+    return new Promise((resolve, reject) => {
+        let timeoutId;
+        let isResolved = false;
+        const conn = manager.getConnection();
+        // Set up timeout
+        timeoutId = setTimeout(() => {
+            if (!isResolved) {
+                isResolved = true;
+                // Try to abort the running command
+                const abortTimeout = setTimeout(() => {
+                    // If abort command itself times out, we'll just reject
+                }, 5000);
+                conn.exec('timeout 3s pkill -f \'' + escapeCommandForShell(command) + '\' 2>/dev/null || true', (err, abortStream) => {
+                    if (abortStream) {
+                        abortStream.on('close', () => {
+                            clearTimeout(abortTimeout);
+                        });
+                    }
+                    else {
+                        clearTimeout(abortTimeout);
+                    }
+                });
+                reject(new McpError(ErrorCode.InternalError, `Command execution timed out after ${DEFAULT_TIMEOUT}ms`));
+            }
+        }, DEFAULT_TIMEOUT);
+        conn.exec(command, (err, stream) => {
+            if (err) {
+                if (!isResolved) {
+                    isResolved = true;
+                    clearTimeout(timeoutId);
+                    reject(new McpError(ErrorCode.InternalError, `SSH exec error: ${err.message}`));
+                }
+                return;
+            }
+            let stdout = '';
+            let stderr = '';
+            stream.on('close', (code, signal) => {
+                if (!isResolved) {
+                    isResolved = true;
+                    clearTimeout(timeoutId);
+                    if (stderr) {
+                        reject(new McpError(ErrorCode.InternalError, `Error (code ${code}):\n${stderr}`));
+                    }
+                    else {
+                        resolve({
+                            content: [{
+                                    type: 'text',
+                                    text: stdout,
+                                }],
+                        });
+                    }
+                }
+            });
+            stream.on('data', (data) => {
+                stdout += data.toString();
+            });
+            stream.stderr.on('data', (data) => {
+                stderr += data.toString();
+            });
+        });
+    });
+}
+// Keep the old function for backward compatibility (used in tests)
 export async function execSshCommand(sshConfig, command) {
     return new Promise((resolve, reject) => {
         const conn = new SSHClient();
@@ -198,10 +346,29 @@ async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
     console.error("SSH MCP Server running on stdio");
+    // Handle graceful shutdown
+    const cleanup = () => {
+        console.error("Shutting down SSH MCP Server...");
+        if (connectionManager) {
+            connectionManager.close();
+            connectionManager = null;
+        }
+        process.exit(0);
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+    process.on('exit', () => {
+        if (connectionManager) {
+            connectionManager.close();
+        }
+    });
 }
 if (process.env.SSH_MCP_DISABLE_MAIN !== '1') {
     main().catch((error) => {
         console.error("Fatal error in main():", error);
+        if (connectionManager) {
+            connectionManager.close();
+        }
         process.exit(1);
     });
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ssh-mcp",
   "license": "MIT",
-  "version": "1.1.0",
+  "version": "1.2.2",
   "description": "MCP server exposing SSH control for Linux and Windows systems via Model Context Protocol.",
   "type": "module",
   "bin": {