@prmichaelsen/acp-mcp 0.7.0 → 1.0.0

package/dist/server.js

@@ -433,70 +433,6 @@ function loadSSHPrivateKey() {
   }
 }
 
-// src/tools/acp-remote-list-files.ts
-var acpRemoteListFilesTool = {
-  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"]
-  }
-};
-async function handleAcpRemoteListFiles(args, sshConnection) {
-  const { path, recursive = false, includeHidden = true } = args;
-  try {
-    const entries = await listRemoteFiles(sshConnection, path, recursive, includeHidden);
-    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}`
-        }
-      ]
-    };
-  }
-}
-async function listRemoteFiles(ssh, dirPath, recursive, includeHidden) {
-  const entries = await ssh.listFiles(dirPath, includeHidden);
-  const allEntries = [...entries];
-  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;
-}
-
 // src/utils/logger.ts
 var LOG_LEVELS = {
   error: 0,
@@ -746,195 +682,8 @@ async function executeWithProgress(command, cwd, sshConnection, progressToken, s
   };
 }
 
-// src/tools/acp-remote-read-file.ts
-var acpRemoteReadFileTool = {
-  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"]
-  }
-};
-async function handleAcpRemoteReadFile(args, sshConnection) {
-  const { path, encoding = "utf-8", maxSize = 1048576 } = args;
-  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 = {
-      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)
-        }
-      ]
-    };
-  }
-}
-
-// src/tools/acp-remote-write-file.ts
-var acpRemoteWriteFileTool = {
-  name: "acp_remote_write_file",
-  description: "Write file contents to the remote machine via SSH",
-  inputSchema: {
-    type: "object",
-    properties: {
-      path: {
-        type: "string",
-        description: "Absolute path to file"
-      },
-      content: {
-        type: "string",
-        description: "File contents to write"
-      },
-      encoding: {
-        type: "string",
-        description: "File encoding (default: utf-8)",
-        default: "utf-8"
-      },
-      createDirs: {
-        type: "boolean",
-        description: "Create parent directories if they don't exist (default: false)",
-        default: false
-      },
-      backup: {
-        type: "boolean",
-        description: "Backup existing file before overwriting (default: false)",
-        default: false
-      }
-    },
-    required: ["path", "content"]
-  }
-};
-async function handleAcpRemoteWriteFile(args, sshConnection) {
-  const { path, content, encoding = "utf-8", createDirs = false, backup = false } = args;
-  logger.debug("Writing remote file", { path, contentSize: content.length, encoding, createDirs, backup });
-  try {
-    const result = await sshConnection.writeFile(path, content, {
-      encoding,
-      createDirs,
-      backup
-    });
-    logger.debug("File write successful", { path, bytesWritten: result.bytesWritten, backupPath: result.backupPath });
-    const output = {
-      success: result.success,
-      bytesWritten: result.bytesWritten,
-      backupPath: result.backupPath
-    };
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(output, null, 2)
-        }
-      ]
-    };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    logger.error("File write error", { path, error: errorMessage });
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify({
-            success: false,
-            bytesWritten: 0,
-            error: errorMessage
-          }, null, 2)
-        }
-      ]
-    };
-  }
-}
-
 // src/utils/ssh-connection.ts
 import { Client } from "ssh2";
-
-// src/types/file-entry.ts
-function modeToPermissionString(mode) {
-  const perms = [
-    mode & 256 ? "r" : "-",
-    mode & 128 ? "w" : "-",
-    mode & 64 ? "x" : "-",
-    mode & 32 ? "r" : "-",
-    mode & 16 ? "w" : "-",
-    mode & 8 ? "x" : "-",
-    mode & 4 ? "r" : "-",
-    mode & 2 ? "w" : "-",
-    mode & 1 ? "x" : "-"
-  ];
-  return perms.join("");
-}
-function parsePermissions(mode) {
-  return {
-    mode,
-    string: modeToPermissionString(mode),
-    owner: {
-      read: (mode & 256) !== 0,
-      write: (mode & 128) !== 0,
-      execute: (mode & 64) !== 0
-    },
-    group: {
-      read: (mode & 32) !== 0,
-      write: (mode & 16) !== 0,
-      execute: (mode & 8) !== 0
-    },
-    others: {
-      read: (mode & 4) !== 0,
-      write: (mode & 2) !== 0,
-      execute: (mode & 1) !== 0
-    }
-  };
-}
-function getFileType(stats) {
-  if (stats.isDirectory())
-    return "directory";
-  if (stats.isFile())
-    return "file";
-  if (stats.isSymbolicLink())
-    return "symlink";
-  return "other";
-}
-
-// src/utils/ssh-connection.ts
 var SSHConnectionManager = class {
   client;
   config;
@@ -1015,9 +764,10 @@ var SSHConnectionManager = class {
       await this.connect();
     }
     const startTime = Date.now();
-    logger.sshCommand(command, void 0, timeoutSeconds);
+    const wrappedCommand = this.wrapCommandWithShellInit(command);
+    logger.sshCommand(wrappedCommand, void 0, timeoutSeconds);
     const execPromise = new Promise((resolve, reject) => {
-      this.client.exec(command, (err, stream) => {
+      this.client.exec(wrappedCommand, (err, stream) => {
         if (err) {
           reject(err);
           return;
@@ -1073,10 +823,11 @@ var SSHConnectionManager = class {
       await this.connect();
     }
     const fullCommand = cwd ? `cd "${cwd}" && ${command}` : command;
+    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,
@@ -1112,241 +863,15 @@ var SSHConnectionManager = class {
     });
   }
   /**
-   * Get SFTP wrapper for file operations
-   */
-  async getSFTP() {
-    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
-   */
-  async listFiles(path, includeHidden = true) {
-    const startTime = Date.now();
-    logger.debug("Listing files", { path, includeHidden });
-    try {
-      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"
-      });
-      const sftp = await this.getSFTP();
-      const entries = [];
-      for (const filename of filenames) {
-        const fullPath = `${path}/${filename}`.replace(/\/+/g, "/");
-        try {
-          const stats = await new Promise((resolve, reject) => {
-            sftp.stat(fullPath, (err, stats2) => {
-              if (err)
-                reject(err);
-              else
-                resolve(stats2);
-            });
-          });
-          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 * 1e3).toISOString(),
-              modified: new Date(stats.mtime * 1e3).toISOString()
-            }
-          });
-        } catch (error) {
-          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) {
-      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
-   */
-  async listFilesViaSFTP(path, includeHidden) {
-    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 * 1e3).toISOString(),
-            modified: new Date(item.attrs.mtime * 1e3).toISOString()
-          }
-        }));
-        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
+   * @param command - The command to wrap
+   * @returns Wrapped command that sources shell config first
    */
-  async readFile(path, encoding = "utf-8", maxSize = 1048576) {
-    const startTime = Date.now();
-    logger.fileOperation("read", path, { encoding, maxSize });
-    const sftp = await this.getSFTP();
-    return new Promise((resolve, reject) => {
-      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;
-        }
-        sftp.readFile(path, { encoding }, (err2, data) => {
-          if (err2) {
-            logger.error("File read failed", { path, error: err2.message });
-            reject(new Error(`Failed to read file: ${err2.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, content, options = {}) {
-    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 = () => {
-        if (backup) {
-          const backupPath = `${path}.backup`;
-          sftp.rename(path, backupPath, (err) => {
-            if (err && err.message !== "No such file") {
-              reject(new Error(`Failed to create backup: ${err.message}`));
-              return;
-            }
-            performWrite(backupPath);
-          });
-        } else {
-          performWrite();
-        }
-      };
-      const performWrite = (backupPath) => {
-        const buffer = Buffer.from(content, encoding);
-        const tempPath = `${path}.tmp`;
-        sftp.writeFile(tempPath, buffer, (err) => {
-          if (err) {
-            reject(new Error(`Failed to write file: ${err.message}`));
-            return;
-          }
-          sftp.rename(tempPath, path, (err2) => {
-            if (err2) {
-              logger.error("File rename failed", { tempPath, path, error: err2.message });
-              reject(new Error(`Failed to rename temp file: ${err2.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
-            });
-          });
-        });
-      };
-      if (createDirs) {
-        const dirPath = path.substring(0, path.lastIndexOf("/"));
-        this.exec(`mkdir -p ${dirPath}`).then(() => {
-          writeOperation();
-        }).catch(reject);
-      } else {
-        writeOperation();
-      }
-    });
+  wrapCommandWithShellInit(command) {
+    return `(source ~/.zshrc 2>/dev/null || source ~/.bashrc 2>/dev/null || source ~/.profile 2>/dev/null || true) && ${command}`;
   }
   /**
    * Disconnect from the SSH server
@@ -1393,7 +918,7 @@ async function main() {
   );
   server.setRequestHandler(ListToolsRequestSchema, async () => {
     logger.debug("Tool discovery requested");
-    const tools = [acpRemoteListFilesTool, acpRemoteExecuteCommandTool, acpRemoteReadFileTool, acpRemoteWriteFileTool];
+    const tools = [acpRemoteExecuteCommandTool];
     logger.debug(`Returning ${tools.length} tools`, { tools: tools.map((t) => t.name) });
     return { tools };
   });
@@ -1402,14 +927,8 @@ async function main() {
     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") {
+      if (request.params.name === "acp_remote_execute_command") {
         result = await handleAcpRemoteExecuteCommand(request.params.arguments, sshConnection, extra, server);
-      } 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}`);
       }