@aaarc/handfree-ssh-mcp 1.0.9 → 1.0.10

package/build/config/server.js

@@ -1,6 +1,6 @@
 export const SERVER_CONFIG = {
     name: "ssh-mcp-server",
-    version: "1.0.9",
+    version: "1.0.10",
 };
 export const SERVER_INSTRUCTIONS = `This server provides SSH access to servers loaded from OpenSSH config (~/.ssh/config by default) and optional YAML config/policy overlays.
 

package/build/services/ssh-connection-manager.js

@@ -777,6 +777,60 @@ export class SSHConnectionManager {
             });
         });
     }
+    /**
+     * Default inactivity window (ms) for SFTP data transfers when the caller does
+     * not pass an explicit timeout. Deliberately generous: a healthy transfer
+     * moves bytes far more often than this, so tripping it means the connection
+     * is effectively dead, not merely slow.
+     */
+    static DEFAULT_TRANSFER_STALL_TIMEOUT_MS = 60_000;
+    /** Chunk size for buffered SFTP writes, sized to yield per-ack progress. */
+    static SFTP_WRITE_CHUNK_BYTES = 256 * 1024;
+    /**
+     * Resolve the inactivity window for a data transfer: the caller's timeout if
+     * valid, otherwise the generous default so a dead connection never hangs.
+     */
+    transferStallTimeout(timeout) {
+        return (this.normalizeConnectTimeout(timeout) ??
+            SSHConnectionManager.DEFAULT_TRANSFER_STALL_TIMEOUT_MS);
+    }
+    /**
+     * Pipe a readable into a writable under the inactivity watchdog, aborting if
+     * no bytes flow for the stall window. Used by the non-fast download and relay
+     * paths, which otherwise settle only on close/finish/error and so hang on a
+     * dead reused connection. Read-side `data` events drive progress; the caller
+     * supplies error mappers so each path keeps its own error code/message.
+     */
+    pipeWithInactivityTimeout(readStream, writeStream, timeoutMs, description, debug, mapReadError, mapWriteError) {
+        const teardown = () => {
+            this.unpipeStream(readStream, writeStream);
+            this.destroyStream(readStream);
+            this.destroyStream(writeStream);
+        };
+        return this.runWithInactivityTimeout((onProgress) => new Promise((resolve, reject) => {
+            let settled = false;
+            const settle = (err) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (err) {
+                    teardown();
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            };
+            readStream.on("data", () => onProgress());
+            // Resolve on whichever completion event the write side emits: local fs
+            // writables emit "finish", SFTP writables emit "close".
+            writeStream.on("finish", () => settle());
+            writeStream.on("close", () => settle());
+            writeStream.on("error", (err) => settle(mapWriteError(err)));
+            readStream.on("error", (err) => settle(mapReadError(err)));
+            readStream.pipe(writeStream);
+        }), timeoutMs, description, debug, teardown);
+    }
     /**
      * Open a TCP tunnel from the target's jump chain to `config.host:config.port`
      * and return the duplex stream to be used as `sock` for the target SSH client.
@@ -2111,47 +2165,100 @@ export class SSHConnectionManager {
     }
     /**
      * Read an SFTP file fully into a Buffer.
+     *
+     * Guarded by an inactivity watchdog: if no bytes arrive for the stall window
+     * (a dead reused connection can open the channel but never stream) the read
+     * aborts with a retriable error instead of hanging. An actively-streaming
+     * read is never killed because each chunk resets the watchdog.
      */
     async sftpReadBuffer(client, remotePath, expectedSize, timeout, debug) {
         const sftp = await this.openSftp(client, "read", timeout, debug);
-        return new Promise((resolve, reject) => {
-            const chunks = [];
-            let received = 0;
-            const stream = sftp.createReadStream(remotePath);
-            stream.on("data", (chunk) => {
-                chunks.push(chunk);
-                received += chunk.length;
-            });
-            stream.on("error", (e) => {
-                sftp.end();
-                reject(this.makeSftpError("Remote read failed", e));
-            });
-            stream.on("end", () => {
+        const endSftp = () => {
+            try {
                 sftp.end();
-                if (received !== expectedSize) {
-                    return reject(new ToolError("SFTP_ERROR", `Remote read short: expected ${expectedSize} bytes, got ${received}`, false));
-                }
-                resolve(Buffer.concat(chunks, received));
-            });
-        });
+            }
+            catch {
+                // Ignore late SFTP cleanup errors.
+            }
+        };
+        try {
+            return await this.runWithInactivityTimeout((onProgress) => new Promise((resolve, reject) => {
+                const chunks = [];
+                let received = 0;
+                const stream = sftp.createReadStream(remotePath);
+                stream.on("data", (chunk) => {
+                    chunks.push(chunk);
+                    received += chunk.length;
+                    onProgress();
+                });
+                stream.on("error", (e) => {
+                    reject(this.makeSftpError("Remote read failed", e));
+                });
+                stream.on("end", () => {
+                    if (received !== expectedSize) {
+                        return reject(new ToolError("SFTP_ERROR", `Remote read short: expected ${expectedSize} bytes, got ${received}`, false));
+                    }
+                    resolve(Buffer.concat(chunks, received));
+                });
+            }), this.transferStallTimeout(timeout), `remote read ${remotePath}`, debug, endSftp);
+        }
+        finally {
+            endSftp();
+        }
     }
     /**
      * Write a Buffer to an SFTP path (overwrites if exists).
+     *
+     * The payload is written in chunks so the inactivity watchdog gets a real
+     * progress signal per acknowledged chunk: a dead reused connection that opens
+     * the channel but never acks a write aborts with a retriable error instead of
+     * hanging, while an actively-flushing write is never killed.
      */
     async sftpWriteBuffer(client, remotePath, payload, timeout, debug) {
         const sftp = await this.openSftp(client, "write", timeout, debug);
-        return new Promise((resolve, reject) => {
-            const writeStream = sftp.createWriteStream(remotePath);
-            writeStream.on("close", () => {
-                sftp.end();
-                resolve();
-            });
-            writeStream.on("error", (e) => {
+        const endSftp = () => {
+            try {
                 sftp.end();
-                reject(this.makeSftpError("File upload failed", e));
-            });
-            writeStream.end(payload);
-        });
+            }
+            catch {
+                // Ignore late SFTP cleanup errors.
+            }
+        };
+        try {
+            await this.runWithInactivityTimeout((onProgress) => new Promise((resolve, reject) => {
+                const writeStream = sftp.createWriteStream(remotePath);
+                let offset = 0;
+                let ended = false;
+                writeStream.on("close", () => resolve());
+                writeStream.on("error", (e) => {
+                    reject(this.makeSftpError("File upload failed", e));
+                });
+                const writeNext = () => {
+                    if (offset >= payload.length) {
+                        if (!ended) {
+                            ended = true;
+                            writeStream.end();
+                        }
+                        return;
+                    }
+                    const end = Math.min(offset + SSHConnectionManager.SFTP_WRITE_CHUNK_BYTES, payload.length);
+                    const chunk = payload.subarray(offset, end);
+                    offset = end;
+                    writeStream.write(chunk, (err) => {
+                        if (err) {
+                            // The "error" event will reject; nothing else to do here.
+                            return;
+                        }
+                        onProgress();
+                        writeNext();
+                    });
+                };
+                writeNext();
+            }), this.transferStallTimeout(timeout), `upload ${remotePath}`, debug, endSftp);
+        }
+        finally {
+            endSftp();
+        }
     }
     /**
      * Upload a local file using ssh2's parallel SFTP fastPut implementation.
@@ -2179,7 +2286,7 @@ export class SSHConnectionManager {
                     }
                     resolve();
                 });
-            }), this.normalizeConnectTimeout(timeout), `fast upload ${localPath} -> ${remotePath}`, debug, endSftp);
+            }), this.transferStallTimeout(timeout), `fast upload ${localPath} -> ${remotePath}`, debug, endSftp);
         }
         finally {
             endSftp();
@@ -2211,7 +2318,7 @@ export class SSHConnectionManager {
                     }
                     resolve();
                 });
-            }), this.normalizeConnectTimeout(timeout), `fast download ${remotePath} -> ${localPath}`, debug, endSftp);
+            }), this.transferStallTimeout(timeout), `fast download ${remotePath} -> ${localPath}`, debug, endSftp);
         }
         finally {
             endSftp();
@@ -2240,27 +2347,17 @@ export class SSHConnectionManager {
                 return this.appendDebugOutput("File downloaded successfully via fast SFTP", debugCollector);
             }
             const sftp = await this.openSftp(connection.client, "download", options?.timeout, debug);
-            await new Promise((resolve, reject) => {
-                let settled = false;
-                const readStream = sftp.createReadStream(validatedRemotePath);
-                const writeStream = fs.createWriteStream(validatedLocalPath);
-                const settle = (err) => {
-                    if (settled)
-                        return;
-                    settled = true;
-                    if (err) {
-                        this.unpipeStream(readStream, writeStream);
-                        this.destroyStream(readStream);
-                        this.destroyStream(writeStream);
-                    }
+            try {
+                await this.pipeWithInactivityTimeout(sftp.createReadStream(validatedRemotePath), fs.createWriteStream(validatedLocalPath), this.transferStallTimeout(options?.timeout), `download ${validatedRemotePath} -> ${validatedLocalPath}`, debug, (err) => this.makeSftpError("File download failed", err), (err) => new ToolError("LOCAL_FILE_WRITE_FAILED", `Failed to save file: ${err.message}`, false));
+            }
+            finally {
+                try {
                     sftp.end();
-                    err ? reject(err) : resolve();
-                };
-                writeStream.on("finish", () => settle());
-                writeStream.on("error", (err) => settle(new ToolError("LOCAL_FILE_WRITE_FAILED", `Failed to save file: ${err.message}`, false)));
-                readStream.on("error", (err) => settle(this.makeSftpError("File download failed", err)));
-                readStream.pipe(writeStream);
-            });
+                }
+                catch {
+                    // Ignore late SFTP cleanup errors.
+                }
+            }
             return this.appendDebugOutput("File downloaded successfully", debugCollector);
         }
         catch (error) {
@@ -2417,30 +2514,11 @@ export class SSHConnectionManager {
                     }
                 }
             }
-            const readStream = srcSftp.createReadStream(validatedSourcePath);
-            const writeStream = dstSftp.createWriteStream(validatedDestPath);
             // Bind the validated paths into the rest of the verification flow so
             // we never accidentally fall back to the un-validated originals.
             sourceRemotePath = validatedSourcePath;
             destRemotePath = validatedDestPath;
-            await new Promise((resolve, reject) => {
-                let settled = false;
-                const settle = (err) => {
-                    if (settled)
-                        return;
-                    settled = true;
-                    if (err) {
-                        this.unpipeStream(readStream, writeStream);
-                        this.destroyStream(readStream);
-                        this.destroyStream(writeStream);
-                    }
-                    err ? reject(err) : resolve();
-                };
-                writeStream.on("close", () => settle());
-                writeStream.on("error", (err) => settle(this.makeSftpError("Dest write error", err)));
-                readStream.on("error", (err) => settle(this.makeSftpError("Source read error", err)));
-                readStream.pipe(writeStream);
-            });
+            await this.pipeWithInactivityTimeout(srcSftp.createReadStream(validatedSourcePath), dstSftp.createWriteStream(validatedDestPath), this.transferStallTimeout(options?.timeout), `relay ${sourceName}:${validatedSourcePath} -> ${destName}:${validatedDestPath}`, debug, (err) => this.makeSftpError("Source read error", err), (err) => this.makeSftpError("Dest write error", err));
             // --- Verification ---
             const dstStat = await this.sftpStat(dstSftp, destRemotePath, "dest");
             const verification = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aaarc/handfree-ssh-mcp",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "description": "Handfree SSH MCP Server - A hands-free SSH automation tool via MCP protocol",
   "main": "build/index.js",
   "type": "module",
@@ -19,7 +19,7 @@
     "access": "public"
   },
   "scripts": {
-    "test": "npm run build && node --test build/tests/config.test.js build/tests/command-validation.test.js build/tests/tool-error.test.js build/tests/tools.test.js build/tests/output-collector.test.js build/tests/output-log-writer.test.js build/tests/recent-fixes.test.js",
+    "test": "npm run build && node --test build/tests/config.test.js build/tests/command-validation.test.js build/tests/tool-error.test.js build/tests/tools.test.js build/tests/output-collector.test.js build/tests/output-log-writer.test.js build/tests/recent-fixes.test.js build/tests/sftp-stall-timeout.test.js",
     "test:config": "npm run build && node --test build/tests/config.test.js",
     "test:cmd": "npm run build && node --test build/tests/command-validation.test.js",
     "test:tools": "npm run build && node --test build/tests/tools.test.js",