@prmichaelsen/acp-mcp 0.7.0 → 1.0.0

package/src/utils/ssh-connection.ts

@@ -1,6 +1,5 @@
-import { Client, SFTPWrapper } from 'ssh2';
+import { Client } from 'ssh2';
 import { SSHConfig } from '../types/ssh-config.js';
-import { FileEntry, parsePermissions, getFileType } from '../types/file-entry.js';
 import { logger } from './logger.js';
 
 /**
@@ -106,10 +105,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;
@@ -181,11 +182,13 @@ export class SSHConnectionManager {
     }
 
     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(fullCommand, cwd);
+    logger.sshCommand(wrappedCommand, cwd);
 
     return new Promise((resolve, reject) => {
-      this.client.exec(fullCommand, (err, stream) => {
+      this.client.exec(wrappedCommand, (err, stream) => {
         if (err) {
           logger.error('SSH exec failed', {
             command: fullCommand,
@@ -227,305 +230,17 @@ export class SSHConnectionManager {
   }
 
   /**
-   * Get SFTP wrapper for file operations
-   */
-  async getSFTP(): Promise<SFTPWrapper> {
-    if (!this.connected) {
-      await this.connect();
-    }
-
-    return new Promise((resolve, reject) => {
-      this.client.sftp((err, sftp) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(sftp);
-        }
-      });
-    });
-  }
-
-  /**
-   * List files in a directory with comprehensive metadata
-   * Uses hybrid approach: shell ls for filenames (includes hidden), SFTP stat for metadata
+   * 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 path - Directory path to list
-   * @param includeHidden - Whether to include hidden files (default: true)
-   * @returns Array of FileEntry objects with complete metadata
+   * @param command - The command to wrap
+   * @returns Wrapped command that sources shell config first
    */
