ssh2-sftp-client 9.0.4 → 10.0.0

package/README.md

@@ -1,110 +1,103 @@
-- [Overview](#sec-1)
-  - [Version 9.x Changes](#sec-1-1)
-- [Installation](#sec-2)
-- [Basic Usage](#sec-3)
-- [Documentation](#sec-4)
-  - [Specifying Paths](#sec-4-1)
-  - [Methods](#sec-4-2)
-    - [new SftpClient(name) ===> SFTP client object](#sec-4-2-1)
-    - [connect(config) ===> SFTP object](#sec-4-2-2)
-    - [list(path, filter) ==> Array[object]](#sec-4-2-3)
-    - [exists(path) ==> boolean](#sec-4-2-4)
-    - [stat(path) ==> object](#sec-4-2-5)
-    - [get(path, dst, options) ==> String|Stream|Buffer](#sec-4-2-6)
-    - [fastGet(remotePath, localPath, options) ===> string](#sec-4-2-7)
-    - [put(src, remotePath, options) ==> string](#sec-4-2-8)
-    - [fastPut(localPath, remotePath, options) ==> string](#sec-4-2-9)
-    - [append(input, remotePath, options) ==> string](#sec-4-2-10)
-    - [mkdir(path, recursive) ==> string](#sec-4-2-11)
-    - [rmdir(path, recursive) ==> string](#sec-4-2-12)
-    - [delete(path, noErrorOK) ==> string](#sec-4-2-13)
-    - [rename(fromPath, toPath) ==> string](#sec-4-2-14)
-    - [posixRename(fromPath, toPath) ==> string](#sec-4-2-15)
-    - [chmod(path, mode) ==> string](#sec-4-2-16)
-    - [realPath(path) ===> string](#sec-4-2-17)
-    - [cwd() ==> string](#sec-4-2-18)
-    - [uploadDir(srcDir, dstDir, options) ==> string](#sec-4-2-19)
-    - [downloadDir(srcDir, dstDir, options) ==> string](#sec-4-2-20)
-    - [createReadStream(remotePath, options)) ==> stream object](#sec-4-2-21)
-    - [createWriteStream(remotePath, options) ==> stream object](#sec-4-2-22)
-    - [rcopy(srcPath, dstPath) ==> string](#sec-4-2-23)
-    - [end() ==> boolean](#sec-4-2-24)
-    - [Add and Remove Listeners](#sec-4-2-25)
-- [Platform Quirks & Warnings](#sec-5)
-  - [Server Capabilities](#sec-5-1)
-  - [Issues with `fastPut()` and `fastGet()` Methods](#sec-5-2)
-  - [Promises, Events & Managing Exceptions](#sec-5-3)
-    - [Adding Custom Handlers](#sec-5-3-1)
-  - [Windows Based Servers](#sec-5-4)
-  - [Don't Re-use SftpClient Objects](#sec-5-5)
-- [FAQ](#sec-6)
-  - [Remote server drops connections with only an end event](#sec-6-1)
-  - [How can I pass writeable stream as dst for get method?](#sec-6-2)
-  - [How can I upload files without having to specify a password?](#sec-6-3)
-  - [How can I connect through a Socks Proxy](#sec-6-4)
-  - [Timeout while waiting for handshake or handshake errors](#sec-6-5)
-  - [How can I limit upload/download speed](#sec-6-6)
-  - [Connection hangs or fails for larger files](#sec-6-7)
-- [Examples](#sec-7)
-- [Troubleshooting](#sec-8)
-  - [Common Errors](#sec-8-1)
-    - [Not returning the promise in a `then()` block](#sec-8-1-1)
-    - [Mixing Promise Chains and Async/Await](#sec-8-1-2)
-    - [Try/catch and Error Handlers](#sec-8-1-3)
-    - [Server Differences](#sec-8-1-4)
-    - [Avoid Concurrent Operations](#sec-8-1-5)
-  - [Debugging Support](#sec-8-2)
-- [Logging Issues](#sec-9)
-- [Pull Requests](#sec-10)
-- [Contributors](#sec-11)
-
-
-# Overview<a id="sec-1"></a>
+- [Overview](#org4821cd9)
+  - [Version 10.0.0 Changes](#org196e8b6)
+- [Installation](#orgeac23df)
+- [Basic Usage](#orgda0ed58)
+- [Documentation](#orgd0ca540)
+  - [Specifying Paths](#orgabfbdff)
+  - [Methods](#org35528cc)
+    - [new SftpClient(name) ===> SFTP client object](#org6d917af)
+    - [connect(config) ===> SFTP object](#org3ca98bb)
+    - [list(path, filter) ==> Array[object]](#org067b5c0)
+    - [exists(path) ==> boolean](#orgfde631c)
+    - [stat(path) ==> object](#orge6ccca9)
+    - [get(path, dst, options) ==> String|Stream|Buffer](#org63cf95f)
+    - [fastGet(remotePath, localPath, options) ===> string](#orga32496c)
+    - [put(src, remotePath, options) ==> string](#org6bdfd59)
+    - [fastPut(localPath, remotePath, options) ==> string](#org4296214)
+    - [append(input, remotePath, options) ==> string](#org01aa427)
+    - [mkdir(path, recursive) ==> string](#orge74ab72)
+    - [rmdir(path, recursive) ==> string](#org2692b91)
+    - [delete(path, noErrorOK) ==> string](#org59254a5)
+    - [rename(fromPath, toPath) ==> string](#org287873a)
+    - [posixRename(fromPath, toPath) ==> string](#orgb7290ba)
+    - [chmod(path, mode) ==> string](#org0e57abe)
+    - [realPath(path) ===> string](#org52444ca)
+    - [cwd() ==> string](#org34966e3)
+    - [uploadDir(srcDir, dstDir, options) ==> string](#org5c58fad)
+    - [downloadDir(srcDir, dstDir, options) ==> string](#orgb346779)
+    - [createReadStream(remotePath, options)) ==> stream object](#orga0edaaf)
+    - [createWriteStream(remotePath, options) ==> stream object](#org7287ad7)
+    - [rcopy(srcPath, dstPath) ==> string](#org4b84e95)
+    - [end() ==> boolean](#org6af9411)
+    - [Add and Remove Listeners](#org79d7176)
+- [Platform Quirks & Warnings](#org8815934)
+  - [Server Capabilities](#orgcf08239)
+  - [Issues with `fastPut()` and `fastGet()` Methods](#org92f1dc4)
+  - [Promises, Events & Managing Exceptions](#org27f104a)
+    - [Adding Custom Handlers](#orgd903953)
+  - [Windows Based Servers](#orged5ee01)
+  - [Don't Re-use SftpClient Objects](#orgfafec91)
+- [FAQ](#orgbe306ce)
+  - [Remote server drops connections with only an end event](#org9377d69)
+  - [How can I pass writeable stream as dst for get method?](#org0cf3ed0)
+  - [How can I upload files without having to specify a password?](#org14d1415)
+  - [How can I connect through a Socks Proxy](#org118bb9f)
+  - [Timeout while waiting for handshake or handshake errors](#orgc720a77)
+  - [How can I limit upload/download speed](#orge322728)
+  - [Connection hangs or fails for larger files](#org4164c6c)
+  - [Typescript definition file out of date](#orgd28c1e8)
+- [Examples](#orgfab3156)
+- [Troubleshooting](#orga11079b)
+  - [Common Errors](#org0372c41)
+    - [Not returning the promise in a `then()` block](#org0d8dc85)
+    - [Mixing Promise Chains and Async/Await](#org199b814)
+    - [Try/catch and Error Handlers](#org46e5412)
+    - [Server Differences](#org8a2ebba)
+    - [Avoid Concurrent Operations](#org24c4235)
+  - [Debugging Support](#org1d067af)
+- [Logging Issues](#orgdc52f71)
+- [Pull Requests](#orge4e0c24)
+- [Contributors](#org7f7c9a1)
+
+
+
+<a id="org4821cd9"></a>
+
+# Overview
 
 an SFTP client for node.js, a wrapper around [SSH2](https://github.com/mscdex/ssh2) which provides a high level convenience abstraction as well as a Promise based API.
 
-Documentation on the methods and available options in the underlying modules can be found on the [SSH2](https://github.com/mscdex/ssh2) project pages.
+Documentation on the methods and available options in the underlying modules can be found on the [SSH2](https://github.com/mscdex/ssh2) project pages. As this module is really just a wrapper around the `ssh2` module, you will find lots of useful information, tips and examples in the `ssh2` repository.
 
-Current stable release is **v9.0.4**.
+Current stable release is \*v10.0.0.
 
-Code has been tested against Node versions 14.20.0, 16.17.2 and 18.8.0
+Code has been tested against Node versions 16.20.2, 18.18.2, 20.10.0 and 21.5.0. However, only versions from v18 are actively supported. It should also be noted that a significant performance improvement has been observed with versions >= 18. Version v16 is significantly slower.
 
-Node versions < 14.x are not supported.
+Node versions < 16.x are not supported.
 
-## Version 9.x Changes<a id="sec-1-1"></a>
 
--   Fix bug in `connect()` method when private key data was corrupted. The method was not handling errors fro corrupted ssh private keys and would hang indefinitely without reporting any error. Now reports that it was unable to parse the private key.
--   Fix bug in `end()` method where it was possible for the module to attempt calling the underlying ssh2 `end()` method when ssh2 has not been initialised. This could lead to undefined reference errors.
--   Fix bug in `get()` method where supplied destination streams were not close, creating a possible resource leak. If the remote file did not exist, the method would return an error, but failed to close any passed in stream supplied as the destination for the data in the `get()` call.
--   Change the default end and close handlers not to throw error or reject promises. Previously, an end or close event would cause an error to be raised or a promise to be rejected if the event was deemed to be *unexpected*. However, classification of events as being unexpected was unreliable and didn't add much real value. Both these handlers will now invalidate the SFTP connection object and log that the event fired and nothing else.
--   Changed when event handled flags are reset. Now they are reset after a new set of temporary listeners are added.
--   Don't throw an error when calling end() if there is no active SFTP connection. It does no harm to call end() when there is no connection, so no need to raise an error.
--   Use nullish coalescing when setting retry parameters instead of or'ing with defaults. Allows setting values to 0.
--   **Breaking Change**: This version uses syntax not supported in node versions prior to v14. Therefore, node versions less than v14 will not work.
--   **Breaking Change**: This `list()` method no longer accepts a regular expression for filtering the entries to be returned. You can now specify a filter function instead. The function is called for each item in the list of items to be returned, passing in the item object as its only argument. Essentially, this is just a call to `Array.filter()`, so the filter function should behave in the same way i.e. return true for items to be retained and false for those to be dropped.
--   **Breaking Change**: The ability to set `autoClose` on read and write streams and the ability to set `end` on `pipe` operations has been removed. These options caused confusion for users and were too easy to get wrong, plus it made the methods overly complicated. For those use-cases where you want to control streams at a low level, two new methods have been added, `createReadStream()` and `createWriteStream()`. However, it should be noted that client code is 100% responsible for managing streams obtained using these methods. Use at your own risk!
--   **Breaking Change**: The 3rd argument to `uploadDir()` and `downloadDir()` methods has been change. Previously, the argument was a filter function used to select which directories and files to be transferred. The 3rd argument is now an options object with two supported properties, `filter` and `useFastput` (for `uploadDir()`) or `useFastget` (for `downloadDir()`). If `useFastput` is true, the `fastPut()` method will be used to upload files. If `false` or missing, the slower, but better supported, `put()` method will be used. Likewise, the `useFastget` options can be set to `true` to use the `fastGet()` method for downloading files, otherwise the slower, but more reliable, `get()` method will be used.
--   The `uploadDir()` and `downloadDir()` methods now use asynchronous processes to upload/download files. This should result in improved performance for these two methods.
--   New Methods: Two new methods, `createWriteStream()` and `createReadStream()` have been added. These methods will return a stream object connected to a remote file on the `SFTP` server. Client code is responsible for managing these stream objects. This includes adding any necessary event listeners and disposing of the objects once finished with them.
--   Re-factoring of Listeners: The library manages temporary listeners in order to provide a way to catch events and processes them inside a `Promise` context. Previously, every method added its own set of temporary listeners. However, this could result in multiple sets of listeners being added, especially for methods which call other methods as part of their processing e.g. `rmdir(),` `uploadDir()` and `dowqnloadDir()`. To avoid this, *internal only* versions of each method have been created. These internal methods use an *underscore* `_` prefix. Client code should not use these methods directly.
--   New method: Added `rcopy()` method to perform a remote copy of a file on the remote SFTP server.
--   Bumped ssh2 version to 1.11.0
+<a id="org196e8b6"></a>
 
-# Installation<a id="sec-2"></a>
+## Version 10.0.0 Changes
 
-```shell
+-   The main change in this version is adding of limits on the number of promises which can be active at the same time. Version 9.1.0 extended the use of multiple promises to improve performance with downloadDir() and uploadDir(). However, for directories with really large numbers of files, this often resulted in an error because the methods would try to create more concurrent promises than was possible given available resources. This issue has been fixed by adding a new property called `promiseLimit`, which is limited to 10 by default. A new configuration property, `promiseLimit`, is now available for setting the maximum number of concurrent promises the downloadDir()/uploadDir() methods will create when downloading or uploading directory trees.
+    -   Various minor documentation fixes and some minor fixes for typos in option property names.
+
+
+<a id="orgeac23df"></a>
 
-npm
+# Installation
 
+```shell
 npm install ssh2-sftp-client
 ```
 
-# Basic Usage<a id="sec-3"></a>
 
-```javascript
+<a id="orgda0ed58"></a>
 
-let
+# Basic Usage
 
+```js
 let Client = require('ssh2-sftp-client');
 let sftp = new Client();
 
@@ -122,13 +115,21 @@ sftp.connect({
 });
 ```
 
-# Documentation<a id="sec-4"></a>
 
-The connection options are the same as those offered by the underlying SSH2 module. For full details, please see [SSH2 client methods](https://github.com/mscdex/ssh2#user-content-client-methods)
+<a id="orgd0ca540"></a>
+
+# Documentation
+
+The connection options are the same as those offered by the underlying SSH2 module, with just a couple of additional properties added to tweak the `retry` parameters, add a `debug` function and set the `promiseLimit` property. For full details on the other properties, please see [SSH2 client methods](https://github.com/mscdex/ssh2#user-content-client-methods). In particular, see the `ssh2` documentation for details relating to setting various key exchange and encryption/signing algorithms used as part of the ssh2 protocol.
+
+All the methods will return a Promise, except for `on(), ~removeListener()`, `createReadStream` and `createWriteStream`, which are typically only used in special use cases.
+
+Note that I don't use Typescript and I don't maintain any typescript definition files. There are some typescript type definition files for this module, but they are maintained separately and have nothing to do with this project. Therefore, please do not log any issues arising from the use of these definition files with this project. Instead, refer your issues to the maintainers of those modules.
 
-All the methods will return a Promise, except for `on()` and `removeListener()`, which are typically only used in special use cases.
 
-## Specifying Paths<a id="sec-4-1"></a>
+<a id="orgabfbdff"></a>
+
+## Specifying Paths
 
 The convention with both FTP and SFTP is that paths are specified using a 'nix' style i.e. use `/` as the path separator. This means that even if your SFTP server is running on a win32 platform, you should use `/` instead of `\` as the path separator. For example, for a win32 path of `C:\Users\fred` you would actually use `/C:/Users/fred`. If your win32 server does not support the 'nix' path convention, you can try setting the `remotePathSep` property of the `SftpClient` object to the path separator of your remote server. This **might** work, but has not been tested. Please let me know if you need to do this and provide details of the SFTP server so that I can try to create an appropriate environment and adjust things as necessary. At this point, I'm not aware of any win32 based SFTP servers which do not support the 'nix' path convention.
 
@@ -141,35 +142,32 @@ There is a small performance hit for using `./` and `../` as the module must que
 When specifying file paths, ensure to include a full path i.e. include the remote file name. Don't expect the module to append the local file name to the path you provide. For example, the following will not work
 
 ```javascript
-
-
-
 client.put('/home/fred/test.txt', '/remote/dir');
 ```
 
 will not result in the file `test.txt` being copied to `/remote/dir/test.txt`. You need to specify the target file name as well e.g.
 
 ```javascript
-
-
-
 client.put('/home/fred/test.txt', '/remote/dir/test.txt');
 ```
 
 Note that the remote file name does not have to be the same as the local file name. The following works fine;
 
 ```javascript
-
-
-
 client.put('/home/fred/test.txt', '/remote/dir/test-copy.txt');
 ```
 
 This will copy the local file `test.txt` to the remote file `test-copy.txt` in the directory `/remote/dir`.
 
-## Methods<a id="sec-4-2"></a>
 
-### new SftpClient(name) ===> SFTP client object<a id="sec-4-2-1"></a>
+<a id="org35528cc"></a>
+
+## Methods
+
+
+<a id="org6d917af"></a>
+
+### new SftpClient(name) ===> SFTP client object
 
 Constructor to create a new `ssh2-sftp-client` object. An optional `name` string can be provided, which will be used in error messages to help identify which client has thrown the error.
 
@@ -180,9 +178,6 @@ Constructor to create a new `ssh2-sftp-client` object. An optional `name` string
 2.  Example Use
 
     ```javascript
-    
-    'use
-    
     'use strict';
     
     const Client = require('ssh2-sftp-client');
@@ -208,7 +203,10 @@ Constructor to create a new `ssh2-sftp-client` object. An optional `name` string
       });
     ```
 
-### connect(config) ===> SFTP object<a id="sec-4-2-2"></a>
+
+<a id="org3ca98bb"></a>
+
+### connect(config) ===> SFTP object
 
 Connect to an sftp server. Full documentation for connection options is available [here](https://github.com/mscdex/ssh2#user-content-client-methods)
 
@@ -218,10 +216,9 @@ Connect to an sftp server. Full documentation for connection options is availabl
     
     The `retries`, `retry_factor` and `retry_minTimeout` options are not part of the SSH2 module. These are part of the configuration for the [retry](https://www.npmjs.com/package/retry) package and what is used to enable retrying of sftp connection attempts. See the documentation for that package for an explanation of these values.
     
-    ```javascript
-    
-    //
+    The `promiseLimit` is another option which is not part of the `ssh2` module and is specific to `ssh2-sftp-client`. It is a property used to limit the maximum number of concurrent promises possible when either downloading or uploading a directory tree using the `downloadDir()` or `uploadDir()` methods. The default setting for this property is 10. **NOTE**: bigger doe snot mean better. Many factors can affect what is the ideal setting for `promiseLimit`. If it is too large, any benefits are lost while node spends time switching contexts and/or withi the overheads associated with creating and cleaning up promises. Lots of factors can affect what the setting should be, including size of files, number of files, speed of network, version of node, capabilities of remote sftp server etc. A setting of 10 seems to be a reasonably good default and should be adequate for most use cases. However, if you feel it needs to be changed, I highly recommend that you benchmark different values to work out what is the best maximum size before you begin to see a performance drop off.
     
+    ```javascript
     // common options
     
     let commonOpts {
@@ -235,12 +232,13 @@ Connect to an sftp server. Full documentation for connection options is availabl
       privateKey: fs.readFileSync('/path/to/key'), // Buffer or string that contains
       passphrase: 'a pass phrase', // string - For an encrypted private key
       readyTimeout: 20000, // integer How long (in ms) to wait for the SSH handshake
-      strictVendor: true // boolean - Performs a strict server vendor check
-      debug: myDebug // function - Set this to a function that receives a single
+      strictVendor: true, // boolean - Performs a strict server vendor check
+      debug: myDebug,// function - Set this to a function that receives a single
                     // string argument to get detailed (local) debug information.
-      retries: 2 // integer. Number of times to retry connecting
-      retry_factor: 2 // integer. Time factor used to calculate time between retries
-      retry_minTimeout: 2000 // integer. Minimum timeout between attempts
+      retries: 2, // integer. Number of times to retry connecting
+      retry_factor: 2, // integer. Time factor used to calculate time between retries
+      retry_minTimeout: 2000, // integer. Minimum timeout between attempts
+      promiseLimit: 10, // max concurrent promises for downloadDir/uploadDir
     };
     
     // rarely used options
@@ -266,19 +264,18 @@ Connect to an sftp server. Full documentation for connection options is availabl
 2.  Example Use
 
     ```javascript
-    
-    sftp.connect({
-    
-    
     sftp.connect({
-      host: example.com,
+      host: 'example.com',
       port: 22,
       username: 'donald',
       password: 'youarefired'
     });
     ```
 
-### list(path, filter) ==> Array[object]<a id="sec-4-2-3"></a>
+
+<a id="org067b5c0"></a>
+
+### list(path, filter) ==> Array[object]
 
 Retrieves a directory listing. This method returns a Promise, which once realised, returns an array of objects representing items in the remote directory.
 
@@ -288,9 +285,6 @@ Retrieves a directory listing. This method returns a Promise, which once realise
 1.  Example Use
 
     ```javascript
-    
-    const
-    
     const Client = require('ssh2-sftp-client');
     
     const config = {
@@ -300,7 +294,7 @@ Retrieves a directory listing. This method returns a Promise, which once realise
       password: 'my-secret'
     };
     
-    let sftp = new Client;
+    let sftp = new Client();
     
     sftp.connect(config)
       .then(() => {
@@ -321,24 +315,34 @@ Retrieves a directory listing. This method returns a Promise, which once realise
 
     The objects in the array returned by `list()` have the following properties;
     
-    ```nillangnilswitchesnilflags
-    nilbody
-    #+END_SRC
-    
-    ***
-    nilbody
+    ```javascript
+    {
+      type: '-', // file type(-, d, l)
+      name: 'example.txt', // file name
+      size: 43, // file size
+      modifyTime: 1675645360000, // file timestamp of modified time
+      accessTime: 1675645360000, // file timestamp of access time
+      rights: {
+        user: 'rw',
+        group: 'r',
+        other: 'r',
+      },
+      owner: 1000, // user ID
+      group: 1000, // group ID
+      longname: '-rw-r--r--  1 fred  fred  43 Feb 6 12:02 exaple.txt', // like ls -l line
+    }
     ```
 
-### exists(path) ==> boolean<a id="sec-4-2-4"></a>
+
+<a id="orgfde631c"></a>
+
+### exists(path) ==> boolean
 
 Tests to see if remote file or directory exists. Returns type of remote object if it exists or false if it does not.
 
 1.  Example Use
 
     ```javascript
-    
-    const
-    
     const Client = require('ssh2-sftp-client');
     
     const config = {
@@ -348,7 +352,7 @@ Tests to see if remote file or directory exists. Returns type of remote object i
       password: 'my-secret'
     };
     
-    let sftp = new Client;
+    let sftp = new Client();
     
     sftp.connect(config)
       .then(() => {
@@ -365,7 +369,10 @@ Tests to see if remote file or directory exists. Returns type of remote object i
       });
     ```
 
-### stat(path) ==> object<a id="sec-4-2-5"></a>
+
+<a id="orge6ccca9"></a>
+
+### stat(path) ==> object
 
 Returns the attributes associated with the object pointed to by `path`.
 
@@ -376,9 +383,6 @@ Returns the attributes associated with the object pointed to by `path`.
     The `stat()` method returns an object with the following properties;
     
     ```javascript
-    
-    let
-    
     let stats = {
       mode: 33279, // integer representing type and permissions
       uid: 1000, // user ID
@@ -399,9 +403,6 @@ Returns the attributes associated with the object pointed to by `path`.
 2.  Example Use
 
     ```javascript
-    
-    let
-    
     let client = new Client();
     
     client.connect(config)
@@ -419,7 +420,10 @@ Returns the attributes associated with the object pointed to by `path`.
       });
     ```
 
-### get(path, dst, options) ==> String|Stream|Buffer<a id="sec-4-2-6"></a>
+
+<a id="org63cf95f"></a>
+
+### get(path, dst, options) ==> String|Stream|Buffer
 
 Retrieve a file from a remote SFTP server. The `dst` argument defines the destination and can be either a string, a stream object or undefined. If it is a string, it is interpreted as the path to a location on the local file system (path should include the file name). If it is a stream object, the remote data is passed to it via a call to pipe(). If `dst` is undefined, the method will put the data into a buffer and return that buffer when the Promise is resolved. If `dst` is defined, it is returned when the Promise is resolved.
 
@@ -434,9 +438,6 @@ In general, if you're going to pass in a string as the destination, you are bett
     The `options` argument can be used to pass options to the underlying streams and pipe call used by this method. The argument is an object with three possible properties, `readStreamOptions`, `writeStreamOptions` and `pipeOptions`. The values for each of these properties should be an object containing the required options. For example, possible read stream and pipe options could be defined as
     
     ```javascript
-    
-    let
-    
     let options = {
       readStreamOptions: {
         flags: 'r',
@@ -456,9 +457,6 @@ In general, if you're going to pass in a string as the destination, you are bett
 2.  Example Use
 
     ```javascript
-    
-    let
-    
     let client = new Client();
     
     let remotePath = '/remote/server/path/file.txt';
@@ -478,9 +476,14 @@ In general, if you're going to pass in a string as the destination, you are bett
     
     -   **Tip:** See examples file in the Git repository for more examples. You can pass any writeable stream in as the destination. For example, if you pass in `zlib.createGunzip()` writeable stream, you can both download and decompress a gzip file 'on the fly'.
 
-### fastGet(remotePath, localPath, options) ===> string<a id="sec-4-2-7"></a>
 
-Downloads a file at remotePath to localPath using parallel reads for faster throughput. This is the simplest method if you just want to download a file.
+<a id="orga32496c"></a>
+
+### fastGet(remotePath, localPath, options) ===> string
+
+Downloads a file at remotePath to localPath using parallel reads for faster throughput. This is the simplest method if you just want to download a file. However, fastGet functionality depends heavily on remote sftp server capabilities and not all servers have the concurrency support required. See the Platform Quirks & Warnings section of this README.
+
+Bottom line, when it works, it tends to work reliably. However, for many servers, it simply won't work or will result in truncated/corrupted data.
 
 -   **remotePath:** String. Path to the remote file to download
 -   **localPath:** String. Path on local file system for the downloaded file. The local path should include the filename to use for saving the file.
@@ -488,12 +491,13 @@ Downloads a file at remotePath to localPath using parallel reads for faster thro
 
 1.  Options
 
-    ```nillangnilswitchesnilflags
-    nilbody
-    #+END_SRC
-    
-    -
-    nilbody
+    ```javascript
+    {
+      concurrency: 64, // integer. Number of concurrent reads to use
+      chunkSize: 32768, // integer. Size of each read in bytes
+      step: function(total_transferred, chunk, total) // callback called each time a
+                                                      // chunk is transferred
+    }
     ```
     
     -   **Warning:** Some servers do not respond correctly to requests to alter chunk size. This can result in lost or corrupted data.
@@ -501,9 +505,6 @@ Downloads a file at remotePath to localPath using parallel reads for faster thro
 2.  Sample Use
 
     ```javascript
-    
-    let
-    
     let client = new Client();
     let remotePath = '/server/path/file.txt';
     let localPath = '/local/path/file.txt';
@@ -520,7 +521,10 @@ Downloads a file at remotePath to localPath using parallel reads for faster thro
       });
     ```
 
-### put(src, remotePath, options) ==> string<a id="sec-4-2-8"></a>
+
+<a id="org6bdfd59"></a>
+
+### put(src, remotePath, options) ==> string
 
 Upload data from local system to remote server. If the `src` argument is a string, it is interpreted as a local file path to be used for the data to transfer. If the `src` argument is a buffer, the contents of the buffer are copied to the remote file and if it is a readable stream, the contents of that stream are piped to the `remotePath` on the server.
 
@@ -532,12 +536,13 @@ Upload data from local system to remote server. If the `src` argument is a strin
 
     The options object supports three properties, `readStreamOptions`, `writeStreamOptions` and `pipeOptions`. The value for each property should be an object with options as properties and their associated values representing the option value. For example, you might use the following to set `writeStream` options.
     
-    ```nillangnilswitchesnilflags
-    nilbody
-    #+END_SRC
-    
-    The
-    nilbody
+    ```javascript
+    {
+      writeStreamOptions: {
+        flags: 'w',  // w - write and a - append
+        encoding: null, // use null for binary files
+        mode: 0o666, // mode to use for created file (rwx)
+    }}
     ```
     
     The most common options to use are mode and encoding. The values shown above are the defaults. You do not have to set encoding to utf-8 for text files, null is fine for all file types. However, using utf-8 encoding for binary files will often result in data corruption.
@@ -547,9 +552,6 @@ Upload data from local system to remote server. If the `src` argument is a strin
 2.  Example Use
 
     ```javascript
-    
-    let
-    
     let client = new Client();
     
     let data = fs.createReadStream('/path/to/local/file.txt');
@@ -569,9 +571,14 @@ Upload data from local system to remote server. If the `src` argument is a strin
     
     -   **Tip:** If the src argument is a path string, consider just using `fastPut()`.
 
-### fastPut(localPath, remotePath, options) ==> string<a id="sec-4-2-9"></a>
 
-Uploads the data in file at `localPath` to a new file on remote server at `remotePath` using concurrency. The options object allows tweaking of the fast put process.
+<a id="org4296214"></a>
+
+### fastPut(localPath, remotePath, options) ==> string
+
+Uploads the data in file at `localPath` to a new file on remote server at `remotePath` using concurrency. The options object allows tweaking of the fast put process. Note that this functionality is heavily dependent on the capabilities of the remote sftp server, which must support the concurrency operations used by this method. This is not part of the standard and therefore is not available in all sftp servers. See the Platform Quirks & Warnings for more details.
+
+Bottom line, when it works, it tends to work well. However, when it doesn't work, it may fail completely or it may result in truncated or corrupted data transfers.
 
 -   **localPath:** string. Path to local file to upload
 -   **remotePath:** string. Path to remote file to create
@@ -579,12 +586,14 @@ Uploads the data in file at `localPath` to a new file on remote server at `remot
 
 1.  Options
 
-    ```nillangnilswitchesnilflags
-    nilbody
-    #+END_SRC
-    
-    -
-    nilbody
+    ```javascript
+    {
+      concurrency: 64, // integer. Number of concurrent reads
+      chunkSize: 32768, // integer. Size of each read in bytes
+      mode: 0o755, // mixed. Integer or string representing the file mode to set
+      step: function(total_transferred, chunk, total) // function. Called every time
+      // a part of a file was transferred
+    }
     ```
     
     -   **Warning:** There have been reports that some SFTP servers will not honour requests for non-default chunk sizes. This can result in data loss or corruption.
@@ -592,9 +601,6 @@ Uploads the data in file at `localPath` to a new file on remote server at `remot
 2.  Example Use
 
     ```javascript
-    
-    let
-    
     let localFile = '/path/to/file.txt';
     let remoteFile = '/path/to/remote/file.txt';
     let client = new Client();
@@ -611,7 +617,10 @@ Uploads the data in file at `localPath` to a new file on remote server at `remot
       });
     ```
 
-### append(input, remotePath, options) ==> string<a id="sec-4-2-10"></a>
+
+<a id="org01aa427"></a>
+
+### append(input, remotePath, options) ==> string
 
 Append the `input` data to an existing remote file. There is no integrity checking performed apart from normal writeStream checks. This function simply opens a writeStream on the remote file in append mode and writes the data passed in to the file.
 
@@ -623,12 +632,13 @@ Append the `input` data to an existing remote file. There is no integrity checki
 
     The following options are supported;
     
-    ```nillangnilswitchesnilflags
-    nilbody
-    #+END_SRC
-    
-    The
-    nilbody
+    ```javascript
+    {
+      flags: 'a',  // w - write and a - append
+      encoding: null, // use null for binary files
+      mode: 0o666, // mode to use for created file (rwx)
+      autoClose: true // automatically close the write stream when finished
+    }
     ```
     
     The most common options to use are mode and encoding. The values shown above are the defaults. You do not have to set encoding to utf-8 for text files, null is fine for all file types. Generally, I would not attempt to append binary files.
@@ -636,9 +646,6 @@ Append the `input` data to an existing remote file. There is no integrity checki
 2.  Example Use
 
     ```javascript
-    
-    let
-    
     let remotePath = '/path/to/remote/file.txt';
     let client = new Client();
     
@@ -654,7 +661,10 @@ Append the `input` data to an existing remote file. There is no integrity checki
       });
     ```
 
-### mkdir(path, recursive) ==> string<a id="sec-4-2-11"></a>
+
+<a id="orge74ab72"></a>
+
+### mkdir(path, recursive) ==> string
 
 Create a new directory. If the recursive flag is set to true, the method will create any directories in the path which do not already exist. Recursive flag defaults to false.
 
@@ -664,9 +674,6 @@ Create a new directory. If the recursive flag is set to true, the method will cr
 1.  Example Use
 
     ```javascript
-    
-    let
-    
     let remoteDir = '/path/to/new/dir';
     let client = new Client();
     
@@ -682,7 +689,10 @@ Create a new directory. If the recursive flag is set to true, the method will cr
       });
     ```
 
-### rmdir(path, recursive) ==> string<a id="sec-4-2-12"></a>
+
+<a id="org2692b91"></a>
+
+### rmdir(path, recursive) ==> string
 
 Remove a directory. If removing a directory and recursive flag is set to `true`, the specified directory and all sub-directories and files will be deleted. If set to false and the directory has sub-directories or files, the action will fail.
 
@@ -694,9 +704,6 @@ Remove a directory. If removing a directory and recursive flag is set to `true`,
 1.  Example Use
 
     ```javascript
-    
-    let
-    
     let remoteDir = '/path/to/remote/dir';
     let client = new Client();
     
@@ -712,7 +719,10 @@ Remove a directory. If removing a directory and recursive flag is set to `true`,
       });
     ```
 
-### delete(path, noErrorOK) ==> string<a id="sec-4-2-13"></a>
+
+<a id="org59254a5"></a>
+
+### delete(path, noErrorOK) ==> string
 
 Delete a file on the remote server.
 
@@ -723,9 +733,6 @@ Delete a file on the remote server.
 1.  Example Use
 
     ```javascript
-    
-    let
-    
     let remoteFile = '/path/to/remote/file.txt';
     let client = new Client();
     
@@ -741,7 +748,10 @@ Delete a file on the remote server.
       });
     ```
 
-### rename(fromPath, toPath) ==> string<a id="sec-4-2-14"></a>
+
+<a id="org287873a"></a>
+
+### rename(fromPath, toPath) ==> string
 
 Rename a file or directory from `fromPath` to `toPath`. You must have the necessary permissions to modify the remote file.
 
@@ -751,9 +761,6 @@ Rename a file or directory from `fromPath` to `toPath`. You must have the necess
 1.  Example Use
 
     ```javascript
-    
-    let
-    
     let from = '/remote/path/to/old.txt';
     let to = '/remote/path/to/new.txt';
     let client = new Client();
@@ -770,7 +777,10 @@ Rename a file or directory from `fromPath` to `toPath`. You must have the necess
       });
     ```
 
-### posixRename(fromPath, toPath) ==> string<a id="sec-4-2-15"></a>
+
+<a id="orgb7290ba"></a>
+
+### posixRename(fromPath, toPath) ==> string
 
 This method uses the openssh POSIX rename extension introduced in OpenSSH 4.8. The advantage of this version of rename over standard SFTP rename is that it is an atomic operation and will allow renaming a resource where the destination name exists. The POSIX rename will also work on some file systems which do not support standard SFTP rename because they don't support the system hardlink() call. The POSIX rename extension is available on all openSSH servers from 4.8 and some other implementations. This is an extension to the standard SFTP protocol and therefore is not supported on all sftp servers.
 
@@ -778,9 +788,6 @@ This method uses the openssh POSIX rename extension introduced in OpenSSH 4.8. T
 -   **toPath:** string. Path for new name. If it already exists, it will be replaced by file specified in fromPath
 
 ```javascript
-
-let
-
 let from = '/remote/path/to/old.txt';
 let to = '/remote/path/to/new.txt';
 let client = new Client();
@@ -797,7 +804,10 @@ client.connect(config)
   });
 ```
 
-### chmod(path, mode) ==> string<a id="sec-4-2-16"></a>
+
+<a id="org0e57abe"></a>
+
+### chmod(path, mode) ==> string
 
 Change the mode (read, write or execute permissions) of a remote file or directory.
 
@@ -807,9 +817,6 @@ Change the mode (read, write or execute permissions) of a remote file or directo
 1.  Example Use
 
     ```javascript
-    
-    let
-    
     let path = '/path/to/remote/file.txt';
     let newMode = 0o644;  // rw-r-r
     let client = new Client();
@@ -826,7 +833,10 @@ Change the mode (read, write or execute permissions) of a remote file or directo
       });
     ```
 
-### realPath(path) ===> string<a id="sec-4-2-17"></a>
+
+<a id="org52444ca"></a>
+
+### realPath(path) ===> string
 
 Converts a relative path to an absolute path on the remote server. This method is mainly used internally to resolve remote path names.
 
@@ -834,11 +844,17 @@ Converts a relative path to an absolute path on the remote server. This method i
 
 -   **path:** A file path, either relative or absolute. Can handle '.' and '..', but does not expand '~'.
 
-### cwd() ==> string<a id="sec-4-2-18"></a>
+
+<a id="org34966e3"></a>
+
+### cwd() ==> string
 
 Returns what the server believes is the current remote working directory.
 
-### uploadDir(srcDir, dstDir, options) ==> string<a id="sec-4-2-19"></a>
+
+<a id="org5c58fad"></a>
+
+### uploadDir(srcDir, dstDir, options) ==> string
 
 Upload the directory specified by `srcDir` to the remote directory specified by `dstDir`. The `dstDir` will be created if necessary. Any sub directories within `srcDir` will also be uploaded. Any existing files in the remote path will be overwritten.
 
@@ -857,57 +873,57 @@ The `useFastput` option is a boolean option. If `true`, the method will use the
 1.  Example
 
     ```javascript
+    'use strict';
     
+    // Example of using the uploadDir() method to upload a directory
+    // to a remote SFTP server
     
+    const path = require('path');
+    const SftpClient = require('../src/index');
     
-         'use strict';
-    
-         // Example of using the uploadDir() method to upload a directory
-         // to a remote SFTP server
-    
-         const path = require('path');
-         const SftpClient = require('../src/index');
-    
-         const dotenvPath = path.join(__dirname, '..', '.env');
-         require('dotenv').config({path: dotenvPath});
+    const dotenvPath = path.join(__dirname, '..', '.env');
+    require('dotenv').config({path: dotenvPath});
     
-         const config = {
-           host: process.env.SFTP_SERVER,
-           username: process.env.SFTP_USER,
-           password: process.env.SFTP_PASSWORD,
-           port: process.env.SFTP_PORT || 22
-         };
+    const config = {
+      host: process.env.SFTP_SERVER,
+      username: process.env.SFTP_USER,
+      password: process.env.SFTP_PASSWORD,
+      port: process.env.SFTP_PORT || 22
+    };
     
-         async function main() {
-           const client = new SftpClient('upload-test');
-           const src = path.join(__dirname, '..', 'test', 'testData', 'upload-src');
-           const dst = '/home/tim/upload-test';
+    async function main() {
+      const client = new SftpClient('upload-test');
+      const src = path.join(__dirname, '..', 'test', 'testData', 'upload-src');
+      const dst = '/home/tim/upload-test';
     
-           try {
-             await client.connect(config);
-             client.on('upload', info => {
-               console.log(`Listener: Uploaded ${info.source}`);
-             });
-             let rslt = await client.uploadDir(src, dst);
-             return rslt;
-           } catch (err) {
-             console.error(err);
-           } finally {
-             client.end();
-           }
-         }
+      try {
+        await client.connect(config);
+        client.on('upload', info => {
+          console.log(`Listener: Uploaded ${info.source}`);
+        });
+        let rslt = await client.uploadDir(src, dst);
+        return rslt;
+      } catch (err) {
+        console.error(err);
+      } finally {
+        client.end();
+      }
+    }
     
-         main()
-           .then(msg => {
-             console.log(msg);
-           })
-           .catch(err => {
-             console.log(`main error: ${err.message}`);
-           });
+    main()
+      .then(msg => {
+        console.log(msg);
+      })
+      .catch(err => {
+        console.log(`main error: ${err.message}`);
+      });
     
     ```
 
-### downloadDir(srcDir, dstDir, options) ==> string<a id="sec-4-2-20"></a>
+
+<a id="orgb346779"></a>
+
+### downloadDir(srcDir, dstDir, options) ==> string
 
 Download the remote directory specified by `srcDir` to the local file system directory specified by `dstDir`. The `dstDir` directory will be created if required. All sub directories within `srcDir` will also be copied. Any existing files in the local path will be overwritten. No files in the local path will be deleted.
 
@@ -924,9 +940,6 @@ If the `useFastget` property is set to `true`, the method will use `fastGet()` t
 1.  Example
 
     ```javascript
-    
-    'use
-    
     'use strict';
     
     // Example of using the downloadDir() method to upload a directory
@@ -972,7 +985,10 @@ If the `useFastget` property is set to `true`, the method will use `fastGet()` t
     
     ```
 
-### createReadStream(remotePath, options)) ==> stream object<a id="sec-4-2-21"></a>
+
+<a id="orga0edaaf"></a>
+
+### createReadStream(remotePath, options)) ==> stream object
 
 Returns a read stream object which is attached to the remote file specified by the `remotePath` argument. This is a low level method which just returns a read stream object. Client code is fully responsible for managing and releasing the resources associated with the stream once finished i.e. closing files, removing listeners etc.
 
@@ -986,7 +1002,10 @@ Returns a read stream object which is attached to the remote file specified by t
     -   **start:** Default 0. Position to start reading bytes from (inclusive)
     -   **end:** Position to stop reading bytes (inclusive).
 
-### createWriteStream(remotePath, options) ==> stream object<a id="sec-4-2-22"></a>
+
+<a id="org7287ad7"></a>
+
+### createWriteStream(remotePath, options) ==> stream object
 
 Returns a write stream object which is attached to the remote file specified in the `remotePath` argument. This is a low level function which just returns the stream object. Client code is fully responsible for managing that object, including closing any file descriptors and removing listeners etc.
 
@@ -998,23 +1017,26 @@ Returns a write stream object which is attached to the remote file specified in
     -   **autoClose:** true
     -   **start:** Byte position to start writing from (inclusive). May require changing flag to 'r+'.
 
-### rcopy(srcPath, dstPath) ==> string<a id="sec-4-2-23"></a>
+
+<a id="org4b84e95"></a>
+
+### rcopy(srcPath, dstPath) ==> string
 
 Perform a remote file copy. The file identified by the `srcPath` argument will be copied to the file specified as the `dstPath` argument. The directory where `dstPath` will be placed must exist, but the actual file must not i.e. no overwrites allowed.
 
 -   **srcPath:** Path to remote file to be copied specified as a string
 -   **dstPath:** Path to where the copy will be created specified as a string
 
-### end() ==> boolean<a id="sec-4-2-24"></a>
+
+<a id="org6af9411"></a>
+
+### end() ==> boolean
 
 Ends the current client session, releasing the client socket and associated resources. This function also removes all listeners associated with the client.
 
 1.  Example Use
 
     ```javascript
-    
-    let
-    
     let client = new Client();
     
     client.connect(config)
@@ -1029,7 +1051,10 @@ Ends the current client session, releasing the client socket and associated reso
       });
     ```
 
-### Add and Remove Listeners<a id="sec-4-2-25"></a>
+
+<a id="org79d7176"></a>
+
+### Add and Remove Listeners
 
 Although normally not required, you can add and remove custom listeners on the ssh2 client object. This object supports a number of events, but only a few of them have any meaning in the context of SFTP. These are
 
@@ -1047,21 +1072,33 @@ Although normally not required, you can add and remove custom listeners on the s
 
     Removes the specified listener from the event specified in eventType. Note that the `end()` method automatically removes all listeners from the client object.
 
-# Platform Quirks & Warnings<a id="sec-5"></a>
 
-## Server Capabilities<a id="sec-5-1"></a>
+<a id="org8815934"></a>
+
+# Platform Quirks & Warnings
+
+
+<a id="orgcf08239"></a>
+
+## Server Capabilities
 
 All SFTP servers and platforms are not equal. Some facilities provided by `ssh2-sftp-client` either depend on capabilities of the remote server or the underlying capabilities of the remote server platform. As an example, consider `chmod()`. This command depends on a remote file system which implements the 'nix' concept of users and groups. The *win32* platform does not have the same concept of users and groups, so `chmod()` will not behave in the same way.
 
 One way to determine whether an issue you are encountering is due to `ssh2-sftp-client` or due to the remote server or server platform is to use a simple CLI sftp program, such as openSSH's sftp command. If you observe the same behaviour using plain `sftp` on the command line, the issue is likely due to server or remote platform limitations. Note that you should not use a GUI sftp client, like `Filezilla` or `winSCP` as such GUI programs often attempt to hide these server and platform incompatibilities and will take additional steps to simulate missing functionality etc. You want to use a CLI program which does as little as possible.
 
-## Issues with `fastPut()` and `fastGet()` Methods<a id="sec-5-2"></a>
+
+<a id="org92f1dc4"></a>
+
+## Issues with `fastPut()` and `fastGet()` Methods
 
 The `fastPut()` and `fastGet()` methods are known to be somewhat dependent on SFTP server capabilities. Some SFTP servers just do not work correctly with concurrent connections and some are known to have issues with negotiating packet sizes. These issues can sometimes be resolved by tweaking the options supplied to the methods, such as setting number of concurrent connections or a specific packet size.
 
 To see an example of the type of issues you can observe with `fastPut()` or `fastGet()`, have a look at [issue 407](https://github.com/theophilusx/ssh2-sftp-client/issues/407), which describes the experiences of one user. Bottom line, when it works, it tends to work well and be significantly faster than using just `get()` or `put()`. However, when developing code to run against different SFTP servers, especially where you are unable to test against each server, you are likely better off just using `get()` and `put()` or structuring your code so that users can select which method to use (this is what `ssh2-sftp-client` does - for example, see the `!downloadDir()` and `uploadDir()` methods.
 
-## Promises, Events & Managing Exceptions<a id="sec-5-3"></a>
+
+<a id="org27f104a"></a>
+
+## Promises, Events & Managing Exceptions
 
 One of the challenges in providing a Promise based API over a module like SSH2, which is event based is how to ensure events are handled appropriately. The challenge is due to the synchronous nature of events. You cannot use `try/catch` for events because you have no way of knowing when the event might fire. For example, it could easily fire after your `try/catch` block as completed execution.
 
@@ -1077,25 +1114,40 @@ The other area where additional events are fired is during the end() call. To de
 
 In addition to the promise based event handlers, `ssh2-sftp-client` also implements global event handlers which will catch any `error`, `end` or `close` events. Essentially, these global handlers only reset the `sftp` property of the client object, effectively ensuring any subsequent calls are rejected and in the case of an error, send the error to the console.
 
-### Adding Custom Handlers<a id="sec-5-3-1"></a>
+
+<a id="orgd903953"></a>
+
+### Adding Custom Handlers
 
 While the above strategies appear to work for the majority of use cases, there are always going to be edge cases which require more flexible or powerful event handling. To support this, the `on()` and `removeListener()` methods are provided. Any event listener added using the `on()` method will be added at the beginning of the list of handlers for that event, ensuring it will be called before any global or promise local events. See the documentation for the `on()` method for details.
 
-## Windows Based Servers<a id="sec-5-4"></a>
+
+<a id="orged5ee01"></a>
+
+## Windows Based Servers
 
 It appears that when the sftp server is running on Windows, a *ECONNRESET* error signal is raised when the end() method is called. Unfortunately, this signal is raised after a considerable delay. This means we cannot remove the error handler used in the end() promise as otherwise you will get an uncaught exception error. Leaving the handler in place, even though we will ignore this error, solves that issue, but unfortunately introduces a new problem. Because we are not removing the listener, if you re-use the client object for subsequent connections, an additional error handler will be added. If this happens more than 11 times, you will eventually see the Node warning about a possible memory leak. This is because node monitors the number of error handlers and if it sees more than 11 added to an object, it assumes there is a problem and generates the warning.
 
 The best way to avoid this issue is to not re-use client objects. Always generate a new sftp client object for each new connection.
 
-## Don't Re-use SftpClient Objects<a id="sec-5-5"></a>
+
+<a id="orgfafec91"></a>
+
+## Don't Re-use SftpClient Objects
 
 Due to an issue with *ECONNRESET* error signals when connecting to Windows based SFTP servers, it is not possible to remove the error handler in the end() method. This means that if you re-use the SftpClient object for multiple connections e.g. calling connect(), then end(), then connect() etc, you run the risk of multiple error handlers being added to the SftpClient object. After 11 handlers have been added, Node will generate a possible memory leak warning.
 
 To avoid this problem, don't re-use SftpClient objects. Generate a new SftpClient object for each connection. You can perform multiple actions with a single connection e.g. upload multiple files, download multiple files etc, but after you have called end(), you should not try to re-use the object with a further connect() call. Create a new object instead.
 
-# FAQ<a id="sec-6"></a>
 
-## Remote server drops connections with only an end event<a id="sec-6-1"></a>
+<a id="orgbe306ce"></a>
+
+# FAQ
+
+
+<a id="org9377d69"></a>
+
+## Remote server drops connections with only an end event
 
 Many SFTP servers have rate limiting protection which will drop connections once a limit has been reached. In particular, openSSH has the setting `MaxStartups`, which can be a tuple of the form `max:drop:full` where `max` is the maximum allowed unauthenticated connections, `drop` is a percentage value which specifies percentage of connections to be dropped once `max` connections has been reached and `full` is the number of connections at which point all subsequent connections will be dropped. e.g. `10:30:60` means allow up to 10 unauthenticated connections after which drop 30% of connection attempts until reaching 60 unauthenticated connections, at which time, drop all attempts.
 
@@ -1103,16 +1155,16 @@ Clients first make an unauthenticated connection to the SFTP server to begin neg
 
 One way to avoid this type of issue is to add a delay between connection attempts. It does not need to be a very long delay - just sufficient to permit the previous connection to be authenticated. In fact, the default setting for openSSH is `10:30:60`, so you really just need to have enough delay to ensure that the 1st connection has completed authentication before the 11th connection is attempted.
 
-## How can I pass writeable stream as dst for get method?<a id="sec-6-2"></a>
+
+<a id="org0cf3ed0"></a>
+
+## How can I pass writeable stream as dst for get method?
 
 If the dst argument passed to the get method is a writeable stream, the remote file will be piped into that writeable. If the writeable you pass in is a writeable stream created with `fs.createWriteStream()`, the data will be written to the file specified in the constructor call to `createWriteStream()`.
 
 The writeable stream can be any type of write stream. For example, the below code will convert all the characters in the remote file to upper case before it is saved to the local file system. This could just as easily be something like a gunzip stream from `zlib`, enabling you to decompress remote zipped files as you bring them across before saving to local file system.
 
 ```javascript
-
-'use
-
 'use strict';
 
 // Example of using a writeable with get to retrieve a file.
@@ -1162,16 +1214,16 @@ sftp
   });
 ```
 
-## How can I upload files without having to specify a password?<a id="sec-6-3"></a>
+
+<a id="org14d1415"></a>
+
+## How can I upload files without having to specify a password?
 
 There are a couple of ways to do this. Essentially, you want to setup SSH keys and use these for authentication to the remote server.
 
 One solution, provided by @KalleVuorjoki is to use the SSH agent process. **Note**: SSH<sub>AUTH</sub><sub>SOCK</sub> is normally created by your OS when you load the ssh-agent as part of the login session.
 
 ```javascript
-
-let
-
 let sftp = new Client();
 sftp.connect({
   host: 'YOUR-HOST',
@@ -1186,9 +1238,6 @@ sftp.connect({
 Another alternative is to just pass in the SSH key directly as part of the configuration.
 
 ```javascript
-
-let
-
 let sftp = new Client();
 sftp.connect({
   host: 'YOUR-HOST',
@@ -1200,14 +1249,16 @@ sftp.connect({
 }
 ```
 
-## How can I connect through a Socks Proxy<a id="sec-6-4"></a>
 
-This solution was provided by @jmorino.
+<a id="org118bb9f"></a>
 
-```javascript
+## How can I connect through a Socks Proxy
+
+This solution was provided by @jmorino.
 
-import
+When a SOCKS 5 client is connected it must be ingested by ssh2-sftp-client immediately, otherwise a timeout occurs.
 
+```javascript
 import { SocksClient } from 'socks';
 import SFTPClient from 'ssh2-sftp-client';
 
@@ -1215,7 +1266,7 @@ const host = 'my-sftp-server.net';
 const port = 22; // default SSH/SFTP port on remote server
 
 // connect to SOCKS 5 proxy
-const { socks } = await SocksClient.createConnection({
+const { socket } = await SocksClient.createConnection({
   proxy: {
     host: 'my.proxy', // proxy hostname
     port: 1080, // proxy port
@@ -1228,79 +1279,91 @@ const { socks } = await SocksClient.createConnection({
 const client = new SFTPClient();
 client.connect({
   host,
-  sock: socks.socket, // pass the socket to proxy here (see ssh2 doc)
-  username: '.....',
-  privateKey: '.....'
+  sock: socket, // pass the socket to proxy here (see ssh2 doc)
+  // other config options
 })
 
 // client is connected
 ```
 
-## Timeout while waiting for handshake or handshake errors<a id="sec-6-5"></a>
+
+<a id="orgc720a77"></a>
+
+## Timeout while waiting for handshake or handshake errors
 
 Some users have encountered the error 'Timeout while waiting for handshake' or 'Handshake failed, no matching client->server ciphers. This is often due to the client not having the correct configuration for the transport layer algorithms used by ssh2. One of the connect options provided by the ssh2 module is `algorithm`, which is an object that allows you to explicitly set the key exchange, ciphers, hmac and compression algorithms as well as server host key used to establish the initial secure connection. See the SSH2 documentation for details. Getting these parameters correct usually resolves the issue.
 
 When encountering this type of problem, one worthwhile approach is to use openSSH's CLI sftp program with the `-v` switch to raise logging levels. This will show you what algorithms the CLI is using. You can then use this information to match the names with the accepted algorithm names documented in the `ssh2` README to set the properties in the `algorithms` object.
 
-## How can I limit upload/download speed<a id="sec-6-6"></a>
+
+<a id="orge322728"></a>
+
+## How can I limit upload/download speed
 
 If you want to limit the amount of bandwidth used during upload/download of data, you can use a stream to limit throughput. The following example was provided by *kennylbj*. Note that there is a caveat that we must set the `autoClose` flag to false to avoid calling an extra `_read()` on a closed stream that may cause \_get Permission Denied error in ssh2-streams.
 
 ```javascript
 
 
+const Throttle = require('throttle');
+const progress = require('progress-stream');
 
+// limit download speed
+const throttleStream = new Throttle(config.throttle);
 
+// download progress stream
+const progressStream = progress({
+  length: fileSize,
+  time: 500,
+});
+progressStream.on('progress', (progress) => {
+  console.log(progress.percentage.toFixed(2));
+});
 
+const outStream = createWriteStream(localPath);
 
+// pipe streams together
+throttleStream.pipe(progressStream).pipe(outStream);
 
+try {
+  // set autoClose to false
+  await client.get(remotePath, throttleStream, { autoClose: false });
+} catch (e) {
+  console.log('sftp error', e);
+} finally {
+  await client.end();
+}
+```
 
 
+<a id="org4164c6c"></a>
 
+## Connection hangs or fails for larger files
 
-        const Throttle = require('throttle');
-        const progress = require('progress-stream');
+This was contributed by Ladislav Jacho. Thanks.
 
-        // limit download speed
-        const throttleStream = new Throttle(config.throttle);
+A symptom of this issue is that you are able to upload small files, but uploading larger ones fail. You probably have an MTU/fragmentation problem. For each network interface on both client and server set the MTU to 576, e.g. `ifconfig eth0 mtu 576`. If that works, you need to find the largest MTU which will work for your network. An MTU which is too small will adversely affect throughput speed. A common value to use is an MTU of 1400.
 
-        // download progress stream
-        const progressStream = progress({
-          length: fileSize,
-          time: 500,
-        });
-        progressStream.on('progress', (progress) => {
-          console.log(progress.percentage.toFixed(2));
-        });
+For more explanation, see [issue #342](https://github.com/theophilusx/ssh2-sftp-client/issues/342).
 
-        const outStream = createWriteStream(localPath);
 
-        // pipe streams together
-        throttleStream.pipe(progressStream).pipe(outStream);
+<a id="orgd28c1e8"></a>
 
-        try {
-          // set autoClose to false
-          await client.get(remotePath, throttleStream, { autoClose: false });
-        } catch (e) {
-          console.log('sftp error', e);
-        } finally {
-          await client.end();
-        }
-```
+## Typescript definition file out of date
 
-## Connection hangs or fails for larger files<a id="sec-6-7"></a>
+This project does not use Typescript. However, typescript definition files are provided by other 3rd parties. Sometimes, these definition files have not stayed up-to-date with the current version of this module. If you encounter this issue, you need to report it to the party responsible for the definition file, not this project.
 
-This was contributed by Ladislav Jacho. Thanks.
 
-A symptom of this issue is that you are able to upload small files, but uploading larger ones fail. You probably have an MTU/fragmentation problem. For each network interface on both client and server set the MTU to 576, e.g. `ifconfig eth0 mtu 576`. If that works, you need to find the largest MTU which will work for your network. An MTU which is too small will adversely affect throughput speed. A common value to use is an MTU of 1400.
+<a id="orgfab3156"></a>
 
-For more explanation, see [issue #342](https://github.com/theophilusx/ssh2-sftp-client/issues/342).
-
-# Examples<a id="sec-7"></a>
+# Examples
 
 I have started collecting example scripts in the example directory of the repository. These are mainly scripts I have put together in order to investigate issues or provide samples for users. They are not robust, lack adequate error handling and may contain errors. However, I think they are still useful for helping developers see how the module and API can be used.
 
-# Troubleshooting<a id="sec-8"></a>
+
+<a id="orga11079b"></a>
+
+# Troubleshooting
 
 The `ssh2-sftp-client` module is essentially a wrapper around the `ssh2` and `ssh2-streams` modules, providing a higher level `promise` based API. When you run into issues, it is important to try and determine where the issue lies - either in the ssh2-sftp-client module or the underlying `ssh2` and `ssh2-streams` modules. One way to do this is to first identify a minimal reproducible example which reproduces the issue. Once you have that, try to replicate the functionality just using the `ssh2` and `ssh2-streams` modules. If the issue still occurs, then you can be fairly confident it is something related to those later 2 modules and therefore and issue which should be referred to the maintainer of that module.
 
@@ -1312,18 +1375,21 @@ Note also that in the repository there are two useful directories. The first is
 
 The second directory is the validation directory. I have some very simple scripts in this directory which perform basic tasks using only the `ssh2` modules (no `ssh2-sftp-client` module). These can be useful when trying to determine if the issue is with the underlying `ssh2` module or the `ssh2-sftp-client` wrapper module.
 
-## Common Errors<a id="sec-8-1"></a>
 
-There are some common errors people tend to make when using Promises or Async/Await. These are by far the most common problem found in issues logged against this module. Please check for some of these before logging your issue.
+<a id="org0372c41"></a>
 
-### Not returning the promise in a `then()` block<a id="sec-8-1-1"></a>
+## Common Errors
 
-All methods in `ssh2-sftp-client` return a Promise. This means methods are executed *asynchrnously*. When you call a method inside the `then()` block of a promise chain, it is critical that you return the Promise that call generates. Failing to do this will result in the `then()` block completing and your code starting execution of the next `then()`, `catch()` or `finally()` block before your promise has been fulfilled. For example, the following will not do what you expect
+There are some common errors people tend to make when using Promises or Async/Await. These are by far the most common problem found in issues logged against this module. Please check for some of these before logging your issue.
 
-```javascript
 
+<a id="org0d8dc85"></a>
 
+### Not returning the promise in a `then()` block
 
+All methods in `ssh2-sftp-client` return a Promise. This means methods are executed *asynchrnously*. When you call a method inside the `then()` block of a promise chain, it is critical that you return the Promise that call generates. Failing to do this will result in the `then()` block completing and your code starting execution of the next `then()`, `catch()` or `finally()` block before your promise has been fulfilled. For example, the following will not do what you expect
+
+```javascript
 sftp.connect(config)
   .then(() => {
     sftp.fastGet('foo.txt', 'bar.txt');
@@ -1338,9 +1404,6 @@ sftp.connect(config)
 In the above code, the `sftp.end()` method will almost certainly be called before `sftp.fastGet()` has been fulfilled (unless the *foo.txt* file is really small!). In fact, the whole promise chain will complete and exit even before the `sftp.end()` call has been fulfilled. The correct code would be something like
 
 ```javascript
-
-
-
 sftp.connect(config)
   .then(() => {
     return sftp.fastGet('foo.txt', 'bar.txt');
@@ -1356,14 +1419,14 @@ Note the `return` statements. These ensure that the Promise returned by the clie
 
 A common symptom of this type of error is for file uploads or download to fail to complete or for data in those files to be truncated. What is happening is that the connection is being ended before the transfer has completed.
 
-### Mixing Promise Chains and Async/Await<a id="sec-8-1-2"></a>
-
-Another common error is to mix Promise chains and async/await calls. This is rarely a great idea. While you can do this, it tends to create complicated and difficult to maintain code. Select one approach and stick with it. Both approaches are functionally equivalent, so there is no reason to mix up the two paradigms. My personal preference would be to use async/await as I think that is more *natural* for most developers. For example, the following is more complex and difficult to follow than necessary (and has a bug!)
 
-```javascript
+<a id="org199b814"></a>
 
+### Mixing Promise Chains and Async/Await
 
+Another common error is to mix Promise chains and async/await calls. This is rarely a great idea. While you can do this, it tends to create complicated and difficult to maintain code. Select one approach and stick with it. Both approaches are functionally equivalent, so there is no reason to mix up the two paradigms. My personal preference would be to use async/await as I think that is more *natural* for most developers. For example, the following is more complex and difficult to follow than necessary (and has a bug!)
 
+```javascript
 sftp.connect(config)
   .then(() => {
     return sftp.cwd();
@@ -1386,9 +1449,6 @@ The main bug in the above code is the `then()` block is not returning the Promis
 Using async/await inside the promise chain has created unnecessary complexity and leads to incorrect assumptions regarding how the code will execute. A quick glance at the code is likely to give the impression that execution will wait for the `sftp.fastGet()` call to be fulfilled before continuing. This is not the case. The code would be more clearly expressed as either
 
 ```javascript
-
-
-
 sftp.connect(config)
   .then(() => {
     return sftp.cwd();
@@ -1405,9 +1465,6 @@ sftp.connect(config)
 **or, using async/await**
 
 ```javascript
-
-
-
 async function doSftp() {
   try {
     let sftp = await sftp.connect(conf);
@@ -1416,13 +1473,16 @@ async function doSftp() {
     await sftp.fastGet(`${d}/foo.txt`, 'bat.txt');
   } catch (e) {
     console.error(e.message);
-  } finally () {
+  } finally {
     await sftp.end();
   }
 }
 ```
 
-### Try/catch and Error Handlers<a id="sec-8-1-3"></a>
+
+<a id="org46e5412"></a>
+
+### Try/catch and Error Handlers
 
 Another common error is to try and use a try/catch block to catch event signals, such as an error event. In general, you cannot use try/catch blocks for asynchronous code and expect errors to be caught by the `catch` block. Handling errors in asynchronous code is one of the key reasons we now have the Promise and async/await frameworks.
 
@@ -1430,24 +1490,30 @@ The basic problem is that the try/catch block will have completed execution befo
 
 Error events are essentially asynchronous code. You don't know when such events will fire. Therefore, you cannot use a try/catch block to catch such event errors. Even creating an error handler which then throws an exception won't help as the key problem is that your try/catch block has already executed. There are a number of alternative ways to deal with this situation. However, the key symptom is that you see occasional uncaught error exceptions that cause your script to exit abnormally despite having try/catch blocks in your script. What you need to do is look at your code and find where errors are raised asynchronously and use an event handler or some other mechanism to manage any errors raised.
 
-### Server Differences<a id="sec-8-1-4"></a>
+
+<a id="org8a2ebba"></a>
+
+### Server Differences
 
 Not all SFTP servers are the same. Like most standards, the SFTP protocol has some level of interpretation and allows different levels of compliance. This means there can be differences in behaviour between different servers and code which works with one server will not work the same with another. For example, the value returned by *realpath* for non-existent objects can differ significantly. Some servers will throw an error for a particular operation while others will just return null, some servers support concurrent operations (such as used by fastGet/fastPut) while others will not and of course, the text of error messages can vary significantly. In particular, we have noticed significant differences across different platforms. It is therefore advisable to do comprehensive testing when the SFTP server is moved to a new platform. This includes moving from to a cloud based service even if the underlying platform remains the same. I have noticed that some cloud platforms can generate unexpected events, possibly related to additional functionality or features associated with the cloud implementation. For example, it appears SFTP servers running under Azure will generate an error event when the connection is closed even when the client has requested the connection be terminated. The same SFTP server running natively on Windows does not appear to exhibit such behaviour.
 
-### Avoid Concurrent Operations<a id="sec-8-1-5"></a>
+
+<a id="org24c4235"></a>
+
+### Avoid Concurrent Operations
 
 Technically, SFTP should be able to perform multiple operations concurrently. As node is single threaded, what we a really talking about is running multiple execution contexts as a pool where node will switch contexts when each context is blocked due to things like waiting on network data etc. However, I have found this to be extremely unreliable and of very little benefit from a performance perspective. My recommendation is to therefore avoid executing multiple requests over the same connection in parallel (for example, generating multiple `get()` promises and using something like `Promise.all()` to resolve them.
 
 If you are going to try and perform concurrent operations, you need to test extensively and ensure you are using data which is large enough that context switching does occur (i.e. the request is not completed in a single run). Some SFTP servers will handle concurrent operations better than others.
 
-## Debugging Support<a id="sec-8-2"></a>
 
-You can add a `debug` property to the config object passed in to `connect()` to turn on debugging. This will generate quite a lot of output. The value of the property should be a function which accepts a single string argument. For example;
+<a id="org1d067af"></a>
 
-```javascript
+## Debugging Support
 
-config.debug
+You can add a `debug` property to the config object passed in to `connect()` to turn on debugging. This will generate quite a lot of output. The value of the property should be a function which accepts a single string argument. For example;
 
+```javascript
 config.debug = msg => {
   console.error(msg);
 };
@@ -1457,23 +1523,26 @@ config.debug = msg => {
 Enabling debugging can generate a lot of output. If you use console.error() as the output (as in the example above), you can redirect the output to a file using shell redirection e.g.
 
 ```shell
-
-node
-
 node script.js 2> debug.log
 
 ```
 
 If you just want to see debug messages from `ssh2-sftp-client` and exclude debug messages from the underlying `ssh2` and `ssh2-streams` modules, you can filter based on messages which start with 'CLIENT' e.g.
 
-```nillangnilswitchesnilflags
-nilbody
-#+END_SRC
-*
-nilbody
+```javascript
+{
+  debug: (msg) => {
+    if (msg.startsWith('CLIENT')) {
+      console.error(msg);
+    }
+  }
+}
 ```
 
-# Logging Issues<a id="sec-9"></a>
+
+<a id="orgdc52f71"></a>
+
+# Logging Issues
 
 Please log an issue for all bugs, questions, feature and enhancement requests. Please ensure you include the module version, node version and platform.
 
@@ -1487,7 +1556,10 @@ I am happy to try and help diagnose and fix any issues you encounter while using
 
 Perhaps the best assistance is a minimal reproducible example of the issue. Once the issue can be readily reproduced, it can usually be fixed very quickly.
 
-# Pull Requests<a id="sec-10"></a>
+
+<a id="orge4e0c24"></a>
+
+# Pull Requests
 
 Pull requests are always welcomed. However, please ensure your changes pass all tests and if you're adding a new feature, that tests for that feature are included. Likewise, for new features or enhancements, please include any relevant documentation updates.
 
@@ -1496,10 +1568,15 @@ Pull requests are always welcomed. However, please ensure your changes pass all
 This module will adopt a standard semantic versioning policy. Please indicate in your pull request what level of change it represents i.e.
 
 -   **Major:** Change to API or major change in functionality which will require an increase in major version number.
+
 -   **Minor:** Minor change, enhancement or new feature which does not change existing API and will not break existing client code.
+
 -   **Bug Fix:** No change to functionality or features. Simple fix of an existing bug.
 
-# Contributors<a id="sec-11"></a>
+
+<a id="org7f7c9a1"></a>
+
+# Contributors
 
 This module was initially written by jyu213. On August 23rd, 2019, theophilusx took over responsibility for maintaining this module. A number of other people have contributed to this module, but until now, this was not tracked. My intention is to credit anyone who contributes going forward.