chore: update confit

WIP(docs): outline docs in own folder
WIP(readme): improve docs in readme
2018-01-21 15:01:11 -07:00 · 2018-01-21 14:57:49 -07:00 · 2018-01-21 14:57:49 -07:00
153 changed files with 7345 additions and 20570 deletions
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -1,97 +1,140 @@
 version: 2
-
 jobs:
-  build:
+  build_node_8:
    docker:
-      - image: &node-image circleci/node:lts
+      - image: circleci/node:8
    steps:
      - checkout
      - restore_cache:
-          keys:
-            - &npm-cache-key npm-cache-{{ .Branch }}-{{ .Revision }}
-            - npm-cache-{{ .Branch }}
-            - npm-cache
+          key: npm-install-node-8-{{ checksum "package.json" }}
      - run:
          name: Install
-          command: npm ci
-      - persist_to_workspace:
-          root: .
+          command: npm install
+      - save_cache:
+          key: npm-install-node-8-{{ checksum "package.json" }}
          paths:
            - node_modules
+
+  build_node_6:
+    docker:
+      - image: circleci/node:6
+    steps:
+      - checkout
+      - restore_cache:
+          key: npm-install-node-6-{{ checksum "package.json" }}
+      - run:
+          name: Install
+          command: npm install
      - save_cache:
-          key: *npm-cache-key
+          key: npm-install-node-6-{{ checksum "package.json" }}
          paths:
-            - ~/.npm/_cacache
+            - node_modules

  lint:
    docker:
-      - image: *node-image
+      - image: circleci/node:8
    steps:
      - checkout
-      - attach_workspace:
-          at: .
+      - restore_cache:
+          key: npm-install-node-8-{{ checksum "package.json" }}
      - run:
          name: Lint
-          command: npm run verify
+          command: npm run verify:js

-  test:
+  test_node_8:
    docker:
-      - image: *node-image
+      - image: circleci/node:8
    steps:
      - checkout
-      - attach_workspace:
-          at: .
-      - deploy:
-          name: Test
-          command: |
-            npm run test
+      - restore_cache:
+          key: npm-install-node-8-{{ checksum "package.json" }}
+      - run:
+          name: Test Node 8
+          command: npm run test:coverage
+          when: always
+      - store_test_results:
+          path: reports
+      - store_artifacts:
+          path: reports/coverage
+          prefix: coverage

-  release_dry_run:
+  test_node_6:
    docker:
-      - image: *node-image
+      - image: circleci/node:6
    steps:
      - checkout
-      - attach_workspace:
-          at: .
-      - deploy:
-          name: Dry Release
-          command: |
-            npm run semantic-release -- --dry-run
+      - restore_cache:
+          key: npm-install-node-6-{{ checksum "package.json" }}
+      - run:
+          name: Test Node 6
+          command: npm run test:coverage
+          when: always
+      - store_test_results:
+          path: reports
+      - store_artifacts:
+          path: reports/coverage
+          prefix: coverage

  release:
    docker:
-      - image: *node-image
+      - image: circleci/node:8
    steps:
      - checkout
-      - attach_workspace:
-          at: .
-      - deploy:
-          name: Release
+      - restore_cache:
+          key: npm-install-node-6-{{ checksum "package.json" }}
+      - run:
+          name: Update NPM
          command: |
-            npm run semantic-release
+            npm install npm@5
+            npm install semantic-release@11
+      - deploy:
+          name: Semantic Release
+          command: |
+            npm run semantic-release || true

 workflows:
  version: 2
-  publish:
+  test_and_tag:
    jobs:
-      - build
-      - lint:
-          requires:
-            - build
-      - test:
-          requires:
-            - build
-      - release_dry_run:
+      - build_node_8:
          filters:
            branches:
              only: master
+      - build_node_6:
+          filters:
+            branches:
+              only: master
+      - lint:
          requires:
-            - test
-            - lint
-      - hold_release:
-          type: approval
+            - build_node_8
+      - test_node_6:
          requires:
-            - release_dry_run
+            - build_node_6
+      - test_node_8:
+          requires:
+            - build_node_8
      - release:
          requires:
