@prmichaelsen/acp-mcp 0.4.0 → 0.5.0

package/dist/utils/logger.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Logger utility for ACP MCP Server
+ * Provides structured logging with configurable log levels
+ */
+export type LogLevel = 'error' | 'warn' | 'info' | 'debug' | 'trace';
+declare class Logger {
+    private level;
+    private enabled;
+    constructor();
+    private shouldLog;
+    private formatMessage;
+    error(message: string, data?: any): void;
+    warn(message: string, data?: any): void;
+    info(message: string, data?: any): void;
+    debug(message: string, data?: any): void;
+    trace(message: string, data?: any): void;
+    /**
+     * Log tool invocation with parameters
+     */
+    toolInvoked(toolName: string, params: any, userId?: string): void;
+    /**
+     * Log tool completion with result summary
+     */
+    toolCompleted(toolName: string, duration: number, resultSize?: number): void;
+    /**
+     * Log tool failure with error details
+     */
+    toolFailed(toolName: string, error: Error, params?: any): void;
+    /**
+     * Log SSH command execution
+     */
+    sshCommand(command: string, cwd?: string, timeout?: number): void;
+    /**
+     * Log SSH command result
+     */
+    sshCommandResult(exitCode: number, duration: number, stdoutSize: number, stderrSize: number): void;
+    /**
+     * Log file operation
+     */
+    fileOperation(operation: string, path: string, details?: any): void;
+}
+export declare const logger: Logger;
+export {};

package/esbuild.build.js

@@ -7,7 +7,7 @@ const sharedConfig = {
   target: 'node18',
   format: 'esm',
   sourcemap: true,
-  external: ['@modelcontextprotocol/sdk'],
+  external: ['@modelcontextprotocol/sdk', 'ssh2'],
 };
 
 // Build standalone server

package/esbuild.watch.js

@@ -6,7 +6,7 @@ const sharedConfig = {
   target: 'node18',
   format: 'esm',
   sourcemap: true,
-  external: ['@modelcontextprotocol/sdk'],
+  external: ['@modelcontextprotocol/sdk', 'ssh2'],
 };
 
 // Watch standalone server

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prmichaelsen/acp-mcp",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "MCP server for a remote machine MCP server that will be wrapped by /home/prmichaelsen/mcp-auth",
   "type": "module",
   "main": "dist/server.js",

package/src/server-factory.ts

@@ -10,6 +10,7 @@ import { acpRemoteReadFileTool, handleAcpRemoteReadFile } from './tools/acp-remo
 import { acpRemoteWriteFileTool, handleAcpRemoteWriteFile } from './tools/acp-remote-write-file.js';
 import { ServerConfig } from './types/ssh-config.js';
 import { SSHConnectionManager } from './utils/ssh-connection.js';
