mcp-ssh-server-tool 1.0.6 → 2.0.0

package/index.js

@@ -1,352 +1,99 @@
-import { Client } from 'ssh2';
-import { v4 as uuidv4 } from 'uuid';
-import * as fs from 'fs';
-
-class SSHSession {
-  constructor(sessionId, client, host, username) {
-    this.sessionId = sessionId;
-    this.client = client;
-    this.host = host;
-    this.username = username;
-    this.connected = true;
-  }
-}
-
-class SSHConnectionManager {
-  constructor() {
-    this.sessions = new Map();
-  }
-
-  connect(options) {
-    return new Promise((resolve) => {
-      const client = new Client();
-      const sessionId = uuidv4();
-      const port = options.port || 22;
-      const timeout = (options.timeout || 10) * 1000;
-
-      const config = {
-        host: options.host,
-        port: port,
-        username: options.username,
-        timeout: timeout,
-        readyTimeout: timeout,
-      };
-
-      if (options.authType === 'password') {
-        if (!options.password) {
-          resolve({
-            success: false,
-            error: 'Password is required for password authentication',
-            errorType: 'MissingPassword',
-          });
-          return;
-        }
-        config.password = options.password;
-      } else if (options.authType === 'public_key') {
-        if (!options.privateKeyPath) {
-          resolve({
-            success: false,
-            error: 'Private key path is required for public key authentication',
-            errorType: 'MissingPrivateKey',
-          });
-          return;
-        }
-        try {
-          config.privateKey = fs.readFileSync(options.privateKeyPath);
-          if (options.passphrase) {
-            config.passphrase = options.passphrase;
-          }
-        } catch (err) {
-          resolve({
-            success: false,
-            error: `Failed to read private key: ${err.message}`,
-            errorType: 'PrivateKeyError',
-          });
-          return;
-        }
-      }
-
-      client.on('ready', () => {
-        const session = new SSHSession(sessionId, client, options.host, options.username);
-        this.sessions.set(sessionId, session);
-
-        resolve({
-          success: true,
-          sessionId,
-          host: options.host,
-          port,
-          username: options.username,
-          message: `Successfully connected to ${options.host}:${port}`,
-        });
-      });
-
-      client.on('error', (err) => {
-        resolve({
-          success: false,
-          error: err.message,
-          errorType: 'ConnectionError',
-        });
-      });
-
-      client.connect(config);
-    });
-  }
-
-  execCommand(sessionId, command) {
-    const session = this.sessions.get(sessionId);
-
-    if (!session) {
-      return {
-        success: false,
-        error: `Session ${sessionId} not found`,
-        errorType: 'SessionNotFound',
-      };
-    }
-
-    if (!session.connected) {
-      return {
-        success: false,
-        error: `Session ${sessionId} is not connected`,
-        errorType: 'SessionNotConnected',
-      };
-    }
-
-    return new Promise((resolve) => {
-      session.client.exec(command, (err, stream) => {
-        if (err) {
-          resolve({
-            success: false,
-            error: err.message,
-            errorType: 'ExecError',
-            sessionId,
-          });
-          return;
-        }
-
-        let stdout = '';
-        let stderr = '';
-
-        stream.on('close', (code) => {
-          resolve({
-            success: true,
-            sessionId,
-            command,
-            stdout,
-            stderr,
-            exitCode: code,
-          });
-        });
-
-        stream.on('data', (data) => {
-          stdout += data.toString();
-        });
-
-        stream.stderr.on('data', (data) => {
-          stderr += data.toString();
-        });
-      });
-    });
-  }
-
-  disconnect(sessionId) {
-    const session = this.sessions.get(sessionId);
-
-    if (!session) {
-      return {
-        success: false,
-        error: `Session ${sessionId} not found`,
-        errorType: 'SessionNotFound',
-      };
-    }
-
-    try {
-      session.client.end();
-      session.connected = false;
-      this.sessions.delete(sessionId);
-
-      return {
-        success: true,
-        sessionId,
-        message: 'Disconnected successfully',
-      };
-    } catch (err) {
-      return {
-        success: false,
-        error: err.message,
-        errorType: 'DisconnectError',
-      };
-    }
-  }
-
-  listSessions() {
-    const sessions = [];
-
-    this.sessions.forEach((session) => {
-      sessions.push({
-        sessionId: session.sessionId,
-        host: session.host,
-        username: session.username,
-        connected: session.connected,
-      });
-    });
-
-    return {
-      success: true,
-      sessions,
-      count: sessions.length,
-    };
-  }
-}
+import { SSHConnectionManager } from './ssh_manager.js';
 
 const sshManager = new SSHConnectionManager();
 
 const tools = [
   {
     name: 'ssh_connect',
-    description: 'Establish an SSH connection to a remote server',
+    description: 'Establish an SSH connection. Returns session_id for subsequent commands.',
     inputSchema: {
       type: 'object',
       properties: {
-        host: {
-          type: 'string',
-          description: 'Server hostname or IP address',
-        },
-        port: {
-          type: 'number',
-          description: 'SSH port number',
-          default: 22,
-        },
-        username: {
-          type: 'string',
-          description: 'SSH username',
-        },
-        auth_type: {
-          type: 'string',
-          enum: ['password', 'public_key'],
-          description: 'Authentication type',
-        },
-        password: {
-          type: 'string',
-          description: 'Password (required if auth_type is password)',
-        },
-        private_key_path: {
-          type: 'string',
-          description: 'Path to private key file (required if auth_type is public_key)',
-        },
-        passphrase: {
-          type: 'string',
-          description: 'Passphrase for private key (optional)',
-        },
-        timeout: {
-          type: 'number',
-          description: 'Connection timeout in seconds',
-          default: 10,
-        },
+        host: { type: 'string', description: 'Server hostname or IP' },
+        port: { type: 'number', description: 'SSH port (default: 22)', default: 22 },
+        username: { type: 'string', description: 'SSH username' },
+        password: { type: 'string', description: 'Password (for password auth)' },
+        auth_type: { type: 'string', enum: ['password', 'public_key'], description: 'Auth type' },
+        private_key_path: { type: 'string', description: 'Path to private key' },
+        passphrase: { type: 'string', description: 'Passphrase for private key' },
+        timeout: { type: 'number', description: 'Timeout in seconds (default: 10)', default: 10 },
       },
-      required: ['host', 'username', 'auth_type'],
+      required: ['host', 'username'],
     },
   },
   {
     name: 'ssh_exec',
-    description: 'Execute a command on an SSH session. Use session_id if you have an active session, or provide host/username/password to connect directly.',
+    description: 'Execute command(s) on SSH server. Supports direct mode (host/username) or session mode (session_id).',
     inputSchema: {
       type: 'object',
       properties: {
-        session_id: {
-          type: 'string',
-          description: 'The SSH session ID from ssh_connect (optional if providing host/username/password)',
-        },
-        command: {
-          type: 'string',
-          description: 'The command to execute',
-        },
-        host: {
-          type: 'string',
-          description: 'Server hostname (optional, used if session_id not provided)',
-        },
-        port: {
-          type: 'number',
-          description: 'SSH port (default: 22)',
-          default: 22,
-        },
-        username: {
-          type: 'string',
-          description: 'SSH username (optional)',
-        },
-        password: {
-          type: 'string',
-          description: 'SSH password (optional)',
-        },
-        auth_type: {
-          type: 'string',
-          enum: ['password', 'public_key'],
-          description: 'Authentication type (default: password)',
-          default: 'password',
-        },
-        private_key_path: {
-          type: 'string',
-          description: 'Private key path (for public_key auth)',
-        },
-        passphrase: {
-          type: 'string',
-          description: 'Passphrase for private key',
-        },
+        host: { type: 'string', description: 'Server hostname (use for direct execution)' },
+        port: { type: 'number', description: 'SSH port', default: 22 },
+        username: { type: 'string', description: 'SSH username' },
+        password: { type: 'string', description: 'Password' },
+        auth_type: { type: 'string', enum: ['password', 'public_key'], description: 'Auth type' },
+        private_key_path: { type: 'string', description: 'Path to private key' },
+        passphrase: { type: 'string', description: 'Passphrase for private key' },
+        timeout: { type: 'number', description: 'Timeout in seconds', default: 10 },
+        session_id: { type: 'string', description: 'Session ID from ssh_connect (use for session mode)' },
+        command: { type: 'string', description: 'Command to execute' },
+        commands: { type: 'array', items: { type: 'string' }, description: 'Multiple commands to execute sequentially' },
       },
-      required: ['command'],
     },
   },
   {
     name: 'ssh_disconnect',
-    description: 'Disconnect an SSH session',
+    description: 'Close an SSH session',
     inputSchema: {
       type: 'object',
       properties: {
-        session_id: {
-          type: 'string',
-          description: 'The SSH session ID to disconnect',
-        },
+        session_id: { type: 'string', description: 'Session ID to disconnect' },
       },
       required: ['session_id'],
     },
   },
   {
-    name: 'ssh_list_sessions',
-    description: 'List all active SSH sessions',
+    name: 'ssh_test',
+    description: 'Quick connection test. Connects, executes a test command, and disconnects.',
     inputSchema: {
       type: 'object',
-      properties: {},
+      properties: {
+        host: { type: 'string', description: 'Server hostname' },
+        port: { type: 'number', description: 'SSH port', default: 22 },
+        username: { type: 'string', description: 'SSH username' },
+        password: { type: 'string', description: 'Password' },
+        auth_type: { type: 'string', enum: ['password', 'public_key'], description: 'Auth type' },
+        private_key_path: { type: 'string', description: 'Path to private key' },
+        passphrase: { type: 'string', description: 'Passphrase' },
+        timeout: { type: 'number', description: 'Timeout in seconds', default: 10 },
+        test_command: { type: 'string', description: 'Test command (default: echo test)', default: 'echo test' },
+      },
+      required: ['host', 'username'],
     },
   },
+  {
+    name: 'ssh_list_sessions',
+    description: 'List active SSH sessions',
+    inputSchema: { type: 'object', properties: {} },
+  },
 ];
 
 function send(message) {
   process.stdout.write(JSON.stringify(message) + '\n');
 }
 
