@prmichaelsen/acp-mcp 0.4.1 → 0.5.1

package/dist/server.js

@@ -481,20 +481,127 @@ 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(`${entry.name}/`);
+      files.push(`${fullPath}/`);
       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);
       }
     } else {
-      files.push(entry.name);
+      files.push(fullPath);
     }
   }
   return files.sort();
 }
 
+// src/utils/logger.ts
+var LOG_LEVELS = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3,
+  trace: 4
+};
+var Logger = class {
+  level;
+  enabled;
+  constructor() {
+    this.level = process.env.ACP_MCP_LOG_LEVEL || "info";
+    this.enabled = process.env.ACP_MCP_DEBUG === "true" || process.env.NODE_ENV === "development";
+  }
+  shouldLog(level) {
+    if (!this.enabled && level !== "error" && level !== "warn") {
+      return false;
+    }
+    return LOG_LEVELS[level] <= LOG_LEVELS[this.level];
+  }
+  formatMessage(level, message, data) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const prefix = `[${timestamp}] [${level.toUpperCase()}]`;
+    if (data !== void 0) {
+      const dataStr = typeof data === "object" ? JSON.stringify(data, null, 2) : String(data);
+      return `${prefix} ${message}
+${dataStr}`;
+    }
+    return `${prefix} ${message}`;
+  }
+  error(message, data) {
+    if (this.shouldLog("error")) {
+      console.error(this.formatMessage("error", message, data));
+    }
+  }
+  warn(message, data) {
+    if (this.shouldLog("warn")) {
+      console.error(this.formatMessage("warn", message, data));
+    }
+  }
+  info(message, data) {
+    if (this.shouldLog("info")) {
+      console.error(this.formatMessage("info", message, data));
+    }
+  }
+  debug(message, data) {
+    if (this.shouldLog("debug")) {
+      console.error(this.formatMessage("debug", message, data));
+    }
+  }
+  trace(message, data) {
+    if (this.shouldLog("trace")) {
+      console.error(this.formatMessage("trace", message, data));
+    }
+  }
+  /**
+   * Log tool invocation with parameters
+   */
+  toolInvoked(toolName, params, userId) {
+    this.info(`Tool invoked: ${toolName}`);
+    this.debug("Tool parameters", { tool: toolName, params, userId });
+  }
+  /**
+   * Log tool completion with result summary
+   */
+  toolCompleted(toolName, duration, resultSize) {
+    this.info(`Tool completed: ${toolName}`);
+    this.debug("Tool performance", { tool: toolName, duration: `${duration}ms`, resultSize });
+  }
+  /**
+   * Log tool failure with error details
+   */
+  toolFailed(toolName, error, params) {
+    this.error(`Tool execution failed: ${toolName}`, {
+      tool: toolName,
+      error: error.message,
+      stack: error.stack,
+      params
+    });
+  }
+  /**
+   * Log SSH command execution
+   */
+  sshCommand(command, cwd, timeout) {
+    this.debug("Executing SSH command", { command, cwd, timeout });
+  }
+  /**
+   * Log SSH command result
+   */
+  sshCommandResult(exitCode, duration, stdoutSize, stderrSize) {
+    this.debug("SSH command completed", {
+      exitCode,
+      duration: `${duration}ms`,
+      stdout: `${stdoutSize} bytes`,
+      stderr: `${stderrSize} bytes`
+    });
+  }
+  /**
+   * Log file operation
+   */
+  fileOperation(operation, path, details) {
+    this.info(`File operation: ${operation}`, { path, ...details });
+  }
+};
+var logger = new Logger();
+
 // src/tools/acp-remote-execute-command.ts
 var acpRemoteExecuteCommandTool = {
   name: "acp_remote_execute_command",
@@ -521,9 +628,16 @@ var acpRemoteExecuteCommandTool = {
 };
 async function handleAcpRemoteExecuteCommand(args, sshConnection) {
   const { command, cwd, timeout = 30 } = args;
+  logger.debug("Executing remote command", { command, cwd, timeout });
   try {
     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
+    });
     const output = {
       stdout: result.stdout,
       stderr: result.stderr,
@@ -540,6 +654,7 @@ async function handleAcpRemoteExecuteCommand(args, sshConnection) {
     };
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.error("Command execution error", { command, error: errorMessage });
     return {
       content: [
         {
@@ -584,8 +699,10 @@ var acpRemoteReadFileTool = {
 };
 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,
@@ -601,6 +718,7 @@ async function handleAcpRemoteReadFile(args, sshConnection) {
     };
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.error("File read error", { path, error: errorMessage });
     return {
       content: [
         {
@@ -653,12 +771,14 @@ var acpRemoteWriteFileTool = {
 };
 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,
@@ -674,6 +794,7 @@ async function handleAcpRemoteWriteFile(args, sshConnection) {
     };
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
+    logger.error("File write error", { path, error: errorMessage });
     return {
       content: [
         {
@@ -704,13 +825,27 @@ var SSHConnectionManager = class {
    */
   async connect() {
     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({
         host: this.config.host,
@@ -756,6 +891,8 @@ var SSHConnectionManager = class {
     if (!this.connected) {
       await this.connect();
     }
+    const startTime = Date.now();
+    logger.sshCommand(command, void 0, timeoutSeconds);
     const execPromise = new Promise((resolve, reject) => {
       this.client.exec(command, (err, stream) => {
         if (err) {
@@ -765,6 +902,8 @@ var SSHConnectionManager = class {
         let stdout = "";
         let stderr = "";
         stream.on("close", (code) => {
+          const duration = Date.now() - startTime;
+          logger.sshCommandResult(code, duration, stdout.length, stderr.length);
           resolve({ stdout, stderr, exitCode: code });
         }).on("data", (data) => {
           stdout += data.toString();
@@ -783,6 +922,7 @@ var SSHConnectionManager = class {
       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",
@@ -790,6 +930,10 @@ var SSHConnectionManager = class {
           timedOut: true
         };
       }
+      logger.error("SSH command execution failed", {
+        command,
+        error: error instanceof Error ? error.message : String(error)
+      });
       throw error;
     }
   }
@@ -833,22 +977,30 @@ var SSHConnectionManager = class {
    * Read file contents from remote machine
    */
   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,
@@ -863,6 +1015,13 @@ var SSHConnectionManager = class {
    */
   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 = () => {
@@ -889,9 +1048,17 @@ var SSHConnectionManager = class {
           }
           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,
@@ -915,6 +1082,10 @@ var SSHConnectionManager = class {
    */
   disconnect() {
     if (this.connected) {
+      logger.info("Disconnecting from SSH server", {
+        host: this.config.host,
+        username: this.config.username
+      });
       this.client.end();
       this.connected = false;
     }
@@ -949,26 +1120,39 @@ async function main() {
       }
     }
   );
-  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, request.params.arguments);
+      throw error;
     }
-    throw new Error(`Unknown tool: ${request.params.name}`);
   });
   const cleanup = () => {
-    console.error("Shutting down...");
+    logger.info("Shutting down server");
     sshConnection.disconnect();
     process.exit(0);
   };
@@ -976,10 +1160,10 @@ async function main() {
   process.on("SIGTERM", cleanup);
   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);
 });
 //# sourceMappingURL=server.js.map