@prmichaelsen/acp-mcp 0.5.1 → 0.7.0

package/dist/server-factory.js

@@ -8,7 +8,7 @@ import {
 // 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",
+  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: {
@@ -20,20 +20,26 @@ var acpRemoteListFilesTool = {
         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 } = args;
+  const { path, recursive = false, includeHidden = true } = args;
   try {
-    const files = await listRemoteFiles(sshConnection, path, recursive);
+    const entries = await listRemoteFiles(sshConnection, path, recursive, includeHidden);
+    const output = JSON.stringify(entries, null, 2);
     return {
       content: [
         {
           type: "text",
-          text: files.join("\n")
+          text: output
         }
       ]
     };
@@ -49,22 +55,18 @@ async function handleAcpRemoteListFiles(args, sshConnection) {
     };
   }
 }
-async function listRemoteFiles(ssh, dirPath, recursive) {
-  const entries = await ssh.listFiles(dirPath);
-  const files = [];
-  for (const entry of entries) {
-    const fullPath = `${dirPath}/${entry.name}`.replace(/\/+/g, "/");
-    if (entry.isDirectory) {
-      files.push(`${fullPath}/`);
-      if (recursive) {
-        const subFiles = await listRemoteFiles(ssh, fullPath, recursive);
-        files.push(...subFiles);
+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);
       }
-    } else {
-      files.push(fullPath);
     }
   }
-  return files.sort();
+  return allEntries;
 }
 
 // src/utils/logger.ts
@@ -177,7 +179,7 @@ var logger = new Logger();
 // src/tools/acp-remote-execute-command.ts
 var acpRemoteExecuteCommandTool = {
   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: {
@@ -191,17 +193,21 @@ var acpRemoteExecuteCommandTool = {
       },
       timeout: {
         type: "number",
-        description: "Timeout in seconds (default: 30)",
+        description: "Timeout in seconds (default: 30). Ignored if progress streaming is used.",
         default: 30
       }
     },
     required: ["command"]
   }
 };
-async function handleAcpRemoteExecuteCommand(args, sshConnection) {
+async function handleAcpRemoteExecuteCommand(args, sshConnection, extra, server) {
   const { command, cwd, timeout = 30 } = args;
-  logger.debug("Executing remote command", { command, cwd, timeout });
+  const progressToken = extra?._meta?.progressToken;
+  logger.debug("Executing remote command", { command, cwd, timeout, hasProgressToken: !!progressToken });
   try {
+    if (progressToken && server) {
+      return await executeWithProgress(command, cwd, sshConnection, progressToken, server);
+    }
     const fullCommand = cwd ? `cd ${cwd} && ${command}` : command;
     const result = await sshConnection.execWithTimeout(fullCommand, timeout);
     logger.debug("Command execution result", {
@@ -242,6 +248,75 @@ async function handleAcpRemoteExecuteCommand(args, sshConnection) {
     };
   }
 }
+async function executeWithProgress(command, cwd, sshConnection, progressToken, server) {
+  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;
+  stream.on("data", (chunk) => {
+    const text = chunk.toString();
+    stdout += text;
+    bytesReceived += chunk.length;
+    const now = Date.now();
+    if (now - lastProgressTime >= MIN_PROGRESS_INTERVAL) {
+      try {
+        server.notification({
+          method: "notifications/progress",
+          params: {
+            progressToken,
+            progress: bytesReceived,
+            total: void 0,
+            // 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)
+        });
+      }
+    }
+  });
+  stderrStream.on("data", (chunk) => {
+    stderr += chunk.toString();
+  });
+  stream.on("error", (error) => {
+    logger.error("Stream error during execution", {
+      command,
+      error: error.message
+    });
+  });
+  const finalExitCode = await exitCode;
+  logger.debug("Streaming execution completed", {
+    command,
+    exitCode: finalExitCode,
+    stdoutBytes: stdout.length,
+    stderrBytes: stderr.length
+  });
+  const output = {
+    stdout,
+    stderr,
+    exitCode: finalExitCode,
+    timedOut: false,
+    streamed: true
+    // Indicate this was streamed
+  };
+  return {
+    content: [{
+      type: "text",
+      text: JSON.stringify(output, null, 2)
+    }]
+  };
+}
 
 // src/tools/acp-remote-read-file.ts
 var acpRemoteReadFileTool = {
@@ -384,6 +459,54 @@ async function handleAcpRemoteWriteFile(args, sshConnection) {
 
 // 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;
@@ -509,6 +632,57 @@ var SSHConnectionManager = class {
       throw error;
     }
   }
+  /**
+   * 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, cwd) {
+    if (!this.connected) {
+      await this.connect();
+    }
+    const fullCommand = cwd ? `cd "${cwd}" && ${command}` : command;
+    const startTime = Date.now();
+    logger.sshCommand(fullCommand, cwd);
+    return new Promise((resolve, reject) => {
+      this.client.exec(fullCommand, (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((resolveExit) => {
+          stream.on("close", (code) => {
+            const duration = Date.now() - startTime;
+            logger.debug("SSH stream closed", {
+              command: fullCommand,
+              exitCode: code,
+              duration: `${duration}ms`
+            });
+            resolveExit(code);
+          });
+        });
+        stream.on("error", (error) => {
+          logger.error("SSH stream error", {
+            command: fullCommand,
+            error: error.message
+          });
+        });
+        resolve({
+          stream,
+          stderr: stream.stderr,
+          exitCode: exitCodePromise
+        });
+      });
+    });
+  }
   /**
    * Get SFTP wrapper for file operations
    */
@@ -527,21 +701,118 @@ var SSHConnectionManager = class {
     });
   }
   /**
-   * List files in a directory using SFTP
+   * List files in a directory with comprehensive metadata
+   * Uses hybrid approach: shell ls for filenames (includes hidden), SFTP stat for metadata
+   *
+   * @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) {
+  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;
         }
-        const files = list.map((item) => ({
+        let entries = list.map((item) => ({
           name: item.filename,
-          isDirectory: item.attrs.isDirectory()
+          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()
+          }
         }));
-        resolve(files);
+        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);
       });
     });
   }
@@ -698,7 +969,7 @@ async function createServer(serverConfig) {
     logger.debug(`Returning ${tools.length} tools`, { tools: tools.map((t) => t.name), userId: serverConfig.userId });
     return { tools };
   });
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
     const startTime = Date.now();
     logger.toolInvoked(request.params.name, request.params.arguments, serverConfig.userId);
     try {
@@ -706,7 +977,7 @@ async function createServer(serverConfig) {
       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);
+        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") {