+import { logger } from './utils/logger.js';
 
 /**
  * Create an MCP server instance for a specific user with SSH configuration
@@ -19,11 +20,20 @@ import { SSHConnectionManager } from './utils/ssh-connection.js';
  * @returns Configured MCP Server instance
  */
 export async function createServer(serverConfig: ServerConfig): Promise<Server> {
+  logger.info('Creating server instance', { userId: serverConfig.userId });
+  logger.debug('SSH configuration', {
+    host: serverConfig.ssh.host,
+    port: serverConfig.ssh.port,
+    username: serverConfig.ssh.username,
+  });
+  
   // Create SSH connection manager
   const sshConnection = new SSHConnectionManager(serverConfig.ssh);
   
   // Connect to remote server
   await sshConnection.connect();
+  
+  logger.info('Server created successfully', { userId: serverConfig.userId });
 
   const server = new Server(
     {
@@ -38,34 +48,53 @@ export async function createServer(serverConfig: ServerConfig): Promise<Server>
   );
 
   // Register tools with SSH connection context
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: [acpRemoteListFilesTool, acpRemoteExecuteCommandTool, acpRemoteReadFileTool, acpRemoteWriteFileTool],
-  }));
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    logger.debug('Tool discovery requested', { userId: serverConfig.userId });
+    const tools = [acpRemoteListFilesTool, acpRemoteExecuteCommandTool, acpRemoteReadFileTool, acpRemoteWriteFileTool];
+    logger.debug(`Returning ${tools.length} tools`, { tools: tools.map(t => t.name), userId: serverConfig.userId });
+    return { tools };
+  });
 
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    if (request.params.name === 'acp_remote_list_files') {
-      // Pass SSH connection to handler for remote operations
-      return await handleAcpRemoteListFiles(request.params.arguments, sshConnection);
-    }
-    if (request.params.name === 'acp_remote_execute_command') {
-      return await handleAcpRemoteExecuteCommand(request.params.arguments, sshConnection);
-    }
-    if (request.params.name === 'acp_remote_read_file') {
-      return await handleAcpRemoteReadFile(request.params.arguments, sshConnection);
-    }
-    if (request.params.name === 'acp_remote_write_file') {
-      return await handleAcpRemoteWriteFile(request.params.arguments, sshConnection);
+    const startTime = Date.now();
+    logger.toolInvoked(request.params.name, request.params.arguments, serverConfig.userId);
+    
+    try {
+      let result;
+      
+      if (request.params.name === 'acp_remote_list_files') {
+        // Pass SSH connection to handler for remote operations
+        result = await handleAcpRemoteListFiles(request.params.arguments, sshConnection);
+      } else if (request.params.name === 'acp_remote_execute_command') {
+        result = await handleAcpRemoteExecuteCommand(request.params.arguments, sshConnection);
+      } else if (request.params.name === 'acp_remote_read_file') {
+        result = await handleAcpRemoteReadFile(request.params.arguments, sshConnection);
+      } else if (request.params.name === 'acp_remote_write_file') {
+        result = await handleAcpRemoteWriteFile(request.params.arguments, sshConnection);
+      } else {
+        throw new Error(`Unknown tool: ${request.params.name}`);
+      }
+      
+      const duration = Date.now() - startTime;
+      const resultSize = JSON.stringify(result).length;
+      logger.toolCompleted(request.params.name, duration, resultSize);
+      
+      return result;
+    } catch (error) {
+      logger.toolFailed(request.params.name, error as Error, request.params.arguments);
+      throw error;
     }
-    throw new Error(`Unknown tool: ${request.params.name}`);
   });
 
   // Handle server shutdown to cleanup SSH connection
   process.on('SIGINT', () => {
+    logger.info('Received SIGINT, shutting down', { userId: serverConfig.userId });
     sshConnection.disconnect();
     process.exit(0);
   });
 
   process.on('SIGTERM', () => {
+    logger.info('Received SIGTERM, shutting down', { userId: serverConfig.userId });
     sshConnection.disconnect();
     process.exit(0);
   });

package/src/server.ts

@@ -12,6 +12,7 @@ import { acpRemoteExecuteCommandTool, handleAcpRemoteExecuteCommand } from './to
 import { acpRemoteReadFileTool, handleAcpRemoteReadFile } from './tools/acp-remote-read-file.js';
 import { acpRemoteWriteFileTool, handleAcpRemoteWriteFile } from './tools/acp-remote-write-file.js';
 import { SSHConnectionManager } from './utils/ssh-connection.js';
