ssh2-sftp-client 7.2.2 → 8.1.0

package/src/index.js

@@ -34,7 +34,6 @@ class SftpClient {
     this.remotePathSep = '/';
     this.remotePlatform = 'unix';
     this.debug = undefined;
-    this.tempListeners = {};
 
     this.client.on('close', () => {
       if (this.endCalled || this.closeHandled) {
@@ -59,14 +58,13 @@ class SftpClient {
     this.client.on('error', (err) => {
       if (this.endCalled || this.errorHandled) {
         // error event expected or handled elsewhere
-        this.debugMsg('Global: Ignoring handled error');
+        this.debugMsg(`Global: Ignoring handled error: ${err.message}`);
       } else {
         this.debugMsg(`Global; Handling unexpected error; ${err.message}`);
         this.sftp = undefined;
         console.log(
           `ssh2-sftp-client: Unexpected error: ${err.message}. Error code: ${err.code}`
         );
-        //throw fmtError(err, 'Global');
       }
     });
   }
@@ -119,34 +117,31 @@ class SftpClient {
    *
    */
   getConnection(config) {
-    let doReady;
-    return (
-      new Promise((resolve, reject) => {
-        addTempListeners(this, 'getConnection', reject);
-        this.debugMsg('getConnection: created promise');
-        doReady = () => {
-          this.debugMsg('getConnection: got connection - promise resolved');
-          resolve(true);
-        };
-        this.on('ready', doReady);
-        this.client.connect(config);
-      })
-        // .catch((err) => {
-        //   return Promise.reject(err);
-        // })
-        .finally(async () => {
-          this.debugMsg('getConnection: finally clause fired');
-          await sleep(500);
-          this.removeListener('ready', doReady);
-          removeTempListeners(this, 'getConnection');
-          this._resetEventFlags();
-        })
-    );
+    let doReady, listeners;
+    return new Promise((resolve, reject) => {
+      listeners = addTempListeners(this, 'getConnection', reject);
+      this.debugMsg('getConnection: created promise');
+      doReady = () => {
+        this.debugMsg(
+          'getConnection ready listener: got connection - promise resolved'
+        );
+        resolve(true);
+      };
+      this.on('ready', doReady);
+      this.client.connect(config);
+    }).finally(async () => {
+      this.debugMsg('getConnection: finally clause fired');
+      await sleep(500);
+      this.removeListener('ready', doReady);
+      removeTempListeners(this, listeners, 'getConnection');
+      this._resetEventFlags();
+    });
   }
 
   getSftpChannel() {
+    let listeners;
     return new Promise((resolve, reject) => {
-      addTempListeners(this, 'getSftpChannel', reject);
+      listeners = addTempListeners(this, 'getSftpChannel', reject);
       this.debugMsg('getSftpChannel: created promise');
       this.client.sftp((err, sftp) => {
         if (err) {
@@ -161,7 +156,7 @@ class SftpClient {
       });
     }).finally(() => {
       this.debugMsg('getSftpChannel: finally clause fired');
-      removeTempListeners(this, 'getSftpChannel');
+      removeTempListeners(this, listeners, 'getSftpChannel');
       this._resetEventFlags();
     });
   }
@@ -196,8 +191,17 @@ class SftpClient {
         (retry, attempt) => {
           this.debugMsg(`connect: Connect attempt ${attempt}`);
           return this.getConnection(config).catch((err) => {
-            this.debugMsg('getConnection retry catch');
-            retry(err);
+            this.debugMsg(
+              `getConnection retry catch: ${err.message} Code: ${err.code}`
+            );
+            switch (err.code) {
+              case 'ENOTFOUND':
+              case 'ECONNREFUSED':
+              case 'ERR_SOCKET_BAD_PORT':
+                throw err;
+              default:
+                retry(err);
+            }
           });
         },
         {
@@ -226,9 +230,10 @@ class SftpClient {
    * @returns {Promise<String>} - remote absolute path or ''
    */
   realPath(remotePath) {
+    let listeners;
     return new Promise((resolve, reject) => {
+      listeners = addTempListeners(this, 'realPath', reject);
       this.debugMsg(`realPath -> ${remotePath}`);
-      addTempListeners(this, 'realPath', reject);
       if (haveConnection(this, 'realPath', reject)) {
         this.sftp.realpath(remotePath, (err, absPath) => {
           if (err) {
@@ -246,7 +251,7 @@ class SftpClient {
         });
       }
     }).finally(() => {
-      removeTempListeners(this, 'realPath');
+      removeTempListeners(this, listeners, 'realPath');
       this._resetEventFlags();
     });
   }
@@ -270,9 +275,10 @@ class SftpClient {
    */
   async stat(remotePath) {
     const _stat = (aPath) => {
+      let listeners;
       return new Promise((resolve, reject) => {
+        listeners = addTempListeners(this, '_stat', reject);
         this.debugMsg(`_stat: ${aPath}`);
-        addTempListeners(this, '_stat', reject);
         this.sftp.stat(aPath, (err, stats) => {
           if (err) {
             this.debugMsg(`_stat: Error ${err.message} code: ${err.code}`);
@@ -310,7 +316,7 @@ class SftpClient {
           }
         });
       }).finally(() => {
-        removeTempListeners(this, '_stat');
+        removeTempListeners(this, listeners, '_stat');
       });
     };
 
@@ -394,11 +400,12 @@ class SftpClient {
    * @returns {Promise<Array>} array of file description objects
    */
   list(remotePath, pattern = /.*/) {
+    let listeners;
     return new Promise((resolve, reject) => {
+      listeners = addTempListeners(this, 'list', reject);
       if (haveConnection(this, 'list', reject)) {
         const reg = /-/gi;
         this.debugMsg(`list: ${remotePath} filter: ${pattern}`);
-        addTempListeners(this, 'list', reject);
         this.sftp.readdir(remotePath, (err, fileList) => {
           if (err) {
             this.debugMsg(`list: Error ${err.message} code: ${err.code}`);
@@ -421,6 +428,7 @@ class SftpClient {
                   },
                   owner: item.attrs.uid,
                   group: item.attrs.gid,
+                  longname: item.longname,
                 };
               });
             }
@@ -439,7 +447,7 @@ class SftpClient {
         });
       }
     }).finally(() => {
-      removeTempListeners(this, 'list');
+      removeTempListeners(this, listeners, 'list');
       this._resetEventFlags();
     });
   }
@@ -464,12 +472,11 @@ class SftpClient {
     dst,
     options = { readStreamOptions: {}, writeStreamOptions: {}, pipeOptions: {} }
   ) {
-    let rdr, wtr;
-
+    let rdr, wtr, listeners;
     return new Promise((resolve, reject) => {
+      listeners = addTempListeners(this, 'get', reject);
       if (haveConnection(this, 'get', reject)) {
         this.debugMsg(`get -> ${remotePath} `, options);
-        addTempListeners(this, 'get', reject);
         rdr = this.sftp.createReadStream(
           remotePath,
           options.readStreamOptions ? options.readStreamOptions : {}
@@ -542,7 +549,7 @@ class SftpClient {
         rdr.pipe(wtr, options.pipeOptions ? options.pipeOptions : {});
       }
     }).finally(() => {
-      removeTempListeners(this, 'get');
+      removeTempListeners(this, listeners, 'get');
       this._resetEventFlags();
       if (
         rdr &&
@@ -592,13 +599,14 @@ class SftpClient {
         err.code = errorCode.badPath;
         throw err;
       }
+      let listeners;
       let rslt = await new Promise((resolve, reject) => {
+        listeners = addTempListeners(this, 'fastGet', reject);
         if (haveConnection(this, 'fastGet', reject)) {
           this.debugMsg(
             `fastGet -> remote: ${remotePath} local: ${localPath} `,
             options
           );
-          addTempListeners(this, 'fastGet', reject);
           this.sftp.fastGet(remotePath, localPath, options, (err) => {
             if (err) {
               this.debugMsg(`fastGet error ${err.message} code: ${err.code}`);
@@ -608,7 +616,7 @@ class SftpClient {
           });
         }
       }).finally(() => {
-        removeTempListeners(this, 'fastGet');
+        removeTempListeners(this, listeners, 'fastGet');
       });
       return rslt;
     } catch (err) {
@@ -631,8 +639,10 @@ class SftpClient {
    * @return {Promise<String>} the result of downloading the file
    */
   fastPut(localPath, remotePath, options) {
+    let listeners;
     this.debugMsg(`fastPut -> local ${localPath} remote ${remotePath}`);
     return new Promise((resolve, reject) => {
+      listeners = addTempListeners(this, 'fastPut', reject);
       const localCheck = haveLocalAccess(localPath);
       if (!localCheck.status) {
         reject(
@@ -656,7 +666,6 @@ class SftpClient {
             options
           )}`
         );
-        addTempListeners(this, 'fastPut', reject);
         this.sftp.fastPut(localPath, remotePath, options, (err) => {
           if (err) {
             this.debugMsg(`fastPut error ${err.message} ${err.code}`);
@@ -673,7 +682,7 @@ class SftpClient {
         });
       }
     }).finally(() => {
-      removeTempListeners(this, 'fastPut');
+      removeTempListeners(this, listeners, 'fastPut');
       this._resetEventFlags();
     });
   }
@@ -699,9 +708,9 @@ class SftpClient {
       pipeOptions: {},
     }
   ) {
-    let wtr, rdr;
-
+    let wtr, rdr, listeners;
     return new Promise((resolve, reject) => {
+      listeners = addTempListeners(this, 'put', reject);
       if (typeof localSrc === 'string') {
         const localCheck = haveLocalAccess(localSrc);
         if (!localCheck.status) {
@@ -716,7 +725,6 @@ class SftpClient {
         }
       }
       if (haveConnection(this, 'put')) {
-        addTempListeners(this, 'put', reject);
         wtr = this.sftp.createWriteStream(
           remotePath,
           options.writeStreamOptions
@@ -761,7 +769,7 @@ class SftpClient {
         }
       }
     }).finally(() => {
-      removeTempListeners(this, 'put');
+      removeTempListeners(this, listeners, 'put');
       this._resetEventFlags();
       if (
         rdr &&
@@ -783,44 +791,63 @@ class SftpClient {
    * @param  {Object} options
    * @return {Promise<String>}
    */
+
   async append(input, remotePath, options = {}) {
-    const fileType = await this.exists(remotePath);
-    if (fileType && fileType === 'd') {
-      throw fmtError(
-        `Bad path: ${remotePath}: cannot append to a directory`,
-        'append',
-        errorCode.badPath
-      );
-    }
-    return await new Promise((resolve, reject) => {
-      if (haveConnection(this, 'append', reject)) {
-        if (typeof input === 'string') {
-          reject(fmtError('Cannot append one file to another', 'append'));
+    const _append = (input, remotePath, options) => {
+      return new Promise((resolve, reject) => {
+        this.debugMsg(`append -> remote: ${remotePath} `, options);
+        options.flags = 'a';
+        let stream = this.sftp.createWriteStream(remotePath, options);
+        stream.on('error', (err) => {
+          this.debugMsg(
+            `append: Error ${err.message} appending to ${remotePath}`
+          );
+          reject(fmtError(`${err.message} ${remotePath}`, 'append', err.code));
+        });
+        stream.on('close', () => {
+          this.debugMsg(`append: data appended to ${remotePath}`);
+          resolve(`Appended data to ${remotePath}`);
+        });
+        if (input instanceof Buffer) {
+          this.debugMsg('append: writing data buffer to remote file');
+          stream.write(input);
+          stream.end();
         } else {
-          this.debugMsg(`append -> remote: ${remotePath} `, options);
-          addTempListeners(this, 'append', reject);
-          options.flags = 'a';
-          let stream = this.sftp.createWriteStream(remotePath, options);
-          stream.on('error', (err_1) => {
-            reject(
-              fmtError(`${err_1.message} ${remotePath}`, 'append', err_1.code)
-            );
-          });
-          stream.on('finish', () => {
-            resolve(`Appended data to ${remotePath}`);
-          });
-          if (input instanceof Buffer) {
-            stream.write(input);
-            stream.end();
-          } else {
-            input.pipe(stream);
-          }
+          this.debugMsg('append: writing stream to remote file');
+          input.pipe(stream);
         }
+      });
+    };
+
+    let listeners;
+    try {
+      listeners = addTempListeners(this, 'append');
+      if (typeof input === 'string') {
+        this.debugMsg('append: attempt to append two files - throw');
+        throw fmtError(
+          'Cannot append one file to another',
+          'append',
+          errorCode.badPath
+        );
       }
-    }).finally(() => {
-      removeTempListeners(this, 'append');
+      if (haveConnection(this, 'append')) {
+        const fileType = await this.exists(remotePath);
+        if (fileType && fileType === 'd') {
+          this.debugMsg(`append: Error ${remotePath} not a file`);
+          throw fmtError(
+            `Bad path: ${remotePath}: cannot append to a directory`,
+            'append',
+            errorCode.badPath
+          );
+        }
+        await _append(input, remotePath, options);
+      }
+    } catch (e) {
+      throw e.custom ? e : fmtError(e.message, 'append', e.code);
+    } finally {
+      removeTempListeners(this, listeners, 'append');
       this._resetEventFlags();
-    });
+    }
   }
 
   /**
@@ -834,9 +861,10 @@ class SftpClient {
    */
   async mkdir(remotePath, recursive = false) {
     const _mkdir = (p) => {
+      let listeners;
       return new Promise((resolve, reject) => {
+        listeners = addTempListeners(this, '_mkdir', reject);
         this.debugMsg(`_mkdir: create ${p}`);
-        addTempListeners(this, '_mkdir', reject);
         this.sftp.mkdir(p, (err) => {
           if (err) {
             this.debugMsg(`_mkdir: Error ${err.message} code: ${err.code}`);
@@ -860,7 +888,7 @@ class SftpClient {
           }
         });
       }).finally(() => {
-        removeTempListeners(this, '_mkdir');
+        removeTempListeners(this, listeners, '_mkdir');
         this._resetEventFlags();
       });
     };
@@ -907,45 +935,83 @@ class SftpClient {
    * @return {Promise<String>}
    */
   async rmdir(remotePath, recursive = false) {
+    const _delete = (remotePath) => {
+      return new Promise((resolve, reject) => {
+        this.sftp.unlink(remotePath, (err) => {
+          if (err && err.code !== 2) {
+            reject(fmtError(`${err.message} ${remotePath}`, 'rmdir', err.code));
+          }
+          resolve(true);
+        });
+      });
+    };
+
     const _rmdir = (p) => {
       return new Promise((resolve, reject) => {
         this.debugMsg(`rmdir -> ${p}`);
-        addTempListeners(this, 'rmdir', reject);
         this.sftp.rmdir(p, (err) => {
           if (err) {
             this.debugMsg(`rmdir error ${err.message} code: ${err.code}`);
-            reject(fmtError(`${err.message} ${p}`, '_rmdir', err.code));
+            reject(fmtError(`${err.message} ${p}`, 'rmdir', err.code));
           }
           resolve('Successfully removed directory');
         });
       }).finally(() => {
-        removeTempListeners(this, 'rmdir');
+        removeTempListeners(this, listeners, '_rmdir');
       });
     };
 
+    const _dormdir = async (p, recur) => {
+      try {
+        if (recur) {
+          let list = await this.list(p);
+          if (list.length) {
+            let files = list.filter((item) => item.type !== 'd');
+            let dirs = list.filter((item) => item.type === 'd');
+            this.debugMsg('rmdir contents (files): ', files);
+            this.debugMsg('rmdir contents (dirs): ', dirs);
+            for (let d of dirs) {
+              await _dormdir(`${p}${this.remotePathSep}${d.name}`, true);
+            }
+            let promiseList = [];
+            for (let f of files) {
+              promiseList.push(_delete(`${p}${this.remotePathSep}${f.name}`));
+            }
+            await Promise.all(promiseList);
+          }
+        }
+        return await _rmdir(p);
+      } catch (err) {
+        throw err.custom ? err : fmtError(err, '_dormdir', err.code);
+      }
+    };
+
+    let listeners;
     try {
+      listeners = addTempListeners(this, 'rmdir');
       haveConnection(this, 'rmdir');
       let absPath = await normalizeRemotePath(this, remotePath);
-      if (!recursive) {
-        return _rmdir(absPath);
-      }
-      let list = await this.list(absPath);
-      if (list.length) {
-        let files = list.filter((item) => item.type !== 'd');
-        let dirs = list.filter((item) => item.type === 'd');
-        this.debugMsg('rmdir contents (files): ', files);
-        this.debugMsg('rmdir contents (dirs): ', dirs);
-        for (let f of files) {
-          await this.delete(`${absPath}${this.remotePathSep}${f.name}`);
-        }
-        for (let d of dirs) {
-          await this.rmdir(`${absPath}${this.remotePathSep}${d.name}`, true);
-        }
+      let dirStatus = await this.exists(absPath);
+      if (dirStatus && dirStatus !== 'd') {
+        throw fmtError(
+          `Bad path: ${absPath} not a directory`,
+          'rmdir',
+          errorCode.badPath
+        );
+      } else if (!dirStatus) {
+        throw fmtError(
+          `Bad path: ${absPath} No such file`,
+          'rmdir',
+          errorCode.badPath
+        );
+      } else {
+        return await _dormdir(absPath, recursive);
       }
-      return _rmdir(absPath);
     } catch (err) {
       this._resetEventFlags();
       throw err.custom ? err : fmtError(err, 'rmdir', err.code);
+    } finally {
+      removeTempListeners(this, listeners, 'rmdir');
     }
   }
 
@@ -961,10 +1027,11 @@ class SftpClient {
    *
    */
   delete(remotePath, notFoundOK = false) {
+    let listeners;
     return new Promise((resolve, reject) => {
+      listeners = addTempListeners(this, 'delete', reject);
       if (haveConnection(this, 'delete', reject)) {
         this.debugMsg(`delete -> ${remotePath}`);
-        addTempListeners(this, 'delete', reject);
         this.sftp.unlink(remotePath, (err) => {
           if (err) {
             this.debugMsg(`delete error ${err.message} code: ${err.code}`);
@@ -981,7 +1048,7 @@ class SftpClient {
         });
       }
     }).finally(() => {
-      removeTempListeners(this, 'delete');
+      removeTempListeners(this, listeners, 'delete');
       this._resetEventFlags();
     });
   }
@@ -998,10 +1065,11 @@ class SftpClient {
    *
    */
   rename(fromPath, toPath) {
+    let listeners;
     return new Promise((resolve, reject) => {
+      listeners = addTempListeners(this, 'rename', reject);
       if (haveConnection(this, 'rename', reject)) {
         this.debugMsg(`rename -> ${fromPath} ${toPath}`);
-        addTempListeners(this, 'rename', reject);
         this.sftp.rename(fromPath, toPath, (err) => {
           if (err) {
             this.debugMsg(`rename error ${err.message} code: ${err.code}`);
@@ -1017,7 +1085,7 @@ class SftpClient {
         });
       }
     }).finally(() => {
-      removeTempListeners(this, 'rename');
+      removeTempListeners(this, listeners, 'rename');
       this._resetEventFlags();
     });
   }
@@ -1035,10 +1103,11 @@ class SftpClient {
    *
    */
   posixRename(fromPath, toPath) {
+    let listeners;
     return new Promise((resolve, reject) => {
+      listeners = addTempListeners(this, 'posixRename', reject);
       if (haveConnection(this, 'posixRename', reject)) {
         this.debugMsg(`posixRename -> ${fromPath} ${toPath}`);
-        addTempListeners(this, 'posixRename', reject);
         this.sftp.ext_openssh_rename(fromPath, toPath, (err) => {
           if (err) {
             this.debugMsg(`posixRename error ${err.message} code: ${err.code}`);
@@ -1054,7 +1123,7 @@ class SftpClient {
         });
       }
     }).finally(() => {
-      removeTempListeners(this, 'posixRename');
+      removeTempListeners(this, listeners, 'posixRename');
       this._resetEventFlags();
     });
   }
@@ -1070,9 +1139,10 @@ class SftpClient {
    * @return {Promise<String>}
    */
   chmod(remotePath, mode) {
+    let listeners;
     return new Promise((resolve, reject) => {
+      listeners = addTempListeners(this, 'chmod', reject);
       this.debugMsg(`chmod -> ${remotePath} ${mode}`);
-      addTempListeners(this, 'chmod', reject);
       this.sftp.chmod(remotePath, mode, (err) => {
         if (err) {
           reject(fmtError(`${err.message} ${remotePath}`, 'chmod', err.code));
@@ -1080,7 +1150,7 @@ class SftpClient {
         resolve('Successfully change file mode');
       });
     }).finally(() => {
-      removeTempListeners(this, 'chmod');
+      removeTempListeners(this, listeners, 'chmod');
       this._resetEventFlags();
     });
   }
@@ -1093,14 +1163,25 @@ class SftpClient {
    * server.
    * @param {String} srcDir - local source directory
    * @param {String} dstDir - remote destination directory
-   * @param {RegExp} filter - (Optional) a regular expression used to select
-   *                         files and directories to upload
+   * @param {function(String,Boolean):Boolean} filter - (Optional) The first argument is the full path of the item to be uploaded and the second argument is a boolean, which will be true if the target path is for a directory.  If the function returns true, the item will be uploaded
    * @returns {Promise<String>}
    */
-  async uploadDir(srcDir, dstDir, filter = /.*/) {
+  async uploadDir(srcDir, dstDir, filter) {
     try {
-      this.debugMsg(`uploadDir -> ${srcDir} ${dstDir}`);
+      this.debugMsg(`uploadDir -> SRC = ${srcDir} DST = ${dstDir}`);
+      haveConnection(this, 'uploadDir');
+      //let absSrcDir = fs.realpathSync(srcDir);
+      let absDstDir = await normalizeRemotePath(this, dstDir);
+
+      this.debugMsg(`uploadDir <- SRC = ${srcDir} DST = ${absDstDir}`);
       const srcType = localExists(srcDir);
+      if (!srcType) {
+        throw fmtError(
+          `Bad path: ${srcDir} not exist`,
+          'uploadDir',
+          errorCode.badPath
+        );
+      }
       if (srcType !== 'd') {
         throw fmtError(
           `Bad path: ${srcDir}: not a directory`,
@@ -1108,36 +1189,43 @@ class SftpClient {
           errorCode.badPath
         );
       }
-      haveConnection(this, 'uploadDir');
-      let dstStatus = await this.exists(dstDir);
+      let dstStatus = await this.exists(absDstDir);
       if (dstStatus && dstStatus !== 'd') {
-        throw fmtError(`Bad path ${dstDir}`, 'uploadDir', errorCode.badPath);
+        this.debugMsg(`UploadDir: DST ${absDstDir} exists but not a directory`);
+        throw fmtError(
+          `Bad path ${absDstDir} Not a directory`,
+          'uploadDir',
+          errorCode.badPath
+        );
       }
       if (!dstStatus) {
-        await this.mkdir(dstDir, true);
+        this.debugMsg(`UploadDir: Creating directory ${absDstDir}`);
+        await this.mkdir(absDstDir, true);
       }
       let dirEntries = fs.readdirSync(srcDir, {
         encoding: 'utf8',
         withFileTypes: true,
       });
-      dirEntries = dirEntries.filter((item) => filter.test(item.name));
+      if (filter) {
+        dirEntries = dirEntries.filter((item) =>
+          filter(join(srcDir, item.name), item.isDirectory())
+        );
+      }
       for (let e of dirEntries) {
+        let newSrc = join(srcDir, e.name);
+        let newDst = `${absDstDir}${this.remotePathSep}${e.name}`;
         if (e.isDirectory()) {
-          let newSrc = join(srcDir, e.name);
-          let newDst = dstDir + this.remotePathSep + e.name;
           await this.uploadDir(newSrc, newDst, filter);
         } else if (e.isFile()) {
-          let src = join(srcDir, e.name);
-          let dst = dstDir + this.remotePathSep + e.name;
-          await this.fastPut(src, dst);
-          this.client.emit('upload', { source: src, destination: dst });
+          await this.put(newSrc, newDst);
+          this.client.emit('upload', { source: newSrc, destination: newDst });
         } else {
           this.debugMsg(
             `uploadDir: File ignored: ${e.name} not a regular file`
           );
         }
       }
-      return `${srcDir} uploaded to ${dstDir}`;
+      return `${srcDir} uploaded to ${absDstDir}`;
     } catch (err) {
       this._resetEventFlags();
       throw err.custom ? err : fmtError(err, 'uploadDir');
@@ -1152,15 +1240,22 @@ class SftpClient {
    * file system.
    * @param {String} srcDir - remote source directory
    * @param {String} dstDir - local destination directory
-   * @param {RegExp} filter - (Optional) a regular expression used to select
-   *                         files and directories to upload
+   * @param {function(String,Boolean):Boolean} filter - (Optional) The first argument is the full path of the item to be downloaded and the second argument is a boolean, which will be true if the target path is for a directory.  If the function returns true, the item will be downloaded
    * @returns {Promise<String>}
    */
-  async downloadDir(srcDir, dstDir, filter = /.*/) {
+  async downloadDir(srcDir, dstDir, filter) {
     try {
       this.debugMsg(`downloadDir -> ${srcDir} ${dstDir}`);
       haveConnection(this, 'downloadDir');
-      let fileList = await this.list(srcDir, filter);
+      let fileList = await this.list(srcDir);
+      if (filter) {
+        fileList = fileList.filter((item) =>
+          filter(
+            `${srcDir}${this.remotePathSep}${item.name}`,
+            item.type === 'd' ? true : false
+          )
+        );
+      }
       const localCheck = haveLocalCreate(dstDir);
       if (!localCheck.status && localCheck.details === 'permission denied') {
         throw fmtError(
@@ -1178,15 +1273,13 @@ class SftpClient {
         );
       }
       for (let f of fileList) {
+        let newSrc = `${srcDir}${this.remotePathSep}${f.name}`;
+        let newDst = join(dstDir, f.name);
         if (f.type === 'd') {
-          let newSrc = srcDir + this.remotePathSep + f.name;
-          let newDst = join(dstDir, f.name);
           await this.downloadDir(newSrc, newDst, filter);
         } else if (f.type === '-') {
-          let src = srcDir + this.remotePathSep + f.name;
-          let dst = join(dstDir, f.name);
-          await this.fastGet(src, dst);
-          this.client.emit('download', { source: src, destination: dst });
+          await this.get(newSrc, newDst);
+          this.client.emit('download', { source: newSrc, destination: newDst });
         } else {
           this.debugMsg(
             `downloadDir: File ignored: ${f.name} not regular file`
@@ -1208,10 +1301,10 @@ class SftpClient {
    * @returns {Promise<Boolean>}
    */
   end() {
-    let endCloseHandler;
+    let endCloseHandler, listeners;
     return new Promise((resolve, reject) => {
+      listeners = addTempListeners(this, 'end', reject);
       this.endCalled = true;
-      addTempListeners(this, 'end', reject);
       endCloseHandler = () => {
         this.sftp = undefined;
         this.debugMsg('end: Connection closed');
@@ -1224,7 +1317,7 @@ class SftpClient {
       }
     }).finally(() => {
       this.debugMsg('end: finally clause fired');
-      removeTempListeners(this, 'end');
+      removeTempListeners(this, listeners, 'end');
       this.removeListener('close', endCloseHandler);
       this.endCalled = false;
       this._resetEventFlags();