ssh-client-wrapper 2.14.0 → 2.15.0

package/README.md

@@ -96,6 +96,40 @@ Downloads files or directories from the remote host using `rsync`.
 *   `dst` (string): The local destination path.
 *   Returns: `Promise<void>`
 
+### `.remoteToRemoteCopy(src, dstHostInfo, dst, [opt], [timeout])`
+Copies files or directories directly from this remote host to another remote host using `rsync` with SSH agent forwarding.
+
+*   `src` (string[]): An array of file or directory paths on this (source) remote host.
+*   `dstHostInfo` (Object): Destination host information (requires `host` property; optionally `user`, `port`, `noStrictHostKeyChecking`).
+*   `dst` (string): Destination path on the destination remote host.
+*   `opt` (string[], optional): Additional options for rsync (e.g., `["--exclude=*.log"]`).
+*   `timeout` (number, optional): Timeout in seconds.
+*   Returns: `Promise<void>`
+
+**Note:** This method requires SSH agent forwarding to be enabled. Your SSH key must be loaded in the SSH agent on localhost, and the connection to the source host must forward the agent. No password or keyFile is needed for the source → destination connection as it uses the forwarded SSH agent.
+
+**Example:**
+```javascript
+const srcHost = new SshClientWrapper({
+  host: 'source.server.com',
+  user: 'user1',
+  keyFile: '/path/to/key'
+});
+
+const dstHostInfo = {
+  host: 'destination.server.com',
+  user: 'user2'
+};
+
+// Copy files directly from source to destination
+await srcHost.remoteToRemoteCopy(
+  ['/remote/path/file.txt', '/remote/path/dir/'],
+  dstHostInfo,
+  '/destination/path/',
+  ['--exclude=*.tmp']
+);
+```
+
 ### `.canConnect([timeout])`
 Checks if a connection to the remote host can be established.
 

package/lib/index.js

@@ -220,6 +220,42 @@ class SshClientWrapper {
     return this.deps.canConnect(this.hostInfo, timeout);
   }
 
+  /**
+   * Copy files directly from this remote host to another remote host using SSH agent forwarding.
+   * @param {string[]} src - File or directory paths on this (source) remote host.
+   * @param {object} dstHostInfo - Destination host information (needs host and user properties).
+   * @param {string} dst - Destination path on the destination remote host.
+   * @param {string[]} opt - options for rsync
+   * @param {Integer} timeout - timeout in seconds
+   * @returns {Promise} - Resolved when file transfer is done.
+   * 
+   * Note: This requires SSH agent forwarding to be available.
+   * The SSH agent on localhost must be forwarded to the source host,
+   * and then forwarded again to the destination host.
+   */
+  async remoteToRemoteCopy(src, dstHostInfo, dst, opt = [], timeout = 0) {
+    debug("remoteToRemoteCopy called", src, "to", dstHostInfo.host, dst);
+
+    if (!isArrayOfString(src)) {
+      return logAndReject("src must be array of string");
+    }
+    if (!src.some((e)=>{
+      return e !== "";
+    })) {
+      return logAndReject("src must contain non-empty string");
+    }
+    if (typeof dstHostInfo !== "object" || !dstHostInfo.host) {
+      return logAndReject("dstHostInfo must be object with host property");
+    }
+    if (typeof dst !== "string" || dst === "") {
+      return logAndReject("dst must be non-empty string");
+    }
+    if (typeof opt !== "undefined" && !isArrayOfString(opt)) {
+      return logAndReject("opt must be array of string");
+    }
+    return this.deps.remoteToRemoteCopy(this.hostInfo, src, dstHostInfo, dst, opt, timeout);
+  }
+
   /**
    * Disconnect master session
    */

package/lib/rsyncExec.js

@@ -127,3 +127,70 @@ export async function recv(hostInfo, argSrc, dst, rsyncOpt, timeout) {
   debugVerbose(`recv: ${rsyncCmd} ${args.join(" ")}`);
   return retryWrapper(fork.bind(null, hostInfo, rsyncCmd, args, timeout, null, acceptableRsyncRetrunCodes), hostInfo);
 }