+import { logger } from './utils/logger.js';
 
 async function main() {
   // Load SSH private key
@@ -42,29 +43,46 @@ async function main() {
   );
 
   // Register tools
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: [acpRemoteListFilesTool, acpRemoteExecuteCommandTool, acpRemoteReadFileTool, acpRemoteWriteFileTool],
-  }));
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    logger.debug('Tool discovery requested');
+    const tools = [acpRemoteListFilesTool, acpRemoteExecuteCommandTool, acpRemoteReadFileTool, acpRemoteWriteFileTool];
+    logger.debug(`Returning ${tools.length} tools`, { tools: tools.map(t => t.name) });
+    return { tools };
+  });
 
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    if (request.params.name === 'acp_remote_list_files') {
-      return await handleAcpRemoteListFiles(request.params.arguments, sshConnection);
-    }
-    if (request.params.name === 'acp_remote_execute_command') {
-      return await handleAcpRemoteExecuteCommand(request.params.arguments, sshConnection);
-    }
-    if (request.params.name === 'acp_remote_read_file') {
-      return await handleAcpRemoteReadFile(request.params.arguments, sshConnection);
-    }
-    if (request.params.name === 'acp_remote_write_file') {
-      return await handleAcpRemoteWriteFile(request.params.arguments, sshConnection);
+    const startTime = Date.now();
+    logger.toolInvoked(request.params.name, request.params.arguments);
+    
+    try {
+      let result;
+      
+      if (request.params.name === 'acp_remote_list_files') {
+        result = await handleAcpRemoteListFiles(request.params.arguments, sshConnection);
+      } else if (request.params.name === 'acp_remote_execute_command') {
+        result = await handleAcpRemoteExecuteCommand(request.params.arguments, sshConnection);
+      } else if (request.params.name === 'acp_remote_read_file') {
+        result = await handleAcpRemoteReadFile(request.params.arguments, sshConnection);
+      } else if (request.params.name === 'acp_remote_write_file') {
+        result = await handleAcpRemoteWriteFile(request.params.arguments, sshConnection);
+      } else {
+        throw new Error(`Unknown tool: ${request.params.name}`);
+      }
+      
+      const duration = Date.now() - startTime;
+      const resultSize = JSON.stringify(result).length;
+      logger.toolCompleted(request.params.name, duration, resultSize);
+      
+      return result;
+    } catch (error) {
+      logger.toolFailed(request.params.name, error as Error, request.params.arguments);
+      throw error;
     }
-    throw new Error(`Unknown tool: ${request.params.name}`);
   });
 
   // Handle shutdown to cleanup SSH connection
   const cleanup = () => {
-    console.error('Shutting down...');
+    logger.info('Shutting down server');
     sshConnection.disconnect();
     process.exit(0);
   };
@@ -75,10 +93,10 @@ async function main() {
   // Start server
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error('ACP MCP Server running on stdio');
+  logger.info('ACP MCP Server running on stdio');
 }
 
 main().catch((error) => {
-  console.error('Server error:', error);
+  logger.error('Server startup failed', { error: error.message, stack: error.stack });
   process.exit(1);
 });

package/src/tools/acp-remote-execute-command.ts

@@ -1,5 +1,6 @@
 import { Tool } from '@modelcontextprotocol/sdk/types.js';
 import { SSHConnectionManager } from '../utils/ssh-connection.js';
