@aaarc/handfree-ssh-mcp 1.0.5 → 1.0.7

package/build/tools/close-connection.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { SSHConnectionManager } from "../services/ssh-connection-manager.js";
+import { Logger } from "../utils/logger.js";
+import { formatToolErrorResponse, toToolError } from "../utils/tool-error.js";
+/**
+ * Register close-connection tool
+ */
+export function registerCloseConnectionTool(server) {
+    const sshManager = SSHConnectionManager.getInstance();
+    server.tool("close-connection", "Close the cached SSH connection for a configured server. Use this after a timeout, stale connection suspicion, or before retrying a host with a clean cached connection. This affects only cached/reused SSH clients; reuseConnection=false command clients already close after each command. Closing a jump host also closes cached target connections whose jump chain uses that host.", {
+        connectionName: z
+            .string()
+            .optional()
+            .describe("Target server name from list-servers. Required when multiple servers are enabled; optional when only one server is enabled."),
+    }, async ({ connectionName }) => {
+        try {
+            const result = sshManager.closeConnection(connectionName);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(result),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const toolError = toToolError(error, "INVALID_CONFIGURATION");
+            Logger.handleError(toolError, "Failed to close SSH connection");
+            return {
+                content: [{ type: "text", text: formatToolErrorResponse(toolError) }],
+                isError: true,
+            };
+        }
+    });
+}

package/build/tools/download.js

