ssh-mcp 1.0.4 → 1.0.6

package/README.md

@@ -28,10 +28,18 @@
 - Execute shell commands on remote Linux and Windows systems
 - Secure authentication via password or SSH key
 - Built with TypeScript and the official MCP SDK
+- **Configurable timeout protection** with automatic process abortion
+- **Graceful timeout handling** - attempts to kill hanging processes before closing connections
 
 ### Tools
 
 - `exec`: Execute a shell command on the remote server
+  - **Parameters:**
+    - `command` (required): Shell command to execute on the remote SSH server
+  - **Timeout Configuration:**
+    - Timeout is configured via command line argument `--timeout` (in milliseconds)
+    - Default timeout: 60000ms (1 minute)
+    - When a command times out, the server automatically attempts to abort the running process before closing the connection
 
 ## Installation
 
@@ -48,11 +56,16 @@
 ## Client Setup
 
 You can configure Claude Desktop to use this MCP Server.
-   - `host`: Hostname or IP of the Linux or Windows server
-   - `port`: SSH port (default: 22)
-   - `user`: SSH username
-   - `password`: SSH password (or use `key` for key-based auth) (optional)
-   - `key`: Path to private SSH key (optional)
+
+**Required Parameters:**
+- `host`: Hostname or IP of the Linux or Windows server
+- `user`: SSH username
+
+**Optional Parameters:**
+- `port`: SSH port (default: 22)
+- `password`: SSH password (or use `key` for key-based auth)
+- `key`: Path to private SSH key
+- `timeout`: Command execution timeout in milliseconds (default: 60000ms = 1 minute)
 
 
 ```commandline
@@ -68,7 +81,8 @@ You can configure Claude Desktop to use this MCP Server.
                 "--port=22",
                 "--user=root",
                 "--password=pass",
-                "--key=path/to/key"
+                "--key=path/to/key",
+                "--timeout=30000"
             ]
         }
     }

package/build/index.js

@@ -1,10 +1,10 @@
+#!/usr/bin/env node
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
 import { Client as SSHClient } from 'ssh2';
 import { z } from 'zod';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-// Parse SSH config from process.argv
-// Example usage: node build/index.js --host=1.2.3.4 --port=22 --user=root --password=pass --key=path/to/key
+// Example usage: node build/index.js --host=1.2.3.4 --port=22 --user=root --password=pass --key=path/to/key --timeout=5000
 function parseArgv() {
     const args = process.argv.slice(2);
     const config = {};
@@ -22,6 +22,7 @@ const PORT = argvConfig.port ? parseInt(argvConfig.port) : 22;
 const USER = argvConfig.user;
 const PASSWORD = argvConfig.password;
 const KEY = argvConfig.key;
+const DEFAULT_TIMEOUT = argvConfig.timeout ? parseInt(argvConfig.timeout) : 60000; // 60 seconds default timeout
 function validateConfig(config) {
     const errors = [];
     if (!config.host)
@@ -37,7 +38,7 @@ function validateConfig(config) {
 validateConfig(argvConfig);
 const server = new McpServer({
     name: 'SSH MCP Server',
-    version: '1.0.4',
+    version: '1.0.6',
     capabilities: {
         resources: {},
         tools: {},
@@ -76,27 +77,61 @@ server.tool("exec", "Execute a shell command on the remote SSH server and return
 async function execSshCommand(sshConfig, command) {
     return new Promise((resolve, reject) => {
         const conn = new SSHClient();
+        let timeoutId;
+        let isResolved = false;
+        // Set up timeout
+        timeoutId = setTimeout(() => {
+            if (!isResolved) {
+                isResolved = true;
+                // Try to abort the running command before closing connection
+                const abortTimeout = setTimeout(() => {
+                    // If abort command itself times out, force close connection
+                    conn.end();
+                }, 5000); // 5 second timeout for abort command
+                conn.exec('timeout 3s pkill -f "' + command + '" 2>/dev/null || true', (err, abortStream) => {
+                    if (abortStream) {
+                        abortStream.on('close', () => {
+                            clearTimeout(abortTimeout);
+                            conn.end();
+                        });
+                    }
+                    else {
+                        clearTimeout(abortTimeout);
+                        conn.end();
+                    }
+                });
+                reject(new McpError(ErrorCode.InternalError, `Command execution timed out after ${DEFAULT_TIMEOUT}ms`));
+            }
+        }, DEFAULT_TIMEOUT);
         conn.on('ready', () => {
             conn.exec(command, (err, stream) => {
                 if (err) {
-                    reject(new McpError(ErrorCode.InternalError, `SSH exec error: ${err.message}`));
+                    if (!isResolved) {
+                        isResolved = true;
+                        clearTimeout(timeoutId);
+                        reject(new McpError(ErrorCode.InternalError, `SSH exec error: ${err.message}`));
+                    }
                     conn.end();
                     return;
                 }
                 let stdout = '';
                 let stderr = '';
                 stream.on('close', (code, signal) => {
-                    conn.end();
-                    if (stderr) {
-                        reject(new McpError(ErrorCode.InternalError, `Error (code ${code}):\n${stderr}`));
-                    }
-                    else {
-                        resolve({
-                            content: [{
-                                    type: 'text',
-                                    text: stdout,
-                                }],
-                        });
+                    if (!isResolved) {
+                        isResolved = true;
+                        clearTimeout(timeoutId);
+                        conn.end();
+                        if (stderr) {
+                            reject(new McpError(ErrorCode.InternalError, `Error (code ${code}):\n${stderr}`));
+                        }
+                        else {
+                            resolve({
+                                content: [{
+                                        type: 'text',
+                                        text: stdout,
+                                    }],
+                            });
+                        }
                     }
                 });
                 stream.on('data', (data) => {
@@ -108,7 +143,11 @@ async function execSshCommand(sshConfig, command) {
             });
         });
         conn.on('error', (err) => {
-            reject(new McpError(ErrorCode.InternalError, `SSH connection error: ${err.message}`));
+            if (!isResolved) {
+                isResolved = true;
+                clearTimeout(timeoutId);
+                reject(new McpError(ErrorCode.InternalError, `SSH connection error: ${err.message}`));
+            }
         });
         conn.connect(sshConfig);
     });

package/package.json

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