-            - hold_release
+            - lint
+            - test_node_6
+            - test_node_8
+
+  build_and_test:
+    jobs:
+      - build_node_8:
+          filters:
+            branches:
+              ignore: master
+      - build_node_6:
+          filters:
+            branches:
+              ignore: master
+      - lint:
+          requires:
+            - build_node_8
+      - test_node_6:
+          requires:
+            - build_node_6
+      - test_node_8:
+          requires:
+            - build_node_8
--- a/old/.editorconfig
+++ b/old/.editorconfig
--- a/.eslintignore
+++ b/.eslintignore
@@ -0,0 +1,9 @@
+# START_CONFIT_GENERATED_CONTENT
+# Common folders to ignore
+node_modules/*
+bower_components/*
+
+# Config folder (optional - you might want to lint this...)
+config/*
+
+# END_CONFIT_GENERATED_CONTENT
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,7 @@
-test_tmp/
-
 node_modules/

 dist/
+reports/
 npm-debug.log
+.nyc_output/
+test_tmp/
--- a/.nycrc
+++ b/.nycrc
@@ -0,0 +1,24 @@
+{
+    "check-coverage": true,
+    "per-file": false,
+    "lines": 90,
+    "statements": 90,
+    "functions": 85,
+    "branches": 75,
+    "include": [
+      "src/**/*.js"
+    ],
+    "exclude": [
+      "test/**/*.spec.js"
+    ],
+    "reporter": [
+      "lcovonly",
+      "html",
+      "text",
+      "cobertura",
+      "json"
+    ],
+    "cache": true,
+    "all": true,
+    "report-dir": "./reports/coverage/"
+}
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -0,0 +1,211 @@
+<!--[CN_HEADING]-->
+# Contributing
+
+Welcome! This document explains how you can contribute to making **ftp-srv** even better.
+
+
+<!--[]-->
+
+<!--[CN_GETTING_STARTED]-->
+# Getting Started
+
+## Installation
+
+```
+git clone <this repo>
+npm install -g commitizen
+npm install -g semantic-release-cli
+npm install
+```
+
+
+<!--[]-->
+
+<!--[RM_DIR_STRUCTURE]-->
+## Directory Structure
+
+Code is organised into modules which contain one-or-more components. This a great way to ensure maintainable code by encapsulation of behavior logic. A component is basically a self contained app usually in a single file or a folder with each concern as a file: style, template, specs, e2e, and component class. Here's how it looks:
+```
+ftp-srv/
+ ├──config/                       * configuration files live here (e.g. eslint, verify, testUnit)
+ │
+ ├──src/                          * source code files should be here
+ │
+ ├──dist/                         * production-build code should live here
+ │
+ ├──reports/                      * test reports appear here
+ │
+ ├──test/                         * unit test specifications live here
+ │
+ ├──confit.yml                    * the project config file generated by 'yo confit'
+ ├──CONTRIBUTING.md               * how to contribute to the project
+ ├──README.md                     * this file
+ └──package.json                  * NPM package description file
+```
+
+
+<!--[]-->
+
+<!--[CN_GITFLOW_PROCESS]-->
+# GitFlow Development Process
+
+This project uses the [GitHub Flow](https://guides.github.com/introduction/flow/index.html) workflow.
+
+## Create a branch
+When you're working on a project, you're going to have a bunch of different features or ideas in progress at any given time – some of which are ready to go, and others which are not. Branching exists to help you manage this workflow.
+
+When you create a branch in your project, you're creating an environment where you can try out new ideas. Changes you make on a branch don't affect the `master` branch, so you're free to experiment and commit changes, safe in the knowledge that your branch won't be merged until it's ready to be reviewed by someone you're collaborating with.
+
+###ProTip
+
+Branching is a core concept in Git, and the entire GitHub Flow is based upon it. There's only one rule: anything in the `master` branch is always deployable.
+
+Because of this, it's extremely important that your new branch is created off of `master` when working on a feature or a fix. Your branch name should be descriptive (e.g., `refactor-authentication`, `user-content-cache-key`, `make-retina-avatars`), so that others can see what is being worked on.
+
+## Add commits
+Once your branch has been created, it's time to start making changes. Whenever you add, edit, or delete a file, you're making a commit, and adding them to your branch. This process of adding commits keeps track of your progress as you work on a feature branch.
+
+Commits also create a transparent history of your work that others can follow to understand what you've done and why. Each commit has an associated commit message, which is a description explaining why a particular change was made. Furthermore, each commit is considered a separate unit of change. This lets you roll back changes if a bug is found, or if you decide to head in a different direction.
+
+###ProTip
+
+Commit messages are important, especially since Git tracks your changes and then displays them as commits once they're pushed to the server. By writing clear commit messages, you can make it easier for other people to follow along and provide feedback.
+
+## Open a pull request
+
+Pull Requests initiate discussion about your commits. Because they're tightly integrated with the underlying Git repository, anyone can see exactly what changes would be merged if they accept your request.
+
+You can open a Pull Request at any point during the development process: when you have little or no code but want to share some screenshots or general ideas, when you're stuck and need help or advice, or when you're ready for someone to review your work. By using GitHub's @mention system in your Pull Request message, you can ask for feedback from specific people or teams, whether they're down the hall or ten time zones away.
+
+###ProTip
+
+Pull Requests are useful for contributing to open source projects and for managing changes to shared repositories. If you're using a Fork & Pull Model, Pull Requests provide a way to notify project maintainers about the changes you'd like them to consider. If you're using a Shared Repository Model, Pull Requests help start code review and conversation about proposed changes before they're merged into the `master` branch.
+
+## Discuss and review your code
+Once a Pull Request has been opened, the person or team reviewing your changes may have questions or comments. Perhaps the coding style doesn't match project guidelines, the change is missing unit tests, or maybe everything looks great and props are in order. Pull Requests are designed to encourage and capture this type of conversation.
+
+You can also continue to push to your branch in light of discussion and feedback about your commits. If someone comments that you forgot to do something or if there is a bug in the code, you can fix it in your branch and push up the change. GitHub will show your new commits and any additional feedback you may receive in the unified Pull Request view.
+
+###ProTip
+
+Pull Request comments are written in Markdown, so you can embed images and emoji, use pre-formatted text blocks, and other lightweight formatting.
+
+## Merge to `master`
+
+Once your PR has passed any the integration tests and received approval to merge, it is time to merge your code into the `master` branch.
+
+Once merged, Pull Requests preserve a record of the historical changes to your code. Because they're searchable, they let anyone go back in time to understand why and how a decision was made.
+
+###ProTip
+
+By incorporating certain keywords into the text of your Pull Request, you can associate issues with code. When your Pull Request is merged, the related issues are also closed. For example, entering the phrase Closes #32 would close issue number 32 in the repository. For more information, check out our help article.
+
+
+<!--[]-->
+
+<!--[CN_BUILD_TASKS]-->
+## Build Tasks
+
+Command | Description
+:------ | :----------
+<pre>npm run build</pre> | Generate production build into [dist/](dist/) folder
+<pre>npm run dev</pre> | Run project in development mode (verify code, and re-verify when code is changed)
+<pre>npm start</pre> | Alias for `npm run dev` task
+
+
+
+<!--[]-->
+
+<!--[CN_TEST_TASKS]-->
+## Test Tasks
+
+Command | Description
+:------ | :----------
+<pre>npm test</pre> | Alias for `npm run test:unit` task
+<pre>npm run test:coverage</pre> | Run instrumented unit tests then verify coverage meets defined thresholds<ul><li>Returns non-zero exit code when coverage does not meet thresholds (as defined in istanbul.js)</li></ul>
+<pre>npm run test:unit</pre> | Run unit tests whenever JS source or tests change<ul><li>Uses Mocha</li><li>Code coverage</li><li>Runs continuously (best to run in a separate window)</li></ul>
+<pre>npm run test:unit:once</pre> | Run unit tests once<ul><li>Uses Mocha</li><li>Code coverage</li></ul>
+
+
+
+<!--[]-->
+
+<!--[CN_VERIFY_TASKS]-->
+## Verification (Linting) Tasks
+
+Command | Description
+:------ | :----------
+<pre>npm run verify</pre> | Verify code style and syntax<ul><li>Verifies source *and test code* aginst customisable rules (unlike Webpack loaders)</li></ul>
+<pre>npm run verify:js</pre> | Verify Javascript code style and syntax
+<pre>npm run verify:js:fix</pre> | Verify Javascript code style and syntax and fix any errors that can be fixed automatically
+<pre>npm run verify:js:watch</pre> | Verify Javascript code style and syntax and watch files for changes
+<pre>npm run verify:watch</pre> | Runs verify task whenever JS or CSS code is changed
+
+
+
+<!--[]-->
+
+<!--[CN_COMMIT_TASKS]-->
+## Commit Tasks
+
+Command | Description
+:------ | :----------
+<pre>git status</pre> | Lists the current branch and the status of changed files
+<pre>git log</pre> | Displays the commit log (press Q to quit viewing)
+<pre>git add .</pre> | Stages all modified & untracked files, ready to be committed
+<pre>git cz</pre> | Commit changes to local repository using Commitizen.<ul><li>Asks questions about the change to generate a valid conventional commit message</li><li>Can be customised by modifying [config/release/commitMessageConfig.js](config/release/commitMessageConfig.js)</li></ul>
+<pre>git push</pre> | Push local repository changes to remote repository
+
+
+<!--[]-->
+
+<!--[CN_DOCUMENTATION_TASKS]-->
+
+
+
+<!--[]-->
+
+<!--[CN_RELEASE_TASKS]-->
+## Release Tasks
+
+Command | Description
+:------ | :----------
+<pre>npm run commitmsg</pre> | Git commit message hook that validates the commit message conforms to your commit message conventions.
+<pre>npm run pre-release</pre> | Verify code, run unit tests, check test coverage, build software. This task is designed to be run before
+the `semantic-release` task.
+<ul><li>Run `semantic-release-cli setup` once you have a remote repository. See https://github.com/semantic-release/cli for details.</li><li>Semantic-release integrates with Travis CI (or similar tools) to generate release notes
+for each release (which appears in the "Releases" section in GitHub) and
+publishes the package to NPM (when all the tests are successful) with a semantic version number.
+</li></ul>
+<pre>npm run prepush</pre> | Git pre-push hook that verifies code and checks unit test coverage meet minimum thresholds.
+<pre>npm run upload-coverage</pre> | Uploads code-coverage metrics to Coveralls.io<ul><li>Setup - https://coveralls.zendesk.com/hc/en-us/articles/201347419-Coveralls-currently-supports</li><li>Define an environment variable called COVERALLS_REPO_TOKEN in your build environment with the repo token from https://coveralls.io/github/<repo-name>/settings</li><li>In your CI configuration (e.g. `travis.yml`), call `npm run upload-coverage` if the build is successful.</li></ul>
+
+
+
+<!--[]-->
+
+
+<!--[CN_CHANGING_BUILD_TOOL_CONFIG]-->
+## Changing build-tool configuration
+
+There are 3 ways you can change the build-tool configuration for this project:
+
+1. BEST: Modify the Confit configuration file ([confit.yml](confit.yml)) by hand, then re-run `yo confit` and tell it to use the existing configuration.
+1. OK: Re-run `yo confit` and provide new answers to the questions. **Confit will attempt to overwrite your existing configuration (it will prompt for confirmation), so make sure you have committed your code to a source control (e.g. git) first**.
+  There are certain configuration settings which can **only** be specified by hand, in which case the first approach is still best.
+1. RISKY: Modify the generated build-tool config by hand. Be aware that if you re-run `yo confit` it will attempt to overwrite your changes. So commit your changes to source control first.
+
+Additionally, the **currently-generated** configuration can be extended in the following ways:
+
+- The task configuration is defined in [package.json](package.json). It is possible to change the task definitions to add your own sub-tasks.
+You can also use the `pre...` and `post...` script-name prefixes to run commands before (pre) and after (post) the generated commands.
+
+- The `entryPoint.entryPoints` string in [confit.yml](confit.yml) is designed to be edited manually. It represents the starting-point(s) of the application (like a `main()` function). A NodeJS application has one entry point. E.g. `src/index.js`
+
+
+
+
+<!--[]-->
+
+
+
--- a/old/LICENSE
+++ b/old/LICENSE
@@ -1,6 +1,6 @@
 MIT License

-Copyright (c) 2019 Tyler Stewart
+Copyright (c) 2017 Tyler Stewart

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
--- a/README.md
+++ b/README.md
@@ -0,0 +1,85 @@
+<p align="center">
+  <a href="https://github.com/trs/ftp-srv">
+    <img alt="ftp-srv" src="logo.png" width="600px"  />
+  </a>
+</p>
+
+
+<p align="center">
+  Modern, extensible FTP Server
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/ftp-srv">
+    <img alt="npm" src="https://img.shields.io/npm/dm/ftp-srv.svg?style=for-the-badge" />
+  </a>
+
+  <a href="https://circleci.com/gh/trs/ftp-srv">
+    <img alt="npm" src="https://img.shields.io/circleci/project/github/trs/ftp-srv.svg?style=for-the-badge" />
+  </a>
+
+  <a href="https://coveralls.io/github/trs/ftp-srv?branch=master">
+    <img alt="npm" src="https://img.shields.io/coveralls/github/trs/ftp-srv.svg?style=for-the-badge" />
+  </a>
+</p>
+
+---
+
+## Synopsis
+
+`ftp-srv` is an extensible FTP server solution that enables custom file systems per connection allowing the use of virtual file systems. By default, it acts like a regular FTP server. Just include it in your project and start listening.
+
+## Features
+
+- Passive and Active transfer support
+- [Explicit](https://en.wikipedia.org/wiki/FTPS#Explicit) & [Implicit](https://en.wikipedia.org/wiki/FTPS#Implicit) TLS connections
+- Extensible [file systems](#file-system) per connection
+- Promise based API
+
+## Install
+
+```
+$ npm install ftp-srv
+``` 
+
+## Quick Start
+
+```js
+const FtpSrv = require('ftp-srv');
+
+const ftpServer = new FtpSrv('ftp://0.0.0.0:9876');
+
+ftpServer.on('login', ({connection, username, password}, resolve, reject) => {
+  // fetch credentials from database, file, or hard coded
+  database.users.fetch({username, password})
+  .then(() => {
+    connection.on('STOR', (err, file) => console.log(`Uploaded file: ${file}`));
+
+    resolve({
+      root: '/'
+    });
+  })
+  .catch(() => reject);
+});
+
+ftpServer.listen()
+.then(() => {
+  console.log('Waiting for connections!');
+});
+```
+
+## API
+
+Checkout the [Documentation](/docs).
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## License
+
+This software is licensed under the MIT Licence. See [LICENSE](LICENSE).
+
+## References
+
+- [https://cr.yp.to/ftp.html](https://cr.yp.to/ftp.html)
--- a/config/release/commitMessageConfig.js
+++ b/config/release/commitMessageConfig.js
@@ -0,0 +1,38 @@
+'use strict';
+
+module.exports = {
+
+  types: [
+    {value: 'feat',     name: 'feat:     A new feature'},
+    {value: 'fix',      name: 'fix:      A bug fix'},
+    {value: 'docs',     name: 'docs:     Documentation only changes'},
+    {value: 'style',    name: 'style:    Changes that do not affect the meaning of the code\n            (white-space, formatting, missing semi-colons, etc)'},
+    {value: 'refactor', name: 'refactor: A code change that neither fixes a bug nor adds a feature'},
+    {value: 'perf',     name: 'perf:     A code change that improves performance'},
+    {value: 'test',     name: 'test:     Adding missing tests'},
+    {value: 'chore',    name: 'chore:    Changes to the build process or auxiliary tools\n            and libraries such as documentation generation'},
+    {value: 'revert',   name: 'revert:   Revert to a commit'},
+    {value: 'WIP',      name: 'WIP:      Work in progress'}
+  ],
+
+  scopes: [],
+
+  // it needs to match the value for field type. Eg.: 'fix'
+  /*
+   scopeOverrides: {
+   fix: [
+
+   {name: 'merge'},
+   {name: 'style'},
+   {name: 'e2eTest'},
+   {name: 'unitTest'}
+   ]
+   },
+   */
+
+  allowCustomScopes: true,
+  allowBreakingChanges: ['feat', 'fix'],
+
+  // Appends the branch name to the footer of the commit. Useful for tracking commits after branches have been merged
+  appendBranchNameToCommitMessage: false
+};
--- a/config/testUnit/mocha.opts
+++ b/config/testUnit/mocha.opts
@@ -0,0 +1,5 @@
+test/**/*.spec.js
+--reporter mocha-multi-reporters
+--reporter-options configFile=config/testUnit/reporters.json
+--ui bdd
+--bail
--- a/config/testUnit/reporters.json
+++ b/config/testUnit/reporters.json
@@ -0,0 +1,6 @@
+{
+  "reporterEnabled": "mocha-pretty-bunyan-nyan",
+  "mochaJunitReporterReporterOptions": {
+    "mochaFile": "reports/junit.xml"
+  }
+}
--- a/config/verify/.eslintrc
+++ b/config/verify/.eslintrc
@@ -0,0 +1,162 @@
+{
+  "extends": "eslint:recommended",
+  "env": {
+    "node": true,
+    "mocha": true,
+    "es6": true
+  },
+  "plugins": [
+    "mocha",
+    "node"
+  ],
+  "rules": {
+    "mocha/no-exclusive-tests": 2,
+    "no-warning-comments": [
+      1,
+      {
+        "terms": ["todo", "fixme", "xxx"],
+        "location": "start"
+      },
+    ],
+    "object-curly-spacing": [
+      2,
+      "never"
+    ],
+    "array-bracket-spacing": [
+      2,
+      "never"
+    ],
+    "brace-style": [
+      2,
+      "1tbs"
+    ],
+    "consistent-return": 0,
+    "indent": [
+      "error",
+      2,
+      {
+        "SwitchCase": 1,
+        "MemberExpression": "off"
+      }
+    ],
+    "no-multiple-empty-lines": [
+      2,
+      {
+        "max": 2
+      }
+    ],
+    "no-use-before-define": [
+      2,
+      "nofunc"
+    ],
+    "one-var": [
+      2,
+      "never"
+    ],
+    "quote-props": [
+      2,
+      "as-needed"
+    ],
+    "quotes": [
+      2,
+      "single"
+    ],
+    "keyword-spacing": 2,
+    "space-before-function-paren": [
+      2,
+      {
+        "anonymous": "always",
+        "named": "never"
+      }
+    ],
+    "space-in-parens": [
+      2,
+      "never"
+    ],
+    "strict": [
+      2,
+      "global"
+    ],
+    "curly": [
+      2,
+      "multi-line"
+    ],
+    "eol-last": 2,
+    "key-spacing": [
+      2,
+      {
+        "beforeColon": false,
+        "afterColon": true
+      }
+    ],
+    "no-eval": 2,
+    "no-with": 2,
+    "space-infix-ops": 2,
+    "dot-notation": [
+      2,
+      {
+        "allowKeywords": true
+      }
+    ],
+    "eqeqeq": 2,
+    "no-alert": 2,
+    "no-caller": 2,
+    "no-extend-native": 2,
+    "no-extra-bind": 2,
+    "no-implied-eval": 2,
+    "no-iterator": 2,
+    "no-label-var": 2,
+    "no-labels": 2,
+    "no-lone-blocks": 2,
+    "no-loop-func": 2,
+    "no-multi-spaces": 2,
+    "no-multi-str": 2,
+    "no-native-reassign": 2,
+    "no-new": 2,
+    "no-new-func": 2,
+    "no-new-wrappers": 2,
+    "no-octal-escape": 2,
+    "no-proto": 2,
+    "no-return-assign": 2,
+    "no-script-url": 2,
+    "no-sequences": 2,
+    "no-unused-expressions": 2,
+    "yoda": 2,
+    "no-shadow": 2,
+    "no-shadow-restricted-names": 2,
+    "no-undef-init": 2,
+    "no-console": 1,
+    "camelcase": [
+      0,
+      {
+        "properties": "never"
+      }
+    ],
+    "comma-spacing": 2,
+    "comma-dangle": 1,
+    "new-cap": 2,
+    "new-parens": 2,
+    "arrow-parens": [2, "as-needed"],
+    "no-array-constructor": 2,
+    "array-callback-return": 1,
+    "no-extra-parens": 2,
+    "no-new-object": 2,
+    "no-spaced-func": 2,
+    "no-trailing-spaces": 2,
+    "no-underscore-dangle": 0,
+    "no-fallthrough": 0,
+    "semi": 2,
+    "semi-spacing": [
+      2,
+      {
+        "before": false,
+        "after": true
+      }
+    ]
+  },
+  "parserOptions": {
+    "emcaVersion": 6,
+    "sourceType": "module",
+    "impliedStrict": true
+  }
+}
--- a/confit.yml
+++ b/confit.yml
@@ -0,0 +1,49 @@
+generator-confit:
+  app:
+    _version: 462ecd915fd9db1aef6a37c2b5ce8b58b80c18ba
+    buildProfile: Latest
+    copyrightOwner: Tyler Stewart
+    license: MIT
+    projectType: node
+    publicRepository: true
+    repositoryType: GitHub
+  paths:
+    _version: 780b129e0c7e5cab7e29c4f185bcf78524593a33
+    config:
+      configDir: config/
+    input:
+      srcDir: src/
+      unitTestDir: test/
+    output:
+      prodDir: dist/
+      reportDir: reports/
+  buildJS:
+    _version: ead8ce4280b07d696aff499a5fca1a933727582f
+    framework: []
+    frameworkScripts: []
+    outputFormat: ES6
+    sourceFormat: ES6
+  entryPoint:
+    _version: 39082c3df887fbc08744dfd088c25465e7a2e3a4
+    entryPoints:
+      main:
+        - ftp-srv.js
+  testUnit:
+    _version: 30eee42a88ee42cce4f1ae48fe0cbe81647d189a
+    testDependencies: []
+    testFramework: mocha
+  verify:
+    _version: 30ae86c5022840a01fc08833e238a82c683fa1c7
+    jsCodingStandard: none
+  documentation:
+    _version: b1658da3278b16d1982212f5e8bc05348af20e0b
+    generateDocs: false
+  release:
+    _version: 47f220593935b502abf17cb34a396f692e453c49
+    checkCodeCoverage: true
+    commitMessageFormat: Conventional
+    useSemantic: true
+  sampleApp:
+    _version: 00c0a2c6fc0ed17fcccce2d548d35896121e58ba
+    createSampleApp: false
+  zzfinish: {}
--- a/docs/README.md
+++ b/docs/README.md
@@ -0,0 +1,2 @@
+## Documentation
+
--- a/example/index.ts
+++ b/example/index.ts
@@ -1,15 +0,0 @@
-import FTPServer from '../src/server';
-
-const server = new FTPServer();
-server.registerPlugin({
-    command: 'PASS',
-    handler: async ({connection, reply}) => {
-        const username = connection.getContext('username');
-        const password = connection.getContext('password');
-
-        // AUTHENTICATE
-
-        reply.set([230]);
-    }
-});
-server.listen();
--- a/ftp-srv.d.ts
+++ b/ftp-srv.d.ts
@@ -0,0 +1,122 @@
+import * as tls from 'tls'
+import { Stats } from 'fs'
+
+export class FileSystem {
+
+	readonly connection: FtpConnection;
+	readonly root: string;
+	readonly cwd: string;
+
+    constructor(connection: FtpConnection, {root, cwd}?: {
+        root: any;
+        cwd: any;
+    });
+
+    currentDirectory(): string;
+
+    get(fileName: string): Promise<any>;
+
+    list(path?: string): Promise<any>;
+
+    chdir(path?: string): Promise<string>;
+
+    write(fileName: string, {append, start}?: {
+        append?: boolean;
+        start?: any;
+    }): any;
+
+    read(fileName: string, {start}?: {
+        start?: any;
+    }): Promise<any>;
+
+    delete(path: string): Promise<any>;
+
+    mkdir(path: string): Promise<any>;
+
+    rename(from: string, to: string): Promise<any>;
+
+    chmod(path: string, mode: string): Promise<any>;
+
+    getUniqueName(): string;
+}
+
+export class FtpConnection {
+	server: FtpServer;
+	id: string;
+	log: any;
+	transferType: string;
+	encoding: string;
+	bufferSize: boolean;
+	readonly ip: string;
+	restByteCount: number | undefined;
+	secure: boolean
+
+	close (code: number, message: number): Promise<any>
+	login (username: string, password: string): Promise<any>
+	reply (options: number | Object, ...letters: Array<any>): Promise<any>
+
+}
+
+export interface FtpServerOptions {
+    pasv_range?: number | string,
+    greeting?: string | string[],
+    tls?: tls.SecureContext | false,
+    anonymous?: boolean,
+    blacklist?: Array<string>,
+    whitelist?: Array<string>,
+    file_format?: (stat: Stats) => string | Promise<string> | "ls" | "ep",
+	log?: any
+}
+
+export class FtpServer {
+    constructor(url: string, options?: FtpServerOptions);
+
+    readonly isTLS: boolean;
+
+    listen(): any;
+
+    emitPromise(action: any, ...data: any[]): Promise<any>;
+
+    emit(action: any, ...data: any[]): void;
+
+    setupTLS(_tls: boolean): boolean | {
+      cert: string;
+      key: string;
+      ca: string
+    };
+
+    setupGreeting(greet: string): string[];
+
+    setupFeaturesMessage(): string;
+
+    disconnectClient(id: string): Promise<any>;
+
+    close(): any;
+
+	on(event: "login", listener: (
+		data: {
+			connection: FtpConnection,
+			username: string,
+			password: string
+		},
+		resolve: (config: {
+            fs?: FileSystem,
+            root?: string,
+            cwd?: string,
+            blacklist?: Array<string>,
+            whitelist?: Array<string>
+        }) => void,
+		reject: (err?: Error) => void
+	) => void)
+
+	on(event: "client-error", listener: (
+		data: {
+			connection: FtpConnection,
+			context: string,
+			error: Error,
+		}
+	) => void)
+}
+
+export {FtpServer as FtpSrv};
+export default FtpServer;
--- a/old/ftp-srv.js
+++ b/old/ftp-srv.js
@@ -1,8 +1,6 @@
 const FtpSrv = require('./src');
 const FileSystem = require('./src/fs');
-const errors = require('./src/errors');

 module.exports = FtpSrv;
 module.exports.FtpSrv = FtpSrv;
 module.exports.FileSystem = FileSystem;
-module.exports.ftpErrors = errors;
--- a/old/logo.png
+++ b/old/logo.png
--- a/old/meta/logo/generate.js
+++ b/old/meta/logo/generate.js
--- a/old/meta/logo/logo.html
+++ b/old/meta/logo/logo.html
--- a/old/.eslintignore
+++ b/old/.eslintignore
@@ -1,2 +0,0 @@
-node_modules/*
-bower_components/*
--- a/old/CONTRIBUTING.md
+++ b/old/CONTRIBUTING.md
@@ -1,25 +0,0 @@
-<p align="center">
-  <a href="https://github.com/trs/ftp-srv">
-    <img alt="ftp-srv" src="logo.png" width="400px"  />
-  </a>
-</p>
-
-<h1 align="center">
-  Contributing Guide
-</h1>
-
-## Welcome
-
- Thank you for your eagerness to contribute, pull requests are encouraged!
-
-## Guidelines
-
- Any new fixes are features should include new or updated [tests](/test).
- Commits follow the [AngularJS Git Commit Message Conventions](https://docs.google.com/document/d/1QrDFcIiPjSLDn3EL15IJygNPiHORgU1_OOAqWjiDU5Y/edit), please review and commit accordingly
- Submit your pull requests to the `master` branch, these will normally be merged into a separate branch for any finally changes before being merged into `master`.
- Submit any bugs or requests to the issues page in Github.
-
-## Setup
-
- Clone the repository `git clone`
- Install dependencies `npm install`
--- a/old/README.md
+++ b/old/README.md
@@ -1,358 +0,0 @@
-<p align="center">
-  <a href="https://github.com/trs/ftp-srv">
-    <img alt="ftp-srv" src="logo.png" width="600px"  />
-  </a>
-</p>
-
-
-<p align="center">
-  Modern, extensible FTP Server
-</p>
-
-<p align="center">
-  <a href="https://www.npmjs.com/package/ftp-srv">
-    <img alt="npm" src="https://img.shields.io/npm/dm/ftp-srv.svg?style=for-the-badge" />
-  </a>
-
-  <a href="https://circleci.com/gh/trs/workflows/ftp-srv/tree/master">
-    <img alt="circleci" src="https://img.shields.io/circleci/project/github/trs/ftp-srv/master.svg?style=for-the-badge" />
-  </a>
-</p>
-
---
-
- [Overview](#overview)
- [Features](#features)
- [Install](#install)
- [Usage](#usage)
-  - [API](#api)
-  - [CLI](#cli)
-  - [Events](#events)
-  - [Supported Commands](#supported-commands)
-  - [File System](#file-system)
- [Contributing](#contributing)
- [License](#license)
-
-## Overview
-`ftp-srv` is a modern and extensible FTP server designed to be simple yet configurable.
-
-## Features
- Extensible [file systems](#file-system) per connection
- Passive and active transfers
- [Explicit](https://en.wikipedia.org/wiki/FTPS#Explicit) & [Implicit](https://en.wikipedia.org/wiki/FTPS#Implicit) TLS connections
- Promise based API
-
-## Install
-`npm install ftp-srv --save`
-
-## Usage
-
-```js
-// Quick start
-
-const FtpSrv = require('ftp-srv');
-const ftpServer = new FtpSrv({ options ... });
-
-ftpServer.on('login', (data, resolve, reject) => { ... });
-...
-
-ftpServer.listen()
-.then(() => { ... });
-```
-
-## API
-
-### `new FtpSrv({options})`
-#### url
-[URL string](https://nodejs.org/api/url.html#url_url_strings_and_url_objects) indicating the protocol, hostname, and port to listen on for connections.
-Supported protocols:
- `ftp` Plain FTP
- `ftps` Implicit FTP over TLS
-
-_Note:_ The hostname must be the external IP address to accept external connections. `0.0.0.0` will listen on any available hosts for server and passive connections.  
-__Default:__ `"ftp://127.0.0.1:21"`
-
-#### `pasv_url`
-The hostname to provide a client when attempting a passive connection (`PASV`). This defaults to the provided `url` hostname.
-
-_Note:_ If set to `0.0.0.0`, this will automatically resolve to the external IP of the box.  
-__Default:__ `"127.0.0.1"`
-
-#### `pasv_min`
-Tne starting port to accept passive connections.  
-__Default:__ `1024`
-
-#### `pasv_max`
-The ending port to accept passive connections.  
-The range is then queried for an available port to use when required.  
-__Default:__ `65535`
-
-#### `greeting`
-A human readable array of lines or string to send when a client connects.  
-__Default:__ `null`
-
-#### `tls`
-Node [TLS secure context object](https://nodejs.org/api/tls.html#tls_tls_createsecurecontext_options) used for implicit (`ftps` protocol) or explicit (`AUTH TLS`) connections.  
-__Default:__ `false`
-
-#### `anonymous`
-If true, will allow clients to authenticate using the username `anonymous`, not requiring a password from the user.  
-Can also set as a string which allows users to authenticate using the username provided.  
-The `login` event is then sent with the provided username and `@anonymous` as the password.  
-__Default:__ `false`
-
-#### `blacklist`
-Array of commands that are not allowed.  
-Response code `502` is sent to clients sending one of these commands.  
-__Example:__ `['RMD', 'RNFR', 'RNTO']` will not allow users to delete directories or rename any files.  
-__Default:__ `[]`
-
-#### `whitelist`
-Array of commands that are only allowed.  
-Response code `502` is sent to clients sending any other command.  
-__Default:__ `[]`
-
-#### `file_format`
-Sets the format to use for file stat queries such as `LIST`.  
-__Default:__ `"ls"`  
-__Allowable values:__
-  - `ls` [bin/ls format](https://cr.yp.to/ftp/list/binls.html)
-  - `ep` [Easily Parsed LIST format](https://cr.yp.to/ftp/list/eplf.html)
-  - `function () {}` A custom function returning a format or promise for one.
-    - Only one argument is passed in: a node [file stat](https://nodejs.org/api/fs.html#fs_class_fs_stats) object with additional file `name` parameter
-
-#### `log`
-A [bunyan logger](https://github.com/trentm/node-bunyan) instance. Created by default.
-
-#### `timeout`
-Sets the timeout (in ms) after that an idle connection is closed by the server  
-__Default:__ `0`
-
-## CLI
-
-`ftp-srv` also comes with a builtin CLI.
-
-```bash
-$ ftp-srv [url] [options]
-```
-
-```bash
-$ ftp-srv ftp://0.0.0.0:9876 --root ~/Documents
-```
-
-#### `url`
-
-Set the listening URL.
-
-Defaults to `ftp://127.0.0.1:21`
-
-#### `--root` / `-r`
-
-Set the default root directory for users.
-
-Defaults to the current directory.
-
-#### `--credentials` / `-c`
-
-Set the path to a json credentials file.
-
-Format:
-
-```js
-[
-  {
-    "username": "...",
-    "password": "...",
-    "root": "..." // Root directory
-  },
-  ...
-]
-```
-
-#### `--username`
-
-Set the username for the only user. Do not provide an argument to allow anonymous login.
-
-#### `--password`
-
-Set the password for the given `username`.
-
-## Events
-
-The `FtpSrv` class extends the [node net.Server](https://nodejs.org/api/net.html#net_class_net_server). Some custom events can be resolved or rejected, such as `login`.
-
-### `login`
-```js
-ftpServer.on('login', ({connection, username, password}, resolve, reject) => { ... });
-```
-
-Occurs when a client is attempting to login. Here you can resolve the login request by username and password.
-
-`connection` [client class object](src/connection.js)  
-`username` string of username from `USER` command  
-`password` string of password from `PASS` command  
-`resolve` takes an object of arguments:  
- `fs`
-  - Set a custom file system class for this connection to use.
-  - See [File System](#file-system) for implementation details.
- `root`
-  - If `fs` is not provided, this will set the root directory for the connection.
-  - The user cannot traverse lower than this directory.
- `cwd`
-  - If `fs` is not provided, will set the starting directory for the connection
-  - This is relative to the `root` directory.
- `blacklist`
-  - Commands that are forbidden for only this connection
- `whitelist`
-  - If set, this connection will only be able to use the provided commands
-
-`reject` takes an error object
-
-### `client-error`
-```js
-ftpServer.on('client-error', ({connection, context, error}) => { ... });
-```
-
-Occurs when an error arises in the client connection.
-
-`connection` [client class object](src/connection.js)  
-`context` string of where the error occurred  
-`error` error object
-
-### `RETR`
-```js
-connection.on('RETR', (error, filePath) => { ... });
-```
-
-Occurs when a file is downloaded.
-
-`error` if successful, will be `null`  
-`filePath` location to which file was downloaded
-
-### `STOR`
-```js
-connection.on('STOR', (error, fileName) => { ... });
-```
-
-Occurs when a file is uploaded.
-
-`error` if successful, will be `null`  
-`fileName` name of the file that was uploaded
-
-### `RNTO`
-```js
-connection.on('RNTO', (error, fileName) => { ... });
-```
-
-Occurs when a file is renamed.
-
-`error` if successful, will be `null`  
-`fileName` name of the file that was renamed
-
-## Supported Commands
-
-See the [command registry](src/commands/registration) for a list of all implemented FTP commands.
-
-## File System
-The default [file system](src/fs.js) can be overwritten to use your own implementation.  
-This can allow for virtual file systems, and more.  
-Each connection can set it's own file system based on the user.  
-
-The default file system is exported and can be extended as needed:  
-```js
-const {FtpSrv, FileSystem} = require('ftp-srv');
-
-class MyFileSystem extends FileSystem {
-  constructor() {
-    super(...arguments);
-  }
-
-  get(fileName) {
-    ...
-  }
-}
-```
-
-Custom file systems can implement the following variables depending on the developers needs:
-
-### Methods
-#### [`currentDirectory()`](src/fs.js#L40)
-Returns a string of the current working directory  
-__Used in:__ `PWD`
-
-#### [`get(fileName)`](src/fs.js#L44)
-Returns a file stat object of file or directory  
-__Used in:__ `LIST`, `NLST`, `STAT`, `SIZE`, `RNFR`, `MDTM`
-
-#### [`list(path)`](src/fs.js#L50)
-Returns array of file and directory stat objects  
-__Used in:__ `LIST`, `NLST`, `STAT`
-
-#### [`chdir(path)`](src/fs.js#L67)
-Returns new directory relative to current directory  
-__Used in:__ `CWD`, `CDUP`
-
-#### [`mkdir(path)`](src/fs.js#L114)
-Returns a path to a newly created directory  
-__Used in:__ `MKD`
-
-#### [`write(fileName, {append, start})`](src/fs.js#L79)
-Returns a writable stream  
-Options:  
- `append` if true, append to existing file  
- `start` if set, specifies the byte offset to write to  
-__Used in:__ `STOR`, `APPE`
-
-#### [`read(fileName, {start})`](src/fs.js#L90)
-Returns a readable stream  
-Options:  
- `start` if set, specifies the byte offset to read from  
-__Used in:__ `RETR`
-
-#### [`delete(path)`](src/fs.js#L105)
-Delete a file or directory  
-__Used in:__ `DELE`
-
-#### [`rename(from, to)`](src/fs.js#L120)
-Renames a file or directory  
-__Used in:__ `RNFR`, `RNTO`
-
-#### [`chmod(path)`](src/fs.js#L126)
-Modifies a file or directory's permissions  
-__Used in:__ `SITE CHMOD`
-
-#### [`getUniqueName()`](src/fs.js#L131)
-Returns a unique file name to write to  
-__Used in:__ `STOU`
-
-## Contributing
-
-See [CONTRIBUTING.md](CONTRIBUTING.md).
-
-## Contributors
-
- [OzairP](https://github.com/OzairP)
- [TimLuq](https://github.com/TimLuq)
- [crabl](https://github.com/crabl)
- [hirviid](https://github.com/hirviid)
- [DiegoRBaquero](https://github.com/DiegoRBaquero)
- [edin-m](https://github.com/edin-m)
- [voxsoftware](https://github.com/voxsoftware)
- [jorinvo](https://github.com/jorinvo)
- [Johnnyrook777](https://github.com/Johnnyrook777)
- [qchar](https://github.com/qchar)
- [mikejestes](https://github.com/mikejestes)
- [pkeuter](https://github.com/pkeuter)
- [qiansc](https://github.com/qiansc)
- [broofa](https://github.com/broofa)
- [lafin](https://github.com/lafin)
- [alancnet](https://github.com/alancnet)
- [zgwit](https://github.com/zgwit)
-
-## License
-
-This software is licensed under the MIT Licence. See [LICENSE](LICENSE).
-
-## References
-
- [https://cr.yp.to/ftp.html](https://cr.yp.to/ftp.html)
--- a/old/bin/index.js
+++ b/old/bin/index.js
@@ -1,141 +0,0 @@
-#!/usr/bin/env node
-
-const yargs = require('yargs');
-const path = require('path');
-
-const FtpSrv = require('../src');
-const errors = require('../src/errors');
-
-const args = setupYargs();
-const state = setupState(args);
-startFtpServer(state);
-
-function setupYargs() {
-  return yargs
-    .option('credentials', {
-      alias: 'c',
-      describe: 'Load user & pass from json file',
-      normalize: true
-    })
-    .option('username', {
-      describe: 'Blank for anonymous',
-      type: 'string',
-      default: ''
-    })
-    .option('password', {
-      describe: 'Password for given username',
-      type: 'string'
-    })
-    .option('root', {
-      alias: 'r',
-      describe: 'Default root directory for users',
-      type: 'string',
-      normalize: true
-    })
-    .option('read-only', {
-      describe: 'Disable write actions such as upload, delete, etc',
-      boolean: true,
-      default: false
-    })
-    .option('pasv_url', {
-      describe: 'URL to provide for passive connections',
-      type: 'string'
-    })
-    .option('pasv_min', {
-      describe: 'Starting point to use when creating passive connections',
-      type: 'number',
-      default: 1024
-    })
-    .option('pasv_max', {
-      describe: 'Ending port to use when creating passive connections',
-      type: 'number',
-      default: 65535
-    })
-    .parse();
-}
-
-function setupState(_args) {
-  const _state = {};
-
-  function setupOptions() {
-    if (_args._ && _args._.length > 0) {
-      _state.url = _args._[0];
-    }
-    _state.pasv_url = _args.pasv_url;
-    _state.pasv_min = _args.pasv_min;
-    _state.pasv_max = _args.pasv_max;
-    _state.anonymous = _args.username === '';
-  }
-
-  function setupRoot() {
-    const dirPath = _args.root;
-    if (dirPath) {
-      _state.root = dirPath;
-    } else {
-      _state.root = process.cwd();
-    }
-  }
-
-  function setupCredentials() {
-    _state.credentials = {};
-
-    const setCredentials = (username, password, root = null) => {
-      _state.credentials[username] = {
-        password,
-        root
-      };
-    };
-
-    if (_args.credentials) {
-      const credentialsFile = path.resolve(_args.credentials);
-      const credentials = require(credentialsFile);
-
-      for (const cred of credentials) {
-        setCredentials(cred.username, cred.password, cred.root);
-      }
-    } else if (_args.username) {
-      setCredentials(_args.username, _args.password);
-    }
-  }
-
-  function setupCommandBlacklist() {
-    if (_args.readOnly) {
-      _state.blacklist = ['ALLO', 'APPE', 'DELE', 'MKD', 'RMD', 'RNRF', 'RNTO', 'STOR', 'STRU'];
-    }
-  }
-
-  setupOptions();
-  setupRoot();
-  setupCredentials();
-  setupCommandBlacklist();
-
-  return _state;
-}
-
-function startFtpServer(_state) {
-  // Remove null/undefined options so they get set to defaults, below
-  for (const key in _state) {
-    if (_state[key] === undefined) delete _state[key];
-  }
-
-  function checkLogin(data, resolve, reject) {
-    const user = _state.credentials[data.username];
-    if (_state.anonymous || user && user.password === data.password) {
-      return resolve({root: user && user.root || _state.root});
-    }
-
-    return reject(new errors.GeneralError('Invalid username or password', 401));
-  }
-
-  const ftpServer = new FtpSrv({
-    url: _state.url,
-    pasv_url: _state.pasv_url,
-    pasv_min: _state.pasv_min,
-    pasv_max: _state.pasv_max,
-    anonymous: _state.anonymous,
-    blacklist: _state.blacklist
-  });
-
-  ftpServer.on('login', checkLogin);
-  ftpServer.listen();
-}
--- a/old/changelog/v2_to_v3_migation.md
+++ b/old/changelog/v2_to_v3_migation.md
@@ -1,44 +0,0 @@
-# Migration Guide - v2 to v3
-
-The `FtpServer` constructor has been changed to only take one object option. Combining the two just made sense.
-
-### From:
-
-```js
-const server = new FtpServer('ftp://0.0.0.0:21');
-```
-
-### To:
-
-```js
-const server = new FtpServer({
-  url: 'ftp://0.0.0.0:21'
-});
-```
-
----
-
-The `pasv_range` option has been changed to separate integer variables: `pasv_min`, `pasv_max`.
-
-### From:
-
-```js
-const server = new FtpServer(..., {
-  pasv_range: '1000-2000'
-});
-```
-
-### To:
-
-```js
-const server = new FtpServer({
-  pasv_min: 1000,
-  pasv_max: 2000
-})
-```
-
----
-
-The default passive port range has been changed to `1024` - `65535`
-
----
--- a/old/ftp-srv.d.ts
+++ b/old/ftp-srv.d.ts
@@ -1,127 +0,0 @@
-import * as tls from 'tls'
-import { Stats } from 'fs'
-import { EventEmitter } from 'events';
-
-export class FileSystem {
-
-    readonly connection: FtpConnection;
-    readonly root: string;
-    readonly cwd: string;
-
-    constructor(connection: FtpConnection, {root, cwd}?: {
-        root: any;
-        cwd: any;
-    });
-
-    currentDirectory(): string;
-
-    get(fileName: string): Promise<any>;
-
-    list(path?: string): Promise<any>;
-
-    chdir(path?: string): Promise<string>;
-
-    write(fileName: string, {append, start}?: {
-        append?: boolean;
-        start?: any;
-    }): any;
-
-    read(fileName: string, {start}?: {
-        start?: any;
-    }): Promise<any>;
-
-    delete(path: string): Promise<any>;
-
-    mkdir(path: string): Promise<any>;
-
-    rename(from: string, to: string): Promise<any>;
-
-    chmod(path: string, mode: string): Promise<any>;
-
-    getUniqueName(): string;
-}
-
-export class FtpConnection extends EventEmitter {
-    server: FtpServer;
-    id: string;
-    log: any;
-    transferType: string;
-    encoding: string;
-    bufferSize: boolean;
-    readonly ip: string;
-    restByteCount: number | undefined;
-    secure: boolean
-
-    close (code: number, message: number): Promise<any>
-    login (username: string, password: string): Promise<any>
-    reply (options: number | Record<string, any>, ...letters: any[]): Promise<any>
-
-}
-
-export interface FtpServerOptions {
-    url?: string;
-    pasv_min?: number;
-    pasv_max?: number;
-    pasv_url?: string;
-    greeting?: string | string[];
-    tls?: tls.SecureContextOptions | false;
-    anonymous?: boolean;
-    blacklist?: string[];
-    whitelist?: string[];
-    file_format?: (stat: Stats) => string | Promise<string> | "ls" | "ep";
-    log?: any;
-    timeout?: number;
-}
-
-export class FtpServer extends EventEmitter {
-    constructor(options?: FtpServerOptions);
-
-    readonly isTLS: boolean;
-
-    listen(): any;
-
-    emitPromise(action: any, ...data: any[]): Promise<any>;
-
-    // emit is exported from super class
-
-    setupTLS(_tls: boolean): boolean | {
-        cert: string;
-        key: string;
-        ca: string;
-    };
-
-    setupGreeting(greet: string): string[];
-
-    setupFeaturesMessage(): string;
-
-    disconnectClient(id: string): Promise<any>;
-
-    close(): any;
-
-    on(event: "login", listener: (
-        data: {
-            connection: FtpConnection;
-            username: string;
-            password: string;
-        },
-        resolve: (config: {
-            fs?: FileSystem;
-            root?: string;
-            cwd?: string;
-            blacklist?: string[];
-            whitelist?: string[];
-        }) => void,
-        reject: (err?: Error) => void
-    ) => void): this;
-
-    on(event: "client-error", listener: (
-        data: {
-            connection: FtpConnection;
-            context: string;
-            error: Error;
-        }
-    ) => void): this;
-}
-
-export {FtpServer as FtpSrv};
-export default FtpServer;
--- a/old/meta/contributors/contributors.js
+++ b/old/meta/contributors/contributors.js
@@ -1,27 +0,0 @@
-const {get} = require('https');
-
-get('https://api.github.com/repos/trs/ftp-srv/contributors', {
-  headers: {
-    'User-Agent': 'Chrome'
-  }
-}, (res) => {
-  let response = '';
-  res.on('data', (data) => {
-    response += data;
-  });
-  res.on('end', () => {
-    const contributors = JSON.parse(response)
-      .filter((contributor) => contributor.type === 'User');
-
-    for (const contributor of contributors) {
-      const url = contributor.html_url;
-      const username = contributor.login;
-
-      const markdown = `- [${username}](${url})\n`;
-
-      process.stdout.write(markdown);
-    }
-  });
-}).on('error', (err) => {
-  process.stderr.write(err);
-});
--- a/old/package-lock.json
+++ b/old/package-lock.json
--- a/old/package.json
+++ b/old/package.json
@@ -1,91 +0,0 @@
-{
-  "name": "ftp-srv",
-  "version": "0.0.0",
-  "description": "Modern, extensible FTP Server",
-  "keywords": [
-    "ftp",
-    "ftp-server",
-    "ftp-srv",
-    "ftp-svr",
-    "ftpd",
-    "ftpserver",
-    "server"
-  ],
-  "license": "MIT",
-  "files": [
-    "src",
-    "bin",
-    "ftp-srv.d.ts"
-  ],
-  "main": "ftp-srv.js",
-  "bin": "./bin/index.js",
-  "types": "./ftp-srv.d.ts",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/trs/ftp-srv"
-  },
-  "scripts": {
-    "pre-release": "npm run verify",
-    "semantic-release": "semantic-release",
-    "test": "mocha **/*.spec.js --ui bdd --bail",
-    "verify": "eslint src/**/*.js test/**/*.js bin/**/*.js"
-  },
-  "release": {
-    "verifyConditions": "condition-circle"
-  },
-  "husky": {
-    "hooks": {
-      "pre-commit": "lint-staged",
-      "commit-msg": "commitlint -E HUSKY_GIT_PARAMS"
-    }
-  },
-  "lint-staged": {
-    "*.js": [
-      "eslint --fix",
-      "git add"
-    ]
-  },
-  "commitlint": {
-    "extends": [
-      "@commitlint/config-conventional"
-    ]
-  },
-  "eslintConfig": {
-    "extends": "eslint:recommended",
-    "env": {
-      "node": true,
-      "mocha": true,
-      "es6": true
-    },
-    "parserOptions": {
-      "ecmaVersion": 6,
-      "sourceType": "module"
-    }
-  },
-  "dependencies": {
-    "bluebird": "^3.5.1",
-    "bunyan": "^1.8.12",
-    "ip": "^1.1.5",
-    "lodash": "^4.17.10",
-    "moment": "^2.22.1",
-    "uuid": "^3.2.1",
-    "yargs": "^11.0.0"
-  },
-  "devDependencies": {
-    "@commitlint/cli": "^7.5.2",
-    "@commitlint/config-conventional": "^7.5.0",
-    "@icetee/ftp": "^1.0.2",
-    "chai": "^4.2.0",
-    "condition-circle": "^2.0.2",
-    "eslint": "^5.14.1",
-    "husky": "^1.3.1",
-    "lint-staged": "^8.1.4",
-    "mocha": "^5.2.0",
-    "rimraf": "^2.6.1",
-    "semantic-release": "^15.10.6",
-    "sinon": "^2.3.5"
-  },
-  "engines": {
-    "node": ">=6.x"
-  }
-}
--- a/old/src/connector/passive.js
+++ b/old/src/connector/passive.js
@@ -1,86 +0,0 @@
-const net = require('net');
-const tls = require('tls');
-const ip = require('ip');
-const Promise = require('bluebird');
-
-const Connector = require('./base');
-const errors = require('../errors');
-
-class Passive extends Connector {
-  constructor(connection) {
-    super(connection);
-    this.type = 'passive';
-  }
-
-  waitForConnection({timeout = 5000, delay = 50} = {}) {
-    if (!this.dataServer) return Promise.reject(new errors.ConnectorError('Passive server not setup'));
-
-    const checkSocket = () => {
-      if (this.dataServer && this.dataServer.listening && this.dataSocket && this.dataSocket.connected) {
-        return Promise.resolve(this.dataSocket);
-      }
-      return Promise.resolve().delay(delay)
-      .then(() => checkSocket());
-    };
-
-    return checkSocket().timeout(timeout);
-  }
-
-  setupServer() {
-    this.closeServer();
-    return this.server.getNextPasvPort()
-    .then((port) => {
-      const connectionHandler = (socket) => {
-        if (!ip.isEqual(this.connection.commandSocket.remoteAddress, socket.remoteAddress)) {
-          this.log.error({
-            pasv_connection: socket.remoteAddress,
-            cmd_connection: this.connection.commandSocket.remoteAddress
-          }, 'Connecting addresses do not match');
-
-          socket.destroy();
-          return this.connection.reply(550, 'Remote addresses do not match')
-          .finally(() => this.connection.close());
-        }
-        this.log.trace({port, remoteAddress: socket.remoteAddress}, 'Passive connection fulfilled.');
-
-        this.dataSocket = socket;
-        this.dataSocket.setEncoding(this.connection.transferType);
-        this.dataSocket.on('error', (err) => this.server && this.server.emit('client-error', {connection: this.connection, context: 'dataSocket', error: err}));
-
-        if (!this.connection.secure) {
-          this.dataSocket.connected = true;
-        }
-      };
-
-      this.dataSocket = null;
-
-      const serverOptions = Object.assign({}, this.connection.secure ? this.server.options.tls : {}, {pauseOnConnect: true});
-      this.dataServer = (this.connection.secure ? tls : net).createServer(serverOptions, connectionHandler);
-      this.dataServer.maxConnections = 1;
-
-      this.dataServer.on('error', (err) => this.server && this.server.emit('client-error', {connection: this.connection, context: 'dataServer', error: err}));
-      this.dataServer.once('close', () => {
-        this.log.trace('Passive server closed');
-        this.end();
-      });
-
-      if (this.connection.secure) {
-        this.dataServer.on('secureConnection', (socket) => {
-          socket.connected = true;
-        });
-      }
-
-      return new Promise((resolve, reject) => {
-        this.dataServer.listen(port, this.server.url.hostname, (err) => {
-          if (err) reject(err);
-          else {
-            this.log.debug({port}, 'Passive connection listening');
-            resolve(this.dataServer);
-          }
-        });
-      });
-    });
-  }
-
-}
-module.exports = Passive;
--- a/old/src/helpers/find-port.js
+++ b/old/src/helpers/find-port.js
@@ -1,59 +0,0 @@
-const net = require('net');
-const errors = require('../errors');
-
-const MAX_PORT = 65535;
-const MAX_PORT_CHECK_ATTEMPT = 5;
-
-function* portNumberGenerator(min, max = MAX_PORT) {
-  let current = min;
-  while (true) {
-    if (current > MAX_PORT || current > max) {
-      current = min;
-    }
-    yield current++;
-  }
-}
-
-function getNextPortFactory(host, portMin, portMax, maxAttempts = MAX_PORT_CHECK_ATTEMPT) {
-  const nextPortNumber = portNumberGenerator(portMin, portMax);
-  const portCheckServer = net.createServer();
-  portCheckServer.maxConnections = 0;
-
-  return () => new Promise((resolve, reject) => {
-    let attemptCount = 0;
-    const tryGetPort = () => {
-      attemptCount++;
-      if (attemptCount > maxAttempts) {
-        reject(new errors.ConnectorError('Unable to find valid port'));
-        return;
-      }
-
-      const {value: port} = nextPortNumber.next();
-
-      portCheckServer.removeAllListeners();
-      portCheckServer.once('error', (err) => {
-        if (['EADDRINUSE'].includes(err.code)) {
-          tryGetPort();
-        } else {
-          reject(err);
-        }
-      });
-      portCheckServer.once('listening', () => {
-        portCheckServer.close(() => resolve(port));
-      });
-
-      try {
-        portCheckServer.listen(port, host);
-      } catch (err) {
-        reject(err);
-      }
-    };
-
-    tryGetPort();
-  });
-}
-
-module.exports = {
-  getNextPortFactory,
-  portNumberGenerator
-};
--- a/old/src/messages.js
+++ b/old/src/messages.js
@@ -1,56 +0,0 @@
-module.exports = {
-
-| 100
-| 110
-| 120
-| 125
-| 150
-
-
-
-| 200
-| 202
-| 211
-| 212
-| 213
-| 214
-| 215
-| 220
-| 221
-| 225
-| 226
-| 227
-| 230
-| 234
-| 250
-| 257
-
-
-| 331
-| 332
-| 350
-
-
-
-
-| 421
-| 425
-| 426
-| 450
-| 451
-| 452
-
-
-
-| 500
-| 501
-| 502
-| 503
-| 504
-| 530
-| 532
-| 550
-| 551
-| 552
-| 553
-};
--- a/old/test/connector/passive.spec.js
+++ b/old/test/connector/passive.spec.js
@@ -1,156 +0,0 @@
-/* eslint no-unused-expressions: 0 */
-const {expect} = require('chai');
-const sinon = require('sinon');
-
-const Promise = require('bluebird');
-const net = require('net');
-const bunyan = require('bunyan');
-
-const PassiveConnector = require('../../src/connector/passive');
-const {getNextPortFactory} = require('../../src/helpers/find-port');
-
-describe('Connector - Passive //', function () {
-  const host = '127.0.0.1';
-  let mockConnection = {
-    reply: () => Promise.resolve({}),
-    close: () => Promise.resolve({}),
-    encoding: 'utf8',
-    log: bunyan.createLogger({name: 'passive-test'}),
-    commandSocket: {
-      remoteAddress: '::ffff:127.0.0.1'
-    },
-    server: {
-      url: '',
-      getNextPasvPort: getNextPortFactory(host, 1024)
-    }
-  };
-  let sandbox;
-
-  before(() => {
-    sandbox = sinon.sandbox.create().usingPromise(Promise);
-  });
-
-  beforeEach(() => {
-    sandbox.spy(mockConnection, 'reply');
-    sandbox.spy(mockConnection, 'close');
-  });
-  afterEach(() => {
-    sandbox.restore();
-  });
-
-  it('cannot wait for connection with no server', function (done) {
-    let passive = new PassiveConnector(mockConnection);
-    passive.waitForConnection()
-    .catch((err) => {
-      expect(err.name).to.equal('ConnectorError');
-      done();
-    });
-  });
-
-  describe('setup', function () {
-    before(function () {
-      sandbox.stub(mockConnection.server, 'getNextPasvPort').value(getNextPortFactory(host));
-    });
-
-    it('no pasv range provided', function (done) {
-      let passive = new PassiveConnector(mockConnection);
-      passive.setupServer()
-      .catch((err) => {
-        try {
-          expect(err.name).to.contain('RangeError');
-          done();
-        } catch (ex) {
-          done(ex);
-        }
-      });
-    });
-  });
-
-  describe('setup', function () {
-    let connection;
-    before(function () {
-      sandbox.stub(mockConnection.server, 'getNextPasvPort').value(getNextPortFactory(host, -1, -1));
-
-      connection = new PassiveConnector(mockConnection);
-    });
-
-    it('has invalid pasv range', function (done) {
-      connection.setupServer()
-      .catch((err) => {
-        expect(err.name).to.contain('RangeError');
-        done();
-      });
-    });
-  });
-
-  it('sets up a server', function () {
-    let passive = new PassiveConnector(mockConnection);
-    return passive.setupServer()
-    .then(() => {
-      expect(passive.dataServer).to.exist;
-      return passive.end();
-    });
-  });
-
-  describe('setup', function () {
-    let passive;
-    let closeFnSpy;
-    beforeEach(function () {
-      passive = new PassiveConnector(mockConnection);
-      return passive.setupServer()
-      .then(() => {
-        closeFnSpy = sandbox.spy(passive.dataServer, 'close');
-      });
-    });
-    afterEach(function () {
-      return passive.end();
-    });
-
-    it('destroys existing server, then sets up a server', function () {
-      return passive.setupServer()
-      .then(() => {
-        expect(closeFnSpy.callCount).to.equal(1);
-        expect(passive.dataServer).to.exist;
-      });
-    });
-  });
-
-  it('refuses connection with different remote address', function (done) {
-    sandbox.stub(mockConnection.commandSocket, 'remoteAddress').value('bad');
-
-    let passive = new PassiveConnector(mockConnection);
-    passive.setupServer()
-    .then(() => {
-      expect(passive.dataServer).to.exist;
-
-      const {port} = passive.dataServer.address();
-      net.createConnection(port);
-      passive.dataServer.once('connection', () => {
-        setTimeout(() => {
-          expect(passive.connection.reply.callCount).to.equal(1);
-          expect(passive.connection.reply.args[0][0]).to.equal(550);
-
-          passive.end();
-          done();
-        }, 100);
-      });
-    })
-    .catch(done);
-  });
-
-  it('accepts connection', function () {
-    let passive = new PassiveConnector(mockConnection);
-    return passive.setupServer()
-    .then(() => {
-      expect(passive.dataServer).to.exist;
-
-      const {port} = passive.dataServer.address();
-      net.createConnection(port);
-      return passive.waitForConnection();
-    })
-    .then(() => {
-      expect(passive.dataSocket).to.exist;
-      passive.end();
-    });
-  });
-});
--- a/old/test/fs.spec.js
+++ b/old/test/fs.spec.js
@@ -1,83 +0,0 @@
-const {expect} = require('chai');
-const nodePath = require('path');
-const Promise = require('bluebird');
-
-const FileSystem = require('../src/fs');
-const errors = require('../src/errors');
-
-describe('FileSystem', function () {
-  let fs;
-
-  before(function () {
-    fs = new FileSystem({}, {
-      root: '/tmp/ftp-srv',
-      cwd: 'file/1/2/3'
-    });
-  });
-
-  describe('extend', function () {
-    class FileSystemOV extends FileSystem {
-      chdir() {
-        throw new errors.FileSystemError('Not a valid directory');
-      }
-    }
-    let ovFs;
-    before(function () {
-      ovFs = new FileSystemOV({});
-    });
-
-    it('handles error', function () {
-      return Promise.try(() => ovFs.chdir())
-      .catch((err) => {
-        expect(err).to.be.instanceof(errors.FileSystemError);
-      });
-    });
-  });
-
-  describe('#_resolvePath', function () {
-    it('gets correct relative path', function () {
-      const result = fs._resolvePath();
-      expect(result).to.be.an('object');
-      expect(result.clientPath).to.equal(
-        nodePath.normalize('/file/1/2/3'));
-      expect(result.fsPath).to.equal(
-        nodePath.resolve('/tmp/ftp-srv/file/1/2/3'));
-    });
-
-    it('gets correct relative path', function () {
-      const result = fs._resolvePath('..');
-      expect(result).to.be.an('object');
-      expect(result.clientPath).to.equal(
-        nodePath.normalize('/file/1/2'));
-      expect(result.fsPath).to.equal(
-        nodePath.resolve('/tmp/ftp-srv/file/1/2'));
-    });
-
-    it('gets correct absolute path', function () {
-      const result = fs._resolvePath('/other');
-      expect(result).to.be.an('object');
-      expect(result.clientPath).to.equal(
-        nodePath.normalize('/other'));
-      expect(result.fsPath).to.equal(
-        nodePath.resolve('/tmp/ftp-srv/other'));
-    });
-
-    it('cannot escape root', function () {
-      const result = fs._resolvePath('../../../../../../../../../../..');
-      expect(result).to.be.an('object');
-      expect(result.clientPath).to.equal(
-        nodePath.normalize('/'));
-      expect(result.fsPath).to.equal(
-        nodePath.resolve('/tmp/ftp-srv'));
-    });
-
-    it('resolves to file', function () {
-      const result = fs._resolvePath('/cool/file.txt');
-      expect(result).to.be.an('object');
-      expect(result.clientPath).to.equal(
-        nodePath.normalize('/cool/file.txt'));
-      expect(result.fsPath).to.equal(
-        nodePath.resolve('/tmp/ftp-srv/cool/file.txt'));
-    });
-  });
-});
--- a/old/test/helpers/find-port.spec.js
+++ b/old/test/helpers/find-port.spec.js
@@ -1,29 +0,0 @@
-/* eslint no-unused-expressions: 0 */
-const {expect} = require('chai');
-const net = require('net');
-
-const {getNextPortFactory} = require('../../src/helpers/find-port');
-
-describe('helpers // find-port', function () {
-  describe('keeps trying new ports', () => {
-    let getNextPort;
-    let serverAlreadyRunning;
-    beforeEach((done) => {
-      getNextPort = getNextPortFactory('::', 8821);
-
-      serverAlreadyRunning = net.createServer();
-      serverAlreadyRunning.listen(8821, () => done());
-    });
-
-    afterEach((done) => {
-      serverAlreadyRunning.close(() => done());
-    });
-
-    it('test', () => {
-      return getNextPort()
-      .then((port) => {
-        expect(port).to.equal(8822);
-      });
-    });
-  });
-});
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -1,57 +1,7 @@
 {
  "name": "ftp-srv",
-  "version": "5.0.0",
+  "version": "0.0.0-development",
  "description": "Modern, extensible FTP Server",
-  "main": "build/index",
-  "scripts": {
-    "lint": "eslint src/**/*.ts",
-    "lint:fix": "npm run lint -- --fix"
-  },
-  "jest": {
-    "testEnvironment": "node",
-    "moduleFileExtensions": [
-      "ts",
-      "js",
-      "json"
-    ],
-    "transform": {
-      ".ts": "ts-jest"
-    },
-    "testRegex": "\\.test\\.ts",
-    "globals": {
-      "ts-jest": {
-        "tsConfig": "tsconfig.json"
-      }
-    }
-  },
-  "eslintConfig": {
-    "parser": "@typescript-eslint/parser",
-    "parserOptions": {
-      "project": "tsconfig.json"
-    },
-    "plugins": [
-      "@typescript-eslint",
-      "prettier"
-    ],
-    "extends": "plugin:@typescript-eslint/recommended"
-  },
-  "husky": {
-    "hooks": {
-      "pre-commit": "lint-staged",
-      "commit-msg": "commitlint -E HUSKY_GIT_PARAMS"
-    }
-  },
-  "lint-staged": {
-    "*.ts": [
-      "eslint --fix",
-      "git add"
-    ]
-  },
-  "commitlint": {
-    "extends": [
-      "@commitlint/config-conventional"
-    ]
-  },
  "keywords": [
    "ftp",
    "ftp-server",
@@ -61,32 +11,85 @@
    "ftpserver",
    "server"
  ],
-  "author": "Tyler Stewart",
  "license": "MIT",
+  "files": [
+    "src",
+    "ftp-srv.d.ts"
+  ],
+  "main": "ftp-srv.js",
+  "types": "./ftp-srv.d.ts",
  "repository": {
    "type": "git",
-    "url": "git+https://github.com/trs/ftp-srv.git"
+    "url": "https://github.com/trs/ftp-srv"
  },
-  "bugs": {
-    "url": "https://github.com/trs/ftp-srv/issues"
+  "scripts": {
+    "pre-release": "npm-run-all verify test:coverage build ",
+    "build": "cross-env NODE_ENV=production npm run clean:prod",
+    "clean:prod": "rimraf dist/",
+    "commitmsg": "cz-customizable-ghooks",
+    "dev": "cross-env NODE_ENV=development npm run verify:watch",
+    "prepush": "npm-run-all verify test:coverage --silent",
+    "semantic-release": "semantic-release",
+    "start": "npm run dev",
+    "test": "npm run test:unit",
+    "test:check-coverage": "nyc check-coverage",
+    "test:coverage": "npm-run-all test:unit:once test:check-coverage --silent",
+    "test:unit": "cross-env NODE_ENV=test nyc mocha --opts config/testUnit/mocha.opts -w",
+    "test:unit:once": "cross-env NODE_ENV=test nyc mocha --opts config/testUnit/mocha.opts",
+    "upload-coverage": "cat reports/coverage/lcov.info | coveralls",
+    "verify": "npm run verify:js --silent",
+    "verify:js": "eslint -c config/verify/.eslintrc \"src/**/*.js\" \"test/**/*.js\" \"config/**/*.js\" && echo ✅ verify:js success",
+    "verify:js:fix": "eslint --fix -c config/verify/.eslintrc \"src/**/*.js\" \"test/**/*.js\" \"config/**/*.js\" && echo ✅ verify:js:fix success",
+    "verify:js:watch": "chokidar 'src/**/*.js' 'test/**/*.js' 'config/**/*.js' -c 'npm run verify:js:fix' --initial --silent",
+    "verify:watch": "npm run verify:js:watch --silent"
+  },
+  "config": {
+    "commitizen": {
+      "path": "node_modules/cz-customizable"
+    },
+    "cz-customizable": {
+      "config": "config/release/commitMessageConfig.js"
+    }
+  },
+  "dependencies": {
+    "bluebird": "^3.5.1",
+    "bunyan": "^1.8.12",
+    "lodash": "^4.17.4",
+    "moment": "^2.19.1",
+    "uuid": "^3.1.0"
  },
-  "homepage": "https://github.com/trs/ftp-srv#readme",
  "devDependencies": {
-    "@commitlint/cli": "^7.5.2",
-    "@commitlint/config-conventional": "^7.5.0",
-    "@types/jest": "^24.0.10",
-    "@types/node": "^11.10.5",
-    "@types/signale": "^1.2.1",
-    "@typescript-eslint/eslint-plugin": "^1.4.2",
-    "@typescript-eslint/parser": "^1.4.2",
-    "eslint": "^5.15.1",
-    "eslint-plugin-prettier": "^3.0.1",
-    "husky": "^1.3.1",
-    "jest": "^24.3.1",
-    "lerna": "^3.13.1",
-    "lint-staged": "^8.1.5",
-    "prettier": "1.16.4",
-    "ts-jest": "^24.0.0",
-    "typescript": "^3.3.3333"
+    "@icetee/ftp": "^0.3.15",
+    "chai": "^4.0.2",
+    "chokidar-cli": "1.2.0",
+    "condition-circle": "^1.6.0",
+    "coveralls": "2.13.1",
+    "cross-env": "3.1.4",
+    "cz-customizable": "5.2.0",
+    "cz-customizable-ghooks": "1.5.0",
+    "dotenv": "^4.0.0",
+    "eslint": "4.5.0",
+    "eslint-config-google": "0.8.0",
+    "eslint-friendly-formatter": "3.0.0",
+    "eslint-plugin-mocha": "^4.11.0",
+    "eslint-plugin-node": "5.1.1",
+    "husky": "0.13.3",
+    "istanbul": "0.4.5",
+    "mocha": "3.5.0",
+    "mocha-junit-reporter": "1.13.0",
+    "mocha-multi-reporters": "1.1.5",
+    "mocha-pretty-bunyan-nyan": "^1.0.4",
+    "npm-run-all": "4.0.2",
+    "nyc": "11.1.0",
+    "rimraf": "2.6.1",
+    "semantic-release": "^11.0.2",
+    "sinon": "^2.3.5"
+  },
+  "engines": {
+    "node": ">=6.x",
+    "npm": ">=3.9.5"
+  },
+  "release": {
+    "verifyConditions": "condition-circle"
  }
 }
--- a/src/command/authentication.ts
+++ b/src/command/authentication.ts
@@ -1,65 +0,0 @@
-import { CommandRegistration } from ".";
-
-const user: CommandRegistration = {
-    arguments: ['username'],
-    description: 'Set the username to authenticate with',
-    handler: async function ({connection, command, reply}) {
-        if (connection.hasContext('username')) {
-            /*
-        RFC 959
-        4.1.1.
-        Servers may allow a new USER command to be
-        entered at any point in order to change the access control
-        and/or accounting information.  This has the effect of
-        flushing any user, password, and account information already
-        supplied and beginning the login sequence again.  All
-        transfer parameters are unchanged and any file transfer in
-        progress is completed under the old access control
-        parameters.
-      */
-            connection.unsetContext('username', 'password');
-        }
-
-        connection.setContext('username', command.argument);
-
-        reply.set([331]);
-    }
-};
-
-const pass: CommandRegistration = {
-    arguments: ['password'],
-    description: 'Set the password to authenticate with',
-    handler: async function ({connection, command, reply}) {
-        if (connection.hasContext('password')) {
-            reply.set([202]);
-            return;
-        }
-
-        if (!connection.hasContext('username')) {
-            reply.set([503]);
-            return;
-        }
-
-        connection.setContext('password', command.argument);
-        reply.set([230]);
-    }
-};
-
-const acct: CommandRegistration = {
-    arguments: ['account-information'],
-    description: 'Set the identifying account',
-    handler: async function ({connection, command, reply}) {
-        if (!connection.hasContext('username', 'password')) {
-            reply.set([503]);
-        }
-
-        connection.setContext('account', command.argument);
-        reply.set([230]);
-    }
-};
-
-export {
-    user,
-    pass,
-    acct
-};
--- a/src/command/directory.ts
+++ b/src/command/directory.ts
@@ -1,18 +0,0 @@
-import { CommandRegistration } from ".";
-import { CommandPlugin } from '../server';
-
-const cwd: CommandRegistration = {
-    description: '',
-    handler: async ({command, reply}) => {
-
-    }
-};
-
-const cdup: CommandRegistration = {
-    description: '',
-    handler: async ({command, reply}) => {
-
-    }
-};
-
-export {cwd, cdup};
--- a/src/command/index.ts
+++ b/src/command/index.ts
@@ -1,42 +0,0 @@
-import CommandSocket from "../commandSocket";
-import FTPServer from "../server";
-import { ReplyCode } from "../reply";
-
-export interface Command {
-    identifier: string;
-    argument: string;
-    argumentParts: string[];
-}
-
-export type CommandReply = [ReplyCode, ...string[]];
-
-export interface CommandReplyMod {
-    get: () => CommandReply;
-    set: (v: CommandReply) => void;
-}
-export type CommandHandler = (params: {server: Readonly<FTPServer>; connection: Readonly<CommandSocket>; command: Command; reply: CommandReplyMod}) => Promise<void>;
-
-export interface CommandRegistration {
-    arguments?: string[];
-    description: string;
-    handler: CommandHandler;
-}
-
-export function parseCommandBuffer(data: Buffer): Command {
-    const result = data
-        .toString('utf8')
-        .replace(/\s+/g, ' ')
-        .match(/^(\w+?)(?: (.+)$|$)/);
-
-    if (!result) throw new Error('Invalid command');
-
-    const identifier = result[1].toLocaleUpperCase();
-    const argument = result.length > 1 ? result[2].trim() : '';
-    const argumentParts = argument.split(' ');
-
-    return {
-        identifier,
-        argument,
-        argumentParts
-    };
-}
--- a/src/command/security.ts
+++ b/src/command/security.ts
@@ -1,131 +0,0 @@
-/**
- * https://tools.ietf.org/html/rfc2228
- * https://tools.ietf.org/html/rfc4217
- */
-
-import { CommandRegistration } from ".";
-
-/*
-  AUTHENTICATION/SECURITY MECHANISM (AUTH)
-
-  The argument field is a Telnet string identifying a supported
-  mechanism.  This string is case-insensitive.  Values must be
-  registered with the IANA, except that values beginning with "X-"
-  are reserved for local use.
-
-  If the server does not recognize the AUTH command, it must respond
-  with reply code 500.  This is intended to encompass the large
-  deployed base of non-security-aware ftp servers, which will
-  respond with reply code 500 to any unrecognized command.  If the
-  server does recognize the AUTH command but does not implement the
-  security extensions, it should respond with reply code 502.
-
-  If the server does not understand the named security mechanism, it
-  should respond with reply code 504.
-
-  If the server is not willing to accept the named security
-  mechanism, it should respond with reply code 534.
-
-  If the server is not able to accept the named security mechanism,
-  such as if a required resource is unavailable, it should respond
-  with reply code 431.
-
-  If the server is willing to accept the named security mechanism,
-  but requires security data, it must respond with reply code 334.
-
-  If the server is willing to accept the named security mechanism,
-  and does not require any security data, it must respond with reply
-  code 234.
-
-  If the server is responding with a 334 reply code, it may include
-  security data as described in the next section.
-
-  Some servers will allow the AUTH command to be reissued in order
-  to establish new authentication.  The AUTH command, if accepted,
-  removes any state associated with prior FTP Security commands.
-  The server must also require that the user reauthorize (that is,
-  reissue some or all of the USER, PASS, and ACCT commands) in this
-  case (see section 4 for an explanation of "authorize" in this
-  context).
-
-  AUTH
-    234
-    334
-    502, 504, 534, 431
-    500, 501, 421
-*/
-const auth: CommandRegistration = {
-    arguments: ['<mechanism-name>'],
-    description: 'Set authentication mechanism',
-    handler: async ({command, reply}) => {
-        const method = command.argument.toLocaleUpperCase();
-
-
-
-        switch (method) {
-            default: reply.set([504]);
-        }
-    }
-}
-
-/*
-  PROTECTION BUFFER SIZE (PBSZ)
-
-  The argument is a decimal integer representing the maximum size,
-  in bytes, of the encoded data blocks to be sent or received during
-  file transfer.  This number shall be no greater than can be
-  represented in a 32-bit unsigned integer.
-
-  This command allows the FTP client and server to negotiate a
-  maximum protected buffer size for the connection.  There is no
-  default size; the client must issue a PBSZ command before it can
-  issue the first PROT command.
-
-  The PBSZ command must be preceded by a successful security data
-  exchange.
-
-  If the server cannot parse the argument, or if it will not fit in
-  32 bits, it should respond with a 501 reply code.
-
-  If the server has not completed a security data exchange with the
-  client, it should respond with a 503 reply code.
-
-  Otherwise, the server must reply with a 200 reply code.  If the
-  size provided by the client is too large for the server, it must
-  use a string of the form "PBSZ=number" in the text part of the
-  reply to indicate a smaller buffer size.  The client and the
-  server must use the smaller of the two buffer sizes if both buffer
-  sizes are specified.
-
-  PBSZ
-    200
-    503
-    500, 501, 421, 530
-*/
-const pbsz: CommandRegistration = {
-    arguments: ['<decimal-integer>'],
-    description: 'The maximum size, in bytes, of the encoded data blocks to be sent or received during file transfer.',
-    handler: async ({reply}) => {
-        reply.set([500]);
-    }
-}
-
-/*
-  PROT
-    200
-    504, 536, 503, 534, 431
-    500, 501, 421, 530
-*/
-const prot: CommandRegistration = {
-    arguments: ['<prot-code ::= C | S | E | P>'],
-    description: 'Indicates to the server what type of data channel protection the client and server will be using',
-    handler: async ({reply}) => {
-        reply.set([536]);
-    }
-}
-
-export {
-    auth,
-    pbsz,
-    prot
-};
--- a/src/command/stru.ts
+++ b/src/command/stru.ts
@@ -1,11 +0,0 @@
-import { CommandRegistration } from ".";
-
-const stru: CommandRegistration = {
-    arguments: ['<structure>'],
-    description: 'Set file transfer structure (Only "F" supported)',
-    handler: async ({command, reply}) => {
-        const code = /^F$/i.test(command.argument) ? 200 : 504;
-        reply.set([code]);
-    }
-}
-export {stru};
--- a/src/commandSocket.ts
+++ b/src/commandSocket.ts
@@ -1,76 +0,0 @@
-import { Socket } from "net";
-import { ReplyCode, formatReply } from "./reply";
-import { FileSystem } from "./filesystem";
-
-interface Meta {
-    connectedTime: string;
-    disconnectedTime?: string;
-    address?: string;
-}
-
-interface Context {
-    username?: string;
-    password?: string;
-    account?: string;
-}
-
-export default class CommandSocket {
-    private instance: Socket;
-    private meta: Meta;
-    private context: Context = {};
-    private filesystem: FileSystem;
-
-    constructor(socket: Socket) {
-        this.instance = socket.setEncoding('utf8');
-        this.meta = {
-            address: this.instance.remoteAddress,
-            connectedTime: new Date().toUTCString()
-        };
-        this.filesystem = new FileSystem();
-    };
-
-    public async sendReply(code: ReplyCode, ...lines: string[]) {
-        const reply = formatReply(code, ...lines);
-        await new Promise((resolve, reject) => {
-            this.instance.write(Buffer.from(reply), 'utf8', (err: Error) => {
-                if (err) {
-                    reject(err);
-                    return;
-                }
-                resolve();
-            });
-        });
-    }
-
-    public async close() {
-
-    }
-
-    public hasContext<K extends keyof Context>(...names: K[]): boolean {
-        for (const name of names) {
-            if (!this.context.hasOwnProperty(name)) return false;
-        }
-        return true;
-    }
-
-    public getContext<K extends keyof Context>(name: K): Context[K] {
-        return this.context[name];
-    }
-
-    public setContext<K extends keyof Context>(name: K, value: Context[K]): this {
-        this.context[name] = value;
-        return this;
-    }
-
-    public unsetContext<K extends keyof Context>(...names: K[]): this {
-        for (const name of names) {
-            delete this.context[name];
-        }
-        return this;
-    }
-
-    public unsetAllContext() {
-        this.context = {};
-        return this;
-    }
-}
--- a/old/src/commands/index.js
+++ b/old/src/commands/index.js
@@ -3,30 +3,25 @@ const Promise = require('bluebird');

 const REGISTRY = require('./registry');

-const CMD_FLAG_REGEX = new RegExp(/^-(\w{1})$/);
-
 class FtpCommands {
  constructor(connection) {
    this.connection = connection;
    this.previousCommand = {};
-    this.blacklist = _.get(this.connection, 'server.options.blacklist', []).map((cmd) => _.upperCase(cmd));
-    this.whitelist = _.get(this.connection, 'server.options.whitelist', []).map((cmd) => _.upperCase(cmd));
+    this.blacklist = _.get(this.connection, 'server.options.blacklist', []).map(cmd => _.upperCase(cmd));
+    this.whitelist = _.get(this.connection, 'server.options.whitelist', []).map(cmd => _.upperCase(cmd));
  }

  parse(message) {
    const strippedMessage = message.replace(/"/g, '');
-    let [directive, ...args] = strippedMessage.split(' ');
-    directive = _.chain(directive).trim().toUpper().value();
-
-    const parseCommandFlags = !['RETR', 'SIZE', 'STOR'].includes(directive);
+    const [directive, ...args] = strippedMessage.split(' ');
    const params = args.reduce(({arg, flags}, param) => {
-      if (parseCommandFlags && CMD_FLAG_REGEX.test(param)) flags.push(param);
+      if (/^-{1,2}[a-zA-Z0-9_]+/.test(param)) flags.push(param);
      else arg.push(param);
      return {arg, flags};
    }, {arg: [], flags: []});

    const command = {
-      directive,
+      directive: _.chain(directive).trim().toUpper().value(),
      arg: params.arg.length ? params.arg.join(' ') : null,
      flags: params.flags,
      raw: message
--- a/old/src/commands/registration/abor.js
+++ b/old/src/commands/registration/abor.js
@@ -2,12 +2,12 @@ module.exports = {
  directive: 'ABOR',
  handler: function () {
    return this.connector.waitForConnection()
-    .then((socket) => {
+    .then(socket => {
      return this.reply(426, {socket})
+      .then(() => this.connector.end())
      .then(() => this.reply(226));
    })
-    .catch(() => this.reply(225))
-    .finally(() => this.connector.end());
+    .catch(() => this.reply(225));
  },
  syntax: '{{cmd}}',
  description: 'Abort an active file transfer'
--- a/old/src/commands/registration/allo.js
+++ b/old/src/commands/registration/allo.js
--- a/old/src/commands/registration/appe.js
+++ b/old/src/commands/registration/appe.js
--- a/old/src/commands/registration/auth.js
+++ b/old/src/commands/registration/auth.js
@@ -20,17 +20,17 @@ module.exports = {
 };

 function handleTLS() {
-  if (!this.server.options.tls) return this.reply(502);
+  if (!this.server._tls) return this.reply(502);
  if (this.secure) return this.reply(202);

  return this.reply(234)
  .then(() => {
-    const secureContext = tls.createSecureContext(this.server.options.tls);
+    const secureContext = tls.createSecureContext(this.server._tls);
    const secureSocket = new tls.TLSSocket(this.commandSocket, {
      isServer: true,
      secureContext
    });
-    ['data', 'timeout', 'end', 'close', 'drain', 'error'].forEach((event) => {
+    ['data', 'timeout', 'end', 'close', 'drain', 'error'].forEach(event => {
      function forwardEvent() {
        this.emit.apply(this, arguments);
      }
--- a/old/src/commands/registration/cdup.js
+++ b/old/src/commands/registration/cdup.js
--- a/old/src/commands/registration/cwd.js
+++ b/old/src/commands/registration/cwd.js
@@ -7,12 +7,12 @@ module.exports = {
    if (!this.fs) return this.reply(550, 'File system not instantiated');
    if (!this.fs.chdir) return this.reply(402, 'Not supported by file system');

-    return Promise.try(() => this.fs.chdir(command.arg))
-    .then((cwd) => {
+    return Promise.resolve(this.fs.chdir(command.arg))
+    .then(cwd => {
      const path = cwd ? `"${escapePath(cwd)}"` : undefined;
      return this.reply(250, path);
    })
-    .catch((err) => {
+    .catch(err => {
      log.error(err);
      return this.reply(550, err.message);
    });
--- a/old/src/commands/registration/dele.js
+++ b/old/src/commands/registration/dele.js
@@ -6,11 +6,11 @@ module.exports = {
    if (!this.fs) return this.reply(550, 'File system not instantiated');
    if (!this.fs.delete) return this.reply(402, 'Not supported by file system');

-    return Promise.try(() => this.fs.delete(command.arg))
+    return Promise.resolve(this.fs.delete(command.arg))
    .then(() => {
      return this.reply(250);
    })
-    .catch((err) => {
+    .catch(err => {
      log.error(err);
      return this.reply(550, err.message);
    });
--- a/old/src/commands/registration/eprt.js
+++ b/old/src/commands/registration/eprt.js
--- a/old/src/commands/registration/epsv.js
+++ b/old/src/commands/registration/epsv.js
@@ -5,7 +5,7 @@ module.exports = {
  handler: function () {
    this.connector = new PassiveConnector(this);
    return this.connector.setupServer()
-    .then((server) => {
+    .then(server => {
      const {port} = server.address();

      return this.reply(229, `EPSV OK (|||${port}|)`);
--- a/old/src/commands/registration/feat.js
+++ b/old/src/commands/registration/feat.js
@@ -11,7 +11,7 @@ module.exports = {
        return feats;
      }, ['UTF8'])
      .sort()
-      .map((feat) => ({
+      .map(feat => ({
        message: ` ${feat}`,
        raw: true
      }));
--- a/old/src/commands/registration/help.js
+++ b/old/src/commands/registration/help.js
@@ -12,7 +12,7 @@ module.exports = {
      const reply = _.concat([syntax.replace('{{cmd}}', directive), description]);
      return this.reply(214, ...reply);
    } else {
-      const supportedCommands = _.chunk(Object.keys(registry), 5).map((chunk) => chunk.join('\t'));
+      const supportedCommands = _.chunk(Object.keys(registry), 5).map(chunk => chunk.join('\t'));
      return this.reply(211, 'Supported commands:', ...supportedCommands, 'Use "HELP [command]" for syntax help.');
    }
  },
--- a/old/src/commands/registration/list.js
+++ b/old/src/commands/registration/list.js
@@ -16,33 +16,33 @@ module.exports = {
    const path = command.arg || '.';
    return this.connector.waitForConnection()
    .tap(() => this.commandSocket.pause())
-    .then(() => Promise.try(() => this.fs.get(path)))
-    .then((stat) => stat.isDirectory() ? Promise.try(() => this.fs.list(path)) : [stat])
-    .then((files) => {
-      const getFileMessage = (file) => {
+    .then(() => Promise.resolve(this.fs.get(path)))
+    .then(stat => stat.isDirectory() ? Promise.resolve(this.fs.list(path)) : [stat])
+    .then(files => {
+      const getFileMessage = file => {
        if (simple) return file.name;
        return getFileStat(file, _.get(this, 'server.options.file_format', 'ls'));
      };

-      return Promise.try(() => files.map((file) => {
+      const fileList = files.map(file => {
        const message = getFileMessage(file);
        return {
          raw: true,
          message,
          socket: this.connector.socket
        };
-      }));
+      });
+      return this.reply(150)
+      .then(() => {
+        if (fileList.length) return this.reply({}, ...fileList);
+      });
    })
-    .tap(() => this.reply(150))
-    .then((fileList) => {
-      if (fileList.length) return this.reply({}, ...fileList);
-    })
-    .tap(() => this.reply(226))
-    .catch(Promise.TimeoutError, (err) => {
+    .then(() => this.reply(226))
+    .catch(Promise.TimeoutError, err => {
      log.error(err);
      return this.reply(425, 'No connection established');
    })
-    .catch((err) => {
+    .catch(err => {
      log.error(err);
      return this.reply(451, err.message || 'No directory');
    })
--- a/old/src/commands/registration/mdtm.js
+++ b/old/src/commands/registration/mdtm.js
@@ -7,12 +7,12 @@ module.exports = {
    if (!this.fs) return this.reply(550, 'File system not instantiated');
    if (!this.fs.get) return this.reply(402, 'Not supported by file system');

-    return Promise.try(() => this.fs.get(command.arg))
-    .then((fileStat) => {
+    return Promise.resolve(this.fs.get(command.arg))
+    .then(fileStat => {
      const modificationTime = moment.utc(fileStat.mtime).format('YYYYMMDDHHmmss.SSS');
      return this.reply(213, modificationTime);
    })
-    .catch((err) => {
+    .catch(err => {
      log.error(err);
      return this.reply(550, err.message);
    });
--- a/old/src/commands/registration/mkd.js
+++ b/old/src/commands/registration/mkd.js
@@ -7,12 +7,12 @@ module.exports = {
    if (!this.fs) return this.reply(550, 'File system not instantiated');
    if (!this.fs.mkdir) return this.reply(402, 'Not supported by file system');

-    return Promise.try(() => this.fs.mkdir(command.arg))
-    .then((dir) => {
+    return Promise.resolve(this.fs.mkdir(command.arg))
+    .then(dir => {
      const path = dir ? `"${escapePath(dir)}"` : undefined;
      return this.reply(257, path);
    })
-    .catch((err) => {
+    .catch(err => {
      log.error(err);
      return this.reply(550, err.message);
    });
--- a/old/src/commands/registration/mode.js
+++ b/old/src/commands/registration/mode.js
--- a/old/src/commands/registration/nlst.js
+++ b/old/src/commands/registration/nlst.js
--- a/old/src/commands/registration/noop.js
+++ b/old/src/commands/registration/noop.js
--- a/old/src/commands/registration/opts.js
+++ b/old/src/commands/registration/opts.js
--- a/old/src/commands/registration/pass.js
+++ b/old/src/commands/registration/pass.js
@@ -12,7 +12,7 @@ module.exports = {
    .then(() => {
      return this.reply(230);
    })
-    .catch((err) => {
+    .catch(err => {
      log.error(err);
      return this.reply(530, err.message || 'Authentication failed');
    });
--- a/old/src/commands/registration/pasv.js
+++ b/old/src/commands/registration/pasv.js
@@ -2,25 +2,17 @@ const PassiveConnector = require('../../connector/passive');

 module.exports = {
  directive: 'PASV',
-  handler: function ({log} = {}) {
-    if (!this.server.options.pasv_url) {
-      return this.reply(502);
-    }
-
+  handler: function () {
    this.connector = new PassiveConnector(this);
    return this.connector.setupServer()
-    .then((server) => {
-      const address = this.server.options.pasv_url;
+    .then(server => {
+      const address = this.server.url.hostname;
      const {port} = server.address();
      const host = address.replace(/\./g, ',');
      const portByte1 = port / 256 | 0;
      const portByte2 = port % 256;

      return this.reply(227, `PASV OK (${host},${portByte1},${portByte2})`);
-    })
-    .catch((err) => {
-      log.error(err);
-      return this.reply(425);
    });
  },
  syntax: '{{cmd}}',
--- a/old/src/commands/registration/pbsz.js
+++ b/old/src/commands/registration/pbsz.js
--- a/old/src/commands/registration/port.js
+++ b/old/src/commands/registration/port.js
@@ -3,22 +3,18 @@ const ActiveConnector = require('../../connector/active');

 module.exports = {
  directive: 'PORT',
-  handler: function ({log, command} = {}) {
+  handler: function ({command} = {}) {
    this.connector = new ActiveConnector(this);

    const rawConnection = _.get(command, 'arg', '').split(',');
    if (rawConnection.length !== 6) return this.reply(425);

    const ip = rawConnection.slice(0, 4).join('.');
-    const portBytes = rawConnection.slice(4).map((p) => parseInt(p));
+    const portBytes = rawConnection.slice(4).map(p => parseInt(p));
    const port = portBytes[0] * 256 + portBytes[1];

    return this.connector.setupConnection(ip, port)
-    .then(() => this.reply(200))
-    .catch((err) => {
-      log.error(err);
-      return this.reply(425);
-    });
+    .then(() => this.reply(200));
  },
  syntax: '{{cmd}} <x>,<x>,<x>,<x>,<y>,<y>',
  description: 'Specifies an address and port to which the server should connect'
--- a/old/src/commands/registration/prot.js
+++ b/old/src/commands/registration/prot.js
--- a/old/src/commands/registration/pwd.js
+++ b/old/src/commands/registration/pwd.js
@@ -7,12 +7,12 @@ module.exports = {
    if (!this.fs) return this.reply(550, 'File system not instantiated');
    if (!this.fs.currentDirectory) return this.reply(402, 'Not supported by file system');

-    return Promise.try(() => this.fs.currentDirectory())
-    .then((cwd) => {
+    return Promise.resolve(this.fs.currentDirectory())
+    .then(cwd => {
      const path = cwd ? `"${escapePath(cwd)}"` : undefined;
      return this.reply(257, path);
    })
-    .catch((err) => {
+    .catch(err => {
      log.error(err);
      return this.reply(550, err.message);
    });
--- a/old/src/commands/registration/quit.js
+++ b/old/src/commands/registration/quit.js
--- a/old/src/commands/registration/rest.js
+++ b/old/src/commands/registration/rest.js
@@ -9,7 +9,7 @@ module.exports = {
    if (isNaN(byteCount) || byteCount < 0) return this.reply(501, 'Byte count must be 0 or greater');

    this.restByteCount = byteCount;
-    return this.reply(350, `Restarting next transfer at ${byteCount}`);
+    return this.reply(350, `Resarting next transfer at ${byteCount}`);
  },
  syntax: '{{cmd}} <byte-count>',
  description: 'Restart transfer from the specified point. Resets after any STORE or RETRIEVE'
--- a/old/src/commands/registration/retr.js
+++ b/old/src/commands/registration/retr.js
@@ -6,26 +6,17 @@ module.exports = {
    if (!this.fs) return this.reply(550, 'File system not instantiated');
    if (!this.fs.read) return this.reply(402, 'Not supported by file system');

-    const filePath = command.arg;
-
    return this.connector.waitForConnection()
    .tap(() => this.commandSocket.pause())
-    .then(() => Promise.try(() => this.fs.read(filePath, {start: this.restByteCount})))
-    .then((fsResponse) => {
-      let {stream, clientPath} = fsResponse;
-      if (!stream && !clientPath) {
-        stream = fsResponse;
-        clientPath = filePath;
-      }
-      const serverPath = stream.path || filePath;
-
-      const destroyConnection = (connection, reject) => (err) => {
+    .then(() => Promise.resolve(this.fs.read(command.arg, {start: this.restByteCount})))
+    .then(stream => {
+      const destroyConnection = (connection, reject) => err => {
        if (connection) connection.destroy(err);
        reject(err);
      };

      const eventsPromise = new Promise((resolve, reject) => {
-        stream.on('data', (data) => {
+        stream.on('data', data => {
          if (stream) stream.pause();
          if (this.connector.socket) {
            this.connector.socket.write(data, this.transferType, () => stream && stream.resume());
@@ -41,17 +32,15 @@ module.exports = {

      return this.reply(150).then(() => stream.resume() && this.connector.socket.resume())
      .then(() => eventsPromise)
-      .tap(() => this.emit('RETR', null, serverPath))
-      .then(() => this.reply(226, clientPath))
      .finally(() => stream.destroy && stream.destroy());
    })
-    .catch(Promise.TimeoutError, (err) => {
+    .then(() => this.reply(226))
+    .catch(Promise.TimeoutError, err => {
      log.error(err);
      return this.reply(425, 'No connection established');
    })
-    .catch((err) => {
+    .catch(err => {
      log.error(err);
-      this.emit('RETR', err);
      return this.reply(551, err.message);
    })
    .finally(() => {
--- a/old/src/commands/registration/rmd.js
+++ b/old/src/commands/registration/rmd.js
--- a/old/src/commands/registration/rnfr.js
+++ b/old/src/commands/registration/rnfr.js
@@ -7,12 +7,12 @@ module.exports = {
    if (!this.fs.get) return this.reply(402, 'Not supported by file system');

    const fileName = command.arg;
-    return Promise.try(() => this.fs.get(fileName))
+    return Promise.resolve(this.fs.get(fileName))
    .then(() => {
      this.renameFrom = fileName;
      return this.reply(350);
    })
-    .catch((err) => {
+    .catch(err => {
      log.error(err);
      return this.reply(550, err.message);
    });
--- a/old/src/commands/registration/rnto.js
+++ b/old/src/commands/registration/rnto.js
@@ -11,14 +11,12 @@ module.exports = {
    const from = this.renameFrom;
    const to = command.arg;

-    return Promise.try(() => this.fs.rename(from, to))
+    return Promise.resolve(this.fs.rename(from, to))
    .then(() => {
      return this.reply(250);
    })
-    .tap(() => this.emit('RNTO', null, to))
-    .catch((err) => {
+    .catch(err => {
      log.error(err);
-      this.emit('RNTO', err);
      return this.reply(550, err.message);
    })
    .finally(() => {
--- a/old/src/commands/registration/site/chmod.js
+++ b/old/src/commands/registration/site/chmod.js
@@ -6,11 +6,11 @@ module.exports = function ({log, command} = {}) {

  const [mode, ...fileNameParts] = command.arg.split(' ');
  const fileName = fileNameParts.join(' ');
-  return Promise.try(() => this.fs.chmod(fileName, parseInt(mode, 8)))
+  return Promise.resolve(this.fs.chmod(fileName, parseInt(mode, 8)))
  .then(() => {
    return this.reply(200);
  })
-  .catch((err) => {
+  .catch(err => {
    log.error(err);
    return this.reply(500);
  });
--- a/old/src/commands/registration/site/index.js
+++ b/old/src/commands/registration/site/index.js
--- a/old/src/commands/registration/site/registry.js
+++ b/old/src/commands/registration/site/registry.js
--- a/old/src/commands/registration/size.js
+++ b/old/src/commands/registration/size.js
@@ -6,11 +6,11 @@ module.exports = {
    if (!this.fs) return this.reply(550, 'File system not instantiated');
    if (!this.fs.get) return this.reply(402, 'Not supported by file system');

-    return Promise.try(() => this.fs.get(command.arg))
-    .then((fileStat) => {
+    return Promise.resolve(this.fs.get(command.arg))
+    .then(fileStat => {
      return this.reply(213, {message: fileStat.size});
    })
-    .catch((err) => {
+    .catch(err => {
      log.error(err);
      return this.reply(550, err.message);
    });
--- a/old/src/commands/registration/stat.js
+++ b/old/src/commands/registration/stat.js
@@ -11,28 +11,28 @@ module.exports = {
      if (!this.fs) return this.reply(550, 'File system not instantiated');
      if (!this.fs.get) return this.reply(402, 'Not supported by file system');

-      return Promise.try(() => this.fs.get(path))
-      .then((stat) => {
+      return Promise.resolve(this.fs.get(path))
+      .then(stat => {
        if (stat.isDirectory()) {
          if (!this.fs.list) return this.reply(402, 'Not supported by file system');

-          return Promise.try(() => this.fs.list(path))
-          .then((stats) => [213, stats]);
+          return Promise.resolve(this.fs.list(path))
+          .then(stats => [213, stats]);
        }
        return [212, [stat]];
      })
      .then(([code, fileStats]) => {
-        return Promise.map(fileStats, (file) => {
+        return Promise.map(fileStats, file => {
          const message = getFileStat(file, _.get(this, 'server.options.file_format', 'ls'));
          return {
            raw: true,
            message
          };
        })
-        .then((messages) => [code, messages]);
+        .then(messages => [code, messages]);
      })
      .then(([code, messages]) => this.reply(code, 'Status begin', ...messages, 'Status end'))
-      .catch((err) => {
+      .catch(err => {
        log.error(err);
        return this.reply(450, err.message);
      });
--- a/old/src/commands/registration/stor.js
+++ b/old/src/commands/registration/stor.js
@@ -11,20 +11,10 @@ module.exports = {

    return this.connector.waitForConnection()
    .tap(() => this.commandSocket.pause())
-    .then(() => Promise.try(() => this.fs.write(fileName, {append, start: this.restByteCount})))
-    .then((fsResponse) => {
-      let {stream, clientPath} = fsResponse;
-      if (!stream && !clientPath) {
-        stream = fsResponse;
-        clientPath = fileName;
-      }
-      const serverPath = stream.path || fileName;
-
-      const destroyConnection = (connection, reject) => (err) => {
-        if (connection) {
-          if (connection.writable) connection.end();
-          connection.destroy(err);
-        }
+    .then(() => Promise.resolve(this.fs.write(fileName, {append, start: this.restByteCount})))
+    .then(stream => {
+      const destroyConnection = (connection, reject) => err => {
+        if (connection) connection.destroy(err);
        reject(err);
      };

@@ -34,9 +24,9 @@ module.exports = {
      });

      const socketPromise = new Promise((resolve, reject) => {
-        this.connector.socket.on('data', (data) => {
+        this.connector.socket.on('data', data => {
          if (this.connector.socket) this.connector.socket.pause();
-          if (stream && stream.writable) {
+          if (stream) {
            stream.write(data, this.transferType, () => this.connector.socket && this.connector.socket.resume());
          }
        });
@@ -51,18 +41,16 @@ module.exports = {
      this.restByteCount = 0;

      return this.reply(150).then(() => this.connector.socket.resume())
-      .then(() => Promise.all([streamPromise, socketPromise]))
-      .tap(() => this.emit('STOR', null, serverPath))
-      .then(() => this.reply(226, clientPath))
+      .then(() => Promise.join(streamPromise, socketPromise))
      .finally(() => stream.destroy && stream.destroy());
    })
-    .catch(Promise.TimeoutError, (err) => {
+    .then(() => this.reply(226, fileName))
+    .catch(Promise.TimeoutError, err => {
      log.error(err);
      return this.reply(425, 'No connection established');
    })
-    .catch((err) => {
+    .catch(err => {
      log.error(err);
-      this.emit('STOR', err);
      return this.reply(550, err.message);
    })
    .finally(() => {
--- a/old/src/commands/registration/stou.js
+++ b/old/src/commands/registration/stou.js
@@ -8,10 +8,12 @@ module.exports = {
    if (!this.fs.get || !this.fs.getUniqueName) return this.reply(402, 'Not supported by file system');

    const fileName = args.command.arg;
-    return Promise.try(() => this.fs.get(fileName))
-    .then(() => Promise.try(() => this.fs.getUniqueName()))
-    .catch(() => fileName)
-    .then((name) => {
+    return Promise.try(() => {
+      return Promise.resolve(this.fs.get(fileName))
+      .then(() => Promise.resolve(this.fs.getUniqueName()))
+      .catch(() => Promise.resolve(fileName));
+    })
+    .then(name => {
      args.command.arg = name;
      return stor.call(this, args);
    });
--- a/old/src/commands/registration/stru.js
+++ b/old/src/commands/registration/stru.js
--- a/old/src/commands/registration/syst.js
+++ b/old/src/commands/registration/syst.js
--- a/old/src/commands/registration/type.js
+++ b/old/src/commands/registration/type.js
--- a/old/src/commands/registration/user.js
+++ b/old/src/commands/registration/user.js
@@ -13,7 +13,7 @@ module.exports = {
      .then(() => {
        return this.reply(230);
      })
-      .catch((err) => {
+      .catch(err => {
        log.error(err);
        return this.reply(530, err.message || 'Authentication failed');
      });
--- a/old/src/commands/registry.js
+++ b/old/src/commands/registry.js
@@ -43,7 +43,7 @@ const commands = [

 const registry = commands.reduce((result, cmd) => {
  const aliases = Array.isArray(cmd.directive) ? cmd.directive : [cmd.directive];
-  aliases.forEach((alias) => result[alias] = cmd);
+  aliases.forEach(alias => result[alias] = cmd);
  return result;
 }, {});

--- a/old/src/connection.js
+++ b/old/src/connection.js
@@ -1,7 +1,6 @@
 const _ = require('lodash');
 const uuid = require('uuid');
 const Promise = require('bluebird');
-const EventEmitter = require('events');

 const BaseConnector = require('./connector/base');
 const FileSystem = require('./fs');
@@ -9,9 +8,8 @@ const Commands = require('./commands');
 const errors = require('./errors');
 const DEFAULT_MESSAGE = require('./messages');

-class FtpConnection extends EventEmitter {
+class FtpConnection {
  constructor(server, options) {
-    super();
    this.server = server;
    this.id = uuid.v4();
    this.log = options.log.child({id: this.id, ip: this.ip});
@@ -25,31 +23,27 @@ class FtpConnection extends EventEmitter {
    this.connector = new BaseConnector(this);

    this.commandSocket = options.socket;
-    this.commandSocket.on('error', (err) => {
+    this.commandSocket.on('error', err => {
      this.log.error(err, 'Client error');
      this.server.emit('client-error', {connection: this, context: 'commandSocket', error: err});
    });
    this.commandSocket.on('data', this._handleData.bind(this));
-    this.commandSocket.on('timeout', () => {
-      this.log.trace('Client timeout');
-      this.close().catch((e) => this.log.trace(e, 'Client close error'));
-    });
+    this.commandSocket.on('timeout', () => {});
    this.commandSocket.on('close', () => {
      if (this.connector) this.connector.end();
      if (this.commandSocket && !this.commandSocket.destroyed) this.commandSocket.destroy();
-      this.removeAllListeners();
    });
  }

  _handleData(data) {
    const messages = _.compact(data.toString(this.encoding).split('\r\n'));
    this.log.trace(messages);
-    return Promise.mapSeries(messages, (message) => this.commands.handle(message));
+    return Promise.mapSeries(messages, message => this.commands.handle(message));
  }

  get ip() {
    try {
-      return this.commandSocket ? this.commandSocket.remoteAddress : undefined;
+      return this.dataSocket ? this.dataSocket.remoteAddress : this.commandSocket.remoteAddress;
    } catch (ex) {
      return null;
    }
@@ -71,7 +65,7 @@ class FtpConnection extends EventEmitter {

  close(code = 421, message = 'Closing connection') {
    return Promise.resolve(code)
-      .then((_code) => _code && this.reply(_code, message))
+      .then(_code => _code && this.reply(_code, message))
      .then(() => this.commandSocket && this.commandSocket.end());
  }

@@ -99,7 +93,7 @@ class FtpConnection extends EventEmitter {
      if (!letters.length) letters = [{}];
      return Promise.map(letters, (promise, index) => {
        return Promise.resolve(promise)
-        .then((letter) => {
+        .then(letter => {
          if (!letter) letter = {};
          else if (typeof letter === 'string') letter = {message: letter}; // allow passing in message as first param

@@ -107,7 +101,7 @@ class FtpConnection extends EventEmitter {
          if (!letter.message) letter.message = DEFAULT_MESSAGE[options.code] || 'No information';
          if (!letter.encoding) letter.encoding = this.encoding;
          return Promise.resolve(letter.message) // allow passing in a promise as a message
-          .then((message) => {
+          .then(message => {
            const seperator = !options.hasOwnProperty('eol') ?
              letters.length - 1 === index ? ' ' : '-' :
              options.eol ? ' ' : '-';
@@ -119,11 +113,11 @@ class FtpConnection extends EventEmitter {
      });
    };

-    const processLetter = (letter) => {
+    const processLetter = letter => {
      return new Promise((resolve, reject) => {
        if (letter.socket && letter.socket.writable) {
          this.log.trace({port: letter.socket.address().port, encoding: letter.encoding, message: letter.message}, 'Reply');
-          letter.socket.write(letter.message + '\r\n', letter.encoding, (err) => {
+          letter.socket.write(letter.message + '\r\n', letter.encoding, err => {
            if (err) {
              this.log.error(err);
              return reject(err);
@@ -135,10 +129,10 @@ class FtpConnection extends EventEmitter {
    };

    return satisfyParameters()
-    .then((satisfiedLetters) => Promise.mapSeries(satisfiedLetters, (letter, index) => {
+    .then(satisfiedLetters => Promise.mapSeries(satisfiedLetters, (letter, index) => {
      return processLetter(letter, index);
    }))
-    .catch((err) => {
+    .catch(err => {
      this.log.error(err);
    });
  }
--- a/old/src/connector/active.js
+++ b/old/src/connector/active.js
@@ -29,12 +29,12 @@ class Active extends Connector {
    .then(() => {
      this.dataSocket = new Socket();
      this.dataSocket.setEncoding(this.connection.transferType);
-      this.dataSocket.on('error', (err) => this.server && this.server.emit('client-error', {connection: this.connection, context: 'dataSocket', error: err}));
+      this.dataSocket.on('error', err => this.server && this.server.emit('client-error', {connection: this.connection, context: 'dataSocket', error: err}));
      this.dataSocket.connect({host, port, family}, () => {
        this.dataSocket.pause();

        if (this.connection.secure) {
-          const secureContext = tls.createSecureContext(this.server.options.tls);
+          const secureContext = tls.createSecureContext(this.server._tls);
          const secureSocket = new tls.TLSSocket(this.dataSocket, {
            isServer: true,
            secureContext
--- a/old/src/connector/base.js
+++ b/old/src/connector/base.js
@@ -26,28 +26,22 @@ class Connector {
    return Promise.reject(new errors.ConnectorError('No connector setup, send PASV or PORT'));
  }

-  closeSocket() {
-    if (this.dataSocket) {
-      const socket = this.dataSocket;
-      this.dataSocket.end(() => socket.destroy());
-      this.dataSocket = null;
-    }
-  }
-
-  closeServer() {
-    if (this.dataServer) {
-      this.dataServer.close();
-      this.dataServer = null;
-    }
-  }
-
-
  end() {
-    this.closeSocket();
-    this.closeServer();
+    const closeDataSocket = new Promise(resolve => {
+      if (this.dataSocket) this.dataSocket.end();
+      else resolve();
+    });
+    const closeDataServer = new Promise(resolve => {
+      if (this.dataServer) this.dataServer.close(() => resolve());
+      else resolve();
+    });

-    this.type = false;
-    this.connection.connector = new Connector(this);
+    return Promise.all([closeDataSocket, closeDataServer])
+    .then(() => {
+      this.dataSocket = null;
+      this.dataServer = null;
+      this.type = false;
+    });
  }
 }
 module.exports = Connector;
--- a/src/connector/passive.js
+++ b/src/connector/passive.js
@@ -0,0 +1,101 @@
+const net = require('net');
+const tls = require('tls');
+const Promise = require('bluebird');
+
+const Connector = require('./base');
+const findPort = require('../helpers/find-port');
+const errors = require('../errors');
+
+class Passive extends Connector {
+  constructor(connection) {
+    super(connection);
+    this.type = 'passive';
+  }
+
+  waitForConnection({timeout = 5000, delay = 250} = {}) {
+    if (!this.dataServer) return Promise.reject(new errors.ConnectorError('Passive server not setup'));
+
+    const checkSocket = () => {
+      if (this.dataServer && this.dataServer.listening && this.dataSocket && this.dataSocket.connected) {
+        return Promise.resolve(this.dataSocket);
+      }
+      return Promise.resolve().delay(delay)
+      .then(() => checkSocket());
+    };
+
+    return checkSocket().timeout(timeout);
+  }
+
+  setupServer() {
+    const closeExistingServer = () => this.dataServer ?
+      new Promise(resolve => this.dataServer.close(() => resolve())) :
+      Promise.resolve();
+
+    return closeExistingServer()
+    .then(() => this.getPort())
+    .then(port => {
+      const connectionHandler = socket => {
+        if (this.connection.commandSocket.remoteAddress !== socket.remoteAddress) {
+          this.log.error({
+            pasv_connection: socket.remoteAddress,
+            cmd_connection: this.connection.commandSocket.remoteAddress
+          }, 'Connecting addresses do not match');
+
+          socket.destroy();
+          return this.connection.reply(550, 'Remote addresses do not match')
+          .finally(() => this.connection.close());
+        }
+        this.log.trace({port, remoteAddress: socket.remoteAddress}, 'Passive connection fulfilled.');
+
+        if (this.connection.secure) {
+          const secureContext = tls.createSecureContext(this.server._tls);
+          const secureSocket = new tls.TLSSocket(socket, {
+            isServer: true,
+            secureContext
+          });
+          this.dataSocket = secureSocket;
+        } else {
+          this.dataSocket = socket;
+        }
+        this.dataSocket.connected = true;
+        this.dataSocket.setEncoding(this.connection.transferType);
+        this.dataSocket.on('error', err => this.server && this.server.emit('client-error', {connection: this.connection, context: 'dataSocket', error: err}));
+        this.dataSocket.on('close', () => {
+          this.log.trace('Passive connection closed');
+          this.end();
+        });
+      };
+
+      this.dataSocket = null;
+      this.dataServer = net.createServer({pauseOnConnect: true}, connectionHandler);
+      this.dataServer.maxConnections = 1;
+      this.dataServer.on('error', err => this.server && this.server.emit('client-error', {connection: this.connection, context: 'dataServer', error: err}));
+      this.dataServer.on('close', () => {
+        this.log.trace('Passive server closed');
+        this.dataServer = null;
+      });
+
+      return new Promise((resolve, reject) => {
+        this.dataServer.listen(port, err => {
+          if (err) reject(err);
+          else {
+            this.log.debug({port}, 'Passive connection listening');
+            resolve(this.dataServer);
+          }
+        });
+      });
+    });
+  }
+
+  getPort() {
+    if (this.server.options.pasv_range) {
+      const [min, max] = typeof this.server.options.pasv_range === 'string' ?
+        this.server.options.pasv_range.split('-').map(v => v ? parseInt(v) : v) :
+        [this.server.options.pasv_range];
+      return findPort(min, max);
+    }
+    throw new errors.ConnectorError('Invalid pasv_range');
+  }
+
+}
+module.exports = Passive;
--- a/src/dataSocket.ts
+++ b/src/dataSocket.ts
@@ -1,4 +0,0 @@
-
-export default class DataSocket {
-
-}
--- a/old/src/errors.js
+++ b/old/src/errors.js
--- a/src/filesystem.ts
+++ b/src/filesystem.ts
@@ -1,113 +0,0 @@
-import {parse, join, relative, isAbsolute} from 'path';
-import {promises as fs, constants, Stats} from 'fs';
-
-type Parameters<T> = T extends (... args: infer T) => any ? T : never;
-type ReturnType<T> = T extends (... args: any[]) => infer T ? T : never;
-
-export interface NodeFileSystem {
-    stat: (...args: Parameters<typeof fs.stat>) => ReturnType<typeof fs.stat>;
-    rename: (...args: Parameters<typeof fs.rename>) => ReturnType<typeof fs.rename>;
-    access: (...args: Parameters<typeof fs.access>) => ReturnType<typeof fs.access>;
-    rmdir: (...args: Parameters<typeof fs.rmdir>) => ReturnType<typeof fs.rmdir>;
-    unlink: (...args: Parameters<typeof fs.unlink>) => ReturnType<typeof fs.unlink>;
-    mkdir: (...args: Parameters<typeof fs.mkdir>) => ReturnType<typeof fs.mkdir>;
-    chmod: (...args: Parameters<typeof fs.chmod>) => ReturnType<typeof fs.chmod>;
-    readdir: (...args: Parameters<typeof fs.readdir>) => ReturnType<typeof fs.readdir>;
-}
-
-interface FileSystemConfig {
-    root: string;
-    current: string;
-    fs: NodeFileSystem;
-}
-
-export class FileSystem {
-    private rootDirectory: string;
-    private currentDirectory: string;
-    private fs: NodeFileSystem;
-
-    /**
-   * @param root absolute path on the server to the users root directory
-   * @param current relative path from root to the users current directory
-   */
-    constructor(config: Partial<FileSystemConfig> = {}) {
-        this.rootDirectory = config.root || '/';
-        this.currentDirectory = config.current || '.';
-        this.fs = config.fs || fs as unknown as NodeFileSystem;
-    }
-
-    public async absoluteDirectory() {
-        return this.getAbsolutePath();
-    }
-
-    public async navigate(to: string | null) {
-        const directory = this.resolvePath(this.currentDirectory, to);
-
-        await this.fs.access(this.getAbsolutePath(this.rootDirectory, directory), constants.R_OK);
-
-        this.currentDirectory = directory;
-        return this.currentDirectory;
-    }
-
-    public async stat(path: string | null): Promise<Stats> {
-        path = path ? this.resolvePath(this.currentDirectory, path) : this.currentDirectory;
-        const stat = await this.fs.stat(this.getAbsolutePath(this.rootDirectory, path));
-        return stat;
-    }
-
-    public async rename(from: string, to: string): Promise<string> {
-        from = this.resolvePath(this.currentDirectory, from);
-        to = this.resolvePath(this.currentDirectory, to);
-        await this.fs.rename(
-            this.getAbsolutePath(this.rootDirectory, from),
-            this.getAbsolutePath(this.rootDirectory, to)
-        );
-        return to;
-    }
-
-    public async delete(path: string): Promise<void> {
-        path = this.resolvePath(this.currentDirectory, path);
-        path = this.getAbsolutePath(this.rootDirectory, path);
-
-        const stat = await this.stat(path);
-        if (stat.isDirectory()) await this.fs.rmdir(path);
-        else await this.fs.unlink(path);
-    }
-
-    public async mkdir(path: string, mode?: string | number): Promise<string> {
-        path = this.resolvePath(this.currentDirectory, path);
-        await this.fs.mkdir(this.getAbsolutePath(this.rootDirectory, path), mode);
-        return path;
-    }
-
-    public async chmod(path: string, mode: string | number): Promise<string> {
-        path = this.resolvePath(this.currentDirectory, path);
-        await this.fs.chmod(this.getAbsolutePath(this.rootDirectory, path), mode);
-        return path;
-    }
-
-    public async readdir(path: string | null): Promise<string[]> {
-        path = this.resolvePath(this.currentDirectory, path);
-        const paths = await this.fs.readdir(this.getAbsolutePath(this.rootDirectory, path), {
-            encoding: 'utf8'
-        });
-        return paths as string[];
-    }
-
-    // public write(path: string): any;
-    // public read(path: string | null): any;
-
-    private resolvePath(from: string, to: string | null) {
-        if (!to) return from;
-        if (isAbsolute(to)) {
-            const {root} = parse(this.rootDirectory);
-            const cwd = this.getAbsolutePath(root); // Pretend `cwd` is the absolute path from root
-            to = relative(cwd, to);
-        }
-        return join(from, to);
-    }
-
-    private getAbsolutePath(root = this.rootDirectory, current = this.currentDirectory) {
-        return join(root, current);
-    }
-}
--- a/old/src/fs.js
+++ b/old/src/fs.js
@@ -8,31 +8,18 @@ const errors = require('./errors');
 class FileSystem {
  constructor(connection, {root, cwd} = {}) {
    this.connection = connection;
-    this.cwd = cwd ? nodePath.join(nodePath.sep, cwd) : nodePath.sep;
-    this._root = nodePath.resolve(root || process.cwd());
+    this.cwd = cwd || nodePath.sep;
+    this.root = root || process.cwd();
  }

-  get root() {
-    return this._root;
-  }
-
-  _resolvePath(path = '.') {
-    const clientPath = (() => {
-      path = nodePath.normalize(path);
-      if (nodePath.isAbsolute(path)) {
-        return nodePath.join(path);
-      } else {
-        return nodePath.join(this.cwd, path);
-      }
-    })();
-
-    const fsPath = (() => {
-      const resolvedPath = nodePath.resolve(this.root, `.${nodePath.sep}${clientPath}`);
-      return nodePath.join(resolvedPath);
-    })();
+  _resolvePath(path = '') {
+    const isFromRoot = _.startsWith(path, '/') || _.startsWith(path, nodePath.sep);
+    const cwd = isFromRoot ? nodePath.sep : this.cwd || nodePath.sep;
+    const serverPath = nodePath.join(nodePath.sep, cwd, path);
+    const fsPath = nodePath.join(this.root, serverPath);

    return {
-      clientPath,
+      serverPath,
      fsPath
    };
  }
@@ -44,19 +31,19 @@ class FileSystem {
  get(fileName) {
    const {fsPath} = this._resolvePath(fileName);
    return fs.statAsync(fsPath)
-    .then((stat) => _.set(stat, 'name', fileName));
+    .then(stat => _.set(stat, 'name', fileName));
  }

  list(path = '.') {
    const {fsPath} = this._resolvePath(path);
    return fs.readdirAsync(fsPath)
-    .then((fileNames) => {
-      return Promise.map(fileNames, (fileName) => {
+    .then(fileNames => {
+      return Promise.map(fileNames, fileName => {
        const filePath = nodePath.join(fsPath, fileName);
        return fs.accessAsync(filePath, fs.constants.F_OK)
        .then(() => {
          return fs.statAsync(filePath)
-          .then((stat) => _.set(stat, 'name', fileName));
+          .then(stat => _.set(stat, 'name', fileName));
        })
        .catch(() => null);
      });
@@ -65,47 +52,41 @@ class FileSystem {
  }

  chdir(path = '.') {
-    const {fsPath, clientPath} = this._resolvePath(path);
+    const {fsPath, serverPath} = this._resolvePath(path);
    return fs.statAsync(fsPath)
-    .tap((stat) => {
+    .tap(stat => {
      if (!stat.isDirectory()) throw new errors.FileSystemError('Not a valid directory');
    })
    .then(() => {
-      this.cwd = clientPath;
+      this.cwd = serverPath;
      return this.currentDirectory();
    });
  }

  write(fileName, {append = false, start = undefined} = {}) {
-    const {fsPath, clientPath} = this._resolvePath(fileName);
+    const {fsPath} = this._resolvePath(fileName);
    const stream = fs.createWriteStream(fsPath, {flags: !append ? 'w+' : 'a+', start});
    stream.once('error', () => fs.unlinkAsync(fsPath));
    stream.once('close', () => stream.end());
-    return {
-      stream,
-      clientPath
-    };
+    return stream;
  }

  read(fileName, {start = undefined} = {}) {
-    const {fsPath, clientPath} = this._resolvePath(fileName);
+    const {fsPath} = this._resolvePath(fileName);
    return fs.statAsync(fsPath)
-    .tap((stat) => {
+    .tap(stat => {
      if (stat.isDirectory()) throw new errors.FileSystemError('Cannot read a directory');
    })
    .then(() => {
      const stream = fs.createReadStream(fsPath, {flags: 'r', start});
-      return {
-        stream,
-        clientPath
-      };
+      return stream;
    });
  }

  delete(path) {
    const {fsPath} = this._resolvePath(path);
    return fs.statAsync(fsPath)
-    .then((stat) => {
+    .then(stat => {
      if (stat.isDirectory()) return fs.rmdirAsync(fsPath);
      else return fs.unlinkAsync(fsPath);
    });
--- a/old/src/helpers/escape-path.js
+++ b/old/src/helpers/escape-path.js
--- a/old/src/helpers/file-stat.js
+++ b/old/src/helpers/file-stat.js
@@ -18,8 +18,7 @@ module.exports = function (fileStat, format = 'ls') {
 function ls(fileStat) {
  const now = moment.utc();
  const mtime = moment.utc(new Date(fileStat.mtime));
-  const timeDiff = now.diff(mtime, 'months');
-  const dateFormat = timeDiff < 6 ? 'MMM DD HH:mm' : 'MMM DD  YYYY';
+  const dateFormat = now.diff(mtime, 'months') < 6 ? 'MMM DD HH:mm' : 'MMM DD  YYYY';

  return [
    fileStat.mode ? [
--- a/src/helpers/find-port.js
+++ b/src/helpers/find-port.js
@@ -0,0 +1,27 @@
+const net = require('net');
+const Promise = require('bluebird');
+const errors = require('../errors');
+
+module.exports = function (min = 1, max = undefined) {
+  return new Promise((resolve, reject) => {
+    let checkPort = min;
+    let portCheckServer = net.createServer();
+    portCheckServer.maxConnections = 0;
+    portCheckServer.on('error', () => {
+      if (checkPort < 65535 && (!max || checkPort < max)) {
+        checkPort = checkPort + 1;
+        portCheckServer.listen(checkPort);
+      } else {
+        reject(new errors.GeneralError('Unable to find open port', 500));
+      }
+    });
+    portCheckServer.on('listening', () => {
+      const {port} = portCheckServer.address();
+      portCheckServer.close(() => {
+        portCheckServer = null;
+        resolve(port);
+      });
+    });
+    portCheckServer.listen(checkPort);
+  });
+};
--- a/src/helpers/resolve-host.js
+++ b/src/helpers/resolve-host.js
@@ -0,0 +1,25 @@
+const http = require('http');
+const Promise = require('bluebird');
+const errors = require('../errors');
+
+const IP_WEBSITE = 'http://api.ipify.org/';
+
+module.exports = function (hostname) {
+  return new Promise((resolve, reject) => {
+    if (!hostname || hostname === '0.0.0.0') {
+      let ip = '';
+      http.get(IP_WEBSITE, response => {
+        if (response.statusCode !== 200) {
+          return reject(new errors.GeneralError('Unable to resolve hostname', response.statusCode));
+        }
+        response.setEncoding('utf8');
+        response.on('data', chunk => {
+          ip += chunk;
+        });
+        response.on('end', () => {
+          resolve(ip);
+        });
+      });
+    } else resolve(hostname);
+  });
+};
--- a/old/src/index.js
+++ b/old/src/index.js
@@ -4,47 +4,35 @@ const nodeUrl = require('url');
 const buyan = require('bunyan');
 const net = require('net');
 const tls = require('tls');
-const EventEmitter = require('events');
+const fs = require('fs');

 const Connection = require('./connection');
-const {getNextPortFactory} = require('./helpers/find-port');
+const resolveHost = require('./helpers/resolve-host');

-class FtpServer extends EventEmitter {
-  constructor(options = {}) {
-    super();
-    this.options = Object.assign({
+class FtpServer {
+  constructor(url, options = {}) {
+    this.options = _.merge({
      log: buyan.createLogger({name: 'ftp-srv'}),
-      url: 'ftp://127.0.0.1:21',
-      pasv_min: 1024,
-      pasv_max: 65535,
-      pasv_url: null,
      anonymous: false,
+      pasv_range: 22,
      file_format: 'ls',
      blacklist: [],
      whitelist: [],
      greeting: null,
-      tls: false,
-      timeout: 0
+      tls: false
    }, options);
-
    this._greeting = this.setupGreeting(this.options.greeting);
    this._features = this.setupFeaturesMessage();
+    this._tls = this.setupTLS(this.options.tls);

    delete this.options.greeting;
+    delete this.options.tls;

    this.connections = {};
    this.log = this.options.log;
-    this.url = nodeUrl.parse(this.options.url);
-    this.getNextPasvPort = getNextPortFactory(
-      _.get(this, 'url.hostname'),
-      _.get(this, 'options.pasv_min'),
-      _.get(this, 'options.pasv_max'));
+    this.url = nodeUrl.parse(url || 'ftp://127.0.0.1:21');

-	const timeout = Number(this.options.timeout);
-	this.options.timeout = isNaN(timeout) ? 0 : Number(timeout);
-
-    const serverConnectionHandler = (socket) => {
-      socket.setTimeout(this.options.timeout);
+    const serverConnectionHandler = socket => {
      let connection = new Connection(this, {log: this.log, socket});
      this.connections[connection.id] = connection;

@@ -55,38 +43,37 @@ class FtpServer extends EventEmitter {
      return connection.reply(220, ...greeting, features)
      .finally(() => socket.resume());
    };
-    const serverOptions = Object.assign({}, this.isTLS ? this.options.tls : {}, {pauseOnConnect: true});
+    const serverOptions = _.assign(this.isTLS ? this._tls : {}, {pauseOnConnect: true});

    this.server = (this.isTLS ? tls : net).createServer(serverOptions, serverConnectionHandler);
-    this.server.on('error', (err) => this.log.error(err, '[Event] error'));
+    this.server.on('error', err => this.log.error(err, '[Event] error'));
+    this.on = this.server.on.bind(this.server);
+    this.once = this.server.once.bind(this.server);
+    this.listeners = this.server.listeners.bind(this.server);

-    const quit = _.debounce(this.quit.bind(this), 100);
-
-    process.on('SIGTERM', quit);
-    process.on('SIGINT', quit);
-    process.on('SIGQUIT', quit);
+    process.on('SIGTERM', () => this.quit());
+    process.on('SIGINT', () => this.quit());
+    process.on('SIGQUIT', () => this.quit());
  }

  get isTLS() {
-    return this.url.protocol === 'ftps:' && this.options.tls;
+    return this.url.protocol === 'ftps:' && this._tls;
  }

  listen() {
-    if (!this.options.pasv_url) {
-      this.log.warn('Passive URL not set. Passive connections not available.');
-    }
-
-    return new Promise((resolve, reject) => {
-      this.server.once('error', reject);
-      this.server.listen(this.url.port, this.url.hostname, (err) => {
-        this.server.removeListener('error', reject);
-        if (err) return reject(err);
-        this.log.info({
-          protocol: this.url.protocol.replace(/\W/g, ''),
-          ip: this.url.hostname,
-          port: this.url.port
-        }, 'Listening');
-        resolve('Listening');
+    return resolveHost(this.url.hostname)
+    .then(hostname => {
+      this.url.hostname = hostname;
+      return new Promise((resolve, reject) => {
+        this.server.listen(this.url.port, err => {
+          if (err) return reject(err);
+          this.log.info({
+            protocol: this.url.protocol.replace(/\W/g, ''),
+            ip: this.url.hostname,
+            port: this.url.port
+          }, 'Listening');
+          resolve('Listening');
+        });
      });
    });
  }
@@ -94,7 +81,20 @@ class FtpServer extends EventEmitter {
  emitPromise(action, ...data) {
    return new Promise((resolve, reject) => {
      const params = _.concat(data, [resolve, reject]);
-      this.emit.call(this, action, ...params);
+      this.server.emit(action, ...params);
+    });
+  }
+
+  emit(action, ...data) {
+    this.server.emit(action, ...data);
+  }
+
+  setupTLS(_tls) {
+    if (!_tls) return false;
+    return _.assign({}, _tls, {
+      cert: _tls.cert ? fs.readFileSync(_tls.cert) : undefined,
+      key: _tls.key ? fs.readFileSync(_tls.key) : undefined,
+      ca: _tls.ca ? Array.isArray(_tls.ca) ? _tls.ca.map(_ca => fs.readFileSync(_ca)) : [fs.readFileSync(_tls.ca)] : undefined
    });
  }

@@ -116,7 +116,7 @@ class FtpServer extends EventEmitter {
  }

  disconnectClient(id) {
-    return new Promise((resolve) => {
+    return new Promise(resolve => {
      const client = this.connections[id];
      if (!client) return resolve();
      delete this.connections[id];
@@ -138,14 +138,13 @@ class FtpServer extends EventEmitter {
  close() {
    this.log.info('Server closing...');
    this.server.maxConnections = 0;
-    return Promise.map(Object.keys(this.connections), (id) => Promise.try(this.disconnectClient.bind(this, id)))
-    .then(() => new Promise((resolve) => {
-      this.server.close((err) => {
+    return Promise.map(Object.keys(this.connections), id => Promise.try(this.disconnectClient.bind(this, id)))
+    .then(() => new Promise(resolve => {
+      this.server.close(err => {
        if (err) this.log.error(err, 'Error closing server');
        resolve('Closed');
      });
-    }))
-    .then(() => this.removeAllListeners());
+    }));
  }

 }
--- a/src/messages.js
+++ b/src/messages.js
@@ -0,0 +1,56 @@
+module.exports = {
+  // 100 - 199 :: Remarks
+  100: 'The requested action is being initiated',
+  110: 'Restart marker reply',
+  120: 'Service ready in %s minutes',
+  125: 'Data connection already open; transfer starting',
+  150: 'File status okay; about to open data connection',
+  // 200 - 399 :: Acceptance
+  /// 200 - 299 :: Positive Completion Replies
+  /// These type of replies indicate that the requested action was taken and that the server is awaiting another command.
+  200: 'The requested action has been successfully completed',
+  202: 'Superfluous command',
+  211: 'System status, or system help reply',
+  212: 'Directory status',
+  213: 'File status',
+  214: 'Help message', // On how to use the server or the meaning of a particular non-standard command. This reply is useful only to the human user.
+  215: 'UNIX Type: L8', // NAME system type. Where NAME is an official system name from the list in the Assigned Numbers document.
+  220: 'Service ready for new user',
+  221: 'Service closing control connection', // Logged out if appropriate.
+  225: 'Data connection open; no transfer in progress',
+  226: 'Closing data connection', // Requested file action successful (for example, file transfer or file abort).
+  227: 'Entering Passive Mode', // (h1,h2,h3,h4,p1,p2).
+  230: 'User logged in, proceed',
+  234: 'Honored',
+  250: 'Requested file action okay, completed',
+  257: '\'%s\' created',
+  /// 300 - 399 :: Positive Intermediate Replies
+  /// These types of replies indicate that the requested action was taken and that the server is awaiting further information to complete the request.
+  331: 'Username okay, awaiting password',
+  332: 'Need account for login',
+  350: 'Requested file action pending further information',
+  // 400 - 599 :: Rejection
+  /// 400 - 499 :: Transient Negative Completion Replies
+  /// These types of replies indicate that the command was not accepted; the requested action was not taken.
+  /// However, the error is temporary and the action may be requested again.
+  421: 'Service not available, closing control connection', // This may be a reply to any command if the service knows it must shut down.
+  425: 'Unable to open data connection',
+  426: 'Connection closed; transfer aborted',
+  450: 'Requested file action not taken', // File unavailable (e.g., file busy).
+  451: 'Requested action aborted. Local error in processing',
+  452: 'Requested action not taken. Insufficient storage',
+  /// 500 - 599 :: Permanent Negative Completion Replies
+  /// These types of replies indicate that the command was not accepted; the requested action was not taken.
+  /// The FTP client is "discouraged" from repeating the same exact request.
+  500: 'Syntax error', // Can close connection
+  501: 'Syntax error in parameters or arguments',
+  502: 'Command not supported',
+  503: 'Bad sequence of commands',
+  504: 'Command parameter not supported',
+  530: 'Not logged in', // Permission Denied, Can close connection
+  532: 'Need account for storing files',
+  550: 'Requested action not taken. File unavailable', // (e.g., file not found, no access).
+  551: 'Requested action aborted. Page type unknown',
+  552: 'Requested file action aborted. Exceeded storage allocation', // (for current directory or dataset).
+  553: 'Requested action not taken. File name not allowed'
+};
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Tyler Stewart	90b4b78ddc	chore: update confit	2018-01-21 15:01:11 -07:00
Tyler Stewart	5e20556a0e	WIP(docs): outline docs in own folder	2018-01-21 14:57:49 -07:00
Tyler Stewart	74760189ed	WIP(readme): improve docs in readme	2018-01-21 14:57:49 -07:00