ssh2-sftp-client 10.0.3 → 12.0.0

package/src/index.js

@@ -1,9 +1,7 @@
 'use strict';
-
 const { Client } = require('ssh2');
 const fs = require('node:fs');
 const concat = require('concat-stream');
-const promiseRetry = require('promise-retry');
 const { join, parse } = require('node:path');
 const {
   globalListener,
@@ -19,11 +17,18 @@ const {
 const { errorCode } = require('./constants');
 
 class SftpClient {
-  constructor(clientName) {
-    this.version = '10.0.3';
+  constructor(
+    clientName = 'sftp',
+    callbacks = {
+      error: (err) => console.error(`Global error listener: ${err.message}`),
+      end: () => console.log('Global end listener: end event raised'),
+      close: () => console.log('Global close listener: close event raised'),
+    },
+  ) {
+    this.version = '12.0.0';
     this.client = new Client();
     this.sftp = undefined;
-    this.clientName = clientName || 'sftp';
+    this.clientName = clientName;
     this.endCalled = false;
     this.errorHandled = false;
     this.closeHandled = false;
@@ -31,9 +36,10 @@ class SftpClient {
     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'));
+    this.eventCallbacks = callbacks;
+    this.client.on('close', globalListener(this, 'close', this.eventCallbacks));
+    this.client.on('end', globalListener(this, 'end', this.eventCallbacks));
+    this.client.on('error', globalListener(this, 'error', this.eventCallbacks));
   }
 
   debugMsg(msg, obj) {
@@ -51,35 +57,32 @@ class SftpClient {
   fmtError(err, name = 'sftp', eCode, retryCount) {
     let msg = '';
     let code = '';
-    const retry = retryCount
-      ? ` after ${retryCount} ${retryCount > 1 ? 'attempts' : 'attempt'}`
-      : '';
 
     if (err === undefined) {
       msg = `${name}: Undefined error - probably a bug!`;
       code = errorCode.generic;
     } else if (typeof err === 'string') {
-      msg = `${name}: ${err}${retry}`;
+      msg = `${name}: ${err}`;
       code = eCode || errorCode.generic;
     } else if (err.custom) {
-      msg = `${name}->${err.message}${retry}`;
+      msg = `${name}->${err.message}`;
       code = err.code;
     } else {
       switch (err.code) {
         case 'ENOTFOUND': {
-          msg = `${name}: Address lookup failed for host${retry}`;
+          msg = `${name}: Address lookup failed for host`;
           break;
         }
         case 'ECONNREFUSED': {
-          msg = `${name}: Remote host refused connection${retry}`;
+          msg = `${name}: Remote host refused connection`;
           break;
         }
         case 'ECONNRESET': {
-          msg = `${name}: Remote host has reset the connection: ${err.message}${retry}`;
+          msg = `${name}: Remote host has reset the connection: ${err.message}`;
           break;
         }
         default: {
-          msg = `${name}: ${err.message}${retry}`;
+          msg = `${name}: ${err.message}`;
         }
       }
       code = err.code || errorCode.generic;
@@ -115,27 +118,52 @@ class SftpClient {
   }
 
   /**
-   * @async
    *
-   * Create a new SFTP connection to a remote SFTP server
+   * Create a new SFTP connection to a remote SFTP server.
+   * The connection options are the same as those offered
+   * by the underlying SSH2 module.
    *
    * @param {Object} config - an SFTP configuration object
    *
    * @return {Promise<Object>} which will resolve to an sftp client object
    */
-  getConnection(config) {
+  connect(config) {
     let doReady, listeners;
     return new Promise((resolve, reject) => {
       listeners = addTempListeners(this, 'getConnection', reject);
+      if (config.debug) {
+        this.debug = config.debug;
+        this.debugMsg('connect: Debugging turned on');
+        this.debugMsg(`ssh2-sftp-client Version: ${this.version} `, process.versions);
+      }
+      this.promiseLimit = config.promiseLimit ?? 10;
+
       doReady = () => {
-        this.debugMsg('getConnection ready listener: got connection - promise resolved');
-        resolve(true);
+        this.client.sftp((err, sftp) => {
+          if (err) {
+            reject(this.fmtError(err));
+          } else {
+            this.sftp = sftp;
+            resolve(sftp);
+          }
+        });
       };
       this.on('ready', doReady);
+
       try {
-        this.client.connect(config);
+        if (this.sftp) {
+          reject(
+            this.fmtError(
+              'An existing SFTP connection is already defined',
+              'connect',
+              errorCode.connect,
+            ),
+          );
+        } else {
+          this.client.connect(config);
+        }
       } catch (err) {
-        this.debugMsg(`getConnection: ${err.message}`);
+        this.end();
         reject(err);
       }
     }).finally(() => {
@@ -144,90 +172,6 @@ class SftpClient {
     });
   }
 
-  getSftpChannel() {
-    return new Promise((resolve, reject) => {
-      this.client.sftp((err, sftp) => {
-        if (err) {
-          reject(this.fmtError(err, 'getSftpChannel', err.code));
-        } else {
-          this.sftp = sftp;
-          resolve(sftp);
-        }
-      });
-    });
-  }
-
-  /**
-   * @async
-   *
-   * Create a new SFTP connection to a remote SFTP server.
-   * The connection options are the same as those offered
-   * by the underlying SSH2 module.
-   *
-   * @param {Object} config - an SFTP configuration object
-   *
-   * @return {Promise<Object>} which will resolve to an sftp client object
-   */
-  async connect(config) {
-    let listeners;
-
-    try {
-      listeners = addTempListeners(this, 'connect');
-      if (config.debug) {
-        this.debug = config.debug;
-        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,
-        );
-      }
-      const retryOpts = {
-        retries: config.retries ?? 1,
-        factor: config.retry_factor ?? 2,
-        minTimeout: config.retry_minTimeout ?? 25000,
-      };
-      await promiseRetry(retryOpts, async (retry, attempt) => {
-        try {
-          this.debugMsg(`connect: Connect attempt ${attempt}`);
-          await this.getConnection(config);
-        } catch (err) {
-          switch (err.code) {
-            case 'ENOTFOUND':
-            case 'ECONNREFUSED':
-            case 'ERR_SOCKET_BAD_PORT': {
-              throw err;
-            }
-            case undefined: {
-              if (
-                err.message.endsWith('All configured authentication methods failed') ||
-                err.message.startsWith('Cannot parse privateKey')
-              ) {
-                throw err;
-              }
-              retry(err);
-              break;
-            }
-            default: {
-              retry(err);
-            }
-          }
-        }
-      });
-      const sftp = await this.getSftpChannel();
-      return sftp;
-    } catch (err) {
-      this.end();
-      throw err.custom ? err : this.fmtError(err, 'connect');
-    } finally {
-      removeTempListeners(this, listeners, 'connect');
-    }
-  }
-
   /**
    * @async
    *
@@ -246,18 +190,14 @@ class SftpClient {
       if (addListeners) {
         listeners = addTempListeners(this, 'realPath', reject);
       }
-      this.debugMsg(`realPath -> ${remotePath}`);
       this.sftp.realpath(remotePath, (err, absPath) => {
         if (err) {
           if (err.code === 2) {
-            this.debugMsg('realPath <- ""');
             resolve('');
           } else {
-            this.debugMsg(`${err.message} ${remotePath}`, 'realPath');
             reject(this.fmtError(`${err.message} ${remotePath}`, 'realPath', err.code));
           }
         }
-        this.debugMsg(`realPath <- ${absPath}`);
         resolve(absPath);
       });
     }).finally(() => {
@@ -313,7 +253,6 @@ class SftpClient {
             isFIFO: stats.isFIFO(),
             isSocket: stats.isSocket(),
           };
-          this.debugMsg('_xstat: result = ', result);
           resolve(result);
         }
       };
@@ -382,13 +321,11 @@ class SftpClient {
    *                   object if it does
    */
   async exists(remotePath) {
-    this.debugMsg(`exists: remotePath = ${remotePath}`);
     try {
       if (remotePath === '.') {
         return 'd';
       }
       const info = await this.lstat(remotePath);
-      this.debugMsg('exists: <- ', info);
       if (info.isDirectory) {
         return 'd';
       } else if (info.isSymbolicLink) {
@@ -501,20 +438,20 @@ class SftpClient {
         };
         rdr = this.sftp.createReadStream(remotePath, options.readStreamOptions);
         rdr.once('error', (err) => {
-          if (dst && typeof dst !== 'string' && !dst.destroyed) {
-            dst.destroy();
+          if (dst && typeof dst === 'string' && wtr && !wtr.destroyed) {
+            wtr.destroy();
           }
           reject(this.fmtError(`${err.message} ${remotePath}`, 'get', err.code));
         });
         if (dst === undefined) {
           // no dst specified, return buffer of data
-          this.debugMsg('get resolving buffer of data');
+          this.debugMsg('get resolving with buffer of data');
           wtr = concat((buff) => {
             resolve(buff);
           });
         } else if (typeof dst === 'string') {
           // dst local file path
-          this.debugMsg('get returning local file');
+          this.debugMsg(`get called with file path destination ${dst}`);
           const localCheck = haveLocalCreate(dst);
           if (localCheck.status) {
             wtr = fs.createWriteStream(dst, options.writeStreamOptions);
@@ -528,7 +465,7 @@ class SftpClient {
             );
           }
         } else {
-          this.debugMsg('get: returning data into supplied stream');
+          this.debugMsg('get called with stream destination');
           wtr = dst;
         }
         wtr.once('error', (err) => {
@@ -542,16 +479,17 @@ class SftpClient {
         });
         rdr.once('end', () => {
           if (typeof dst === 'string') {
-            this.debugMsg('get: resolving with dst filename');
             resolve(dst);
           } else if (dst !== undefined) {
-            this.debugMsg('get: resolving with writer stream object');
             resolve(wtr);
           }
         });
         rdr.pipe(wtr, options.pipeOptions);
       }
     }).finally(() => {
+      if (rdr && !rdr.destroyed) {
+        rdr.destroy();
+      }
       if (addListeners) {
         removeTempListeners(this, listeners, 'get');
       }
@@ -661,7 +599,6 @@ class SftpClient {
 
   async fastPut(localPath, remotePath, options) {
     try {
-      this.debugMsg(`fastPut -> local ${localPath} remote ${remotePath}`);
       const localCheck = haveLocalAccess(localPath);
       if (!localCheck.status) {
         throw this.fmtError(
@@ -713,6 +650,9 @@ class SftpClient {
       if (haveConnection(this, '_put', reject)) {
         wtr = this.sftp.createWriteStream(rPath, opts.writeStreamOptions);
         wtr.once('error', (err) => {
+          if (typeof lPath === 'string' && rdr && !rdr.destroyed) {
+            rdr.destroy();
+          }
           reject(
             this.fmtError(
               `Write stream error: ${err.message} ${rPath}`,
@@ -728,10 +668,13 @@ class SftpClient {
           this.debugMsg('put source is a buffer');
           wtr.end(lPath);
         } else {
-          rdr =
-            typeof lPath === 'string'
-              ? fs.createReadStream(lPath, opts.readStreamOptions)
-              : lPath;
+          if (typeof lPath === 'string') {
+            this.debugMsg('put source is string path');
+            rdr = fs.createReadStream(lPath, opts.readStreamOptions);
+          } else {
+            this.debugMsg('put source is a stream');
+            rdr = lPath;
+          }
           rdr.once('error', (err) => {
             reject(
               this.fmtError(
@@ -747,6 +690,9 @@ class SftpClient {
         }
       }
     }).finally(() => {
+      if (wtr && !wtr.destroyed) {
+        wtr.destroy();
+      }
       if (addListeners) {
         removeTempListeners(this, listeners, '_put');
       }
@@ -786,7 +732,6 @@ class SftpClient {
         listeners = addTempListeners(this, '_append', reject);
       }
       if (haveConnection(this, '_append', reject)) {
-        this.debugMsg(`append -> remote: ${rPath} `, opts);
         opts.flags = 'a';
         const stream = this.sftp.createWriteStream(rPath, opts);
         stream.on('error', (err) => {
@@ -826,7 +771,7 @@ class SftpClient {
           errorCode.badPath,
         );
       }
-      await this._append(input, remotePath, options);
+      return await this._append(input, remotePath, options);
     } catch (e) {
       throw e.custom ? e : this.fmtError(e.message, 'append', e.code);
     }
@@ -941,7 +886,6 @@ class SftpClient {
       let listeners;
       return new Promise((resolve, reject) => {
         listeners = addTempListeners(this, '_rmdir', reject);
-        this.debugMsg(`_rmdir: dir = ${dir}`);
         this.sftp.rmdir(dir, (err) => {
           if (err) {
             reject(this.fmtError(`${err.message} ${dir}`, 'rmdir', err.code));
@@ -957,7 +901,6 @@ class SftpClient {
       let listeners;
       return new Promise((resolve, reject) => {
         listeners = addTempListeners(this, '_delFiles', reject);
-        this.debugMsg(`_delFiles: path = ${path} fileList = ${fileList}`);
         const pList = [];
         for (const f of fileList) {
           pList.push(this.delete(`${path}/${f.name}`, true, false));
@@ -973,10 +916,8 @@ class SftpClient {
     };
 
     try {
-      this.debugMsg(`rmdir: dir = ${remoteDir} recursive = ${recursive}`);
       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`,
@@ -992,19 +933,14 @@ class SftpClient {
         );
       }
       if (!recursive) {
-        this.debugMsg('rmdir: non-recursive - just try to remove it');
         return await _rmdir(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);
       }
       const fileList = listing.filter((i) => i.type !== 'd');
-      this.debugMsg(`rmdir: dir content files to remove = ${fileList.length}`);
       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) {
         await this.rmdir(`${absPath}/${d.name}`, true);
@@ -1244,11 +1180,7 @@ class SftpClient {
 
     try {
       haveConnection(this, 'uploadDir');
-      this.debugMsg(
-        `uploadDir: srcDir = ${srcDir} dstDir = ${dstDir} options = ${options}`,
-      );
       const { remoteDir, remoteStatus } = await getRemoteStatus(dstDir);
-      this.debugMsg(`uploadDir: remoteDir = ${remoteDir} remoteStatus = ${remoteStatus}`);
       checkLocalStatus(srcDir);
       if (!remoteStatus) {
         await this._mkdir(remoteDir, true);
@@ -1257,7 +1189,6 @@ class SftpClient {
         encoding: 'utf8',
         withFileTypes: true,
       });
-      this.debugMsg(`uploadDir: dirEntries = ${dirEntries}`);
       if (options?.filter) {
         dirEntries = dirEntries.filter((item) =>
           options.filter(join(srcDir, item.name), item.isDirectory()),
@@ -1265,8 +1196,6 @@ class SftpClient {
       }
       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) {
         const src = join(srcDir, d.name);
@@ -1417,7 +1346,7 @@ class SftpClient {
     } catch (err) {
       throw err.custom ? err : this.fmtError(err.message, 'createReadStream', err.code);
     } finally {
-      removeTempListeners(this, listeners, 'createReadStreame');
+      removeTempListeners(this, listeners, 'createReadStream');
     }
   }
 
@@ -1527,6 +1456,7 @@ class SftpClient {
       };
       this.on('close', endCloseHandler);
       if (this.sftp) {
+        this.debugMsg('end: Ending SFTP connection');
         this.client.end();
       } else {
         // no actual connection exists - just resolve
@@ -1536,7 +1466,6 @@ class SftpClient {
     }).finally(() => {
       removeTempListeners(this, listeners, 'end');
       this.removeListener('close', endCloseHandler);
-      this.endCalled = false;
     });
   }
 }

package/src/utils.js

@@ -1,6 +1,54 @@
-const fs = require('node:fs');
-const path = require('node:path');
-const { errorCode } = require('./constants');
+const { statSync, constants, accessSync } = require('node:fs');
+const { dirname } = require('node:path');
+const { errorCode } = require('./constants.js');
+
+function eventHandled(client) {
+  if (client.errorHandled || client.endHandled || client.closeHandled) {
+    return true;
+  }
+  return false;
+}
+
+function globalListener(client, evt, eventCallbacks) {
+  if (evt === 'error') {
+    return (err) => {
+      if (client.errorHandled) {
+        client.debugMsg(`Global error event: Ignoring handled error ${err.message}`);
+        return;
+      }
+      client.debugMsg(`Global error event: ${err.message}`);
+      client.errorHandled = true;
+      if (eventCallbacks?.error) {
+        eventCallbacks.error(err);
+      }
+    };
+  }
+  if (evt === 'end') {
+    return () => {
+      if (client.endCalled || client.endHandled) {
+        client.debugMsg('Global end event: Ignoring handled end event');
+        return;
+      }
+      client.debugMsg('Global end event: Handling end event');
+      client.endHandled = true;
+      if (eventCallbacks?.end) {
+        eventCallbacks.end();
+      }
+    };
+  }
+  return () => {
+    if (client.endCalled || client.closeHandled) {
+      client.debugMsg('Global close event: Ignoring handled close event');
+    } else {
+      client.debugMsg('Global close event: Handling close event');
+      client.closeHandled = true;
+      client.sftp = undefined;
+      if (eventCallbacks?.close) {
+        eventCallbacks.close();
+      }
+    }
+  };
+}
 
 /**
  * Simple default error listener. Will reformat the error message and
@@ -10,12 +58,13 @@ const { errorCode } = require('./constants');
  * @throws {Error} Throws new error
  */
 function errorListener(client, name, reject) {
-  const fn = (err) => {
-    if (client.endCalled || client.errorHandled) {
+  const fn = function (err) {
+    if (eventHandled(client)) {
       // error already handled or expected - ignore
-      client.debugMsg(`${name} errorListener - ignoring handled error`);
+      client.debugMsg(`${name} errorListener - ignoring handled error ${err.message}`);
       return;
     }
+    client.debugMsg(`${name} errorListener - handling error ${err.message}`);
     client.errorHandled = true;
     const newError = new Error(`${name}: ${err.message}`);
     newError.code = err.code;
@@ -28,55 +77,52 @@ function errorListener(client, name, reject) {
   return fn;
 }
 
-function globalListener(client, evt) {
-  return () => {
-    if (client.endCalled || client.errorHandled || client.closeHandled) {
-      // we are processing an expected event handled elsewhere
-      client.debugMsg(`Global ${evt} event: Ignoring expected and handled event`);
-    } else {
-      client.debugMsg(`Global ${evt} event: Handling unexpected event`);
-      client.sftp = undefined;
-    }
-  };
-}
-
-function endListener(client, name) {
+function endListener(client, name, reject) {
   const fn = function () {
     client.sftp = undefined;
-    if (client.endCalled || client.endHandled || client.errorHandled) {
+    if (client.endCalled || eventHandled(client)) {
       // end event already handled - ignore
-      client.debugMsg(`${name} endListener - handled end event`);
+      client.debugMsg(`${name} endListener - ignoring handled end event`);
       return;
     }
     client.endHandled = true;
-    client.debugMsg(`${name} Unexpected end event`);
+    client.debugMsg(`${name} endListener - handling unexpected end event`);
+    const newError = new Error(`${name}: Unexpected end event`);
+    newError.code = errorCode.ERR_GENERIC_CLIENT;
+    if (reject) {
+      reject(newError);
+    } else {
+      throw newError;
+    }
   };
   return fn;
 }
 
-function closeListener(client, name) {
+function closeListener(client, name, reject) {
   const fn = function () {
     client.sftp = undefined;
-    if (
-      client.endCalled ||
-      client.closeHandled ||
-      client.errorHandled ||
-      client.endHandled
-    ) {
+    if (client.endCalled || eventHandled(client)) {
       // handled or expected close event - ignore
-      client.debugMsg(`${name} closeListener - handled close event`);
+      client.debugMsg(`${name} closeListener - ignoring handled close event`);
       return;
     }
     client.closeHandled = true;
-    client.debugMsg(`${name} Unexpected close event`);
+    client.debugMsg(`${name} closeListener - handling unexpected close event`);
+    const newError = new Error(`${name}: Unexpected close event`);
+    newError.code = errorCode.ERR_GENERIC_CLIENT;
+    if (reject) {
+      reject(newError);
+    } else {
+      throw newError;
+    }
   };
   return fn;
 }
 
 function addTempListeners(client, name, reject) {
   const listeners = {
-    end: endListener(client, name),
-    close: closeListener(client, name),
+    end: endListener(client, name, reject),
+    close: closeListener(client, name, reject),
     error: errorListener(client, name, reject),
   };
   client.on('end', listeners.end);
@@ -109,7 +155,7 @@ function removeTempListeners(client, listeners, name) {
  * @returns {string | boolean} returns a string for object type if it exists, false otherwise
  */
 function localExists(filePath) {
-  const stats = fs.statSync(filePath, { throwIfNoEntry: false });
+  const stats = statSync(filePath, { throwIfNoEntry: false });
   if (!stats) {
     return false;
   } else if (stats.isDirectory()) {
@@ -140,11 +186,10 @@ function localExists(filePath) {
  * @returns {Object} with properties status, type, details and code
  */
 function haveLocalAccess(filePath, mode = 'r') {
-  const accessMode =
-    fs.constants.F_OK | (mode === 'w') ? fs.constants.W_OK : fs.constants.R_OK;
+  const accessMode = constants.F_OK | (mode === 'w') ? constants.W_OK : constants.R_OK;
 
   try {
-    fs.accessSync(filePath, accessMode);
+    accessSync(filePath, accessMode);
     const type = localExists(filePath);
     return {
       status: true,
@@ -210,7 +255,7 @@ function haveLocalCreate(filePath) {
       };
     }
     // to create it, parent must be directory and writeable
-    const dirPath = path.dirname(filePath);
+    const dirPath = dirname(filePath);
     const localCheck = haveLocalAccess(dirPath, 'w');
     if (!localCheck.status) {
       // no access to parent directory