ssh-client-wrapper 2.11.0 → 2.13.0

package/lib/index.js

@@ -1,22 +1,24 @@
-"use strict";
-const fs = require("fs");
-const path = require("path");
-const debug = require("debug")("sshClientWrapper:interface");
-const debugVerbose = require("debug")("sshClientWrapper:verbose:interface");
-const { sshExec, canConnect, disconnect, ls } = require("./sshExec.js");
-const { send, recv } = require("./rsyncExec.js");
-const { isArrayOfString, sanityCheck } = require("./util.js");
+import fs from "fs";
+import path from "path";
+import Debug from "debug";
+import * as sshExecModule from "./sshExec.js";
+import * as rsyncExecModule from "./rsyncExec.js";
+import { isArrayOfString, sanityCheck } from "./util.js";
+
+const debug = Debug("sshClientWrapper:debug:interface");
+const debugVerbose = Debug("sshClientWrapper:verbose:interface");
 
 /**
  * Integer means integer number but it is defined as Object for now
  * workaround for eslint-plugin-jsdoc's no-undefined-types rule bug.
- * @typedef {Object} Integer
+ * @typedef {object} Integer
+ * @property
  */
 
 /**
  * host info object which contain all settings for 1 remote host
  * it will be (shallow) copied in constructor.
- * @param {Object} hostInfo - option object
+ * @param {object} hostInfo - option object
  * @param {string} hostInfo.host - destination
  * @param {string} hostInfo.user - login name
  * @param {number} hostInfo.port - port number
@@ -24,32 +26,33 @@ const { isArrayOfString, sanityCheck } = require("./util.js");
  * @param {string | Function} hostInfo.passphrase - passphrase or function which return passphrase of private key
  * @param {string} hostInfo.keyFile - private key filename
  * @param {boolean} hostInfo.noStrictHostKeyChecking - bypass host key checking if true
- * @param {Integer} hostInfo.ControlPersist=180 - how long keep master connection after last client connection has been closed (sec).
- * @param {Integer} hostInfo.ConnectTimeout=60 - timeout used when connectiong to ths SSH server
- * @param {Integer} hostInfo.maxRetry=3 - max number of retry
- * @param {Integer} hostInfo.retryDuration=1000 - duration time (msec) between each retry
+ * @param {Integer} hostInfo.ControlPersist - how long keep master connection after last client connection has been closed (sec).
+ * @param {Integer} hostInfo.ConnectTimeout - timeout used when connectiong to ths SSH server
+ * @param {Integer} hostInfo.maxRetry - max number of retry
+ * @param {Integer} hostInfo.retryDuration - duration time (msec) between each retry
  * @param {string} hostInfo.rcfile - rcfile path which will be sourced before executing actual command
  * @param {string} hostInfo.prependCmd - command string which will be executed before executing actual command
  * @param {string[]} hostInfo.sshOpt - additional options for ssh
  */
 
