@mgsoftwarebv/mg-dashboard-mcp 3.4.4 → 3.5.0

package/dist/index.d.ts

@@ -1 +1,8 @@
 #!/usr/bin/env node
+type SftpWriteInput = {
+    content: string;
+} | {
+    sourcePath: string;
+};
+
+export type { SftpWriteInput };

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { spawn } from 'child_process';
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
+import { existsSync, statSync, readFileSync } from 'fs';
+import { join, isAbsolute } from 'path';
 import { Client as Client$1 } from '@modelcontextprotocol/sdk/client/index.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
@@ -2005,7 +2005,8 @@ function sshExecViaProxy(proxyOpts, targetOpts, command) {
     });
   });
 }
-function connectSshClient(opts, proxy, readyTimeout = 6e4) {
+function connectSshClient(opts, proxy, readyTimeout = 6e4, extraConnect) {
+  const compress = extraConnect?.compress;
   if (!proxy) {
     return new Promise((resolve, reject) => {
       const ssh = new Client();
@@ -2018,7 +2019,8 @@ function connectSshClient(opts, proxy, readyTimeout = 6e4) {
         password: opts.password,
         privateKey: opts.privateKey,
         passphrase: opts.passphrase,
-        readyTimeout
+        readyTimeout,
+        ...compress ? { compress } : {}
       });
     });
   }
@@ -2052,7 +2054,8 @@ function connectSshClient(opts, proxy, readyTimeout = 6e4) {
           password: opts.password,
           privateKey: opts.privateKey,
           passphrase: opts.passphrase,
-          readyTimeout
+          readyTimeout,
+          ...compress ? { compress } : {}
         });
       });
     });
@@ -2192,46 +2195,129 @@ async function sftpRead(opts, filePath, proxy) {
     return `Error: ${e.message}`;
   }
 }
