@prmichaelsen/acp-mcp 0.6.0 → 0.7.1

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

@@ -4,7 +4,7 @@ import { logger } from '../utils/logger.js';
 
 export const acpRemoteExecuteCommandTool: Tool = {
   name: 'acp_remote_execute_command',
-  description: 'Execute a shell command on the remote machine via SSH',
+  description: 'Execute a shell command on the remote machine via SSH. Supports real-time progress streaming if client provides progressToken.',
   inputSchema: {
     type: 'object',
     properties: {
@@ -18,7 +18,7 @@ export const acpRemoteExecuteCommandTool: Tool = {
       },
       timeout: {
         type: 'number',
-        description: 'Timeout in seconds (default: 30)',
+        description: 'Timeout in seconds (default: 30). Ignored if progress streaming is used.',
         default: 30,
       },
     },
@@ -37,27 +37,38 @@ interface ExecuteCommandResult {
   stderr: string;
   exitCode: number;
   timedOut: boolean;
+  streamed?: boolean;
 }
 
 /**
  * Handle the acp_remote_execute_command tool invocation
  * Executes a shell command on the remote machine via SSH
+ * Supports progress streaming when progressToken is provided
  * 
  * @param args - Tool arguments containing command, cwd, and timeout
  * @param sshConnection - SSH connection manager for remote operations
+ * @param extra - Optional extra parameters including progressToken
+ * @param server - Server instance for sending progress notifications (optional)
  */
 export async function handleAcpRemoteExecuteCommand(
   args: any,
-  sshConnection: SSHConnectionManager
+  sshConnection: SSHConnectionManager,
+  extra?: any,
+  server?: any
 ): Promise<{ content: Array<{ type: string; text: string }> }> {
   const { command, cwd, timeout = 30 } = args as ExecuteCommandArgs;
+  const progressToken = extra?._meta?.progressToken;
 
-  logger.debug('Executing remote command', { command, cwd, timeout });
+  logger.debug('Executing remote command', { command, cwd, timeout, hasProgressToken: !!progressToken });
 
   try {
-    // Build command with working directory if specified
-    const fullCommand = cwd ? `cd ${cwd} && ${command}` : command;
+    // If progress token provided and server available, use streaming
+    if (progressToken && server) {
+      return await executeWithProgress(command, cwd, sshConnection, progressToken, server);
+    }
     
+    // Otherwise, use existing timeout-based execution (fallback)
+    const fullCommand = cwd ? `cd ${cwd} && ${command}` : command;
     const result = await sshConnection.execWithTimeout(fullCommand, timeout);
     
     logger.debug('Command execution result', {
@@ -67,7 +78,6 @@ export async function handleAcpRemoteExecuteCommand(
       stderrLength: result.stderr.length,
     });
     
-    // Format output as JSON for structured response
     const output: ExecuteCommandResult = {
       stdout: result.stdout,
       stderr: result.stderr,
@@ -101,3 +111,102 @@ export async function handleAcpRemoteExecuteCommand(
     };
   }
 }
+
+/**
+ * Execute command with progress streaming
+ * Sends real-time progress notifications as output is received
+ * 
+ * @param command - Command to execute
+ * @param cwd - Working directory
+ * @param sshConnection - SSH connection
+ * @param progressToken - Token for progress notifications
+ * @param server - Server instance for sending notifications
+ */
+async function executeWithProgress(
+  command: string,
+  cwd: string | undefined,
+  sshConnection: SSHConnectionManager,
+  progressToken: string | number,
+  server: any
+): Promise<{ content: Array<{ type: string; text: string }> }> {
+  logger.debug('Starting streaming execution', { command, cwd, progressToken });
+  
+  const { stream, stderr: stderrStream, exitCode } = await sshConnection.execStream(command, cwd);
+  
+  let stdout = '';
+  let stderr = '';
+  let bytesReceived = 0;
+  let lastProgressTime = 0;
+  const MIN_PROGRESS_INTERVAL = 100; // 100ms rate limiting
+
+  // Stream stdout with progress notifications
+  stream.on('data', (chunk: Buffer) => {
+    const text = chunk.toString();
+    stdout += text;
+    bytesReceived += chunk.length;
+    
+    // Rate limiting: only send progress if enough time elapsed
+    const now = Date.now();
+    if (now - lastProgressTime >= MIN_PROGRESS_INTERVAL) {
+      try {
+        server.notification({
+          method: 'notifications/progress',
+          params: {
+            progressToken,
+            progress: bytesReceived,
+            total: undefined, // Unknown total for streaming
+            message: text,
+          },
+        });
+        lastProgressTime = now;
+        logger.debug('Progress notification sent', { 
+          progressToken, 
+          bytes: bytesReceived,
+          chunkSize: chunk.length 
+        });
+      } catch (error) {
+        logger.warn('Failed to send progress notification', {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  });
+
+  // Collect stderr (no progress for errors)
+  stderrStream.on('data', (chunk: Buffer) => {
+    stderr += chunk.toString();
+  });
+
+  // Handle stream errors
+  stream.on('error', (error: Error) => {
+    logger.error('Stream error during execution', {
+      command,
+      error: error.message
+    });
+  });
+
+  // Wait for completion
+  const finalExitCode = await exitCode;
+  
+  logger.debug('Streaming execution completed', { 
+    command, 
+    exitCode: finalExitCode,
+    stdoutBytes: stdout.length,
+    stderrBytes: stderr.length,
+  });
+
+  const output: ExecuteCommandResult = {
+    stdout,
+    stderr,
+    exitCode: finalExitCode,
+    timedOut: false,
+    streamed: true, // Indicate this was streamed
+  };
+
+  return {
+    content: [{
+      type: 'text',
+      text: JSON.stringify(output, null, 2),
+    }],
+  };
+}

package/src/utils/ssh-connection.ts

@@ -106,10 +106,12 @@ export class SSHConnectionManager {
     }
 
     const startTime = Date.now();
-    logger.sshCommand(command, undefined, timeoutSeconds);
+    // Wrap command to source shell config for proper PATH and environment
+    const wrappedCommand = this.wrapCommandWithShellInit(command);
+    logger.sshCommand(wrappedCommand, undefined, timeoutSeconds);
 
     const execPromise = new Promise<{ stdout: string; stderr: string; exitCode: number }>((resolve, reject) => {
-      this.client.exec(command, (err, stream) => {
+      this.client.exec(wrappedCommand, (err, stream) => {
         if (err) {
           reject(err);
           return;
@@ -160,6 +162,74 @@ export class SSHConnectionManager {
     }
   }
 
+  /**
+   * Execute a command on the remote server with streaming output
+   * Returns streams instead of buffered output for real-time progress
+   *
+   * @param command - Shell command to execute
+   * @param cwd - Optional working directory
+   * @returns Object with stdout stream, stderr stream, and exit code promise
+   */
+  async execStream(
+    command: string,
+    cwd?: string
+  ): Promise<{
+    stream: NodeJS.ReadableStream;
+    stderr: NodeJS.ReadableStream;
+    exitCode: Promise<number>;
+  }> {
+    if (!this.connected) {
+      await this.connect();
+    }
+
+    const fullCommand = cwd ? `cd "${cwd}" && ${command}` : command;
+    // Wrap command to source shell config for proper PATH and environment
+    const wrappedCommand = this.wrapCommandWithShellInit(fullCommand);
+    const startTime = Date.now();
+    logger.sshCommand(wrappedCommand, cwd);
+
+    return new Promise((resolve, reject) => {
+      this.client.exec(wrappedCommand, (err, stream) => {
+        if (err) {
+          logger.error('SSH exec failed', {
+            command: fullCommand,
+            error: err.message
+          });
+          reject(err);
+          return;
+        }
+
+        logger.debug('SSH stream started', { command: fullCommand });
+
+        const exitCodePromise = new Promise<number>((resolveExit) => {
+          stream.on('close', (code: number) => {
+            const duration = Date.now() - startTime;
+            logger.debug('SSH stream closed', {
+              command: fullCommand,
+              exitCode: code,
+              duration: `${duration}ms`
+            });
+            resolveExit(code);
+          });
+        });
+
+        // Handle stream errors
+        stream.on('error', (error: Error) => {
+          logger.error('SSH stream error', {
+            command: fullCommand,
+            error: error.message
+          });
+        });
+
+        resolve({
+          stream: stream,
+          stderr: stream.stderr,
+          exitCode: exitCodePromise,
+        });
+      });
+    });
+  }
+
   /**
    * Get SFTP wrapper for file operations
    */
@@ -462,6 +532,20 @@ export class SSHConnectionManager {
     });
   }
 
+  /**
+   * Wrap command to source shell configuration files
+   * This ensures PATH and other environment variables are properly set
+   * SSH non-interactive shells don't source ~/.bashrc or ~/.zshrc by default
+   *
+   * @param command - The command to wrap
+   * @returns Wrapped command that sources shell config first
+   */
+  private wrapCommandWithShellInit(command: string): string {
+    // Try to source common shell config files
+    // Use || true to ignore errors if files don't exist
+    return `(source ~/.zshrc 2>/dev/null || source ~/.bashrc 2>/dev/null || source ~/.profile 2>/dev/null || true) && ${command}`;
+  }
+
   /**
    * Disconnect from the SSH server
    */