+
+/**
+ * Copy files directly between remote hosts using rsync over SSH with agent forwarding.
+ * This function executes rsync on the source remote host to transfer files directly
+ * to the destination remote host, avoiding the need to download and upload through localhost.
+ * @param {object} srcHostInfo - source host information object
+ * @param {string[]} argSrc - File or directory paths on the source remote host
+ * @param {object} dstHostInfo - destination host information object (needs host and user properties)
+ * @param {string} dst - Destination path on the destination remote host
+ * @param {string[]} rsyncOpt - optional arguments for rsync
+ * @param {Integer} timeout - timeout in seconds
+ * @returns {Promise} - Resolved when transfer is complete
+ *
+ * Authentication from source to destination uses SSH agent forwarding,
+ * so dstHostInfo does not need keyFile or password.
+ */
+export async function remoteToRemoteCopy(srcHostInfo, argSrc, dstHostInfo, dst, rsyncOpt, timeout) {
+  await connect(srcHostInfo);
+  
+  //Construct destination specification for rsync: user@host:path
+  let dstSpec = dstHostInfo.host;
+  if (dstHostInfo.user) {
+    dstSpec = `${dstHostInfo.user}@${dstHostInfo.host}`;
+  }
+  dstSpec = `${dstSpec}:${dst}`;
+  
+  //Build SSH options for the nested SSH connection (from src to dst)
+  const nestedSshArgs = ["-A"]; //Enable agent forwarding
+  
+  if (dstHostInfo.port) {
+    nestedSshArgs.push("-p", dstHostInfo.port.toString());
+  }
+  if (dstHostInfo.noStrictHostKeyChecking) {
+    nestedSshArgs.push("-oStrictHostKeyChecking=no");
+  }
+  
+  //Build rsync command to be executed on the source host
+  const rshOpt = `-e '${sshCmd} ${nestedSshArgs.join(" ")}'`;
+  const rsyncOptStr = rsyncOpt.length > 0 ? rsyncOpt.join(" ") : "";
+  const srcPaths = argSrc.join(" ");
+  
+  //Create destination directory on the destination host
+  let remoteMkdirCmd = "";
+  if (dst.endsWith("/")) {
+    remoteMkdirCmd = `mkdir -p ${dst}`;
+  } else {
+    const { dir } = path.parse(dst);
+    if (dir !== "" && dir !== "/") {
+      remoteMkdirCmd = `mkdir -p ${dir}`;
+    }
+  }
+  
+  if (remoteMkdirCmd) {
+    //Execute mkdir on destination host via source host with agent forwarding
+    const dstUser = dstHostInfo.user ? `${dstHostInfo.user}@` : "";
+    const mkdirSshCmd = `${sshCmd} -A ${nestedSshArgs.filter(arg=>{return arg !== "-A";}).join(" ")} ${dstUser}${dstHostInfo.host} '${remoteMkdirCmd}'`;
+    debug(`creating remote directory: ${mkdirSshCmd}`);
+    await sshExec(srcHostInfo, mkdirSshCmd, timeout, debugVerbose);
+  }
+  
+  //Execute rsync on source host
+  const rsyncRemoteCmd = `rsync -avv --copy-unsafe-links ${rshOpt} ${rsyncOptStr} ${srcPaths} ${dstSpec}`;
+  debug(`remote to remote copy: ${rsyncRemoteCmd}`);
+  debugVerbose(`executing on ${srcHostInfo.host}: ${rsyncRemoteCmd}`);
+  
+  return sshExec(srcHostInfo, rsyncRemoteCmd, timeout, debugVerbose);
+}

package/lib/util.js

@@ -201,6 +201,12 @@ export const getSshOption = (hostInfo, withoutDestination)=>{
   if (hostInfo.noStrictHostKeyChecking) {
     args.push("-oStrictHostKeyChecking=no");
   }
+  
+  //Enable SSH agent forwarding if keyFile is set (indicates we're using key-based auth)
+  if (hostInfo.keyFile) {
+    args.push("-A");
+  }
+  
   const controlPersist = Number.isInteger(hostInfo.ControlPersist) && hostInfo.ControlPersist >= 0 ? hostInfo.ControlPersist : "180";
   const controlPersistDir = getControlPersistDir(hostInfo);
   args.push("-oControlMaster=auto");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ssh-client-wrapper",
-  "version": "2.14.0",
+  "version": "2.15.0",
   "description": "wrapper library for open ssh client and rsync",
   "keywords": [
     "ssh",
@@ -38,7 +38,7 @@
     "ajv": "^8.17.1",
     "ajv-keywords": "^5.1.0",
     "debug": "^4.4.3",
-    "glob": "^11.0.3",
+    "glob": "^12.0.0",
     "node-pty-prebuilt-multiarch": "^0.10.1-pre.5"
   },
   "devDependencies": {
@@ -51,6 +51,7 @@
     "c8": "^10.1.3",
     "chai": "^5.3.1",
     "chai-as-promised": "^8.0.1",
+    "eslint-plugin-chai-expect": "^3.1.0",
     "eslint-plugin-chai-friendly": "^1.1.0",
     "eslint-plugin-jsdoc": "^54.1.0",
     "eslint-plugin-node": "^11.1.0",