-async function sftpWrite(opts, filePath, content, proxy) {
+var SFTP_FASTPUT_CONCURRENCY = 64;
+var SFTP_FASTPUT_CHUNK_SIZE = 65536;
+var SFTP_IDLE_TIMEOUT_MS = 12e4;
+var SFTP_INLINE_TIMEOUT_MS = 6e4;
+var SFTP_PROGRESS_LOG_BYTES = 50 * 1024 * 1024;
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+async function sftpWrite(opts, filePath, input, proxy) {
   const safe = sanitizePath(filePath);
   assertWritablePath(safe);
+  let mode;
+  let inlineBuffer;
+  let localPath;
+  let expectedBytes = 0;
+  if ("content" in input && typeof input.content === "string") {
+    mode = "content";
+    inlineBuffer = Buffer.from(input.content, "utf-8");
+    expectedBytes = inlineBuffer.length;
+  } else if ("sourcePath" in input && typeof input.sourcePath === "string") {
+    mode = "sourcePath";
+    localPath = input.sourcePath;
+    if (!isAbsolute(localPath)) return `Error: sourcePath must be an absolute path: ${localPath}`;
+    if (!existsSync(localPath)) return `Error: sourcePath does not exist: ${localPath}`;
+    const st = statSync(localPath);
+    if (!st.isFile()) return `Error: sourcePath is not a regular file: ${localPath}`;
+    expectedBytes = st.size;
+  } else {
+    return "Error: sftp-write requires exactly one of: content (string) or sourcePath (absolute local path)";
+  }
+  const compress = mode === "content";
+  const startedAt = Date.now();
   let cleanup;
   try {
-    const { client, cleanup: c } = await connectSshClient(opts, proxy, 6e4);
+    const { client, cleanup: c } = await connectSshClient(opts, proxy, 6e4, { compress });
     cleanup = c;
     return await new Promise((resolve) => {
-      const timer = setTimeout(() => {
+      let resolved = false;
+      let bytesWritten = 0;
+      const finish = (msg) => {
+        if (resolved) return;
+        resolved = true;
+        watchdog?.cancel();
+        wallTimer && clearTimeout(wallTimer);
         cleanup?.();
-        resolve("Error: timeout");
         cleanup = void 0;
-      }, 6e4);
+        resolve(msg);
+      };
+      let watchdog;
+      let wallTimer;
+      if (mode === "sourcePath") {
+        const armWatchdog = () => {
+          let timer = setTimeout(
+            () => finish(`Error: idle timeout (no SFTP progress for ${SFTP_IDLE_TIMEOUT_MS / 1e3}s, wrote ${formatBytes(bytesWritten)} of ${formatBytes(expectedBytes)})`),
+            SFTP_IDLE_TIMEOUT_MS
+          );
+          return {
+            reset: () => {
+              clearTimeout(timer);
+              timer = setTimeout(
+                () => finish(`Error: idle timeout (no SFTP progress for ${SFTP_IDLE_TIMEOUT_MS / 1e3}s, wrote ${formatBytes(bytesWritten)} of ${formatBytes(expectedBytes)})`),
+                SFTP_IDLE_TIMEOUT_MS
+              );
+            },
+            cancel: () => clearTimeout(timer)
+          };
+        };
+        watchdog = armWatchdog();
+      } else {
+        wallTimer = setTimeout(
+          () => finish(`Error: timeout after ${SFTP_INLINE_TIMEOUT_MS / 1e3}s`),
+          SFTP_INLINE_TIMEOUT_MS
+        );
+      }
       client.sftp((err, sftp) => {
-        if (err) {
-          clearTimeout(timer);
-          cleanup?.();
-          cleanup = void 0;
-          resolve(`Error: ${err.message}`);
+        if (err) return finish(`Error: ${err.message}`);
+        if (mode === "content") {
+          const ws = sftp.createWriteStream(safe, { mode: 420 });
+          ws.on("error", (e) => finish(`Error: ${e.message}`));
+          ws.on("close", () => {
+            const elapsed = Date.now() - startedAt;
+            finish(`Written ${expectedBytes} bytes to ${safe} in ${elapsed}ms`);
+          });
+          ws.end(inlineBuffer);
           return;
         }
-        const ws = sftp.createWriteStream(safe, { mode: 420 });
-        ws.on("close", () => {
-          clearTimeout(timer);
-          cleanup?.();
-          cleanup = void 0;
-          resolve(`Written ${content.length} bytes to ${safe}`);
-        });
-        ws.on("error", (e) => {
-          clearTimeout(timer);
-          cleanup?.();
-          cleanup = void 0;
-          resolve(`Error: ${e.message}`);
-        });
-        ws.end(Buffer.from(content, "utf-8"));
+        let nextProgressLog = SFTP_PROGRESS_LOG_BYTES;
+        sftp.fastPut(
+          localPath,
+          safe,
+          {
+            concurrency: SFTP_FASTPUT_CONCURRENCY,
+            chunkSize: SFTP_FASTPUT_CHUNK_SIZE,
+            mode: 420,
+            fileSize: expectedBytes,
+            step: (transferred) => {
+              bytesWritten = transferred;
+              watchdog?.reset();
+              if (transferred >= nextProgressLog) {
+                console.error(
+                  `[sftp-write] ${formatBytes(transferred)} / ${formatBytes(expectedBytes)} \u2192 ${safe}`
+                );
+                nextProgressLog += SFTP_PROGRESS_LOG_BYTES;
+              }
+            }
+          },
+          (fpErr) => {
+            if (fpErr) return finish(`Error: ${fpErr.message}`);
+            const elapsed = Date.now() - startedAt;
+            const mbps = expectedBytes / (1024 * 1024) / Math.max(1e-3, elapsed / 1e3);
+            finish(
+              `Uploaded ${formatBytes(expectedBytes)} from ${localPath} to ${safe} in ${(elapsed / 1e3).toFixed(1)}s (${mbps.toFixed(1)} MB/s)`
+            );
+          }
+        );
       });
     });
   } catch (e) {
     cleanup?.();
-    return `Error: ${e.message}`;
+    return `Error: ${e instanceof Error ? e.message : String(e)}`;
   }
 }
 async function sftpDelete(opts, filePath, proxy) {
@@ -2503,15 +2589,16 @@ var TOOLS = [
   },
   {
     name: "sftp-write",
-    description: "Write content to a file on a remote server via SFTP. Protected system paths are blocked.",
+    description: "Write a file to a remote server via SFTP. Two modes (provide exactly one of `content` or `sourcePath`):\n- `content` (string): inline UTF-8 text. Best for configs, scripts, small JSON. Practical max ~1 MB.\n- `sourcePath` (absolute local path): streams a local file with ssh2 fastPut (64 parallel pipelined writes, 64 KiB chunks). Handles GB-scale files (zips, dumps, builds) without going through the LLM. Only usable when the MCP server runs locally on your machine (i.e. not via --proxy-url).\nProtected system paths on the remote are blocked.",
     inputSchema: {
       type: "object",
       properties: {
         serverId: { type: "string", description: "UUID of the SSH server" },
-        path: { type: "string", description: "File path to write" },
-        content: { type: "string", description: "File content to write" }
+        path: { type: "string", description: "Remote file path to write" },
+        content: { type: "string", description: "Inline UTF-8 file content (mutually exclusive with sourcePath)" },
+        sourcePath: { type: "string", description: "Absolute local file path to upload via fastPut (mutually exclusive with content). Use for files >1 MB or any binary." }
       },
-      required: ["serverId", "path", "content"]
+      required: ["serverId", "path"]
     }
   },
   {
@@ -2824,7 +2911,8 @@ ${result.stderr}`);
       }
       case "sftp-write": {
         const { conn, proxy } = await getServerConnection(String(a.serverId));
-        const result = await sftpWrite(conn, String(a.path), String(a.content), proxy);
+        const input = typeof a.sourcePath === "string" && a.sourcePath.length > 0 ? { sourcePath: a.sourcePath } : { content: String(a.content ?? "") };
+        const result = await sftpWrite(conn, String(a.path), input, proxy);
         return { content: [{ type: "text", text: result }] };
       }
       case "sftp-delete": {