-let buffer = '';
-
-process.stdin.setEncoding('utf8');
-
-process.stdin.on('data', (chunk) => {
-  buffer += chunk;
-  let newlineIndex;
-
-  while ((newlineIndex = buffer.indexOf('\n')) !== -1) {
-    const line = buffer.slice(0, newlineIndex);
-    buffer = buffer.slice(newlineIndex + 1);
-
-    if (line.trim()) {
-      try {
-        const request = JSON.parse(line);
-        handleRequest(request);
-      } catch (err) {
-        console.error('Parse error:', err);
-      }
-    }
+function parseArgs(args) {
+  if (!args) return {};
+  if (typeof args === 'string') {
+    try { return JSON.parse(args); } catch { return {}; }
   }
-});
+  if (typeof args.arguments === 'string') {
+    try { return JSON.parse(args.arguments); } catch { return args; }
+  }
+  return args;
+}
 
-function handleRequest(request) {
+async function handleRequest(request) {
   const { id, method, params } = request;
 
   if (method === 'initialize') {
@@ -356,198 +103,122 @@ function handleRequest(request) {
       result: {
         protocolVersion: '2024-11-05',
         capabilities: { tools: {} },
-        serverInfo: {
-          name: 'ssh-mcp-server',
-          version: '1.0.0',
-        },
+        serverInfo: { name: 'ssh-mcp-server', version: '1.0.0' },
       },
     });
     return;
   }
 
-  if (method === 'notifications/initialized') {
-    return;
-  }
+  if (method === 'notifications/initialized') return;
 
   if (method === 'tools/list') {
-    send({
-      jsonrpc: '2.0',
-      id,
-      result: { tools },
-    });
+    send({ jsonrpc: '2.0', id, result: { tools } });
     return;
   }
 
   if (method === 'tools/call') {
     const { name, arguments: args } = params;
-
-    // Handle nested arguments (stringified JSON)
-    let toolArgs = args;
-    if (typeof args === 'string') {
-      try {
-        toolArgs = JSON.parse(args);
-      } catch (e) {
-        toolArgs = {};
-      }
-    } else if (args && typeof args.arguments === 'string') {
-      try {
-        toolArgs = JSON.parse(args.arguments);
-      } catch (e) {
-        toolArgs = args;
-      }
-    }
+    const toolArgs = parseArgs(args);
 
     if (name === 'ssh_connect') {
-      sshManager.connect({
+      const result = await sshManager.connect({
         host: toolArgs.host,
         port: toolArgs.port,
         username: toolArgs.username,
-        authType: toolArgs.auth_type,
         password: toolArgs.password,
         privateKeyPath: toolArgs.private_key_path,
         passphrase: toolArgs.passphrase,
         timeout: toolArgs.timeout,
-      }).then((result) => {
-        send({
-          jsonrpc: '2.0',
-          id,
-          result: {
-            content: [
-              {
-                type: 'text',
-                text: JSON.stringify(result),
-              },
-            ],
-          },
-        });
       });
+      send({ jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: JSON.stringify(result) }] } });
       return;
     }
 
     if (name === 'ssh_exec') {
-      // 如果有 session_id，使用现有会话
-      if (toolArgs.session_id) {
-        const execResult = sshManager.execCommand(toolArgs.session_id, toolArgs.command);
-        if (execResult && typeof execResult.then === 'function') {
-          execResult.then((result) => {
-            send({
-              jsonrpc: '2.0',
-              id,
-              result: {
-                content: [
-                  {
-                    type: 'text',
-                    text: JSON.stringify(result),
-                  },
-                ],
-              },
-            });
-          }).catch((err) => {
-            send({
-              jsonrpc: '2.0',
-              id,
-              result: {
-                content: [
-                  {
-                    type: 'text',
-                    text: JSON.stringify({ success: false, error: err.message }),
-                  },
-                ],
-              },
-            });
-          });
-        } else {
-          send({
-            jsonrpc: '2.0',
-            id,
-            result: {
-              content: [
-                {
-                  type: 'text',
-                  text: JSON.stringify(execResult),
-                },
-              ],
-            },
-          });
-        }
+      const hasSession = toolArgs.session_id;
+      const hasAuth = toolArgs.host && toolArgs.username;
+
+      if (!hasSession && !hasAuth) {
+        send({ jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: JSON.stringify({ success: false, error: 'Either session_id or host/username required' }) }] } });
         return;
       }
 
-      // 如果没有 session_id，但提供了认证参数，直接连接、执行、断开
-      if (toolArgs.host && toolArgs.username) {
-        const connResult = await sshManager.connect({
+      if (hasAuth && !hasSession) {
+        const conn = await sshManager.connect({
           host: toolArgs.host,
           port: toolArgs.port,
           username: toolArgs.username,
-          authType: toolArgs.auth_type || 'password',
           password: toolArgs.password,
           privateKeyPath: toolArgs.private_key_path,
           passphrase: toolArgs.passphrase,
           timeout: toolArgs.timeout,
         });
 
-        if (!connResult.success) {
-          send({
-            jsonrpc: '2.0',
-            id,
-            result: {
-              content: [
-                {
-                  type: 'text',
-                  text: JSON.stringify(connResult),
-                },
-              ],
-            },
-          });
+        if (!conn.success) {
+          send({ jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: JSON.stringify(conn) }] } });
           return;
         }
 
-        const execResult = await sshManager.execCommand(connResult.sessionId, toolArgs.command);
-        sshManager.disconnect(connResult.sessionId);
+        let result;
+        if (toolArgs.commands) {
+          result = await sshManager.execCommands(conn.sessionId, toolArgs.commands);
+        } else if (toolArgs.command) {
+          result = await sshManager.execCommand(conn.sessionId, toolArgs.command);
+        }
 
-        send({
-          jsonrpc: '2.0',
-          id,
-          result: {
-            content: [
-              {
-                type: 'text',
-                text: JSON.stringify(execResult),
-              },
-            ],
-          },
-        });
+        sshManager.disconnect(conn.sessionId);
+        send({ jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: JSON.stringify(result) }] } });
         return;
       }
 