-  async listFiles(path: string, includeHidden: boolean = true): Promise<FileEntry[]> {
-    const startTime = Date.now();
-    logger.debug('Listing files', { path, includeHidden });
-
-    try {
-      // Step 1: Use shell command to get ALL filenames (including hidden)
-      const lsFlag = includeHidden ? '-A' : '';
-      const command = `ls ${lsFlag} -1 "${path}" 2>/dev/null`;
-      const result = await this.execWithTimeout(command, 10);
-
-      if (result.exitCode !== 0) {
-        throw new Error(`ls command failed: ${result.stderr}`);
-      }
-
-      const filenames = result.stdout
-        .split('\n')
-        .map(f => f.trim())
-        .filter(f => f !== '' && f !== '.' && f !== '..');
-
-      logger.debug('Filenames retrieved via shell', {
-        path,
-        count: filenames.length,
-        method: 'shell',
-      });
-
-      // Step 2: Get rich metadata for each file using SFTP stat()
-      const sftp = await this.getSFTP();
-      const entries: FileEntry[] = [];
-
-      for (const filename of filenames) {
-        const fullPath = `${path}/${filename}`.replace(/\/+/g, '/');
-
-        try {
-          const stats = await new Promise<any>((resolve, reject) => {
-            sftp.stat(fullPath, (err, stats) => {
-              if (err) reject(err);
-              else resolve(stats);
-            });
-          });
-
-          entries.push({
-            name: filename,
-            path: fullPath,
-            type: getFileType(stats),
-            size: stats.size,
-            permissions: parsePermissions(stats.mode),
-            owner: {
-              uid: stats.uid,
-              gid: stats.gid,
-            },
-            timestamps: {
-              accessed: new Date(stats.atime * 1000).toISOString(),
-              modified: new Date(stats.mtime * 1000).toISOString(),
-            },
-          });
-        } catch (error) {
-          // Skip files we can't stat (permissions, race conditions, etc.)
-          logger.warn('Failed to stat file, skipping', {
-            path: fullPath,
-            error: error instanceof Error ? error.message : String(error),
-          });
-        }
-      }
-
-      const duration = Date.now() - startTime;
-      logger.debug('Files listed successfully', {
-        path,
-        count: entries.length,
-        duration: `${duration}ms`,
-        method: 'hybrid',
-      });
-
-      return entries;
-    } catch (error) {
-      // Fallback to SFTP readdir if shell command fails
-      logger.warn('Shell ls command failed, falling back to SFTP readdir', {
-        path,
-        error: error instanceof Error ? error.message : String(error),
-      });
-
-      return this.listFilesViaSFTP(path, includeHidden);
-    }
-  }
-
-  /**
-   * Fallback method: List files using SFTP readdir (may miss hidden files)
-   * @private
-   */
-  private async listFilesViaSFTP(path: string, includeHidden: boolean): Promise<FileEntry[]> {
-    const sftp = await this.getSFTP();
-
-    return new Promise((resolve, reject) => {
-      sftp.readdir(path, (err, list) => {
-        if (err) {
-          logger.error('SFTP readdir failed', { path, error: err.message });
-          reject(err);
-          return;
-        }
-
-        let entries = list.map((item) => ({
-          name: item.filename,
-          path: `${path}/${item.filename}`.replace(/\/+/g, '/'),
-          type: getFileType(item.attrs),
-          size: item.attrs.size,
-          permissions: parsePermissions(item.attrs.mode),
-          owner: {
-            uid: item.attrs.uid,
-            gid: item.attrs.gid,
-          },
-          timestamps: {
-            accessed: new Date(item.attrs.atime * 1000).toISOString(),
-            modified: new Date(item.attrs.mtime * 1000).toISOString(),
-          },
-        }));
-
-        // SFTP readdir doesn't return hidden files, so filter if requested
-        if (!includeHidden) {
-          entries = entries.filter(e => !e.name.startsWith('.'));
-        }
-
-        logger.debug('Files listed via SFTP fallback', {
-          path,
-          count: entries.length,
-          method: 'sftp',
-          note: 'Hidden files may be missing (SFTP limitation)',
-        });
-
-        resolve(entries);
-      });
-    });
-  }
-
-  /**
-   * Read file contents from remote machine
-   */
-  async readFile(
-    path: string,
-    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;
-        }
-
-        // 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,
-            encoding,
-          });
-        });
-      });
-    });
-  }
-
-  /**
-   * Write file contents to remote machine
-   */
-  async writeFile(
-    path: string,
-    content: string,
-    options: {
-      encoding?: string;
-      createDirs?: boolean;
-      backup?: boolean;
-    } = {}
-  ): 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) => {
-      const writeOperation = () => {
-        // Create backup if requested
-        if (backup) {
-          const backupPath = `${path}.backup`;
-          sftp.rename(path, backupPath, (err) => {
-            if (err && err.message !== 'No such file') {
-              // Ignore "no such file" error (file doesn't exist yet)
-              reject(new Error(`Failed to create backup: ${err.message}`));
-              return;
-            }
-            
-            // Write file
-            performWrite(backupPath);
-          });
-        } else {
-          performWrite();
-        }
-      };
-
-      const performWrite = (backupPath?: string) => {
-        const buffer = Buffer.from(content, encoding as BufferEncoding);
-        const tempPath = `${path}.tmp`;
-
-        // Write to temp file first (atomic write)
-        sftp.writeFile(tempPath, buffer, (err) => {
-          if (err) {
-            reject(new Error(`Failed to write file: ${err.message}`));
-            return;
-          }
-
-          // 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,
-              backupPath,
-            });
-          });
-        });
-      };
-
-      // Create parent directories if requested
-      if (createDirs) {
-        const dirPath = path.substring(0, path.lastIndexOf('/'));
-        this.exec(`mkdir -p ${dirPath}`).then(() => {
-          writeOperation();
-        }).catch(reject);
-      } else {
-        writeOperation();
-      }
-    });
+  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}`;
   }
 
   /**

package/dist/tools/acp-remote-list-files.d.ts

@@ -1,16 +0,0 @@
-import { Tool } from '@modelcontextprotocol/sdk/types.js';
-import { SSHConnectionManager } from '../utils/ssh-connection.js';
-export declare const acpRemoteListFilesTool: Tool;
-/**
- * Handle the acp_remote_list_files tool invocation
- * Lists files and directories at the specified path on the remote machine via SSH
- *
- * @param args - Tool arguments containing path and recursive flag
- * @param sshConnection - SSH connection manager for remote operations
- */
-export declare function handleAcpRemoteListFiles(args: any, sshConnection: SSHConnectionManager): Promise<{
-    content: Array<{
-        type: string;
-        text: string;
-    }>;
-}>;

package/dist/tools/acp-remote-read-file.d.ts

@@ -1,16 +0,0 @@
-import { Tool } from '@modelcontextprotocol/sdk/types.js';
-import { SSHConnectionManager } from '../utils/ssh-connection.js';
-export declare const acpRemoteReadFileTool: Tool;
-/**
- * Handle the acp_remote_read_file tool invocation
- * Reads file contents from the remote machine via SSH
- *
- * @param args - Tool arguments containing path, encoding, and maxSize
- * @param sshConnection - SSH connection manager for remote operations
- */
-export declare function handleAcpRemoteReadFile(args: any, sshConnection: SSHConnectionManager): Promise<{
-    content: Array<{
-        type: string;
-        text: string;
-    }>;
-}>;

package/dist/tools/acp-remote-write-file.d.ts

@@ -1,16 +0,0 @@
-import { Tool } from '@modelcontextprotocol/sdk/types.js';
-import { SSHConnectionManager } from '../utils/ssh-connection.js';
-export declare const acpRemoteWriteFileTool: Tool;
-/**
- * Handle the acp_remote_write_file tool invocation
- * Writes file contents to the remote machine via SSH
- *
- * @param args - Tool arguments containing path, content, and options
- * @param sshConnection - SSH connection manager for remote operations
- */
-export declare function handleAcpRemoteWriteFile(args: any, sshConnection: SSHConnectionManager): Promise<{
-    content: Array<{
-        type: string;
-        text: string;
-    }>;
-}>;

package/dist/types/file-entry.d.ts

@@ -1,88 +0,0 @@
-/**
- * Comprehensive file entry with metadata
- */
-export interface FileEntry {
-    /** Filename (without path) */
-    name: string;
-    /** Absolute path to file */
-    path: string;
-    /** File type */
-    type: 'file' | 'directory' | 'symlink' | 'other';
-    /** File size in bytes */
-    size: number;
-    /** File permissions */
-    permissions: {
-        /** Octal mode (e.g., 0o644) */
-        mode: number;
-        /** Human-readable string (e.g., "rw-r--r--") */
-        string: string;
-        /** Owner permissions */
-        owner: {
-            read: boolean;
-            write: boolean;
-            execute: boolean;
-        };
-        /** Group permissions */
-        group: {
-            read: boolean;
-            write: boolean;
-            execute: boolean;
-        };
-        /** Others permissions */
-        others: {
-            read: boolean;
-            write: boolean;
-            execute: boolean;
-        };
-    };
-    /** File ownership */
-    owner: {
-        /** User ID */
-        uid: number;
-        /** Group ID */
-        gid: number;
-    };
-    /** File timestamps */
-    timestamps: {
-        /** Last access time (ISO 8601) */
-        accessed: string;
-        /** Last modification time (ISO 8601) */
-        modified: string;
-    };
-}
-/**
- * Convert Unix mode to human-readable permission string
- * @param mode - Unix file mode (e.g., 33188 for -rw-r--r--)
- * @returns Permission string (e.g., "rw-r--r--")
- */
-export declare function modeToPermissionString(mode: number): string;
-/**
- * Parse Unix mode into structured permissions object
- * @param mode - Unix file mode
- * @returns Structured permissions object
- */
-export declare function parsePermissions(mode: number): {
-    mode: number;
-    string: string;
-    owner: {
-        read: boolean;
-        write: boolean;
-        execute: boolean;
-    };
-    group: {
-        read: boolean;
-        write: boolean;
-        execute: boolean;
-    };
-    others: {
-        read: boolean;
-        write: boolean;
-        execute: boolean;
-    };
-};
-/**
- * Determine file type from SFTP stats
- * @param stats - SFTP file stats
- * @returns File type string
- */
-export declare function getFileType(stats: any): 'file' | 'directory' | 'symlink' | 'other';

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

@@ -1,100 +0,0 @@
-import { Tool } from '@modelcontextprotocol/sdk/types.js';
-import { SSHConnectionManager } from '../utils/ssh-connection.js';
-import { FileEntry } from '../types/file-entry.js';
-
-export const acpRemoteListFilesTool: Tool = {
-  name: 'acp_remote_list_files',
-  description: 'List files and directories in a specified path on the remote machine via SSH. Returns comprehensive metadata including permissions, timestamps, size, and ownership. Includes hidden files by default.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      path: {
-        type: 'string',
-        description: 'The directory path to list files from',
-      },
-      recursive: {
-        type: 'boolean',
-        description: 'Whether to list files recursively',
-        default: false,
-      },
-      includeHidden: {
-        type: 'boolean',
-        description: 'Whether to include hidden files (starting with .)',
-        default: true,
-      },
-    },
-    required: ['path'],
-  },
-};
-
-interface ListFilesArgs {
-  path: string;
-  recursive?: boolean;
-  includeHidden?: boolean;
-}
-
-/**
- * Handle the acp_remote_list_files tool invocation
- * Lists files and directories at the specified path on the remote machine via SSH
- * 
- * @param args - Tool arguments containing path and recursive flag
- * @param sshConnection - SSH connection manager for remote operations
- */
-export async function handleAcpRemoteListFiles(
-  args: any,
-  sshConnection: SSHConnectionManager
-): Promise<{ content: Array<{ type: string; text: string }> }> {
-  const { path, recursive = false, includeHidden = true } = args as ListFilesArgs;
-
-  try {
-    const entries = await listRemoteFiles(sshConnection, path, recursive, includeHidden);
-    
-    // Format as JSON for structured output
-    const output = JSON.stringify(entries, null, 2);
-    
-    return {
-      content: [
-        {
-          type: 'text',
-          text: output,
-        },
-      ],
-    };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    return {
-      content: [
-        {
-          type: 'text',
-          text: `Error listing remote files: ${errorMessage}`,
-        },
-      ],
-    };
-  }
-}
-
-/**
- * Recursively list files in a remote directory via SSH
- * Returns FileEntry objects with comprehensive metadata
- */
-async function listRemoteFiles(
-  ssh: SSHConnectionManager,
-  dirPath: string,
-  recursive: boolean,
-  includeHidden: boolean
-): Promise<FileEntry[]> {
-  const entries = await ssh.listFiles(dirPath, includeHidden);
-  const allEntries: FileEntry[] = [...entries];
-
-  // Recursively list subdirectories if requested
-  if (recursive) {
-    for (const entry of entries) {
-      if (entry.type === 'directory') {
-        const subEntries = await listRemoteFiles(ssh, entry.path, recursive, includeHidden);
-        allEntries.push(...subEntries);
-      }
-    }
-  }
-
-  return allEntries;
-}

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

@@ -1,94 +0,0 @@
-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',
-  description: 'Read file contents from the remote machine via SSH',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      path: {
-        type: 'string',
-        description: 'Absolute path to file',
-      },
-      encoding: {
-        type: 'string',
-        description: 'File encoding (default: utf-8)',
-        default: 'utf-8',
-        enum: ['utf-8', 'ascii', 'base64'],
-      },
-      maxSize: {
-        type: 'number',
-        description: 'Max file size in bytes (default: 1MB)',
-        default: 1048576,
-      },
-    },
-    required: ['path'],
-  },
-};
-
-interface ReadFileArgs {
-  path: string;
-  encoding?: string;
-  maxSize?: number;
-}
-
-interface ReadFileResult {
-  content: string;
-  size: number;
-  encoding: string;
-}
-
-/**
- * Handle the acp_remote_read_file tool invocation
- * Reads file contents from the remote machine via SSH
- * 
- * @param args - Tool arguments containing path, encoding, and maxSize
- * @param sshConnection - SSH connection manager for remote operations
- */
-export async function handleAcpRemoteReadFile(
-  args: any,
-  sshConnection: SSHConnectionManager
-): 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,
-      encoding: result.encoding,
-    };
-    
-    return {
-      content: [
-        {
-          type: 'text',
-          text: JSON.stringify(output, null, 2),
-        },
-      ],
-    };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    logger.error('File read error', { path, error: errorMessage });
-    return {
-      content: [
-        {
-          type: 'text',
-          text: JSON.stringify({
-            error: errorMessage,
-            content: '',
-            size: 0,
-            encoding,
-          }, null, 2),
-        },
-      ],
-    };
-  }
-}