+import { logger } from '../utils/logger.js';
 
 export const acpRemoteExecuteCommandTool: Tool = {
   name: 'acp_remote_execute_command',
@@ -51,12 +52,21 @@ export async function handleAcpRemoteExecuteCommand(
 ): Promise<{ content: Array<{ type: string; text: string }> }> {
   const { command, cwd, timeout = 30 } = args as ExecuteCommandArgs;
 
+  logger.debug('Executing remote command', { command, cwd, timeout });
+
   try {
     // Build command with working directory if specified
     const fullCommand = cwd ? `cd ${cwd} && ${command}` : command;
     
     const result = await sshConnection.execWithTimeout(fullCommand, timeout);
     
+    logger.debug('Command execution result', {
+      exitCode: result.exitCode,
+      timedOut: result.timedOut,
+      stdoutLength: result.stdout.length,
+      stderrLength: result.stderr.length,
+    });
+    
     // Format output as JSON for structured response
     const output: ExecuteCommandResult = {
       stdout: result.stdout,
@@ -75,6 +85,7 @@ export async function handleAcpRemoteExecuteCommand(
     };
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.error('Command execution error', { command, error: errorMessage });
     return {
       content: [
         {

package/src/tools/acp-remote-list-files.ts

@@ -65,6 +65,7 @@ export async function handleAcpRemoteListFiles(
 
 /**
  * Recursively list files in a remote directory via SSH
+ * Returns absolute paths for compatibility with acp_remote_read_file
  */
 async function listRemoteFiles(
   ssh: SSHConnectionManager,
@@ -75,15 +76,17 @@ async function listRemoteFiles(
   const files: string[] = [];
 
   for (const entry of entries) {
+    // Construct absolute path by combining dirPath with entry name
+    const fullPath = `${dirPath}/${entry.name}`.replace(/\/+/g, '/');
+    
     if (entry.isDirectory) {
-      files.push(`${entry.name}/`);
+      files.push(`${fullPath}/`);  // Return absolute path with trailing slash
       if (recursive) {
-        const fullPath = `${dirPath}/${entry.name}`.replace(/\/+/g, '/');
         const subFiles = await listRemoteFiles(ssh, fullPath, recursive);
-        files.push(...subFiles.map(f => `${entry.name}/${f}`));
+        files.push(...subFiles);  // Sub-files already have absolute paths
       }
     } else {
-      files.push(entry.name);
+      files.push(fullPath);  // Return absolute path
     }
   }
 

package/src/tools/acp-remote-read-file.ts

@@ -1,5 +1,6 @@
 import { Tool } from '@modelcontextprotocol/sdk/types.js';
 import { SSHConnectionManager } from '../utils/ssh-connection.js';
+import { logger } from '../utils/logger.js';
 
 export const acpRemoteReadFileTool: Tool = {
   name: 'acp_remote_read_file',
@@ -52,9 +53,13 @@ export async function handleAcpRemoteReadFile(
 ): Promise<{ content: Array<{ type: string; text: string }> }> {
   const { path, encoding = 'utf-8', maxSize = 1048576 } = args as ReadFileArgs;
 
+  logger.debug('Reading remote file', { path, encoding, maxSize });
+
   try {
     const result = await sshConnection.readFile(path, encoding, maxSize);
     
+    logger.debug('File read successful', { path, size: result.size });
+    
     const output: ReadFileResult = {
       content: result.content,
       size: result.size,
@@ -71,6 +76,7 @@ export async function handleAcpRemoteReadFile(
     };
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.error('File read error', { path, error: errorMessage });
     return {
       content: [
         {

package/src/tools/acp-remote-write-file.ts

@@ -1,5 +1,6 @@
 import { Tool } from '@modelcontextprotocol/sdk/types.js';
 import { SSHConnectionManager } from '../utils/ssh-connection.js';
+import { logger } from '../utils/logger.js';
 
 export const acpRemoteWriteFileTool: Tool = {
   name: 'acp_remote_write_file',
@@ -62,6 +63,8 @@ export async function handleAcpRemoteWriteFile(
 ): Promise<{ content: Array<{ type: string; text: string }> }> {
   const { path, content, encoding = 'utf-8', createDirs = false, backup = false } = args as WriteFileArgs;
 
+  logger.debug('Writing remote file', { path, contentSize: content.length, encoding, createDirs, backup });
+
   try {
     const result = await sshConnection.writeFile(path, content, {
       encoding,
@@ -69,6 +72,8 @@ export async function handleAcpRemoteWriteFile(
       backup,
     });
     
+    logger.debug('File write successful', { path, bytesWritten: result.bytesWritten, backupPath: result.backupPath });
+    
     const output: WriteFileResult = {
       success: result.success,
       bytesWritten: result.bytesWritten,
@@ -85,6 +90,7 @@ export async function handleAcpRemoteWriteFile(
     };
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.error('File write error', { path, error: errorMessage });
     return {
       content: [
         {

package/src/utils/logger.ts

@@ -0,0 +1,131 @@
+/**
+ * Logger utility for ACP MCP Server
+ * Provides structured logging with configurable log levels
+ */
+
+export type LogLevel = 'error' | 'warn' | 'info' | 'debug' | 'trace';
+
+const LOG_LEVELS: Record<LogLevel, number> = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3,
+  trace: 4,
+};
+
+class Logger {
+  private level: LogLevel;
+  private enabled: boolean;
+
+  constructor() {
+    // Read configuration from environment variables
+    this.level = (process.env.ACP_MCP_LOG_LEVEL as LogLevel) || 'info';
+    this.enabled = process.env.ACP_MCP_DEBUG === 'true' || process.env.NODE_ENV === 'development';
+  }
+
+  private shouldLog(level: LogLevel): boolean {
+    if (!this.enabled && level !== 'error' && level !== 'warn') {
+      return false;
+    }
+    return LOG_LEVELS[level] <= LOG_LEVELS[this.level];
+  }
+
+  private formatMessage(level: LogLevel, message: string, data?: any): string {
+    const timestamp = new Date().toISOString();
+    const prefix = `[${timestamp}] [${level.toUpperCase()}]`;
+    
+    if (data !== undefined) {
+      const dataStr = typeof data === 'object' ? JSON.stringify(data, null, 2) : String(data);
+      return `${prefix} ${message}\n${dataStr}`;
+    }
+    
+    return `${prefix} ${message}`;
+  }
+
+  error(message: string, data?: any): void {
+    if (this.shouldLog('error')) {
+      console.error(this.formatMessage('error', message, data));
+    }
+  }
+
+  warn(message: string, data?: any): void {
+    if (this.shouldLog('warn')) {
+      console.error(this.formatMessage('warn', message, data));
+    }
+  }
+
+  info(message: string, data?: any): void {
+    if (this.shouldLog('info')) {
+      console.error(this.formatMessage('info', message, data));
+    }
+  }
+
+  debug(message: string, data?: any): void {
+    if (this.shouldLog('debug')) {
+      console.error(this.formatMessage('debug', message, data));
+    }
+  }
+
+  trace(message: string, data?: any): void {
+    if (this.shouldLog('trace')) {
+      console.error(this.formatMessage('trace', message, data));
+    }
+  }
+
+  /**
+   * Log tool invocation with parameters
+   */
+  toolInvoked(toolName: string, params: any, userId?: string): void {
+    this.info(`Tool invoked: ${toolName}`);
+    this.debug('Tool parameters', { tool: toolName, params, userId });
+  }
+
+  /**
+   * Log tool completion with result summary
+   */
+  toolCompleted(toolName: string, duration: number, resultSize?: number): void {
+    this.info(`Tool completed: ${toolName}`);
+    this.debug('Tool performance', { tool: toolName, duration: `${duration}ms`, resultSize });
+  }
+
+  /**
+   * Log tool failure with error details
+   */
+  toolFailed(toolName: string, error: Error, params?: any): void {
+    this.error(`Tool execution failed: ${toolName}`, {
+      tool: toolName,
+      error: error.message,
+      stack: error.stack,
+      params,
+    });
+  }
+
+  /**
+   * Log SSH command execution
+   */
+  sshCommand(command: string, cwd?: string, timeout?: number): void {
+    this.debug('Executing SSH command', { command, cwd, timeout });
+  }
+
+  /**
+   * Log SSH command result
+   */
+  sshCommandResult(exitCode: number, duration: number, stdoutSize: number, stderrSize: number): void {
+    this.debug('SSH command completed', {
+      exitCode,
+      duration: `${duration}ms`,
+      stdout: `${stdoutSize} bytes`,
+      stderr: `${stderrSize} bytes`,
+    });
+  }
+
+  /**
+   * Log file operation
+   */
+  fileOperation(operation: string, path: string, details?: any): void {
+    this.info(`File operation: ${operation}`, { path, ...details });
+  }
+}
+
+// Export singleton instance
+export const logger = new Logger();

package/src/utils/ssh-connection.ts

@@ -1,5 +1,6 @@
 import { Client, SFTPWrapper } from 'ssh2';
 import { SSHConfig } from '../types/ssh-config.js';
+import { logger } from './logger.js';
 
 /**
  * SSH Connection Manager
@@ -20,16 +21,31 @@ export class SSHConnectionManager {
    */
   async connect(): Promise<void> {
     if (this.connected) {
+      logger.debug('SSH connection already established');
       return;
     }
 
+    logger.info('Connecting to SSH server', {
+      host: this.config.host,
+      port: this.config.port || 22,
+      username: this.config.username,
+    });
+
     return new Promise((resolve, reject) => {
       this.client
         .on('ready', () => {
           this.connected = true;
+          logger.info('SSH connection established', {
+            host: this.config.host,
+            username: this.config.username,
+          });
           resolve();
         })
         .on('error', (err) => {
+          logger.error('SSH connection failed', {
+            host: this.config.host,
+            error: err.message,
+          });
           reject(err);
         })
         .connect({
@@ -88,6 +104,9 @@ export class SSHConnectionManager {
       await this.connect();
     }
 
+    const startTime = Date.now();
+    logger.sshCommand(command, undefined, timeoutSeconds);
+
     const execPromise = new Promise<{ stdout: string; stderr: string; exitCode: number }>((resolve, reject) => {
       this.client.exec(command, (err, stream) => {
         if (err) {
@@ -100,6 +119,8 @@ export class SSHConnectionManager {
 
         stream
           .on('close', (code: number) => {
+            const duration = Date.now() - startTime;
+            logger.sshCommandResult(code, duration, stdout.length, stderr.length);
             resolve({ stdout, stderr, exitCode: code });
           })
           .on('data', (data: Buffer) => {
@@ -122,6 +143,7 @@ export class SSHConnectionManager {
       return { ...result, timedOut: false };
     } catch (error) {
       if (error instanceof Error && error.message === 'Command execution timed out') {
+        logger.warn('SSH command timed out', { command, timeout: timeoutSeconds });
         return {
           stdout: '',
           stderr: 'Command execution timed out',
@@ -129,6 +151,10 @@ export class SSHConnectionManager {
           timedOut: true,
         };
       }
+      logger.error('SSH command execution failed', {
+        command,
+        error: error instanceof Error ? error.message : String(error),
+      });
       throw error;
     }
   }
@@ -183,17 +209,24 @@ export class SSHConnectionManager {
     encoding: string = 'utf-8',
     maxSize: number = 1048576
   ): Promise<{ content: string; size: number; encoding: string }> {
+    const startTime = Date.now();
+    logger.fileOperation('read', path, { encoding, maxSize });
+    
     const sftp = await this.getSFTP();
 
     return new Promise((resolve, reject) => {
       // First, get file stats to check size
       sftp.stat(path, (err, stats) => {
         if (err) {
+          logger.error('File stat failed', { path, error: err.message });
           reject(new Error(`File not found or inaccessible: ${path}`));
           return;
         }
 
+        logger.debug('File stat retrieved', { path, size: stats.size });
+
         if (stats.size > maxSize) {
+          logger.warn('File too large', { path, size: stats.size, maxSize });
           reject(new Error(`File too large: ${stats.size} bytes (max: ${maxSize} bytes)`));
           return;
         }
@@ -201,10 +234,14 @@ export class SSHConnectionManager {
         // Read file contents
         sftp.readFile(path, { encoding: encoding as BufferEncoding }, (err, data) => {
           if (err) {
+            logger.error('File read failed', { path, error: err.message });
             reject(new Error(`Failed to read file: ${err.message}`));
             return;
           }
 
+          const duration = Date.now() - startTime;
+          logger.debug('File read completed', { path, size: stats.size, duration: `${duration}ms` });
+
           resolve({
             content: data.toString(),
             size: stats.size,
@@ -228,6 +265,15 @@ export class SSHConnectionManager {
     } = {}
   ): Promise<{ success: boolean; bytesWritten: number; backupPath?: string }> {
     const { encoding = 'utf-8', createDirs = false, backup = false } = options;
+    const startTime = Date.now();
+    
+    logger.fileOperation('write', path, {
+      contentSize: content.length,
+      encoding,
+      createDirs,
+      backup,
+    });
+    
     const sftp = await this.getSFTP();
 
     return new Promise((resolve, reject) => {
@@ -264,10 +310,19 @@ export class SSHConnectionManager {
           // Rename temp file to target (atomic operation)
           sftp.rename(tempPath, path, (err) => {
             if (err) {
+              logger.error('File rename failed', { tempPath, path, error: err.message });
               reject(new Error(`Failed to rename temp file: ${err.message}`));
               return;
             }
 
+            const duration = Date.now() - startTime;
+            logger.debug('File write completed', {
+              path,
+              bytesWritten: buffer.length,
+              duration: `${duration}ms`,
+              backupPath,
+            });
+
             resolve({
               success: true,
               bytesWritten: buffer.length,
@@ -294,6 +349,10 @@ export class SSHConnectionManager {
    */
   disconnect(): void {
     if (this.connected) {
+      logger.info('Disconnecting from SSH server', {
+        host: this.config.host,
+        username: this.config.username,
+      });
       this.client.end();
       this.connected = false;
     }