-      // 既没有 session_id 也没有认证参数
-      send({
-        jsonrpc: '2.0',
-        id,
-        result: {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify({ success: false, error: 'Either session_id or host/username is required' }),
-            },
-          ],
-        },
-      });
-      return;
+      if (hasSession) {
+        let result;
+        if (toolArgs.commands) {
+          result = await sshManager.execCommands(toolArgs.session_id, toolArgs.commands);
+        } else if (toolArgs.command) {
+          result = await sshManager.execCommand(toolArgs.session_id, toolArgs.command);
+        }
+        send({ jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: JSON.stringify(result) }] } });
+        return;
+      }
     }
 
     if (name === 'ssh_disconnect') {
       const result = sshManager.disconnect(toolArgs.session_id);
+      send({ jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: JSON.stringify(result) }] } });
+      return;
+    }
+
+    if (name === 'ssh_test') {
+      const conn = await sshManager.connect({
+        host: toolArgs.host,
+        port: toolArgs.port,
+        username: toolArgs.username,
+        password: toolArgs.password,
+        privateKeyPath: toolArgs.private_key_path,
+        passphrase: toolArgs.passphrase,
+        timeout: toolArgs.timeout,
+      });
+
+      if (!conn.success) {
+        send({ jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: JSON.stringify(conn) }] } });
+        return;
+      }
+
+      const execResult = await sshManager.execCommand(conn.sessionId, toolArgs.test_command || 'echo test');
+      sshManager.disconnect(conn.sessionId);
+
       send({
         jsonrpc: '2.0',
         id,
         result: {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(result),
-            },
-          ],
+          content: [{
+            type: 'text',
+            text: JSON.stringify({
+              connection: conn,
+              test: execResult,
+            }),
+          }],
         },
       });
       return;
