ssh-mcp 1.0.9 → 1.2.0

package/README.md

@@ -48,6 +48,10 @@
     - 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
+  - **Max Command Length Configuration:**
+    - Max command characters are configured via `--maxChars`
+    - Default: `1000`
+    - No-limit mode: set `--maxChars=none` or any `<= 0` value (e.g. `--maxChars=0`)
 
 ## Installation
 
@@ -74,6 +78,7 @@ You can configure Claude Desktop to use this MCP Server.
 - `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)
+- `maxChars`: Maximum allowed characters for the `command` input (default: 1000). Use `none` or `0` to disable the limit.
 
 
 ```commandline
@@ -90,7 +95,8 @@ You can configure Claude Desktop to use this MCP Server.
                 "--user=root",
                 "--password=pass",
                 "--key=path/to/key",
-                "--timeout=30000"
+                "--timeout=30000",
+                "--maxChars=none"
             ]
         }
     }

package/build/index.js

@@ -24,6 +24,27 @@ 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
+// Max characters configuration:
+// - Default: 1000 characters
+// - When set via --maxChars:
+//   * a positive integer enforces that limit
+//   * 0 or a negative value disables the limit (no max)
+//   * the string "none" (case-insensitive) disables the limit (no max)
+const MAX_CHARS_RAW = argvConfig.maxChars;
+const MAX_CHARS = (() => {
+    if (typeof MAX_CHARS_RAW === 'string') {
+        const lowered = MAX_CHARS_RAW.toLowerCase();
+        if (lowered === 'none')
+            return Infinity;
+        const parsed = parseInt(MAX_CHARS_RAW);
+        if (isNaN(parsed))
+            return 1000;
+        if (parsed <= 0)
+            return Infinity;
+        return parsed;
+    }
+    return 1000;
+})();
 function validateConfig(config) {
     const errors = [];
     if (!config.host)
@@ -49,8 +70,8 @@ export function sanitizeCommand(command) {
         throw new McpError(ErrorCode.InvalidParams, 'Command cannot be empty');
     }
     // Length check
-    if (trimmedCommand.length > 1000) {
-        throw new McpError(ErrorCode.InvalidParams, 'Command is too long (max 1000 characters)');
+    if (Number.isFinite(MAX_CHARS) && trimmedCommand.length > MAX_CHARS) {
+        throw new McpError(ErrorCode.InvalidParams, `Command is too long (max ${MAX_CHARS} characters)`);
     }
     return trimmedCommand;
 }
@@ -59,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.0',
     capabilities: {
         resources: {},
         tools: {},
@@ -72,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) {
@@ -95,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();
@@ -177,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.0.9",
+  "version": "1.2.0",
   "description": "MCP server exposing SSH control for Linux and Windows systems via Model Context Protocol.",
   "type": "module",
   "bin": {