-const logAndReject = (message) => {
+const logAndReject = (message)=>{
   debug(message);
   return Promise.reject(new Error(message));
 };
 
 /**
  * Facade class.
- * @constructor
+ * @class
  */
 class SshClientWrapper {
-  constructor (hostInfo) {
+  constructor(hostInfo, deps = { ...sshExecModule, ...rsyncExecModule }) {
     debug("constructor called for", hostInfo.host);
     debugVerbose("hostInfo=", hostInfo);
     this.hostInfo = { ...hostInfo };
     sanityCheck(this.hostInfo);
     this.hostInfo.masterPty = null;
     this.hostInfo.rsyncVersion = null;
+    this.deps = deps;
 
     if (process.env.HOME) {
       try {
@@ -73,13 +76,46 @@ class SshClientWrapper {
    *
    * note rcfile and prependCmd override hostInfo.rcfile and hostInfo.prependCmd respectively
    */
-  async exec (cmd, timeout = 0, outputCallback = null, rcfile = null, prependCmd = null) {
+  async exec(cmd, timeout = 0, outputCallback = null, rcfile = null, prependCmd = null) {
     debug("exec called", cmd);
 
     if (typeof cmd !== "string" || cmd === "") {
       return logAndReject("cmd must be string");
     }
-    return sshExec(this.hostInfo, cmd, timeout, outputCallback, rcfile, prependCmd);
+    return this.deps.sshExec(this.hostInfo, cmd, timeout, outputCallback, rcfile, prependCmd);
+  }
+
+  /**
+   * execute command on remote host and get output text
+   * @param {string} cmd - Cmdline which will be executed.
+   * @param {Integer} timeout - timeout in secconds
+   * @param {string} rcfile - rcfile path which will be sourced before executing actual command
+   * @param {string} prependCmd - command string which will be executed before executing actual command
+   * @returns {object} - output test array (output) and return value of cmd (rt)
+   */
+  async execAndGetOutput(cmd, timeout = 0, rcfile = null, prependCmd = null) {
+    debug("execAndGetOutput called", cmd);
+    const outputArray = [];
+    const cb = (data)=>{
+      outputArray.push(data);
+    };
+    let rt = null;
+    try {
+      rt = await this.deps.sshExec(this.hostInfo, cmd, timeout, cb, rcfile, prependCmd);
+    } catch (e) {
+    //non-zero retrun should be allowed
+      if (typeof e.rt === "undefined" || e.rt < 0) {
+        throw e;
+      }
+    }
+    const output = outputArray.length === 0
+      ? []
+      : outputArray
+          .join("\n")
+          .replace(/\n+/g, "\n")
+          .replace(/\n$/, "")
+          .split("\n");
+    return { output, rt };
   }
 
   /**
@@ -89,9 +125,22 @@ class SshClientWrapper {
    * @param {Integer} timeout - timeout in secconds
    * @returns {string[]} - output from ls
    */
-  async ls (target, lsOpt = [], timeout = 0) {
+  async ls(target, lsOpt = [], timeout = 0) {
     debug("ls called", target, lsOpt);
-    return ls(this.hostInfo, target, lsOpt, timeout);
+    const { output, rt } = await this.execAndGetOutput(`ls ${lsOpt.join(" ")} ${target}`, timeout);
+    return rt === 0 ? output : rt;
+  }
+
+  /**
+   * execute series of comands like expect(3)
+   * @param {string} cmd - Cmdline which will be executed.
+   * @param {Array} expects - array of expect and send string pairs
+   * @param {Integer} timeout - timeout in secconds
+   * @returns {Integer} - Return code of cmd.
+   */
+  async expect(cmd, expects, timeout = 180) {
+    debug("expect called", expects);
+    return this.deps.expect(this.hostInfo, cmd, expects, timeout);
   }
 
   /**
@@ -102,13 +151,13 @@ class SshClientWrapper {
    * @param {Integer} timeout - timeout in secconds
    * @returns {Promise} - Resolved with undefined when file transfer is done.
    */
-  async send (src, dst, opt = [], timeout = 0) {
+  async send(src, dst, opt = [], timeout = 0) {
     debug("send called", src, dst, opt);
 
     if (!isArrayOfString(src)) {
       return logAndReject("src must be array of string");
     }
-    if (!src.some((e) => {
+    if (!src.some((e)=>{
       return e !== "";
     })) {
       return logAndReject("src must contain non-empty string");
@@ -122,7 +171,7 @@ class SshClientWrapper {
     if (typeof opt !== "undefined" && !isArrayOfString(opt)) {
       return logAndReject("opt must be array of string");
     }
-    return send(this.hostInfo, src, dst, opt, timeout);
+    return this.deps.send(this.hostInfo, src, dst, opt, timeout);
   }
 
   /**
@@ -133,13 +182,13 @@ class SshClientWrapper {
    * @param {Integer} timeout - timeout in secconds
    * @returns {Promise} - Resolved with undefined when file transfer is done.
    */
-  async recv (src, dst, opt = [], timeout = 0) {
+  async recv(src, dst, opt = [], timeout = 0) {
     debug("recv called", src, dst, opt);
 
     if (!isArrayOfString(src)) {
       return logAndReject("src must be array of string");
     }
-    if (!src.some((e) => {
+    if (!src.some((e)=>{
       return e !== "";
     })) {
       return logAndReject("src must contain non-empty string");
@@ -153,7 +202,7 @@ class SshClientWrapper {
     if (typeof opt !== "undefined" && !isArrayOfString(opt)) {
       return logAndReject("opt must be array of string");
     }
-    return recv(this.hostInfo, src, dst, opt, timeout);
+    return this.deps.recv(this.hostInfo, src, dst, opt, timeout);
   }
 
   /**
@@ -161,23 +210,23 @@ class SshClientWrapper {
    * @param {Integer} timeout - timeout in secconds
    * @returns {Promise} - Resolved with true on success, otherwise rejected with Error.
    */
-  async canConnect (timeout = 60) {
+  async canConnect(timeout = 60) {
     debug("canConnect called with timeout=", timeout);
     debugVerbose("hostInfo=", this.hostInfo);
 
     if (!Number.isInteger(timeout) || timeout <= 0) {
       return logAndReject("timeout must be positive integer");
     }
-    return canConnect(this.hostInfo, timeout);
+    return this.deps.canConnect(this.hostInfo, timeout);
   }
 
   /**
    * Disconnect master session
    */
-  async disconnect () {
+  async disconnect() {
     debug(`disconnect from ${this.hostInfo.host} called`);
-    disconnect(this.hostInfo);
+    this.deps.disconnect(this.hostInfo);
   }
 }
 
-module.exports = SshClientWrapper;
+export default SshClientWrapper;

package/lib/rsyncExec.js

@@ -1,18 +1,19 @@
-"use strict";
-const path = require("path");
-const fs = require("fs/promises");
-const debug = require("debug")("sshClientWrapper:debug:rsyncExec");
-const debugVerbose = require("debug")("sshClientWrapper:verbose:rsyncExec");
-const { glob, hasMagic } = require("glob");
+import path from "path";
+import fs from "fs/promises";
+import Debug from "debug";
+import { glob, hasMagic } from "glob";
 
-const { connect, retryWrapper, sshExec } = require("./sshExec.js");
-const { fork } = require("./fork.js");
+import { connect, retryWrapper, sshExec } from "./sshExec.js";
+import { fork } from "./fork.js";
 
-const { sshCmd, rsyncCmd, acceptableRsyncRetrunCodes, getSshOption } = require("./util.js");
+import { sshCmd, rsyncCmd, acceptableRsyncRetrunCodes, getSshOption } from "./util.js";
 
-async function checkRsyncVersion (timeout) {
+const debug = Debug("sshClientWrapper:debug:rsyncExec");
+const debugVerbose = Debug("sshClientWrapper:verbose:rsyncExec");
+
+export async function checkRsyncVersion(timeout) {
   const rt = {};
-  await fork(null, rsyncCmd, ["--version"], timeout, (output) => {
+  await fork(null, rsyncCmd, ["--version"], timeout, (output)=>{
     const result = /^rsync *version *(\d+)\.(\d+)\.(\d+).*$/m.exec(output);
 
     if (result) {
@@ -26,7 +27,7 @@ async function checkRsyncVersion (timeout) {
 
 /**
  * Send file or directory and its child to server.
- * @param {Object} hostInfo - hostinfo object
+ * @param {object} hostInfo - hostinfo object
  * @param {[string]} argSrc - File or directory name which to be send.
  * @param {string} dst - Destination path.
  * @param {[string]} rsyncOpt - optional arguments for rsync
@@ -34,13 +35,13 @@ async function checkRsyncVersion (timeout) {
  *
  * this function execute rsync -avv --copy-unsafe-links  src rsync://[user@]host[:port]/dst
  */
-async function send (hostInfo, argSrc, dst, rsyncOpt, timeout) {
+export async function send(hostInfo, argSrc, dst, rsyncOpt, timeout) {
   await connect(hostInfo);
-  const promises = await Promise.allSettled(argSrc.map((e) => {
+  const promises = await Promise.allSettled(argSrc.map((e)=>{
     return glob(e);
   }));
   const src = promises
-    .map((e, i) => {
+    .map((e, i)=>{
       if (e.status !== "fulfilled") {
         return null;
       }
@@ -49,10 +50,10 @@ async function send (hostInfo, argSrc, dst, rsyncOpt, timeout) {
       }
       return e.value;
     })
-    .filter((e) => {
+    .filter((e)=>{
       return e !== null;
     })
-    .flatMap((e) => {
+    .flatMap((e)=>{
       return e;
     });
 
@@ -85,14 +86,14 @@ async function send (hostInfo, argSrc, dst, rsyncOpt, timeout) {
 
 /**
  * format src array to src string for recv
- * @param {Object} hostInfo - hostinfo object
+ * @param {object} hostInfo - hostinfo object
  * @returns {boolean} - rsync command version is higher than 3.2.4 or not
  */
-async function isNewRsync (hostInfo) {
-  if (!hostInfo.rsyncVersion ||
-    !Number.isInteger(hostInfo.rsyncVersion.major) ||
-    !Number.isInteger(hostInfo.rsyncVersion.minor) ||
-    !Number.isInteger(hostInfo.rsyncVersion.patch)) {
+async function isNewRsync(hostInfo) {
+  if (!hostInfo.rsyncVersion
+    || !Number.isInteger(hostInfo.rsyncVersion.major)
+    || !Number.isInteger(hostInfo.rsyncVersion.minor)
+    || !Number.isInteger(hostInfo.rsyncVersion.patch)) {
     hostInfo.rsyncVersion = await checkRsyncVersion(3);
   }
   return hostInfo.rsyncVersion.major >= 3 && hostInfo.rsyncVersion.minor >= 2 && hostInfo.rsyncVersion.patch >= 4;
@@ -100,7 +101,7 @@ async function isNewRsync (hostInfo) {
 
 /**
  * Send file or directory and its child to server.
- * @param {Object} hostInfo - hostinfo object
+ * @param {object} hostInfo - hostinfo object
  * @param {[string]} argSrc - File or directory name which to be send.
  * @param {string} dst - Destination path.
  * @param {[string]} rsyncOpt - optional arguments for rsync
@@ -108,7 +109,7 @@ async function isNewRsync (hostInfo) {
  *
  * this function execute rsync -av --copy-unsafe-links  rsync://[user@]host[:port]/src dst
  */
-async function recv (hostInfo, argSrc, dst, rsyncOpt, timeout) {
+export async function recv(hostInfo, argSrc, dst, rsyncOpt, timeout) {
   await connect(hostInfo);
   const src = `${hostInfo.host}:${argSrc.join(" ")}`;
   const sshArgs = getSshOption(hostInfo, true);
@@ -118,7 +119,7 @@ async function recv (hostInfo, argSrc, dst, rsyncOpt, timeout) {
     args.unshift("--old-args");
   }
 
-  // make destination directory
+  //make destination directory
   const dstDir = argSrc.len > 1 || hasMagic(argSrc[0]) ? dst : path.dirname(dst);
   await fs.mkdir(dstDir, { recursive: true });
 
@@ -126,8 +127,3 @@ 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);
 }
-module.exports = {
-  checkRsyncVersion,
-  send,
-  recv
-};

package/lib/sshExec.js

@@ -1,22 +1,28 @@
-"use strict";
-const crypto = require("crypto");
-const { setTimeout: setTimeoutPromise } = require("timers/promises");
-const debug = require("debug")("sshClientWrapper:debug:sshExec");
-const debugVerbose = require("debug")("sshClientWrapper:verbose:sshExec");
-const debugSendMasterPty = require("debug")("sshClientWrapperInsecure:sshExec_masterPty");
-const { sendPty, sshCmd, getSshOption, sanityCheck, watchDogTimer } = require("./util.js");
-const { fork, createMasterPty, sshLoginCallback } = require("./fork.js");
+import crypto from "crypto";
+import { setTimeout as setTimeoutPromise } from "timers/promises";
+import Debug from "debug";
+import { sendPty, sshCmd, getSshOption, sanityCheck, watchDogTimer } from "./util.js";
+import { fork, createMasterPty, sshLoginCallback } from "./fork.js";
+
+const debug = Debug("sshClientWrapper:debug:sshExec");
+const debugVerbose = Debug("sshClientWrapper:verbose:sshExec");
+const debugSendMasterPty = Debug("sshClientWrapper:insecure:sshExec:masterPty");
+
+/**
+ * @typedef Integer {number} - integer number
+ */
 
 /**
  * Execute command on remote host.
- * @param {Object} hostInfo - hostinfo object
+ * @param {object} hostInfo - hostinfo object
  * @param {string} cmd - Cmdline which will be executed on remote host.
  * @param {number} timeout - timeout (in sec.)
+ * @param {Function} outputCallback - Callback routine for stdout and stderr.
  * @param {string} rcfile - rcfile path which will be sourced before executing actual command
  * @param {string} prependCmd - command string which will be executed before executing actual command
- * @param {Function} outputCallback - Callback routine for stdout and stderr.
+ * @returns {Integer} - return value of cmd
  */
-async function sshExec (hostInfo, cmd, timeout, outputCallback, rcfile, prependCmd) {
+export async function sshExec(hostInfo, cmd, timeout, outputCallback, rcfile, prependCmd) {
   debug("sshExec called");
   await connect(hostInfo);
   debug("exec", cmd, "on remote server");
@@ -44,11 +50,42 @@ async function sshExec (hostInfo, cmd, timeout, outputCallback, rcfile, prependC
     }
     if (e.rt === 126) {
       debug(`${cmd} got Permission deny error but ignored`);
-      return e.rt;
     }
     if (e.rt === 127) {
       debug(`${cmd} not found but ignored`);
-      return e.rt;
+    }
+    return e.rt;
+  }
+}
+
+export async function expect(hostInfo, cmd, expects, timeout) {
+  debug("expect called");
+  await connect(hostInfo);
+  debugVerbose("exec", cmd, "on remote server with", expects);
+  const args = getSshOption(hostInfo, false);
+  const compiledExpects = expects.map((e)=>{
+    return {
+      reExpect: new RegExp(e.expect),
+      send: e.send,
+      keep: e.keep
+    };
+  });
+  const reExpect = hostInfo.prompt ? new RegExp(hostInfo.prompt) : /[$#>] /;
+  compiledExpects.unshift({ reExpect, send: cmd });
+  compiledExpects.push({ reExpect, send: "exit" });
+
+  try {
+    const rt = await fork(hostInfo, sshCmd, args, timeout, null, [], compiledExpects);
+    return rt;
+  } catch (e) {
+    if (typeof e.rt === "undefined") {
+      throw e;
+    }
+    if (e.rt === 126) {
+      debug(`${cmd} got Permission deny error but ignored`);
+    }
+    if (e.rt === 127) {
+      debug(`${cmd} not found but ignored`);
     }
     return e.rt;
   }
@@ -56,32 +93,32 @@ async function sshExec (hostInfo, cmd, timeout, outputCallback, rcfile, prependC
 
 /**
  * Check if you can connect to sepecified server
- * @param {Object} hostInfo - hostinfo object
+ * @param {object} hostInfo - hostinfo object
  * @param {Integer} timeout - timeout in secconds
  */
-async function canConnect (hostInfo, timeout = 60) {
+export async function canConnect(hostInfo, timeout) {
   debug("canConnect called");
   sanityCheck(hostInfo);
 
   await connect(hostInfo, timeout);
   await disconnect(hostInfo);
-  // if connection fail, Error is throwed.
-  // so, if we reach here, connection must be succeeded
+  //if connection fail, Error is throwed.
+  //so, if we reach here, connection must be succeeded
   return true;
 }
 
 /**
  * check if master session exists or not
- * @param {Object} hostInfo - hostinfo object
+ * @param {object} hostInfo - hostinfo object
  * @returns {boolean} - true if master session exists
  */
-async function existsMaster (hostInfo, argTimeout) {
+async function existsMaster(hostInfo, argTimeout) {
   debugVerbose("existsMaster called");
   const args = getSshOption(hostInfo);
   args.push("-Ocheck");
 
   let output = "";
-  const cb = (e) => {
+  const cb = (e)=>{
     output += e;
   };
 
@@ -105,9 +142,9 @@ async function existsMaster (hostInfo, argTimeout) {
 
 /**
  * create master ssh connection
- * @param {Object} hostInfo - hostinfo object
+ * @param {object} hostInfo - hostinfo object
  */
-async function connect (hostInfo, timeout = 60) {
+export async function connect(hostInfo, timeout = 60) {
   debug("connect called");
 
   if (await existsMaster(hostInfo, timeout)) {
@@ -123,8 +160,9 @@ async function connect (hostInfo, timeout = 60) {
   const re = new RegExp(`^${words}`);
 
   let ac = null;
-  const p = new Promise((resolve, reject) => {
-    ac = watchDogTimer(timeout, "make connection", () => {
+  let output = null;
+  const p = new Promise((resolve, reject)=>{
+    ac = watchDogTimer(timeout, "make connection", ()=>{
       sendPty(hostInfo.masterPty, "\n", debugSendMasterPty, 137);
       sendPty(hostInfo.masterPty, "exit\n", debugSendMasterPty, 138);
 
@@ -132,16 +170,17 @@ async function connect (hostInfo, timeout = 60) {
       err.host = hostInfo.host;
       err.user = hostInfo.user;
       err.port = hostInfo.port;
+      err.output = output;
       reject(err);
     });
 
     let done = false;
-    hostInfo.masterPty.onData((data) => {
+    hostInfo.masterPty.onData((data)=>{
       if (done) {
-        // safeguard
+        //safeguard
         return;
       }
-      const output = data.toString();
+      output = data.toString();
       debugVerbose(output);
 
       if (re.test(output)) {
@@ -160,12 +199,12 @@ async function connect (hostInfo, timeout = 60) {
         reject(new Error("Control socket creation failed"));
       }
     });
-    hostInfo.masterPty.onData((data) => {
+    hostInfo.masterPty.onData((data)=>{
       const output = data.toString();
       sshLoginCallback(output, hostInfo.masterPty, hostInfo.password, hostInfo.passphrase, debugSendMasterPty)
         .catch(reject);
     });
-    hostInfo.masterPty.onExit((e) => {
+    hostInfo.masterPty.onExit((e)=>{
       debug("master pty exit", e);
       resolve(e);
     });
@@ -188,9 +227,9 @@ async function connect (hostInfo, timeout = 60) {
 
 /**
  * remove master session
- * @param {Object} hostInfo - hostinfo object
+ * @param {object} hostInfo - hostinfo object
  */
-async function disconnect (hostInfo) {
+export async function disconnect(hostInfo) {
   debug("disconnect called");
 
   if (await existsMaster(hostInfo)) {
@@ -198,7 +237,7 @@ async function disconnect (hostInfo) {
     args.push("-Oexit");
 
     let output = "";
-    const cb = (e) => {
+    const cb = (e)=>{
       output += e;
     };
     try {
@@ -225,50 +264,22 @@ async function disconnect (hostInfo) {
   }
 }
 
-/**
- * execute ls command and return output
- * @param {Object} hostInfo - hostinfo object
- * @param {string} target - file or directory path to watch
- * @param {string[]} lsOpt - optional arguments for ls
- * @param {number} timeout - timeout (in sec.)
- * @returns {string[]} - output from ls
- */
-async function ls (hostInfo, target, lsOpt, timeout) {
-  debug("ls called");
-  const outputArray = [];
-  try {
-    await sshExec(hostInfo, `ls ${lsOpt.join(" ")} ${target}`, timeout, (data) => {
-      outputArray.push(data);
-    });
-  } catch (e) {
-    // non-zero retrun should be allowed
-    if (typeof e.rt === "undefined" || e.rt < 0) {
-      throw e;
-    }
-  }
-  return outputArray.length === 0
-    ? []
-    : outputArray
-      .join("\n")
-      .replace(/\n+/g, "\n")
-      .replace(/\n$/, "")
-      .split("\n");
-}
-
 /**
  * retry fork() if it throw retryable error
  * @param {Function} func - function to be wrapped
- * @param {Object} hostInfo - hostinfo object
+ * @param {object} hostInfo - hostinfo object
  * @param {Integer} argMaxRetry - max retry number
+ * @param {Integer} argDuration - time to wait before retring
+ * @returns {Integer} - return value of func
  */
-async function retryWrapper (func, hostInfo, argMaxRetry, argDuration) {
+export async function retryWrapper(func, hostInfo, argMaxRetry, argDuration) {
   const maxRetry = argMaxRetry || hostInfo.maxRetry || 3;
   const duration = argDuration || hostInfo.retryDuration || 1000;
   if (maxRetry === 1) {
     return func();
   }
   let retryCount = 0;
-  while (true) {
+  for (;;) {
     let rt;
     try {
       rt = await func();
@@ -291,12 +302,3 @@ async function retryWrapper (func, hostInfo, argMaxRetry, argDuration) {
     }
   }
 }
-
-module.exports = {
-  sshExec,
-  canConnect,
-  connect,
-  disconnect,
-  ls,
-  retryWrapper
-};