@@ -555,42 +226,32 @@ function handleRequest(request) {
 
     if (name === 'ssh_list_sessions') {
       const result = sshManager.listSessions();
-      send({
-        jsonrpc: '2.0',
-        id,
-        result: {
-          content: [
-            {
-              type: 'text',
-              text: JSON.stringify(result),
-            },
-          ],
-        },
-      });
+      send({ jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: JSON.stringify(result) }] } });
       return;
     }
 
-    send({
-      jsonrpc: '2.0',
-      id,
-      result: {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify({ success: false, error: `Unknown tool: ${name}` }),
-          },
-        ],
-      },
-    });
+    send({ jsonrpc: '2.0', id, result: { content: [{ type: 'text', text: JSON.stringify({ success: false, error: `Unknown tool: ${name}` }) }] } });
     return;
   }
 
-  send({
-    jsonrpc: '2.0',
-    id,
-    error: {
-      code: -32601,
-      message: 'Method not found',
-    },
-  });
+  send({ jsonrpc: '2.0', id, error: { code: -32601, message: 'Method not found' } });
 }
+
+let buffer = '';
+process.stdin.setEncoding('utf8');
+
+process.stdin.on('data', async (chunk) => {
+  buffer += chunk;
+  let newlineIndex;
+  while ((newlineIndex = buffer.indexOf('\n')) !== -1) {
+    const line = buffer.slice(0, newlineIndex);
+    buffer = buffer.slice(newlineIndex + 1);
+    if (line.trim()) {
+      try {
+        await handleRequest(JSON.parse(line));
+      } catch (err) {
+        console.error('Parse error:', err.message);
+      }
+    }
+  }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-ssh-server-tool",
-  "version": "1.0.6",
+  "version": "2.0.0",
   "description": "MCP Server for SSH connections and remote command execution",
   "main": "index.js",
   "type": "module",
@@ -16,8 +16,7 @@
     "url": ""
   },
   "dependencies": {
-    "ssh2": "^1.15.0",
-    "uuid": "^9.0.0"
+    "ssh2": "^1.15.0"
   },
   "engines": {
     "node": ">=18.0.0"

package/ssh_manager.js

@@ -1,86 +1,62 @@
 import { Client } from 'ssh2';
-import { v4 as uuidv4 } from 'uuid';
+import { randomUUID } from 'crypto';
 import * as fs from 'fs';
+import * as path from 'path';
 
 class SSHSession {
-  constructor(sessionId, client, host, username) {
+  constructor(sessionId, client, config) {
     this.sessionId = sessionId;
     this.client = client;
-    this.host = host;
-    this.username = username;
-    this.connected = true;
+    this.config = config;
+    this.createdAt = Date.now();
   }
 }
 
-export class SSHConnectionManager {
+class SSHConnectionManager {
   constructor() {
     this.sessions = new Map();
   }
 
-  connect(options) {
+  async connect(options) {
     return new Promise((resolve) => {
       const client = new Client();
-      const sessionId = uuidv4();
-      const port = options.port || 22;
-      const timeout = (options.timeout || 10) * 1000;
-
+      const sessionId = randomUUID();
       const config = {
         host: options.host,
-        port: port,
+        port: options.port || 22,
         username: options.username,
-        timeout: timeout,
-        readyTimeout: timeout,
+        password: options.password,
+        privateKey: options.privateKeyPath ? this._readPrivateKey(options.privateKeyPath) : undefined,
+        passphrase: options.passphrase,
+        readyTimeout: (options.timeout || 10) * 1000,
+        keepaliveInterval: 0,
       };
 
-      if (options.authType === 'password') {
-        if (!options.password) {
-          resolve({
-            success: false,
-            error: 'Password is required for password authentication',
-            errorType: 'MissingPassword',
-          });
-          return;
-        }
-        config.password = options.password;
-      } else if (options.authType === 'public_key') {
-        if (!options.privateKeyPath) {
-          resolve({
-            success: false,
-            error: 'Private key path is required for public key authentication',
-            errorType: 'MissingPrivateKey',
-          });
-          return;
-        }
-        try {
-          config.privateKey = fs.readFileSync(options.privateKeyPath);
-          if (options.passphrase) {
-            config.passphrase = options.passphrase;
-          }
-        } catch (err) {
-          resolve({
-            success: false,
-            error: `Failed to read private key: ${err.message}`,
-            errorType: 'PrivateKeyError',
-          });
-          return;
-        }
-      }
+      const timeout = setTimeout(() => {
+        client.end();
+        resolve({
+          success: false,
+          error: 'Connection timeout',
+          errorType: 'Timeout',
+        });
+      }, (options.timeout || 10) * 1000);
 
       client.on('ready', () => {
-        const session = new SSHSession(sessionId, client, options.host, options.username);
+        clearTimeout(timeout);
+        const session = new SSHSession(sessionId, client, { host: config.host, port: config.port, username: config.username });
         this.sessions.set(sessionId, session);
-
         resolve({
           success: true,
           sessionId,
-          host: options.host,
-          port,
-          username: options.username,
-          message: `Successfully connected to ${options.host}:${port}`,
+          host: config.host,
+          port: config.port,
+          username: config.username,
+          message: `Connected to ${config.host}:${config.port}`,
         });
       });
 
       client.on('error', (err) => {
+        clearTimeout(timeout);
         resolve({
           success: false,
           error: err.message,
@@ -92,9 +68,17 @@ export class SSHConnectionManager {
     });
   }
 
-  execCommand(sessionId, command) {
-    const session = this.sessions.get(sessionId);
+  _readPrivateKey(filePath) {
+    try {
+      const resolvedPath = path.resolve(filePath.replace(/^~/, process.env.HOME || process.env.USERPROFILE || ''));
+      return fs.readFileSync(resolvedPath);
+    } catch (err) {
+      throw new Error(`Failed to read private key: ${err.message}`);
+    }
+  }
 
+  async execCommand(sessionId, command) {
+    const session = this.sessions.get(sessionId);
     if (!session) {
       return {
         success: false,
@@ -103,14 +87,6 @@ export class SSHConnectionManager {
       };
     }
 
-    if (!session.connected) {
-      return {
-        success: false,
-        error: `Session ${sessionId} is not connected`,
-        errorType: 'SessionNotConnected',
-      };
-    }
-
     return new Promise((resolve) => {
       session.client.exec(command, (err, stream) => {
         if (err) {
@@ -137,20 +113,24 @@ export class SSHConnectionManager {
           });
         });
 
-        stream.on('data', (data) => {
-          stdout += data.toString();
-        });
-
-        stream.stderr.on('data', (data) => {
-          stderr += data.toString();
-        });
+        stream.on('data', (data) => { stdout += data.toString(); });
+        stream.stderr.on('data', (data) => { stderr += data.toString(); });
       });
     });
   }
 
+  async execCommands(sessionId, commands) {
+    const results = [];
+    for (const cmd of commands) {
+      const result = await this.execCommand(sessionId, cmd);
+      results.push(result);
+      if (!result.success) break;
+    }
+    return results;
+  }
+
   disconnect(sessionId) {
     const session = this.sessions.get(sessionId);
-
     if (!session) {
       return {
         success: false,
@@ -161,39 +141,22 @@ export class SSHConnectionManager {
 
     try {
       session.client.end();
-      session.connected = false;
       this.sessions.delete(sessionId);
-
-      return {
-        success: true,
-        sessionId,
-        message: 'Disconnected successfully',
-      };
+      return { success: true, sessionId, message: 'Disconnected' };
     } catch (err) {
-      return {
-        success: false,
-        error: err.message,
-        errorType: 'DisconnectError',
-      };
+      return { success: false, error: err.message, errorType: 'DisconnectError' };
     }
   }
 
   listSessions() {
-    const sessions = [];
-
-    this.sessions.forEach((session) => {
-      sessions.push({
-        sessionId: session.sessionId,
-        host: session.host,
-        username: session.username,
-        connected: session.connected,
-      });
-    });
-
-    return {
-      success: true,
-      sessions,
-      count: sessions.length,
-    };
+    const sessions = Array.from(this.sessions.values()).map(s => ({
+      sessionId: s.sessionId,
+      host: s.config.host,
+      username: s.config.username,
+      createdAt: s.createdAt,
+    }));
+    return { success: true, sessions, count: sessions.length };
   }
 }
+
+export { SSHConnectionManager };