@@ -11,10 +11,23 @@ export function registerDownloadTool(server) {
         remotePath: z.string().describe("Path to the file on the remote server. Must be an absolute POSIX path (e.g. /var/log/app.log); restricted to allowedRemoteDirectories only if the server configures that list."),
         localPath: z.string().describe("Destination path on the MCP host. Must be inside the MCP working directory or one of the server's allowedLocalDirectories."),
         connectionName: z.string().optional().describe("Target server name from list-servers. Required when multiple servers are enabled; optional when only one server is enabled."),
-    }, async ({ remotePath, localPath, connectionName }) => {
+        reuseConnection: z.boolean().optional().describe("Default true. Reuse the cached SSH connection for SFTP. Set false after a timeout or suspected stale cached SSH connection to force a fresh TCP/SSH connection for this transfer; the fresh connection closes afterwards."),
+        timeout: z.number().positive().optional().describe("Timeout in ms for SSH setup and SFTP channel opening. Transfer stream duration itself is not forcibly interrupted by this option."),
+        vvv: z.boolean().optional().describe("Default false. Append bounded SSH/SFTP debug output. For fresh ssh2 handshake logs, also set reuseConnection=false."),
+        fast: z.boolean().optional().describe("Default false. When true, use ssh2 fastGet for a single-file download, which performs parallel SFTP reads for better throughput."),
+        sftpConcurrency: z.number().int().positive().optional().describe("Only used when fast=true. Number of concurrent SFTP chunks for ssh2 fastGet; omitted uses ssh2's default."),
+        chunkSize: z.number().int().positive().optional().describe("Only used when fast=true. Chunk size in bytes for ssh2 fastGet; omitted uses ssh2's default."),
+    }, async ({ remotePath, localPath, connectionName, reuseConnection, timeout, vvv, fast, sftpConcurrency, chunkSize }) => {
         try {
             const resolvedName = sshManager.resolveServer(connectionName);
-            const result = await sshManager.download(remotePath, localPath, resolvedName);
+            const result = await sshManager.download(remotePath, localPath, resolvedName, {
+                reuseConnection,
+                timeout,
+                vvv,
+                fast,
+                sftpConcurrency,
+                chunkSize,
+            });
             return {
                 content: [{ type: "text", text: result }],
             };

package/build/tools/execute-command.js

@@ -11,7 +11,7 @@ import { formatToolErrorResponse, toToolError } from "../utils/tool-error.js";
  */
 export function registerExecuteCommandTool(server) {
     const sshManager = SSHConnectionManager.getInstance();
-    server.tool("execute-command", "Execute a shell command on a remote server over SSH. Use this for command-line actions on the selected host. Streaming mode is enabled by default so long-running commands can emit progress; set stream=false for short commands where you only want the final output. The returned text is tail-only-capped at maxOutputBytes PER STREAM (default 65536 bytes for stdout and 65536 bytes for stderr, so the response can be up to ~2x that); the FULL stdout/stderr is always persisted to a local log file under <cwd>/.handfree-output/<server>/<user>/, and the response includes that path whenever output was truncated.", {
+    server.tool("execute-command", "Execute a shell command on a remote server over SSH. Use this for command-line actions on the selected host. Streaming mode is enabled by default so long-running commands can emit progress; set stream=false for short commands where you only want the final output. SSH connections are reused by default for speed; if an execute-command call times out or you suspect a stale cached SSH connection, retry with reuseConnection=false to force a fresh TCP/SSH connection for that command. Set vvv=true only when debugging SSH/channel issues; with reuseConnection=false it includes ssh2 handshake/debug lines in the result or error. The returned text is tail-only-capped at maxOutputBytes PER STREAM (default 65536 bytes for stdout and 65536 bytes for stderr, so the response can be up to ~2x that); the FULL stdout/stderr is always persisted to a local log file under <cwd>/.handfree-output/<server>/<user>/, and the response includes that path whenever output was truncated.", {
         cmdString: z.string().describe("Exact remote shell command to run. Prefer a single command per call, for example 'pwd', 'ls -la', 'cat /etc/hostname', or 'git status'. Compound commands may be blocked by command policy even if each subcommand is safe."),
         connectionName: z
             .string()
@@ -20,18 +20,26 @@ export function registerExecuteCommandTool(server) {
         timeout: z
             .number()
             .optional()
-            .describe("Maximum runtime in milliseconds. Defaults to 300000 when stream=true and 30000 when stream=false. Increase this for long-running commands; reduce it for fast probes."),
+            .describe("Timeout in milliseconds applied separately to SSH connection setup, exec-channel opening, and remote command execution for each attempt. Defaults to 300000 when stream=true and 30000 when stream=false. Increase this for long-running commands; reduce it for fast probes."),
         stream: z
             .boolean()
             .optional()
             .describe("Whether to stream progress output. Default is true. Use false for short commands like pwd, ls, cat, head, tail, or git status when you only need the final result."),
+        reuseConnection: z
+            .boolean()
+            .optional()
+            .describe("Whether to reuse the cached SSH connection for this server. Default is true for speed. Set false after a timeout or suspected stale/bad cached connection; false opens a fresh SSH connection for this command and closes it afterwards."),
+        vvv: z
+            .boolean()
+            .optional()
+            .describe("Default false. When true, append bounded SSH/channel debug output to the result or error. For full ssh2 handshake debug, also set reuseConnection=false; already-reused cached clients cannot retroactively emit handshake logs."),
         maxOutputBytes: z
             .number()
             .int()
             .nonnegative()
             .optional()
             .describe("Per-stream cap on bytes returned to the caller (tail-only). Applied independently to stdout and stderr, so the combined response can be up to ~2x this value. Defaults to 65536 (64 KiB). The full output is always saved to disk regardless; only the returned text is trimmed. Set higher when you need more context, lower to save tokens."),
-    }, async ({ cmdString, connectionName, timeout, stream, maxOutputBytes }, extra) => {
+    }, async ({ cmdString, connectionName, timeout, stream, reuseConnection, vvv, maxOutputBytes }, extra) => {
         try {
             const resolvedName = sshManager.resolveServer(connectionName);
             const useStream = stream !== false;
@@ -54,6 +62,8 @@ export function registerExecuteCommandTool(server) {
                 const result = await sshManager.executeCommandWithProgress(cmdString, resolvedName, {
                     timeout: timeout || 300000,
                     maxOutputBytes,
+                    reuseConnection,
+                    vvv,
                     onProgress,
                 });
                 return {
@@ -63,6 +73,8 @@ export function registerExecuteCommandTool(server) {
             const result = await sshManager.executeCommand(cmdString, resolvedName, {
                 timeout: timeout || 30000,
                 maxOutputBytes,
+                reuseConnection,
+                vvv,
             });
             return {
                 content: [{ type: "text", text: result }],

package/build/tools/help.js

@@ -18,19 +18,30 @@ Example:
 Parameters:
   cmdString       (string, required)   The shell command to execute.
   connectionName  (string, see below)  Target server name from list-servers.
-  stream          (boolean, optional)  Default true. Set false for short
-                  commands when you only need the final output.
-  timeout         (number, optional)   Max runtime in ms.
-                  Defaults: 300000 (stream) / 30000 (non-stream).
+  stream          (boolean, optional)  Default true. Set false for short
+                  commands when you only need the final output.
+  reuseConnection (boolean, optional)  Default true. Set false after a timeout
+                  or suspected stale cached SSH connection to force a fresh
+                  TCP/SSH connection for this command.
+  vvv             (boolean, optional)  Default false. Append bounded
+                  SSH/channel debug output. Use with reuseConnection=false
+                  when you need fresh handshake logs.
+  timeout         (number, optional)   Per-attempt phase timeout in ms:
+                                      SSH setup, exec-channel open, and
+                                      remote command execution each use this
+                                      cap.
+                  Defaults: 300000 (stream) / 30000 (non-stream).
 
 connectionName rule:
   • If only one server is enabled → optional (auto-selected).
   • If multiple servers are enabled → REQUIRED.
 
 Examples:
-  execute-command { cmdString: "pwd" }
-  execute-command { cmdString: "docker ps -a", connectionName: "prod", stream: false }
-  execute-command { cmdString: "tail -f /var/log/syslog", stream: true, timeout: 600000 }`,
+  execute-command { cmdString: "pwd" }
+  execute-command { cmdString: "docker ps -a", connectionName: "prod", stream: false }
+  execute-command { cmdString: "tail -f /var/log/syslog", stream: true, timeout: 600000 }
+  execute-command { cmdString: "hostname", connectionName: "scnet", stream: false, reuseConnection: false }
+  execute-command { cmdString: "hostname", connectionName: "scnet", stream: false, reuseConnection: false, vvv: true }`,
     "show-whitelist": `show-whitelist — Show the active command policy for a server.
 
 Parameters:
@@ -41,34 +52,75 @@ connectionName rule:
   • If multiple servers are enabled → REQUIRED.
 
 Returns: Command mode, built-in blacklist, configured whitelist/blacklist patterns, and example commands when whitelist mode is active.`,
-    "upload": `upload — Upload a single local file to a remote server over SFTP.
+    "close-connection": `close-connection — Close a cached SSH connection.
+
+Parameters:
+  connectionName  (string, see below)  Target server name from list-servers.
+
+connectionName rule:
+  • If only one server is enabled → optional (auto-selected).
+  • If multiple servers are enabled → REQUIRED.
+
+Behavior:
+  • Closes the cached/reused SSH client for the target server.
+  • Closing a jump host also closes cached targets whose jump chain uses it.
+  • Does not affect reuseConnection=false commands, because those one-shot
+    connections already close after each command.
+
+Examples:
+  close-connection { connectionName: "scnet" }
+  close-connection { connectionName: "dcu" }`,
+    "upload": `upload — Upload a single local file to a remote server over SFTP.
 
 Parameters:
   localPath       (string, required)   File path on the MCP host.
                   Must be inside the MCP working directory.
-  remotePath      (string, required)   Destination path on the remote server.
-  connectionName  (string, see below)  Target server name from list-servers.
-
-connectionName rule:
-  • If only one server is enabled → optional (auto-selected).
-  • If multiple servers are enabled → REQUIRED.
-
-Example:
-  upload { localPath: "data.csv", remotePath: "/tmp/data.csv" }`,
+  remotePath      (string, required)   Destination path on the remote server.
+  connectionName  (string, see below)  Target server name from list-servers.
+  skipIfIdentical (boolean, optional)  Default true. Skip when remote matches.
+  reuseConnection (boolean, optional)  Default true. Set false after timeout
+                  or suspected stale cached SSH connection.
+  timeout         (number, optional)   SSH setup and SFTP channel-open timeout.
+  vvv             (boolean, optional)  Default false. Append bounded SSH/SFTP debug.
+                  Recursive success returns structured JSON; debug is surfaced
+                  for single-file results, relay results, and recursive errors.
+  fast            (boolean, optional)  Default false. Use ssh2 fastPut for
+                  single-file upload throughput. Not multi-file concurrency.
+  sftpConcurrency (number, optional)   Only with fast=true. Concurrent SFTP chunks.
+  chunkSize       (number, optional)   Only with fast=true. SFTP chunk bytes.
+
+connectionName rule:
+  • If only one server is enabled → optional (auto-selected).
+  • If multiple servers are enabled → REQUIRED.
+
+Example:
+  upload { localPath: "data.csv", remotePath: "/tmp/data.csv" }
+  upload { localPath: "big.bin", remotePath: "/tmp/big.bin", fast: true,
+           sftpConcurrency: 32, chunkSize: 131072 }`,
     "download": `download — Download a single file from a remote server over SFTP.
 
 Parameters:
-  remotePath      (string, required)   File path on the remote server.
-  localPath       (string, required)   Destination on the MCP host.
-                  Must be inside the MCP working directory.
-  connectionName  (string, see below)  Target server name from list-servers.
-
-connectionName rule:
-  • If only one server is enabled → optional (auto-selected).
-  • If multiple servers are enabled → REQUIRED.
-
-Example:
-  download { remotePath: "/var/log/app.log", localPath: "app.log" }`,
+  remotePath      (string, required)   File path on the remote server.
+  localPath       (string, required)   Destination on the MCP host.
+                  Must be inside the MCP working directory.
+  connectionName  (string, see below)  Target server name from list-servers.
+  reuseConnection (boolean, optional)  Default true. Set false after timeout
+                  or suspected stale cached SSH connection.
+  timeout         (number, optional)   SSH setup and SFTP channel-open timeout.
+  vvv             (boolean, optional)  Default false. Append bounded SSH/SFTP debug.
+  fast            (boolean, optional)  Default false. Use ssh2 fastGet for
+                  single-file download throughput. Not multi-file concurrency.
+  sftpConcurrency (number, optional)   Only with fast=true. Concurrent SFTP chunks.
+  chunkSize       (number, optional)   Only with fast=true. SFTP chunk bytes.
+
+connectionName rule:
+  • If only one server is enabled → optional (auto-selected).
+  • If multiple servers are enabled → REQUIRED.
+
+Example:
+  download { remotePath: "/var/log/app.log", localPath: "app.log" }
+  download { remotePath: "/tmp/big.bin", localPath: "big.bin", fast: true,
+             sftpConcurrency: 32, chunkSize: 131072 }`,
     "transfer": `transfer — Move files between hosts (single/recursive/cross-server).
 
 Modes:
@@ -83,15 +135,28 @@ Parameters for upload / download:
   mode            (string, required)   "upload" or "download"
   localPath       (string, required)   Path on the MCP host.
   remotePath      (string, required)   Path on the remote server.
-  connectionName  (string, see below)  Target server name.
-  recursive       (boolean, optional)  True to transfer a whole directory tree.
-
-Parameters for relay:
+  connectionName  (string, see below)  Target server name.
+  recursive       (boolean, optional)  True to transfer a whole directory tree.
+  reuseConnection (boolean, optional)  Default true. Set false after timeout.
+  timeout         (number, optional)   SSH setup and SFTP channel-open timeout.
+  vvv             (boolean, optional)  Default false. Append bounded SSH/SFTP debug.
+  fast            (boolean, optional)  Default false. upload/download only:
+                  use ssh2 fastPut/fastGet for each single file. Directory
+                  recursion stays sequential; no multi-file concurrency.
+  sftpConcurrency (number, optional)   Only with fast=true. Concurrent SFTP chunks.
+  chunkSize       (number, optional)   Only with fast=true. SFTP chunk bytes.
+
+Parameters for relay:
   mode              (string, required)   "relay"
   sourceServer      (string, required)   Server name to read from.
-  sourceRemotePath  (string, required)   File path on source server.
-  destServer        (string, required)   Server name to write to.
-  destRemotePath    (string, required)   File path on dest server.
+  sourceRemotePath  (string, required)   File path on source server.
+  destServer        (string, required)   Server name to write to.
+  destRemotePath    (string, required)   File path on dest server.
+  reuseConnection   (boolean, optional)  Default true. Set false after timeout.
+  timeout           (number, optional)   SSH setup and SFTP channel-open timeout.
+  vvv               (boolean, optional)  Default false. Append bounded SSH/SFTP debug.
+  fast              (boolean, optional)  Accepted but relay keeps the streaming
+                    SFTP pipe path; fastGet/fastPut apply to host<->remote only.
 
 connectionName rule (upload/download):
   • If only one server is enabled → optional.
@@ -113,18 +178,20 @@ Example:
 };
 const TOOL_OVERVIEW = `Available tools (use help { tool: "<name>" } for details):
 
-  list-servers      Discover available SSH servers and their status.
-  execute-command   Run a shell command on a remote server.
+  list-servers      Discover available SSH servers and their status.
+  execute-command   Run a shell command on a remote server.
   show-whitelist    Show the active command policy.
-  upload            Upload a single file to a remote server.
-  download          Download a single file from a remote server.
+  close-connection  Close a cached SSH connection for a server.
+  upload            Upload a single file to a remote server.
+  download          Download a single file from a remote server.
   transfer          Move files: single, recursive, or cross-server relay.
   help              Show this help or detailed per-tool usage.
 
 Quick start:
-  1. list-servers → discover server names
+  1. list-servers → discover server names
   2. show-whitelist { connectionName: "<name>" } → inspect command policy
-  3. execute-command { cmdString: "pwd", connectionName: "<name>" }`;
+  3. execute-command { cmdString: "pwd", connectionName: "<name>" }
+  4. close-connection { connectionName: "<name>" } → drop a stale cached SSH client`;
 /**
  * Register help tool
  */

package/build/tools/index.js

@@ -3,6 +3,7 @@ import { registerUploadTool } from "./upload.js";
 import { registerDownloadTool } from "./download.js";
 import { registerListServersTool } from "./list-servers.js";
 import { registerShowWhitelistTool } from "./show-whitelist.js";
+import { registerCloseConnectionTool } from "./close-connection.js";
 import { registerTransferTool } from "./transfer.js";
 import { registerHelpTool } from "./help.js";
 /**
@@ -15,6 +16,7 @@ export function registerAllTools(server) {
     registerDownloadTool(server);
     registerListServersTool(server);
     registerShowWhitelistTool(server);
+    registerCloseConnectionTool(server);
     registerTransferTool(server);
     registerHelpTool(server);
 }

package/build/tools/transfer.js

@@ -37,22 +37,28 @@ For relay mode, specify sourceServer, sourceRemotePath, destServer, destRemotePa
             "Upload: byte-compare for files \u2264 256 MiB, MD5 otherwise; shell scripts (.sh / .bash / .zsh) ignore CRLF\u2194LF differences. " +
             "Relay: size match + md5sum match on both servers (when available); falls back to transferring if md5sum is missing on either side. " +
             "Download is never skipped. Set to false to force the transfer."),
+        reuseConnection: z.boolean().optional().describe("Default true. Reuse cached SSH connection(s) for SFTP. Set false after a timeout or suspected stale cached connection to force fresh TCP/SSH connection(s) for this transfer; fresh connections close afterwards."),
+        timeout: z.number().positive().optional().describe("Timeout in ms for SSH setup and SFTP channel opening. Transfer stream duration itself is not forcibly interrupted by this option."),
+        vvv: z.boolean().optional().describe("Default false. Append bounded SSH/SFTP debug output for single-file and relay results, and for recursive errors. For fresh ssh2 handshake logs, also set reuseConnection=false."),
+        fast: z.boolean().optional().describe("Default false. Upload/download only: use ssh2 fastPut/fastGet for single files, with parallel SFTP chunks for better throughput. Relay mode keeps the streaming pipe path."),
+        sftpConcurrency: z.number().int().positive().optional().describe("Only used when fast=true for upload/download. Number of concurrent SFTP chunks; omitted uses ssh2's default."),
+        chunkSize: z.number().int().positive().optional().describe("Only used when fast=true for upload/download. Chunk size in bytes; omitted uses ssh2's default."),
     }, async (params) => {
         try {
             const { mode } = params;
             if (mode === "relay") {
-                const { sourceServer, sourceRemotePath, destServer, destRemotePath, skipIfIdentical } = params;
+                const { sourceServer, sourceRemotePath, destServer, destRemotePath, skipIfIdentical, reuseConnection, timeout, vvv } = params;
                 if (!sourceServer || !sourceRemotePath || !destServer || !destRemotePath) {
                     return {
                         content: [{ type: "text", text: "relay mode requires: sourceServer, sourceRemotePath, destServer, destRemotePath" }],
                         isError: true,
                     };
                 }
-                const result = await sshManager.transferBetweenServers(sourceServer, sourceRemotePath, destServer, destRemotePath, { skipIfIdentical: skipIfIdentical !== false });
+                const result = await sshManager.transferBetweenServers(sourceServer, sourceRemotePath, destServer, destRemotePath, { skipIfIdentical: skipIfIdentical !== false, reuseConnection, timeout, vvv });
                 return { content: [{ type: "text", text: result }] };
             }
             // upload or download
-            const { localPath, remotePath, connectionName, recursive, skipIfIdentical } = params;
+            const { localPath, remotePath, connectionName, recursive, skipIfIdentical, reuseConnection, timeout, vvv, fast, sftpConcurrency, chunkSize } = params;
             if (!localPath || !remotePath) {
                 return {
                     content: [{ type: "text", text: `${mode} mode requires: localPath, remotePath` }],
@@ -60,14 +66,15 @@ For relay mode, specify sourceServer, sourceRemotePath, destServer, destRemotePa
                 };
             }
             const resolvedName = sshManager.resolveServer(connectionName);
-            const uploadOptions = { skipIfIdentical: skipIfIdentical !== false };
+            const sftpOptions = { reuseConnection, timeout, vvv, fast, sftpConcurrency, chunkSize };
+            const uploadOptions = { skipIfIdentical: skipIfIdentical !== false, ...sftpOptions };
             if (recursive) {
                 let files;
                 if (mode === "upload") {
                     files = await sshManager.uploadDirectory(localPath, remotePath, resolvedName, uploadOptions);
                 }
                 else {
-                    files = await sshManager.downloadDirectory(remotePath, localPath, resolvedName);
+                    files = await sshManager.downloadDirectory(remotePath, localPath, resolvedName, sftpOptions);
                 }
                 const summary = `Recursive ${mode} complete. ${files.length} file(s) transferred.`;
                 return {
@@ -80,7 +87,7 @@ For relay mode, specify sourceServer, sourceRemotePath, destServer, destRemotePa
                 return { content: [{ type: "text", text: result }] };
             }
             else {
-                const result = await sshManager.download(remotePath, localPath, resolvedName);
+                const result = await sshManager.download(remotePath, localPath, resolvedName, sftpOptions);
                 return { content: [{ type: "text", text: result }] };
             }
         }

package/build/tools/upload.js

@@ -14,11 +14,23 @@ export function registerUploadTool(server) {
         remotePath: z.string().describe("Destination path on the remote server. Must be an absolute POSIX path (e.g. /home/user/uploads/file.txt); restricted to allowedRemoteDirectories only if the server configures that list."),
         connectionName: z.string().optional().describe("Target server name from list-servers. Required when multiple servers are enabled; optional when only one server is enabled."),
         skipIfIdentical: z.boolean().optional().describe("When true (default), skip the upload if the remote file is already identical (byte-compare for files \u2264 256 MiB, MD5 otherwise; shell scripts ignore CRLF\u2194LF differences). Set to false to force re-upload."),
-    }, async ({ localPath, remotePath, connectionName, skipIfIdentical }) => {
+        reuseConnection: z.boolean().optional().describe("Default true. Reuse the cached SSH connection for SFTP. Set false after a timeout or suspected stale cached SSH connection to force a fresh TCP/SSH connection for this transfer; the fresh connection closes afterwards."),
+        timeout: z.number().positive().optional().describe("Timeout in ms for SSH setup and SFTP channel opening. Transfer stream duration itself is not forcibly interrupted by this option."),
+        vvv: z.boolean().optional().describe("Default false. Append bounded SSH/SFTP debug output. For fresh ssh2 handshake logs, also set reuseConnection=false."),
+        fast: z.boolean().optional().describe("Default false. When true, use ssh2 fastPut for a single-file upload, which performs parallel SFTP reads/writes for better throughput. If a shell script needs CRLF-to-LF conversion, the upload falls back to the normal safe path."),
+        sftpConcurrency: z.number().int().positive().optional().describe("Only used when fast=true. Number of concurrent SFTP chunks for ssh2 fastPut; omitted uses ssh2's default."),
+        chunkSize: z.number().int().positive().optional().describe("Only used when fast=true. Chunk size in bytes for ssh2 fastPut; omitted uses ssh2's default."),
+    }, async ({ localPath, remotePath, connectionName, skipIfIdentical, reuseConnection, timeout, vvv, fast, sftpConcurrency, chunkSize }) => {
         try {
             const resolvedName = sshManager.resolveServer(connectionName);
             const result = await sshManager.upload(localPath, remotePath, resolvedName, {
                 skipIfIdentical: skipIfIdentical !== false,
+                reuseConnection,
+                timeout,
+                vvv,
+                fast,
+                sftpConcurrency,
+                chunkSize,
             });
             return {
                 content: [{ type: "text", text: result }],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aaarc/handfree-ssh-mcp",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Handfree SSH MCP Server - A hands-free SSH automation tool via MCP protocol",
   "main": "build/index.js",
   "type": "module",