ssh2-sftp-client 9.1.0 → 10.0.0

package/src/index.js

@@ -1,10 +1,10 @@
 'use strict';
 
 const { Client } = require('ssh2');
-const fs = require('fs');
+const fs = require('node:fs');
 const concat = require('concat-stream');
 const promiseRetry = require('promise-retry');
-const { join, parse } = require('path');
+const { join, parse } = require('node:path');
 const {
   globalListener,
   addTempListeners,
@@ -14,22 +14,23 @@ const {
   localExists,
   haveLocalAccess,
   haveLocalCreate,
+  partition,
 } = require('./utils');
 const { errorCode } = require('./constants');
 
 class SftpClient {
   constructor(clientName) {
-    this.version = '9.0.4';
+    this.version = '10.0.0';
     this.client = new Client();
     this.sftp = undefined;
-    this.clientName = clientName ? clientName : 'sftp';
+    this.clientName = clientName || 'sftp';
     this.endCalled = false;
     this.errorHandled = false;
     this.closeHandled = false;
     this.endHandled = false;
     this.remotePlatform = 'unix';
     this.debug = undefined;
-
+    this.promiseLimit = 10;
     this.client.on('close', globalListener(this, 'close'));
     this.client.on('end', globalListener(this, 'end'));
     this.client.on('error', globalListener(this, 'error'));
@@ -39,7 +40,7 @@ class SftpClient {
     if (this.debug) {
       if (obj) {
         this.debug(
-          `CLIENT[${this.clientName}]: ${msg} ${JSON.stringify(obj, null, ' ')}`
+          `CLIENT[${this.clientName}]: ${msg} ${JSON.stringify(obj, null, ' ')}`,
         );
       } else {
         this.debug(`CLIENT[${this.clientName}]: ${msg}`);
@@ -59,25 +60,29 @@ class SftpClient {
       code = errorCode.generic;
     } else if (typeof err === 'string') {
       msg = `${name}: ${err}${retry}`;
-      code = eCode ? eCode : errorCode.generic;
+      code = eCode || errorCode.generic;
     } else if (err.custom) {
       msg = `${name}->${err.message}${retry}`;
       code = err.code;
     } else {
       switch (err.code) {
-        case 'ENOTFOUND':
+        case 'ENOTFOUND': {
           msg = `${name}: Address lookup failed for host${retry}`;
           break;
-        case 'ECONNREFUSED':
+        }
+        case 'ECONNREFUSED': {
           msg = `${name}: Remote host refused connection${retry}`;
           break;
-        case 'ECONNRESET':
+        }
+        case 'ECONNRESET': {
           msg = `${name}: Remote host has reset the connection: ${err.message}${retry}`;
           break;
-        default:
+        }
+        default: {
           msg = `${name}: ${err.message}${retry}`;
+        }
       }
-      code = err.code ? err.code : errorCode.generic;
+      code = err.code || errorCode.generic;
     }
     const newError = new Error(msg);
     newError.code = code;
@@ -117,7 +122,6 @@ class SftpClient {
    * @param {Object} config - an SFTP configuration object
    *
    * @return {Promise<Object>} which will resolve to an sftp client object
-   *
    */
   getConnection(config) {
     let doReady, listeners;
@@ -163,7 +167,6 @@ class SftpClient {
    * @param {Object} config - an SFTP configuration object
    *
    * @return {Promise<Object>} which will resolve to an sftp client object
-   *
    */
   async connect(config) {
     let listeners;
@@ -175,16 +178,17 @@ class SftpClient {
         this.debugMsg('connect: Debugging turned on');
         this.debugMsg(`ssh2-sftp-client Version: ${this.version} `, process.versions);
       }
+      this.promiseLimit = config.promiseLimit ?? 10;
       if (this.sftp) {
         throw this.fmtError(
           'An existing SFTP connection is already defined',
           'connect',
-          errorCode.connect
+          errorCode.connect,
         );
       }
       const retryOpts = {
         retries: config.retries ?? 1,
-        factor: config.factor ?? 2,
+        factor: config.retry_factor ?? 2,
         minTimeout: config.retry_minTimeout ?? 25000,
       };
       await promiseRetry(retryOpts, async (retry, attempt) => {
@@ -195,8 +199,9 @@ class SftpClient {
           switch (err.code) {
             case 'ENOTFOUND':
             case 'ECONNREFUSED':
-            case 'ERR_SOCKET_BAD_PORT':
+            case 'ERR_SOCKET_BAD_PORT': {
               throw err;
+            }
             case undefined: {
               if (
                 err.message.endsWith('All configured authentication methods failed') ||
@@ -207,8 +212,9 @@ class SftpClient {
               retry(err);
               break;
             }
-            default:
+            default: {
               retry(err);
+            }
           }
         }
       });
@@ -284,7 +290,7 @@ class SftpClient {
   _xstat(cmd, aPath, addListeners = true) {
     let listeners;
     return new Promise((resolve, reject) => {
-      let cb = (err, stats) => {
+      const cb = (err, stats) => {
         if (err) {
           if (err.code === 2 || err.code === 4) {
             reject(this.fmtError(`No such file: ${aPath}`, '_xstat', errorCode.notexist));
@@ -335,7 +341,6 @@ class SftpClient {
    *
    * @param {String} remotePath - path to an object on the remote server
    * @return {Promise<Object>} stats - attributes info
-   *
    */
   async stat(remotePath) {
     try {
@@ -355,7 +360,6 @@ class SftpClient {
    *
    * @param {String} remotePath - path to an object on the remote server
    * @return {Promise<Object>} stats - attributes info
-   *
    */
   async lstat(remotePath) {
     try {
@@ -436,9 +440,9 @@ class SftpClient {
                 modifyTime: item.attrs.mtime * 1000,
                 accessTime: item.attrs.atime * 1000,
                 rights: {
-                  user: item.longname.slice(1, 4).replace(reg, ''),
-                  group: item.longname.slice(4, 7).replace(reg, ''),
-                  other: item.longname.slice(7, 10).replace(reg, ''),
+                  user: item.longname.slice(1, 4).replaceAll(reg, ''),
+                  group: item.longname.slice(4, 7).replaceAll(reg, ''),
+                  other: item.longname.slice(7, 10).replaceAll(reg, ''),
                 },
                 owner: item.attrs.uid,
                 group: item.attrs.gid,
@@ -489,7 +493,10 @@ class SftpClient {
       if (haveConnection(this, 'get', reject)) {
         options = {
           readStreamOptions: { ...options?.readStreamOptions, autoClose: true },
-          writeStreamOptions: { ...options?.writeStreamOptions, autoClose: true },
+          writeStreamOptions: {
+            ...options?.writeStreamOptions,
+            autoClose: true,
+          },
           pipeOptions: { ...options?.pipeOptions, end: true },
         };
         rdr = this.sftp.createReadStream(remotePath, options.readStreamOptions);
@@ -509,17 +516,16 @@ class SftpClient {
           // dst local file path
           this.debugMsg('get returning local file');
           const localCheck = haveLocalCreate(dst);
-          if (!localCheck.status) {
+          if (localCheck.status) {
+            wtr = fs.createWriteStream(dst, options.writeStreamOptions);
+          } else {
             reject(
               this.fmtError(
                 `Bad path: ${dst}: ${localCheck.details}`,
                 'get',
-                localCheck.code
-              )
+                localCheck.code,
+              ),
             );
-            return;
-          } else {
-            wtr = fs.createWriteStream(dst, options.writeStreamOptions);
           }
         } else {
           this.debugMsg('get: returning data into supplied stream');
@@ -530,8 +536,8 @@ class SftpClient {
             this.fmtError(
               `${err.message} ${typeof dst === 'string' ? dst : '<stream>'}`,
               'get',
-              err.code
-            )
+              err.code,
+            ),
           );
         });
         rdr.once('end', () => {
@@ -557,6 +563,10 @@ class SftpClient {
    * Downloads a file at remotePath to localPath using parallel reads
    * for faster throughput.
    *
+   * WARNING: The functionality of fastGet is heavily dependent on the capabilities
+   * of the remote SFTP server. Not all sftp server support or fully support this
+   * functionality. See the Platform Quirks & Warnings section of the README.
+   *
    * @param {String} remotePath
    * @param {String} localPath
    * @param {Object} options
@@ -587,7 +597,7 @@ class SftpClient {
     try {
       const ftype = await this.exists(remotePath);
       if (ftype !== '-') {
-        const msg = `${!ftype ? 'No such file ' : 'Not a regular file'} ${remotePath}`;
+        const msg = `${ftype ? 'Not a regular file' : 'No such file '} ${remotePath}`;
         throw this.fmtError(msg, 'fastGet', errorCode.badPath);
       }
       const localCheck = haveLocalCreate(localPath);
@@ -595,7 +605,7 @@ class SftpClient {
         throw this.fmtError(
           `Bad path: ${localPath}: ${localCheck.details}`,
           'fastGet',
-          errorCode.badPath
+          errorCode.badPath,
         );
       }
       return await this._fastGet(remotePath, localPath, options);
@@ -612,6 +622,10 @@ class SftpClient {
    * See 'fastPut' at
    * https://github.com/mscdex/ssh2-streams/blob/master/SFTPStream.md
    *
+   * WARNING: The fastPut functionality is heavily dependent on the capabilities of
+   * the remote sftp server. Many sftp servers do not support or do not fully support this
+   * functionality. See the Platform Quirks & Warnings section of the README for more details.
+   *
    * @param {String} localPath - path to local file to put
    * @param {String} remotePath - destination path for put file
    * @param {Object} options - additonal fastPut options
@@ -631,8 +645,8 @@ class SftpClient {
               this.fmtError(
                 `${err.message} Local: ${lPath} Remote: ${rPath}`,
                 'fastPut',
-                err.code
-              )
+                err.code,
+              ),
             );
           }
           resolve(`${lPath} was successfully uploaded to ${rPath}!`);
@@ -653,13 +667,13 @@ class SftpClient {
         throw this.fmtError(
           `Bad path: ${localPath}: ${localCheck.details}`,
           'fastPut',
-          localCheck.code
+          localCheck.code,
         );
       } else if (localCheck.status && localExists(localPath) === 'd') {
         throw this.fmtError(
           `Bad path: ${localPath} not a regular file`,
           'fastgPut',
-          errorCode.badPath
+          errorCode.badPath,
         );
       }
       return await this._fastPut(localPath, remotePath, options);
@@ -700,7 +714,11 @@ class SftpClient {
         wtr = this.sftp.createWriteStream(rPath, opts.writeStreamOptions);
         wtr.once('error', (err) => {
           reject(
-            this.fmtError(`Write stream error: ${err.message} ${rPath}`, '_put', err.code)
+            this.fmtError(
+              `Write stream error: ${err.message} ${rPath}`,
+              '_put',
+              err.code,
+            ),
           );
         });
         wtr.once('close', () => {
@@ -721,8 +739,8 @@ class SftpClient {
                   typeof lPath === 'string' ? lPath : '<stream>'
                 }`,
                 '_put',
-                err.code
-              )
+                err.code,
+              ),
             );
           });
           rdr.pipe(wtr, opts.pipeOptions);
@@ -743,7 +761,7 @@ class SftpClient {
           throw this.fmtError(
             `Bad path: ${localSrc} ${localCheck.details}`,
             'put',
-            localCheck.code
+            localCheck.code,
           );
         }
       }
@@ -797,7 +815,7 @@ class SftpClient {
         throw this.fmtError(
           'Cannot append one file to another',
           'append',
-          errorCode.badPath
+          errorCode.badPath,
         );
       }
       const fileType = await this.exists(remotePath);
@@ -805,7 +823,7 @@ class SftpClient {
         throw this.fmtError(
           `Bad path: ${remotePath}: cannot append to a directory`,
           'append',
-          errorCode.badPath
+          errorCode.badPath,
         );
       }
       await this._append(input, remotePath, options);
@@ -837,16 +855,16 @@ class SftpClient {
               this.fmtError(
                 `Bad path: ${p} permission denied`,
                 '_doMkdir',
-                errorCode.badPath
-              )
+                errorCode.badPath,
+              ),
             );
           } else if (err.code === 2) {
             reject(
               this.fmtError(
                 `Bad path: ${p} parent not a directory or not exist`,
                 '_doMkdir',
-                errorCode.badPath
-              )
+                errorCode.badPath,
+              ),
             );
           } else {
             reject(this.fmtError(`${err.message} ${p}`, '_doMkdir', err.code));
@@ -870,7 +888,7 @@ class SftpClient {
         throw this.fmtError(
           `Bad path: ${rPath} already exists as a file`,
           '_mkdir',
-          errorCode.badPath
+          errorCode.badPath,
         );
       } else if (targetExists) {
         return `${rPath} already exists`;
@@ -887,7 +905,7 @@ class SftpClient {
           throw this.fmtError(
             `Bad path: ${dir} not a directory`,
             '_mkdir',
-            errorCode.badPath
+            errorCode.badPath,
           );
         }
       }
@@ -940,7 +958,7 @@ class SftpClient {
       return new Promise((resolve, reject) => {
         listeners = addTempListeners(this, '_delFiles', reject);
         this.debugMsg(`_delFiles: path = ${path} fileList = ${fileList}`);
-        let pList = [];
+        const pList = [];
         for (const f of fileList) {
           pList.push(this.delete(`${path}/${f.name}`, true, false));
         }
@@ -956,36 +974,36 @@ class SftpClient {
 
     try {
       this.debugMsg(`rmdir: dir = ${remoteDir} recursive = ${recursive}`);
-      let absPath = await normalizeRemotePath(this, remoteDir);
-      let existStatus = await this.exists(absPath);
+      const absPath = await normalizeRemotePath(this, remoteDir);
+      const existStatus = await this.exists(absPath);
       this.debugMsg(`rmdir: ${absPath} existStatus = ${existStatus}`);
       if (!existStatus) {
         throw this.fmtError(
           `Bad Path: ${remoteDir}: No such directory`,
           'rmdir',
-          errorCode.badPath
+          errorCode.badPath,
         );
       }
       if (existStatus !== 'd') {
         throw this.fmtError(
           `Bad Path: ${remoteDir}: Not a directory`,
           'rmdir',
-          errorCode.badPath
+          errorCode.badPath,
         );
       }
       if (!recursive) {
         this.debugMsg('rmdir: non-recursive - just try to remove it');
         return await _rmdir(absPath);
       }
-      let listing = await this.list(absPath);
+      const listing = await this.list(absPath);
       this.debugMsg(`rmdir: listing count = ${listing.length}`);
       if (!listing.length) {
         this.debugMsg('rmdir: No sub dir or files, just rmdir');
         return await _rmdir(absPath);
       }
-      let fileList = listing.filter((i) => i.type !== 'd');
+      const fileList = listing.filter((i) => i.type !== 'd');
       this.debugMsg(`rmdir: dir content files to remove = ${fileList.length}`);
-      let dirList = listing.filter((i) => i.type === 'd');
+      const dirList = listing.filter((i) => i.type === 'd');
       this.debugMsg(`rmdir: sub-directories to remove = ${dirList.length}`);
       await _delFiles(absPath, fileList);
       for (const d of dirList) {
@@ -1009,7 +1027,6 @@ class SftpClient {
    * @param {boolean} notFoundOK - if true, ignore errors for missing target.
    *                               Default is false.
    * @return {Promise<String>} with string 'Successfully deleted file' once resolved
-   *
    */
   delete(remotePath, notFoundOK = false, addListeners = true) {
     let listeners;
@@ -1044,7 +1061,6 @@ class SftpClient {
    * @param {Boolean} addListeners - (Optional) if true, add listeners. Default true
    *
    * @return {Promise<String>}
-   *
    */
   rename(fPath, tPath, addListeners = true) {
     let listeners;
@@ -1059,8 +1075,8 @@ class SftpClient {
               this.fmtError(
                 `${err.message} From: ${fPath} To: ${tPath}`,
                 '_rename',
-                err.code
-              )
+                err.code,
+              ),
             );
           }
           resolve(`Successfully renamed ${fPath} to ${tPath}`);
@@ -1084,7 +1100,6 @@ class SftpClient {
    * @param {Boolean} addListeners - (Optional) if true, add listeners. Default true
    *
    * @return {Promise<String>}
-   *
    */
   posixRename(fPath, tPath, addListeners = true) {
     let listeners;
@@ -1099,8 +1114,8 @@ class SftpClient {
               this.fmtError(
                 `${err.message} From: ${fPath} To: ${tPath}`,
                 '_posixRename',
-                err.code
-              )
+                err.code,
+              ),
             );
           }
           resolve(`Successful POSIX rename ${fPath} to ${tPath}`);
@@ -1164,13 +1179,13 @@ class SftpClient {
    */
   async uploadDir(srcDir, dstDir, options) {
     const getRemoteStatus = async (dstDir) => {
-      let absDstDir = await normalizeRemotePath(this, dstDir);
-      let status = await this.exists(absDstDir);
+      const absDstDir = await normalizeRemotePath(this, dstDir);
+      const status = await this.exists(absDstDir);
       if (status && status !== 'd') {
         throw this.fmtError(
           `Bad path ${absDstDir} Not a directory`,
           'getRemoteStatus',
-          errorCode.badPath
+          errorCode.badPath,
         );
       }
       return { remoteDir: absDstDir, remoteStatus: status };
@@ -1182,54 +1197,57 @@ class SftpClient {
         throw this.fmtError(
           `Bad path: ${srcDir} not exist`,
           'getLocalStatus',
-          errorCode.badPath
+          errorCode.badPath,
         );
       }
       if (srcType !== 'd') {
         throw this.fmtError(
           `Bad path: ${srcDir}: not a directory`,
           'getLocalStatus',
-          errorCode.badPath
+          errorCode.badPath,
         );
       }
       return srcType;
     };
 
-    const uploadFiles = (srcDir, dstDir, fileList, useFastput) => {
-      let listeners;
-      return new Promise((resolve, reject) => {
-        listeners = addTempListeners(this, 'uploadFiles', reject);
-        let uploads = [];
+    const uploadFiles = async (srcDir, dstDir, fileList, useFastput) => {
+      let listeners = addTempListeners(this, 'uploadFiles');
+
+      try {
+        const uploadList = [];
         for (const f of fileList) {
-          const newSrc = join(srcDir, f.name);
-          const newDst = `${dstDir}/${f.name}`;
-          if (f.isFile()) {
-            if (useFastput) {
-              uploads.push(this._fastPut(newSrc, newDst, null, false));
-            } else {
-              uploads.push(this._put(newSrc, newDst, null, false));
-            }
-            this.client.emit('upload', { source: newSrc, destination: newDst });
-          } else {
-            this.debugMsg(`uploadFiles: File ignored: ${f.name} not a regular file`);
+          const src = join(srcDir, f.name);
+          const dst = `${dstDir}/${f.name}`;
+          uploadList.push([src, dst]);
+        }
+        const uploadGroups = partition(uploadList, this.promiseLimit);
+        const func = useFastput ? this._fastPut.bind(this) : this._put.bind(this);
+        const uploadResults = [];
+        for (const group of uploadGroups) {
+          const pList = [];
+          for (const [src, dst] of group) {
+            pList.push(func(src, dst, null, false));
+            this.client.emit('upload', { source: src, destination: dst });
+          }
+          const groupResults = await Promise.all(pList);
+          for (const r of groupResults) {
+            uploadResults.push(r);
           }
         }
-        resolve(Promise.all(uploads));
-      })
-        .then((pList) => {
-          return Promise.all(pList);
-        })
-        .finally(() => {
-          removeTempListeners(this, listeners, uploadFiles);
-        });
+        return uploadResults;
+      } catch (e) {
+        throw this.fmtError(`${e.message} ${srcDir} to ${dstDir}`, 'uploadFiles', e.code);
+      } finally {
+        removeTempListeners(this, listeners, uploadFiles);
+      }
     };
 
     try {
       haveConnection(this, 'uploadDir');
       this.debugMsg(
-        `uploadDir: srcDir = ${srcDir} dstDir = ${dstDir} options = ${options}`
+        `uploadDir: srcDir = ${srcDir} dstDir = ${dstDir} options = ${options}`,
       );
-      let { remoteDir, remoteStatus } = await getRemoteStatus(dstDir);
+      const { remoteDir, remoteStatus } = await getRemoteStatus(dstDir);
       this.debugMsg(`uploadDir: remoteDir = ${remoteDir} remoteStatus = ${remoteStatus}`);
       checkLocalStatus(srcDir);
       if (!remoteStatus) {
@@ -1242,17 +1260,17 @@ class SftpClient {
       this.debugMsg(`uploadDir: dirEntries = ${dirEntries}`);
       if (options?.filter) {
         dirEntries = dirEntries.filter((item) =>
-          options.filter(join(srcDir, item.name), item.isDirectory())
+          options.filter(join(srcDir, item.name), item.isDirectory()),
         );
       }
-      let dirUploads = dirEntries.filter((item) => item.isDirectory());
-      let fileUploads = dirEntries.filter((item) => !item.isDirectory());
+      const dirUploads = dirEntries.filter((item) => item.isDirectory());
+      const fileUploads = dirEntries.filter((item) => !item.isDirectory());
       this.debugMsg(`uploadDir: dirUploads = ${dirUploads}`);
       this.debugMsg(`uploadDir: fileUploads = ${fileUploads}`);
       await uploadFiles(srcDir, remoteDir, fileUploads, options?.useFastput);
       for (const d of dirUploads) {
-        let src = join(srcDir, d.name);
-        let dst = `${remoteDir}/${d.name}`;
+        const src = join(srcDir, d.name);
+        const dst = `${remoteDir}/${d.name}`;
         await this.uploadDir(src, dst, options);
       }
       return `${srcDir} uploaded to ${dstDir}`;
@@ -1281,12 +1299,12 @@ class SftpClient {
    * @returns {Promise<Array>}
    */
   async downloadDir(srcDir, dstDir, options = { filter: null, useFastget: false }) {
-    const _getDownloadList = async (srcDir, filter) => {
+    const getDownloadList = async (srcDir, filter) => {
       try {
-        let listing = await this.list(srcDir);
+        const listing = await this.list(srcDir);
         if (filter) {
           return listing.filter((item) =>
-            filter(`${srcDir}/${item.name}`, item.type === 'd')
+            filter(`${srcDir}/${item.name}`, item.type === 'd'),
           );
         }
         return listing;
@@ -1295,14 +1313,14 @@ class SftpClient {
       }
     };
 
-    const _prepareDestination = (dst) => {
+    const prepareDestination = (dst) => {
       try {
         const localCheck = haveLocalCreate(dst);
         if (!localCheck.status && localCheck.details === 'permission denied') {
           throw this.fmtError(
             `Bad path: ${dst}: ${localCheck.details}`,
             'prepareDestination',
-            localCheck.code
+            localCheck.code,
           );
         } else if (localCheck.status && !localCheck.type) {
           fs.mkdirSync(dst, { recursive: true });
@@ -1310,7 +1328,7 @@ class SftpClient {
           throw this.fmtError(
             `Bad path: ${dstDir}: not a directory`,
             '_prepareDestination',
-            errorCode.badPath
+            errorCode.badPath,
           );
         }
       } catch (err) {
@@ -1320,40 +1338,55 @@ class SftpClient {
       }
     };
 
-    const _downloadFiles = (remotePath, localPath, fileList, useFastget) => {
-      let listeners;
-      return new Promise((resolve, reject) => {
-        listeners = addTempListeners(this, '_downloadFIles', reject);
-        let pList = [];
+    const downloadFiles = async (remotePath, localPath, fileList, useFastget) => {
+      let listeners = addTempListeners(this, 'downloadFIles');
+
+      try {
+        const downloadList = [];
         for (const f of fileList) {
-          let src = `${remotePath}/${f.name}`;
-          let dst = join(localPath, f.name);
-          if (useFastget) {
-            pList.push(this.fastGet(src, dst, false));
-          } else {
-            pList.push(this.get(src, dst, false));
+          const src = `${remotePath}/${f.name}`;
+          const dst = join(localPath, f.name);
+          downloadList.push([src, dst]);
+        }
+        const downloadGroups = partition(downloadList, this.promiseLimit);
+        const func = useFastget ? this._fastGet.bind(this) : this.get.bind(this);
+        const downloadResults = [];
+        for (const group of downloadGroups) {
+          const pList = [];
+          for (const [src, dst] of group) {
+            pList.push(func(src, dst, null, false));
+            this.client.emit('download', { source: src, destination: dst });
+          }
+          const groupResults = await Promise.all(pList);
+          for (const r of groupResults) {
+            downloadResults.push(r);
           }
-          this.client.emit('download', { source: src, destination: dst });
         }
-        return resolve(Promise.all(pList));
-      }).finally(() => {
-        removeTempListeners(this, listeners, '_downloadFiles');
-      });
+        return downloadResults;
+      } catch (e) {
+        throw this.fmtError(
+          `${e.message} ${srcDir} to ${dstDir}`,
+          'downloadFiles',
+          e.code,
+        );
+      } finally {
+        removeTempListeners(this, listeners, 'downloadFiles');
+      }
     };
 
     try {
       haveConnection(this, 'downloadDir');
-      let downloadList = await _getDownloadList(srcDir, options.filter);
-      _prepareDestination(dstDir);
-      let fileDownloads = downloadList.filter((i) => i.type !== 'd');
+      const downloadList = await getDownloadList(srcDir, options.filter);
+      prepareDestination(dstDir);
+      const fileDownloads = downloadList.filter((i) => i.type !== 'd');
       if (fileDownloads.length) {
-        await _downloadFiles(srcDir, dstDir, fileDownloads, options.useFastget);
+        await downloadFiles(srcDir, dstDir, fileDownloads, options.useFastget);
       }
-      let dirDownloads = downloadList.filter((i) => i.type === 'd');
+      const dirDownloads = downloadList.filter((i) => i.type === 'd');
       for (const d of dirDownloads) {
-        let src = `${srcDir}/${d.name}`;
-        let dst = join(dstDir, d.name);
-        await this.downloadDir(src, dst);
+        const src = `${srcDir}/${d.name}`;
+        const dst = join(dstDir, d.name);
+        await this.downloadDir(src, dst, options);
       }
       return `${srcDir} downloaded to ${dstDir}`;
     } catch (err) {
@@ -1364,7 +1397,6 @@ class SftpClient {
   }
 
   /**
-   *
    * Returns a read stream object. This is a low level method which will return a read stream
    * connected to the remote file object specified as an argument. Client code is fully responsible
    * for managing this stream object i.e. adding any necessary listeners and disposing of the object etc.
@@ -1374,7 +1406,6 @@ class SftpClient {
    * @param {Object} options - options to pass to the create stream process
    *
    * @returns {Object} a read stream object
-   *
    */
   createReadStream(remotePath, options) {
     let listeners;
@@ -1391,7 +1422,6 @@ class SftpClient {
   }
 
   /**
-   *
    * Create a write stream object connected to a file on the remote sftp server.
    * This is a low level method which will return a write stream for the remote file specified
    * in the 'remotePath' argument. Client code to responsible for managing this object once created.
@@ -1401,7 +1431,6 @@ class SftpClient {
    * @param (Object} options - options to pass to the create write stream process)
    *
    * @returns {Object} a stream object
-   *
    */
   createWriteStream(remotePath, options) {
     let listeners;
@@ -1428,7 +1457,6 @@ class SftpClient {
    * @param {String} dstPath - destination path for the copy.
    *
    * @returns {String}.
-   *
    */
   _rcopy(srcPath, dstPath) {
     return new Promise((resolve, reject) => {
@@ -1458,7 +1486,7 @@ class SftpClient {
         throw this.fmtError(
           `Source does not exist ${srcPath}`,
           'rcopy',
-          errorCode.badPath
+          errorCode.badPath,
         );
       }
       if (srcExists !== '-') {
@@ -1470,7 +1498,7 @@ class SftpClient {
         throw this.fmtError(
           `Destination already exists ${dstPath}`,
           'rcopy',
-          errorCode.badPath
+          errorCode.badPath,
         );
       }
       return this._rcopy(srcPath, dstPath);