3.1.42

fix(core): update
3.1.41
2019-08-29 20:26:24 +02:00 · 2019-08-29 20:26:23 +02:00 · 2019-08-27 16:45:47 +02:00 · 2019-08-27 16:45:46 +02:00 · 2019-08-23 17:04:29 +02:00 · 2019-08-23 17:04:29 +02:00
54 changed files with 5300 additions and 3095 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,22 @@
-dist/
-node_modules/
+.nogit/
+
+# artifacts
 coverage/
 public/
-config.json
+pages/
+
+# installs
+node_modules/
+
+# caches
 .yarn/
+.cache/
+.rpt2_cache
+
+# builds
+dist/
+dist_web/
+dist_serve/
+dist_ts_web/
+
+# custom
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,95 +1,121 @@
-# gitzone standard
-image: hosttoday/ht-docker-node:npmci
+# gitzone ci_default
+image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+variables:
+  GIT_STRATEGY: clone

 cache:
  paths:
-  - .yarn/
+  - .npmci_cache/
  key: "$CI_BUILD_STAGE"

 stages:
 - security
 - test
 - release
- trigger
- pages
+- metadata

+# ====================
+# security stage
+# ====================
 mirror:
  stage: security
  script:
  - npmci git mirror
  tags:
  - docker
+  - notpriv

 snyk:
  stage: security
  script:
-    - npmci command yarn global add snyk
-    - npmci command yarn install --ignore-scripts
+    - npmci npm prepare
+    - npmci command npm install -g snyk
+    - npmci command npm install --ignore-scripts
    - npmci command snyk test
  tags:
  - docker
+  - notpriv

-testLEGACY:
+# ====================
+# test stage
+# ====================
+
+testStable:
  stage: test
  script:
-  - npmci node install legacy
+  - npmci npm prepare
+  - npmci node install stable
  - npmci npm install
  - npmci npm test
  coverage: /\d+.?\d+?\%\s*coverage/
  tags:
  - docker
-  allow_failure: true
+  - priv

-testLTS:
+testBuild:
  stage: test
  script:
+  - npmci npm prepare
  - npmci node install lts
  - npmci npm install
-  - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-  - docker
-    
-testSTABLE:
-  stage: test
-  script:
-  - npmci node install lts
-  - npmci npm install
-  - npmci npm test
+  - npmci command npm run build
  coverage: /\d+.?\d+?\%\s*coverage/
  tags:
  - docker
+  - notpriv

 release:
  stage: release
  script:
-  - npmci npm prepare
+  - npmci node install lts
  - npmci npm publish
  only:
  - tags
  tags:
  - docker
+  - notpriv
+
+# ====================
+# metadata stage
+# ====================
+codequality:
+  stage: metadata
+  allow_failure: true
+  script:
+    - npmci command npm install -g tslint typescript
+    - npmci npm install
+    - npmci command "tslint -c tslint.json ./ts/**/*.ts"
+  tags:
+  - docker
+  - priv

 trigger:
-  stage: trigger
+  stage: metadata
  script:
  - npmci trigger
  only:
  - tags
  tags:
  - docker
+  - notpriv

 pages:
-  image: hosttoday/ht-docker-node:npmci
-  stage: pages
+  image: hosttoday/ht-docker-dbase:npmci
+  services:
+   - docker:18-dind
+  stage: metadata
  script:
-    - npmci command yarn global add npmpage
-    - npmci command npmpage
+    - npmci command npm install -g @gitzone/tsdoc
+    - npmci npm prepare
+    - npmci npm install
+    - npmci command tsdoc
  tags:
    - docker
+    - notpriv
  only:
    - tags
  artifacts:
    expire_in: 1 week
    paths:
    - public
+  allow_failure: true
--- a/.npmignore
+++ b/.npmignore
@@ -1,5 +0,0 @@
-pages/
-coverage/
-test/
-node_modules/
-config.json
--- a/.snyk
+++ b/.snyk
@@ -1,15 +1,4 @@
 # Snyk (https://snyk.io) policy file, patches or ignores known vulnerabilities.
-version: v1.10.2
-# ignores vulnerabilities until expiry date; change duration by modifying expiry date
-ignore:
-  'npm:shelljs:20140723':
-    - shelljs:
-        reason: None given
-        expires: '2018-05-04T20:41:54.426Z'
-    - smartshell > shelljs:
-        reason: None given
-        expires: '2018-05-04T20:41:54.426Z'
-    - smartssh > shelljs:
-        reason: None given
-        expires: '2018-05-04T20:41:54.426Z'
+version: v1.13.1
+ignore: {}
 patch: {}
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -0,0 +1,3 @@
+{
+  "workbench.colorCustomizations": {}
+}
--- a/cli.js
+++ b/cli.js
@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+process.env.CLI_CALL = 'true';
+require('./dist/index');
--- a/cli.ts.js
+++ b/cli.ts.js
@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+process.env.CLI_CALL = 'true';
+require('@gitzone/tsrun');
+require('./ts/index');
--- a/docs/index.md
+++ b/docs/index.md
@@ -1,100 +0,0 @@
-# npmci
-
-node and docker in gitlab ci on steroids
-
-## Availabililty
-
-[![npm](https://gitzone.gitlab.io/assets/repo-button-npm.svg)](https://www.npmjs.com/package/npmci)
-[![git](https://gitzone.gitlab.io/assets/repo-button-git.svg)](https://GitLab.com/gitzone/npmci)
-[![git](https://gitzone.gitlab.io/assets/repo-button-mirror.svg)](https://github.com/gitzone/npmci)
-[![docs](https://gitzone.gitlab.io/assets/repo-button-docs.svg)](https://gitzone.gitlab.io/npmci/)
-
-## Status for master
-
-[![build status](https://GitLab.com/gitzone/npmci/badges/master/build.svg)](https://GitLab.com/gitzone/npmci/commits/master)
-[![coverage report](https://GitLab.com/gitzone/npmci/badges/master/coverage.svg)](https://GitLab.com/gitzone/npmci/commits/master)
-[![npm downloads per month](https://img.shields.io/npm/dm/npmci.svg)](https://www.npmjs.com/package/npmci)
-[![Dependency Status](https://david-dm.org/gitzonetools/npmci.svg)](https://david-dm.org/gitzonetools/npmci)
-[![bitHound Dependencies](https://www.bithound.io/github/gitzonetools/npmci/badges/dependencies.svg)](https://www.bithound.io/github/gitzonetools/npmci/master/dependencies/npm)
-[![bitHound Code](https://www.bithound.io/github/gitzonetools/npmci/badges/code.svg)](https://www.bithound.io/github/gitzonetools/npmci)
-[![TypeScript](https://img.shields.io/badge/TypeScript-2.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
-[![node](https://img.shields.io/badge/node->=%206.x.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
-[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-standard-brightgreen.svg)](http://standardjs.com/)
-
-## Usage
-
-Use TypeScript for best in class instellisense.
-
-npmci is designed to work in docker CI environments. The following docker images come with npmci presinstalled:
-
-Docker Hub:
-
-* [hosttoday/ht-docker-node:npmci](https://hub.docker.com/r/hosttoday/ht-docker-node/)  
-  has LTS node version and npmci preinstalled.
-* [hosttoday/ht-docker-dbase](https://hub.docker.com/r/hosttoday/ht-docker-dbase/)  
-  based on docker:git, can be used to build docker images in conjunction with docker:dind
-
-npmci can be called from commandline:
-
-```shell
-# Install any node version:
-npmci install lts # will install latest LTS node version and update PATH for node and npm versions
-npmci install stable # will install latest stable node version and update PATH for node and npm
-npmci install legacy # will install latest legacy node version and update PATH for node and npm
-npmci install x.x.x #  will install any specific node version.
-
-# Install any node version, install dependencies and run test in cwd:
-npmci test lts # will install latest lts node version and run "npm install" and "npm test".
-npmci test stable # will install latest stable node version and run "npm install" and "npm test".
-npmci test legacy # will install latest legacy node version and run "npm install" and "npm test".
-npmci test x.x.x # will install any specific node version and run "npm install" and "npm test".
-npmci test docker # will test any build image with tests defined in ./npmci/dockertest_1.sh to ./npmci/dockertest_100.sh
-## npmci test docker will look at all Dockerfiles and look for according tags on GitLab container registry
-
-
-# prepare tools
-npmci prepare npm # will look for $NPMCI_TOKEN_NPM env var and create .npmrc, so npm is authenticated
-npmci prepare docker # will look for $NPMCI_LOGIN_DOCKER in form username|password and authenticate docker
-npmci prepare docker-gitlab # will authenticate docker for gitlab container registry
-
-# build containers
-npmci build docker # will build containers
-## all Dockerfiles named Dockerfile* are picked up.
-## specify tags like this Dockerfile_[tag]
-## uploads all built images as [username]/[reponame]:[tag]_test to GitLab
-## then test in next step with "npmci test docker"
-
-# publish npm module
-npmci publish npm # will look vor $NPMCI_TOKEN_NPM env var and push any module in cwd to npm
-npmci publish docker
-
-# trigger webhooks
-npmci trigger # will look for NPMCI_TRIGGER_1 to NPMCI_TRIGGER_100 in form domain|id|token|ref|name  
-```
-
-## Configuration
-
-npmci supports the use of npmextra.
-
-To configure npmci create a `npmextra.json` file at the root of your project
-
-```json
-{
-  "npmci": {
-    "globalNpmTools": ["npm-check-updates", "protractor", "npmts", "gitzone"]
-  }
-}
-```
-
-**Available options**
-
-| setting        | example                       | description                                                                                       |
-| -------------- | ----------------------------- | ------------------------------------------------------------------------------------------------- |
-| globalNpmTools | "globalNpmTools": ["gitbook"] | Will look for the specified package names locally and (if not yet present) install them from npm. |
-
-For further information read the linked docs at the top of this README.
-
-> MIT licensed | **&copy;** [Lossless GmbH](https://lossless.gmbh)
-> | By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy.html)
-
-[![repo-footer](https://gitzone.gitlab.io/assets/repo-footer.svg)](https://push.rocks)
--- a/docs/ssh.md
+++ b/docs/ssh.md
@@ -1,22 +0,0 @@
-# SSH
-
-npmci allows easy usage of ssh:
-
-## Add the SSH KEY to the environment
-
-To make npmci aware of any SSH KEY add it to the environment in the following format
-
-```
-# Key
-NPMCI_SSHKEY_[A_NAME_FROM_YOU]
-# Value:
-[targeted host]|[privatekey as base64]|***
-```
-
-## Use npmci cli tool in your ci script
-
-```
-npmci prepare ssh
-npmci command git remote add heroku ssh://git@heroku.com/[you project name].git
-npmci command git push heroku master
-```
--- a/npmextra.json
+++ b/npmextra.json
@@ -1,20 +1,21 @@
 {
-    "npmts":{
-        "mode":"default",
-        "coverageTreshold": "70",
-        "cli": true
-    },
-    "npmci": {
-        "globalNpmTools": [
-            "npmts"
-        ],
-        "npmGlobalTools": [
-            "npmts"
-        ],
-        "npmAccessLevel": "public"
-    },
-    "npmdocker":{
-        "baseImage":"hosttoday/ht-docker-node:npmci",
-        "command": "npmci test stable"
+  "npmci": {
+    "npmGlobalTools": [],
+    "npmAccessLevel": "public",
+    "npmRegistryUrl": "registry.npmjs.org"
+  },
+  "npmdocker": {
+    "baseImage": "hosttoday/ht-docker-node:npmci",
+    "command": "npmci test stable"
+  },
+  "gitzone": {
+    "module": {
+      "githost": "gitlab.com",
+      "gitscope": "shipzone",
+      "gitrepo": "npmci",
+      "shortDescription": "node and docker in gitlab ci on steroids",
+      "npmPackagename": "@shipzone/npmci",
+      "license": "MIT"
    }
+  }
 }
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -1,16 +1,17 @@
 {
  "name": "@shipzone/npmci",
-  "version": "3.0.29",
+  "version": "3.1.42",
+  "private": false,
  "description": "node and docker in gitlab ci on steroids",
  "main": "dist/index.js",
  "typings": "dist/index.d.ts",
  "bin": {
-    "npmci": "dist/cli.js"
+    "npmci": "cli.js"
  },
  "scripts": {
-    "test": "(rm -f config.json) && (npmts) && (npm run testVersion)",
-    "build": "(rm -f config.json) && (npmts) && (npm run testVersion)",
-    "testVersion": "(cd test/assets/ && node ../../dist/cli.js -v)"
+    "test": "(rm -f config.json) && tstest test/",
+    "build": "(rm -f config.json) && tsbuild && (npm run testVersion)",
+    "testVersion": "(cd test/assets/ && node ../../cli.js -v)"
  },
  "repository": {
    "type": "git",
@@ -23,31 +24,47 @@
  },
  "homepage": "https://gitlab.com/gitzone/npmci#README",
  "devDependencies": {
-    "tapbundle": "^2.0.0"
+    "@gitzone/tsbuild": "^2.1.17",
+    "@gitzone/tsrun": "^1.2.6",
+    "@gitzone/tstest": "^1.0.24",
+    "@pushrocks/tapbundle": "^3.0.13",
+    "@types/node": "^12.7.2",
+    "tslint": "^5.19.0",
+    "tslint-config-prettier": "^1.18.0"
  },
  "dependencies": {
-    "@types/lodash": "^4.14.74",
-    "@types/shelljs": "^0.7.4",
-    "@types/through2": "^2.0.33",
-    "beautylog": "^6.1.10",
-    "cflare": "^1.0.5",
-    "lik": "^2.0.5",
-    "lodash": "^4.17.4",
-    "npmextra": "^2.0.9",
-    "projectinfo": "^3.0.2",
-    "request": "^2.81.0",
-    "shelljs": "^0.8.1",
-    "smartanalytics": "^2.0.9",
-    "smartcli": "^2.0.7",
-    "smartdelay": "^1.0.3",
-    "smartfile": "^4.2.20",
-    "smartparam": "^1.0.2",
-    "smartq": "^1.1.6",
-    "smartshell": "^1.0.18",
-    "smartsocket": "^1.1.10",
-    "smartssh": "^1.2.2",
-    "smartstring": "^2.0.24",
-    "smartsystem": "^2.0.2",
-    "through2": "^2.0.3"
-  }
+    "@pushrocks/lik": "^3.0.11",
+    "@pushrocks/npmextra": "^3.0.5",
+    "@pushrocks/projectinfo": "^4.0.2",
+    "@pushrocks/qenv": "^4.0.2",
+    "@pushrocks/smartanalytics": "^2.0.15",
+    "@pushrocks/smartcli": "^3.0.7",
+    "@pushrocks/smartdelay": "^2.0.3",
+    "@pushrocks/smartfile": "^7.0.2",
+    "@pushrocks/smartgit": "^1.0.13",
+    "@pushrocks/smartlog": "^2.0.19",
+    "@pushrocks/smartlog-destination-local": "^8.0.2",
+    "@pushrocks/smartparam": "^1.0.4",
+    "@pushrocks/smartpromise": "^3.0.2",
+    "@pushrocks/smartrequest": "^1.1.23",
+    "@pushrocks/smartshell": "^2.0.23",
+    "@pushrocks/smartsocket": "^1.1.45",
+    "@pushrocks/smartssh": "^1.2.3",
+    "@pushrocks/smartstring": "^3.0.10",
+    "@servezone/servezone-interfaces": "^2.0.28",
+    "@types/shelljs": "^0.8.5",
+    "@types/through2": "^2.0.34",
+    "through2": "^3.0.1"
+  },
+  "files": [
+    "ts/*",
+    "ts_web/*",
+    "dist/*",
+    "dist_web/*",
+    "dist_ts_web/*",
+    "assets/*",
+    "cli.js",
+    "npmextra.json",
+    "readme.md"
+  ]
 }
--- a/readme.md
+++ b/readme.md
@@ -1,33 +1,101 @@
-# npmci
-
+# @shipzone/npmci
 node and docker in gitlab ci on steroids

-## Availabililty
-
-[![npm](https://shipzone.gitlab.io/assets/repo-button-npm.svg)](https://www.npmjs.com/package/@shipzone/npmci)
-[![git](https://shipzone.gitlab.io/assets/repo-button-git.svg)](https://GitLab.com/shipzone/npmci)
-[![git](https://shipzone.gitlab.io/assets/repo-button-mirror.svg)](https://github.com/shipzone/npmci)
-[![docs](https://shipzone.gitlab.io/assets/repo-button-docs.svg)](https://shipzone.gitlab.io/npmci/)
+## Availabililty and Links
+* [npmjs.org (npm package)](https://www.npmjs.com/package/@shipzone/npmci)
+* [gitlab.com (source)](https://gitlab.com/shipzone/npmci)
+* [github.com (source mirror)](https://github.com/shipzone/npmci)
+* [docs (typedoc)](https://shipzone.gitlab.io/npmci/)

 ## Status for master
-
-[![build status](https://GitLab.com/shipzone/npmci/badges/master/build.svg)](https://GitLab.com/shipzone/npmci/commits/master)
-[![coverage report](https://GitLab.com/shipzone/npmci/badges/master/coverage.svg)](https://GitLab.com/shipzone/npmci/commits/master)
-[![npm downloads per month](https://img.shields.io/npm/dm/npmci.svg)](https://www.npmjs.com/package/@shipzone/npmci)
-[![Dependency Status](https://david-dm.org/shipzone/npmci.svg)](https://david-dm.org/shipzone/npmci)
-[![bitHound Dependencies](https://www.bithound.io/github/shipzone/npmci/badges/dependencies.svg)](https://www.bithound.io/github/shipzone/npmci/master/dependencies/npm)
-[![bitHound Code](https://www.bithound.io/github/shipzone/npmci/badges/code.svg)](https://www.bithound.io/github/shipzone/npmci)
-[![TypeScript](https://img.shields.io/badge/TypeScript-2.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
-[![node](https://img.shields.io/badge/node->=%206.x.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
-[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-standard-brightgreen.svg)](http://standardjs.com/)
+[![build status](https://gitlab.com/shipzone/npmci/badges/master/build.svg)](https://gitlab.com/shipzone/npmci/commits/master)
+[![coverage report](https://gitlab.com/shipzone/npmci/badges/master/coverage.svg)](https://gitlab.com/shipzone/npmci/commits/master)
+[![npm downloads per month](https://img.shields.io/npm/dm/@shipzone/npmci.svg)](https://www.npmjs.com/package/@shipzone/npmci)
+[![Known Vulnerabilities](https://snyk.io/test/npm/@shipzone/npmci/badge.svg)](https://snyk.io/test/npm/@shipzone/npmci)
+[![TypeScript](https://img.shields.io/badge/TypeScript->=%203.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
+[![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
+[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-prettier-ff69b4.svg)](https://prettier.io/)

 ## Usage

 Use TypeScript for best in class instellisense.

+npmci is designed to work in docker CI environments. The following docker images come with npmci presinstalled:
+
+Docker Hub:
+
+- [hosttoday/ht-docker-node:npmci](https://hub.docker.com/r/hosttoday/ht-docker-node/)  
+  has LTS node version and npmci preinstalled.
+- [hosttoday/ht-docker-dbase](https://hub.docker.com/r/hosttoday/ht-docker-dbase/)  
+  based on docker:git, can be used to build docker images in conjunction with docker:dind
+
+npmci can be called from commandline and handle a lot of tasks durug ci:
+
+```shell
+# Handle node versions
+npmci node install stable # will install latest stable node version and update PATH for node and npm
+npmci node install lts # will install latest LTS node version and update PATH for node and npm versions
+npmci node install legacy # will install latest legacy node version and update PATH for node and npm
+npmci node install x.x.x #  will install any specific node version.
+
+# Handle npm and yarn tasks
+npmcu npm login # logs in npm using the auth key provided at env var "NPMCI_TOKEN_NPM"
+npmci npm install  # installs dependencies using npm or yarn dependending on availablity
+npmci npm test # tests the package
+npmci npm publish # builds a package and publishes it
+
+# handle docker tasks
+npmci docker prepare
+## npmci test docker will look at all Dockerfiles and look for according tags on GitLab container registry
+
+
+# prepare tools
+npmci prepare npm # will look for $NPMCI_TOKEN_NPM env var and create .npmrc, so npm is authenticated
+npmci prepare docker # will look for $NPMCI_LOGIN_DOCKER in form username|password and authenticate docker
+npmci prepare docker-gitlab # will authenticate docker for gitlab container registry
+
+# build containers
+npmci docker build # will build containers
+## all Dockerfiles named Dockerfile* are picked up.
+## specify tags like this Dockerfile_[tag]
+## uploads all built images as [username]/[reponame]:[tag]_test to GitLab
+## then test in next step with "npmci test docker"
+
+# publish npm module
+npmci publish npm # will look vor $NPMCI_TOKEN_NPM env var and push any module in cwd to npm
+npmci publish docker
+
+# trigger webhooks
+npmci trigger # will look for NPMCI_TRIGGER_1 to NPMCI_TRIGGER_100 in form domain|id|token|ref|name
+```
+
+## Configuration
+
+npmci supports the use of npmextra.
+
+To configure npmci create a `npmextra.json` file at the root of your project
+
+```json
+{
+  "npmci": {
+    "globalNpmTools": ["npm-check-updates", "protractor", "npmts", "gitzone"]
+  }
+}
+```
+
+**Available options**
+
+| setting        | example                       | description                                                                                       |
+| -------------- | ----------------------------- | ------------------------------------------------------------------------------------------------- |
+| globalNpmTools | "globalNpmTools": ["gitbook"] | Will look for the specified package names locally and (if not yet present) install them from npm. |
+
 For further information read the linked docs at the top of this README.

-> MIT licensed | **&copy;** [Lossless GmbH](https://lossless.gmbh)
-> | By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy.html)
+Use TypeScript for best in class instellisense.

-[![repo-footer](https://shipzone.gitlab.io/assets/repo-footer.svg)](https://push.rocks)
+For further information read the linked docs at the top of this readme.
+
+> MIT licensed | **&copy;** [Lossless GmbH](https://lossless.gmbh)
+| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
+
+[![repo-footer](https://lossless.gitlab.io/publicrelations/repofooter.svg)](https://maintainedby.lossless.com)
--- a/test/test.ts
+++ b/test/test.ts
@@ -1,7 +1,6 @@
-import { tap, expect } from 'tapbundle';
+import { tap, expect } from '@pushrocks/tapbundle';
 import * as path from 'path';

-// Setup test
 process.env.NPMTS_TEST = 'true';

 // set up environment
@@ -18,66 +17,66 @@ process.cwd = () => {
  return path.join(__dirname, 'assets/');
 };

-// require NPMCI files
-import '../ts/index';
-import npmciModDocker = require('../ts/mod_docker/index');
-import npmciModNpm = require('../ts/mod_npm/index');
-import npmciModNode = require('../ts/mod_node/index');
-import npmciModSsh = require('../ts/mod_ssh/index');
-import npmciEnv = require('../ts/npmci.env');
+import * as npmci from '../ts';

 // ======
 // Docker
 // ======

-let dockerfile1: npmciModDocker.Dockerfile;
-let dockerfile2: npmciModDocker.Dockerfile;
-let sortableArray: npmciModDocker.Dockerfile[];
+let dockerfile1: npmci.Dockerfile;
+let dockerfile2: npmci.Dockerfile;
+let sortableArray: npmci.Dockerfile[];

 tap.test('should return valid Dockerfiles', async () => {
-  dockerfile1 = new npmciModDocker.Dockerfile({ filePath: './Dockerfile', read: true });
-  dockerfile2 = new npmciModDocker.Dockerfile({ filePath: './Dockerfile_sometag1', read: true });
+  const npmciInstance = new npmci.Npmci();
+  dockerfile1 = new npmci.Dockerfile(npmciInstance.dockerManager, { filePath: './Dockerfile', read: true });
+  dockerfile2 = new npmci.Dockerfile(npmciInstance.dockerManager, { filePath: './Dockerfile_sometag1', read: true });
  expect(dockerfile1.version).to.equal('latest');
  return expect(dockerfile2.version).to.equal('sometag1');
 });

 tap.test('should read a directory of Dockerfiles', async () => {
-  return npmciModDocker.helpers
-    .readDockerfiles()
-    .then(async (readDockerfilesArrayArg: npmciModDocker.Dockerfile[]) => {
+  const npmciInstance = new npmci.Npmci();
+  return npmci.Dockerfile
+    .readDockerfiles(npmciInstance.dockerManager)
+    .then(async (readDockerfilesArrayArg: npmci.Dockerfile[]) => {
      sortableArray = readDockerfilesArrayArg;
      return expect(readDockerfilesArrayArg[1].version).to.equal('sometag1');
    });
 });

 tap.test('should sort an array of Dockerfiles', async () => {
-  return npmciModDocker.helpers
+  return npmci.Dockerfile
    .sortDockerfiles(sortableArray)
-    .then(async (sortedArrayArg: npmciModDocker.Dockerfile[]) => {
+    .then(async (sortedArrayArg: npmci.Dockerfile[]) => {
      console.log(sortedArrayArg);
    });
 });

 tap.test('should build all Dockerfiles', async () => {
-  return npmciModDocker.handleCli({
+  const npmciInstance = new npmci.Npmci();
+  return npmciInstance.dockerManager.handleCli({
    _: ['docker', 'build']
  });
 });

 tap.test('should test all Dockerfiles', async () => {
-  return await npmciModDocker.handleCli({
+  const npmciInstance = new npmci.Npmci();
+  return npmciInstance.dockerManager.handleCli({
    _: ['docker', 'test']
  });
 });

 tap.test('should test dockerfiles', async () => {
-  return await npmciModDocker.handleCli({
+  const npmciInstance = new npmci.Npmci();
+  return npmciInstance.dockerManager.handleCli({
    _: ['docker', 'test']
  });
 });

 tap.test('should login docker daemon', async () => {
-  return await npmciModDocker.handleCli({
+  const npmciInstance = new npmci.Npmci();
+  return npmciInstance.dockerManager.handleCli({
    _: ['docker', 'login']
  });
 });
@@ -86,6 +85,7 @@ tap.test('should login docker daemon', async () => {
 // SSH
 // ===
 tap.test('should prepare SSH keys', async () => {
+  const npmciModSsh = await import('../ts/mod_ssh');
  return await npmciModSsh.handleCli({
    _: ['ssh', 'prepare']
  });
@@ -95,13 +95,14 @@ tap.test('should prepare SSH keys', async () => {
 // node
 // ====
 tap.test('should install a certain version of node', async () => {
-  await npmciModNode.handleCli({
+  const npmciInstance = new npmci.Npmci();
+  await npmciInstance.nodejsManager.handleCli({
    _: ['node', 'install', 'stable']
  });
-  await npmciModNode.handleCli({
+  await npmciInstance.nodejsManager.handleCli({
    _: ['node', 'install', 'lts']
  });
-  await npmciModNode.handleCli({
+  await npmciInstance.nodejsManager.handleCli({
    _: ['node', 'install', 'legacy']
  });
 });
--- a/ts/connector.cloudly/cloudlyconnector.ts
+++ b/ts/connector.cloudly/cloudlyconnector.ts
@@ -0,0 +1,8 @@
+import * as plugins from '../npmci.plugins';
+
+/**
+ * 
+ */
+export class CloudlyConnector {
+
+}
--- a/ts/index.ts
+++ b/ts/index.ts
@@ -1 +1,10 @@
-import './npmci.cli';
+import { Npmci } from './npmci.classes.npmci';
+import { Dockerfile } from './manager.docker/mod.classes.dockerfile';
+
+export const npmciInstance = new Npmci();
+
+export { Dockerfile, Npmci };
+
+if (process.env.CLI_CALL) {
+  npmciInstance.start();
+}
--- a/ts/manager.docker/index.ts
+++ b/ts/manager.docker/index.ts
@@ -0,0 +1,177 @@
+import { logger } from '../npmci.logging';
+import * as plugins from './mod.plugins';
+import * as paths from '../npmci.paths';
+import { bash } from '../npmci.bash';
+
+// classes
+import { Npmci } from '../npmci.classes.npmci';
+import { Dockerfile } from './mod.classes.dockerfile';
+import { DockerRegistry } from './mod.classes.dockerregistry';
+import { RegistryStorage } from './mod.classes.registrystorage';
+
+export class NpmciDockerManager {
+  public npmciRef: Npmci;
+  public npmciRegistryStorage = new RegistryStorage();
+
+  constructor(npmciArg: Npmci) {
+    this.npmciRef = npmciArg;
+  }
+
+  /**
+   * handle cli input
+   * @param argvArg
+   */
+  public handleCli = async argvArg => {
+    if (argvArg._.length >= 2) {
+      const action: string = argvArg._[1];
+      switch (action) {
+        case 'build':
+          await this.build();
+          break;
+        case 'login':
+        case 'prepare':
+          await this.login();
+          break;
+        case 'test':
+          await this.test();
+          break;
+        case 'push':
+          await this.push(argvArg);
+          break;
+        case 'pull':
+          await this.pull(argvArg);
+          break;
+        default:
+          logger.log('error', `>>npmci docker ...<< action >>${action}<< not supported`);
+      }
+    } else {
+      logger.log(
+        'info',
+        `>>npmci docker ...<< cli arguments invalid... Please read the documentation.`
+      );
+    }
+  }
+
+  /**
+   * builds a cwd of Dockerfiles by triggering a promisechain
+   */
+  public build = async () => {
+    await this.prepare();
+    logger.log('info', 'now building Dockerfiles...');
+    await Dockerfile.readDockerfiles(this)
+      .then(Dockerfile.sortDockerfiles)
+      .then(Dockerfile.mapDockerfiles)
+      .then(Dockerfile.buildDockerfiles);
+  }
+
+  /**
+   * login to the DockerRegistries
+   */
+  public login = async () => {
+    await this.prepare();
+    await this.npmciRegistryStorage.loginAll();
+  }
+
+  /**
+   * logs in docker
+   */
+  public prepare = async () => {
+    // Always login to GitLab Registry
+    if (!process.env.CI_BUILD_TOKEN || process.env.CI_BUILD_TOKEN === '') {
+      logger.log('error', 'No registry token specified by gitlab!');
+      process.exit(1);
+    }
+    this.npmciRegistryStorage.addRegistry(
+      new DockerRegistry({
+        registryUrl: 'registry.gitlab.com',
+        username: 'gitlab-ci-token',
+        password: process.env.CI_BUILD_TOKEN
+      })
+    );
+
+    // handle registries
+    await plugins.smartparam.forEachMinimatch(
+      process.env,
+      'NPMCI_LOGIN_DOCKER*',
+      async envString => {
+        this.npmciRegistryStorage.addRegistry(DockerRegistry.fromEnvString(envString));
+      }
+    );
+    return;
+  }
+
+  /**
+   * pushes an image towards a registry
+   * @param argvArg
+   */
+  public push = async argvArg => {
+    await this.prepare();
+    let dockerRegistryUrls: string[] = [];
+
+    // lets parse the input of cli and npmextra
+    if (argvArg._.length >= 3 && argvArg._[2] !== 'npmextra') {
+      dockerRegistryUrls.push(argvArg._[2]);
+    } else {
+      if (this.npmciRef.npmciConfig.getConfig().dockerRegistries.length === 0) {
+        logger.log(
+          'warn',
+          `There are no docker registries listed in npmextra.json! This is strange!`
+        );
+      }
+      dockerRegistryUrls = dockerRegistryUrls.concat(
+        this.npmciRef.npmciConfig.getConfig().dockerRegistries
+      );
+    }
+
+    // lets determine the suffix
+    let suffix = null;
+    if (argvArg._.length >= 4) {
+      suffix = argvArg._[3];
+    }
+
+    // lets push to the registries
+    for (const dockerRegistryUrl of dockerRegistryUrls) {
+      const dockerfileArray = await Dockerfile.readDockerfiles(this)
+        .then(Dockerfile.sortDockerfiles)
+        .then(Dockerfile.mapDockerfiles);
+      const dockerRegistryToPushTo = this.npmciRegistryStorage.getRegistryByUrl(dockerRegistryUrl);
+      if (!dockerRegistryToPushTo) {
+        logger.log(
+          'error',
+          `Cannot push to registry ${dockerRegistryUrl}, because it was not found in the authenticated registry list.`
+        );
+        process.exit(1);
+      }
+      for (const dockerfile of dockerfileArray) {
+        await dockerfile.push(dockerRegistryToPushTo, suffix);
+      }
+    }
+  }
+
+  /**
+   * pulls an image
+   */
+  public pull = async argvArg => {
+    await this.prepare();
+    const registryUrlArg = argvArg._[2];
+    let suffix = null;
+    if (argvArg._.length >= 4) {
+      suffix = argvArg._[3];
+    }
+    const localDockerRegistry = this.npmciRegistryStorage.getRegistryByUrl(registryUrlArg);
+    const dockerfileArray = await Dockerfile.readDockerfiles(this)
+      .then(Dockerfile.sortDockerfiles)
+      .then(Dockerfile.mapDockerfiles);
+    for (const dockerfile of dockerfileArray) {
+      await dockerfile.pull(localDockerRegistry, suffix);
+    }
+  }
+
+  /**
+   * tests docker files
+   */
+  public test = async () => {
+    await this.prepare();
+    return await Dockerfile.readDockerfiles(this).then(Dockerfile.testDockerfiles);
+  }
+}
--- a/ts/manager.docker/mod.classes.dockerfile.ts
+++ b/ts/manager.docker/mod.classes.dockerfile.ts
@@ -0,0 +1,316 @@
+import * as plugins from './mod.plugins';
+import * as paths from '../npmci.paths';
+
+import { logger } from '../npmci.logging';
+import { bash } from '../npmci.bash';
+
+import { DockerRegistry } from './mod.classes.dockerregistry';
+import * as helpers from './mod.helpers';
+import { NpmciDockerManager } from '.';
+import { Npmci } from '../npmci.classes.npmci';
+
+/**
+ * class Dockerfile represents a Dockerfile on disk in npmci
+ */
+export class Dockerfile {
+  // STATIC
+
+  /**
+   * creates instance of class Dockerfile for all Dockerfiles in cwd
+   * @returns Promise<Dockerfile[]>
+   */
+  public static async readDockerfiles(
+    npmciDockerManagerRefArg: NpmciDockerManager
+  ): Promise<Dockerfile[]> {
+    const fileTree = await plugins.smartfile.fs.listFileTree(paths.cwd, 'Dockerfile*');
+
+    // create the Dockerfile array
+    const readDockerfilesArray: Dockerfile[] = [];
+    logger.log('info', `found ${fileTree.length} Dockerfiles:`);
+    console.log(fileTree);
+    for (const dockerfilePath of fileTree) {
+      const myDockerfile = new Dockerfile(npmciDockerManagerRefArg, {
+        filePath: dockerfilePath,
+        read: true
+      });
+      readDockerfilesArray.push(myDockerfile);
+    }
+
+    return readDockerfilesArray;
+  }
+
+  /**
+   * sorts Dockerfiles into a dependency chain
+   * @param sortableArrayArg an array of instances of class Dockerfile
+   * @returns Promise<Dockerfile[]>
+   */
+  public static async sortDockerfiles(sortableArrayArg: Dockerfile[]): Promise<Dockerfile[]> {
+    const done = plugins.smartpromise.defer<Dockerfile[]>();
+    logger.log('info', 'sorting Dockerfiles:');
+    const sortedArray: Dockerfile[] = [];
+    const cleanTagsOriginal = Dockerfile.cleanTagsArrayFunction(sortableArrayArg, sortedArray);
+    let sorterFunctionCounter: number = 0;
+    const sorterFunction = () => {
+      sortableArrayArg.forEach(dockerfileArg => {
+        const cleanTags = Dockerfile.cleanTagsArrayFunction(sortableArrayArg, sortedArray);
+        if (
+          cleanTags.indexOf(dockerfileArg.baseImage) === -1 &&
+          sortedArray.indexOf(dockerfileArg) === -1
+        ) {
+          sortedArray.push(dockerfileArg);
+        }
+        if (cleanTagsOriginal.indexOf(dockerfileArg.baseImage) !== -1) {
+          dockerfileArg.localBaseImageDependent = true;
+        }
+      });
+      if (sortableArrayArg.length === sortedArray.length) {
+        let counter = 1;
+        for (const dockerfile of sortedArray) {
+          logger.log('info', `tag ${counter}: -> ${dockerfile.cleanTag}`);
+          counter++;
+        }
+        done.resolve(sortedArray);
+      } else if (sorterFunctionCounter < 10) {
+        sorterFunctionCounter++;
+        sorterFunction();
+      }
+    };
+    sorterFunction();
+    return done.promise;
+  }
+
+  /**
+   * maps local Dockerfiles dependencies to the correspoding Dockerfile class instances
+   */
+  public static async mapDockerfiles(sortedDockerfileArray: Dockerfile[]): Promise<Dockerfile[]> {
+    sortedDockerfileArray.forEach(dockerfileArg => {
+      if (dockerfileArg.localBaseImageDependent) {
+        sortedDockerfileArray.forEach((dockfile2: Dockerfile) => {
+          if (dockfile2.cleanTag === dockerfileArg.baseImage) {
+            dockerfileArg.localBaseDockerfile = dockfile2;
+          }
+        });
+      }
+    });
+    return sortedDockerfileArray;
+  }
+
+  /**
+   * builds the correspoding real docker image for each Dockerfile class instance
+   */
+  public static async buildDockerfiles(sortedArrayArg: Dockerfile[]) {
+    for (const dockerfileArg of sortedArrayArg) {
+      await dockerfileArg.build();
+    }
+    return sortedArrayArg;
+  }
+
+  /**
+   * tests all Dockerfiles in by calling class Dockerfile.test();
+   * @param sortedArrayArg Dockerfile[] that contains all Dockerfiles in cwd
+   */
+  public static async testDockerfiles(sortedArrayArg: Dockerfile[]) {
+    for (const dockerfileArg of sortedArrayArg) {
+      await dockerfileArg.test();
+    }
+    return sortedArrayArg;
+  }
+
+  /**
+   * returns a version for a docker file
+   * @execution SYNC
+   */
+  public static dockerFileVersion(dockerfileNameArg: string): string {
+    let versionString: string;
+    const versionRegex = /Dockerfile_([a-zA-Z0-9\.]*)$/;
+    const regexResultArray = versionRegex.exec(dockerfileNameArg);
+    if (regexResultArray && regexResultArray.length === 2) {
+      versionString = regexResultArray[1];
+    } else {
+      versionString = 'latest';
+    }
+    return versionString;
+  }
+
+  /**
+   * returns the docker base image for a Dockerfile
+   */
+  public static dockerBaseImage(dockerfileContentArg: string): string {
+    const baseImageRegex = /FROM\s([a-zA-z0-9\/\-\:]*)\n?/;
+    const regexResultArray = baseImageRegex.exec(dockerfileContentArg);
+    return regexResultArray[1];
+  }
+
+  /**
+   * returns the docker tag
+   */
+  public static getDockerTagString(
+    npmciDockerManagerRef: NpmciDockerManager,
+    registryArg: string,
+    repoArg: string,
+    versionArg: string,
+    suffixArg?: string
+  ): string {
+    // determine wether the repo should be mapped accordingly to the registry
+    const mappedRepo = npmciDockerManagerRef.npmciRef.npmciConfig.getConfig().dockerRegistryRepoMap[
+      registryArg
+    ];
+    const repo = (() => {
+      if (mappedRepo) {
+        return mappedRepo;
+      } else {
+        return repoArg;
+      }
+    })();
+
+    // determine wether the version contais a suffix
+    let version = versionArg;
+    if (suffixArg) {
+      version = versionArg + '_' + suffixArg;
+    }
+
+    const tagString = `${registryArg}/${repo}:${version}`;
+    return tagString;
+  }
+
+  public static async getDockerBuildArgs(
+    npmciDockerManagerRef: NpmciDockerManager
+  ): Promise<string> {
+    logger.log('info', 'checking for env vars to be supplied to the docker build');
+    let buildArgsString: string = '';
+    for (const key of Object.keys(
+      npmciDockerManagerRef.npmciRef.npmciConfig.getConfig().dockerBuildargEnvMap
+    )) {
+      const targetValue =
+        process.env[
+          npmciDockerManagerRef.npmciRef.npmciConfig.getConfig().dockerBuildargEnvMap[key]
+        ];
+      buildArgsString = `${buildArgsString} --build-arg ${key}="${targetValue}"`;
+    }
+    return buildArgsString;
+  }
+
+  /**
+   *
+   */
+  public static cleanTagsArrayFunction(
+    dockerfileArrayArg: Dockerfile[],
+    trackingArrayArg: Dockerfile[]
+  ): string[] {
+    const cleanTagsArray: string[] = [];
+    dockerfileArrayArg.forEach(dockerfileArg => {
+      if (trackingArrayArg.indexOf(dockerfileArg) === -1) {
+        cleanTagsArray.push(dockerfileArg.cleanTag);
+      }
+    });
+    return cleanTagsArray;
+  }
+
+  // INSTANCE
+  public npmciDockerManagerRef: NpmciDockerManager;
+
+  public filePath: string;
+  public repo: string;
+  public version: string;
+  public cleanTag: string;
+  public buildTag: string;
+  public containerName: string;
+  public content: string;
+  public baseImage: string;
+  public localBaseImageDependent: boolean;
+  public localBaseDockerfile: Dockerfile;
+
+  constructor(
+    dockerManagerRefArg: NpmciDockerManager,
+    options: { filePath?: string; fileContents?: string | Buffer; read?: boolean }
+  ) {
+    this.npmciDockerManagerRef = dockerManagerRefArg;
+    this.filePath = options.filePath;
+    this.repo =
+      this.npmciDockerManagerRef.npmciRef.npmciEnv.repo.user +
+      '/' +
+      this.npmciDockerManagerRef.npmciRef.npmciEnv.repo.repo;
+    this.version = Dockerfile.dockerFileVersion(plugins.path.parse(options.filePath).base);
+    this.cleanTag = this.repo + ':' + this.version;
+    this.buildTag = this.cleanTag;
+
+    this.containerName = 'dockerfile-' + this.version;
+    if (options.filePath && options.read) {
+      this.content = plugins.smartfile.fs.toStringSync(plugins.path.resolve(options.filePath));
+    }
+    this.baseImage = Dockerfile.dockerBaseImage(this.content);
+    this.localBaseImageDependent = false;
+  }
+
+  /**
+   * builds the Dockerfile
+   */
+  public async build() {
+    logger.log('info', 'now building Dockerfile for ' + this.cleanTag);
+    const buildArgsString = await Dockerfile.getDockerBuildArgs(this.npmciDockerManagerRef);
+    const buildCommand = `docker build -t ${this.buildTag} -f ${this.filePath} ${buildArgsString} .`;
+    await bash(buildCommand);
+    return;
+  }
+
+  /**
+   * pushes the Dockerfile to a registry
+   */
+  public async push(dockerRegistryArg: DockerRegistry, versionSuffix: string = null) {
+    const pushTag = Dockerfile.getDockerTagString(
+      this.npmciDockerManagerRef,
+      dockerRegistryArg.registryUrl,
+      this.repo,
+      this.version,
+      versionSuffix
+    );
+    await bash(`docker tag ${this.buildTag} ${pushTag}`);
+    await bash(`docker push ${pushTag}`);
+  }
+
+  /**
+   * pulls the Dockerfile from a registry
+   */
+  public async pull(registryArg: DockerRegistry, versionSuffixArg: string = null) {
+    const pullTag = Dockerfile.getDockerTagString(
+      this.npmciDockerManagerRef,
+      registryArg.registryUrl,
+      this.repo,
+      this.version,
+      versionSuffixArg
+    );
+    await bash(`docker pull ${pullTag}`);
+    await bash(`docker tag ${pullTag} ${this.buildTag}`);
+  }
+
+  /**
+   * tests the Dockerfile;
+   */
+  public async test() {
+    const testFile: string = plugins.path.join(paths.NpmciTestDir, 'test_' + this.version + '.sh');
+    const testFileExists: boolean = plugins.smartfile.fs.fileExistsSync(testFile);
+    if (testFileExists) {
+      // run tests
+      await bash(
+        `docker run --name npmci_test_container --entrypoint="bash" ${this.buildTag} -c "mkdir /npmci_test"`
+      );
+      await bash(`docker cp ${testFile} npmci_test_container:/npmci_test/test.sh`);
+      await bash(`docker commit npmci_test_container npmci_test_image`);
+      await bash(`docker run --entrypoint="bash" npmci_test_image -x /npmci_test/test.sh`);
+      await bash(`docker rm npmci_test_container`);
+      await bash(`docker rmi --force npmci_test_image`);
+    } else {
+      logger.log('warn', 'skipping tests for ' + this.cleanTag + ' because no testfile was found!');
+    }
+  }
+
+  /**
+   * gets the id of a Dockerfile
+   */
+  public async getId() {
+    const containerId = await bash(
+      'docker inspect --type=image --format="{{.Id}}" ' + this.buildTag
+    );
+    return containerId;
+  }
+}
--- a/ts/manager.docker/mod.classes.dockerregistry.ts
+++ b/ts/manager.docker/mod.classes.dockerregistry.ts
@@ -1,3 +1,4 @@
+import { logger } from '../npmci.logging';
 import * as plugins from './mod.plugins';
 import { bash } from '../npmci.bash';

@@ -8,26 +9,26 @@ export interface IDockerRegistryConstructorOptions {
 }

 export class DockerRegistry {
-  registryUrl: string;
-  username: string;
-  password: string;
+  public registryUrl: string;
+  public username: string;
+  public password: string;
  constructor(optionsArg: IDockerRegistryConstructorOptions) {
    this.registryUrl = optionsArg.registryUrl;
    this.username = optionsArg.username;
    this.password = optionsArg.password;
-    plugins.beautylog.info(`created DockerRegistry for ${this.registryUrl}`);
+    logger.log('info', `created DockerRegistry for ${this.registryUrl}`);
  }

-  static fromEnvString(envString: string): DockerRegistry {
-    let dockerRegexResultArray = envString.split('|');
+  public static fromEnvString(envString: string): DockerRegistry {
+    const dockerRegexResultArray = envString.split('|');
    if (dockerRegexResultArray.length !== 3) {
-      plugins.beautylog.error('malformed docker env var...');
+      logger.log('error', 'malformed docker env var...');
      process.exit(1);
      return;
    }
-    let registryUrl = dockerRegexResultArray[0];
-    let username = dockerRegexResultArray[1];
-    let password = dockerRegexResultArray[2];
+    const registryUrl = dockerRegexResultArray[0];
+    const username = dockerRegexResultArray[1];
+    const password = dockerRegexResultArray[2];
    return new DockerRegistry({
      registryUrl: registryUrl,
      username: username,
@@ -35,13 +36,13 @@ export class DockerRegistry {
    });
  }

-  async login() {
+  public async login() {
    if (this.registryUrl === 'docker.io') {
      await bash(`docker login -u ${this.username} -p ${this.password}`);
-      plugins.beautylog.info('Logged in to standard docker hub');
+      logger.log('info', 'Logged in to standard docker hub');
    } else {
      await bash(`docker login -u ${this.username} -p ${this.password} ${this.registryUrl}`);
    }
-    plugins.beautylog.ok(`docker authenticated for ${this.registryUrl}!`);
+    logger.log('ok', `docker authenticated for ${this.registryUrl}!`);
  }
 }
--- a/ts/manager.docker/mod.classes.registrystorage.ts
+++ b/ts/manager.docker/mod.classes.registrystorage.ts
@@ -1,5 +1,6 @@
+import { logger } from '../npmci.logging';
 import * as plugins from './mod.plugins';
-import { Objectmap } from 'lik';
+import { Objectmap } from '@pushrocks/lik';

 import { DockerRegistry } from './mod.classes.dockerregistry';

@@ -23,6 +24,6 @@ export class RegistryStorage {
    await this.objectMap.forEach(async registryArg => {
      await registryArg.login();
    });
-    plugins.beautylog.success('logged in successfully into all available DockerRegistries!');
+    logger.log('success', 'logged in successfully into all available DockerRegistries!');
  }
 }
--- a/ts/manager.docker/mod.helpers.ts
+++ b/ts/manager.docker/mod.helpers.ts
@@ -0,0 +1,6 @@
+import { logger } from '../npmci.logging';
+import * as plugins from './mod.plugins';
+import * as paths from '../npmci.paths';
+
+import { Dockerfile } from './mod.classes.dockerfile';
+
--- a/ts/manager.docker/mod.plugins.ts
+++ b/ts/manager.docker/mod.plugins.ts
--- a/ts/manager.git/index.ts
+++ b/ts/manager.git/index.ts
@@ -0,0 +1,65 @@
+import { logger } from '../npmci.logging';
+import * as plugins from './mod.plugins';
+import { bash } from '../npmci.bash';
+import { Npmci } from '../npmci.classes.npmci';
+
+export class NpmciGitManager {
+  public npmciRef: Npmci;
+
+  constructor(npmciRefArg: Npmci) {
+    this.npmciRef = npmciRefArg;
+  }
+
+  /**
+   * handle cli input
+   * @param argvArg
+   */
+  public handleCli = async argvArg => {
+    if (argvArg._.length >= 2) {
+      const action: string = argvArg._[1];
+      switch (action) {
+        case 'mirror':
+          await this.mirror();
+          break;
+        default:
+          logger.log('error', `npmci git -> action >>${action}<< not supported!`);
+      }
+    } else {
+      logger.log('info', `npmci git -> cli arguments invalid! Please read the documentation.`);
+    }
+  }
+
+  public mirror = async () => {
+    const githubToken = process.env.NPMCI_GIT_GITHUBTOKEN;
+    const githubUser = process.env.NPMCI_GIT_GITHUBGROUP || this.npmciRef.npmciEnv.repo.user;
+    const githubRepo = process.env.NPMCI_GIT_GITHUB || this.npmciRef.npmciEnv.repo;
+    if (
+      this.npmciRef.npmciConfig.getConfig().projectInfo.npm.packageJson.private === true ||
+      this.npmciRef.npmciConfig.getConfig().npmAccessLevel === 'private'
+    ) {
+      logger.log(
+        'warn',
+        `refusing to mirror due to private property use a private mirror location instead`
+      );
+      return;
+    }
+    if (githubToken) {
+      logger.log('info', 'found github token.');
+      logger.log('info', 'attempting the mirror the repository to GitHub');
+  
+      // plugins.smartgit.GitRepo;
+  
+      // add the mirror
+      await bash(
+        `git remote add mirror https://${githubToken}@github.com/${githubUser}/${githubRepo}.git`
+      );
+      await bash(`git push mirror --all`);
+      logger.log('ok', 'pushed all branches to mirror!');
+      await bash(`git push mirror --tags`);
+      logger.log('ok', 'pushed all tags to mirror!');
+    } else {
+      logger.log('error', `cannot find NPMCI_GIT_GITHUBTOKEN env var!`);
+      process.exit(1);
+    }
+  }
+}
--- a/ts/manager.git/mod.plugins.ts
+++ b/ts/manager.git/mod.plugins.ts
@@ -0,0 +1,5 @@
+export * from '../npmci.plugins';
+
+import * as smartgit from '@pushrocks/smartgit';
+
+export { smartgit };
--- a/ts/manager.nodejs/index.ts
+++ b/ts/manager.nodejs/index.ts
@@ -0,0 +1,83 @@
+import * as plugins from '../npmci.plugins';
+import * as paths from '../npmci.paths';
+
+import { logger } from '../npmci.logging';
+import { bash, bashNoError, nvmAvailable } from '../npmci.bash';
+import { Npmci } from '../npmci.classes.npmci';
+
+export class NpmciNodeJsManager {
+  public npmciRef: Npmci;
+
+  constructor(npmciRefArg: Npmci) {
+    this.npmciRef = npmciRefArg;
+  }
+
+  /**
+   * handle cli input
+   * @param argvArg
+   */
+  public async handleCli(argvArg) {
+    if (argvArg._.length >= 3) {
+      const action: string = argvArg._[1];
+      switch (action) {
+        case 'install':
+          await this.install(argvArg._[2]);
+          break;
+        default:
+          logger.log('error', `>>npmci node ...<< action >>${action}<< not supported`);
+          process.exit(1);
+      }
+    } else {
+      logger.log(
+        'error',
+        `>>npmci node ...<< cli arguments invalid... Please read the documentation.`
+      );
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Install a specific version of node
+   * @param versionArg
+   */
+  public async install(versionArg) {
+    logger.log('info', `now installing node version ${versionArg}`);
+    let version: string;
+    if (versionArg === 'stable') {
+      version = '12';
+    } else if (versionArg === 'lts') {
+      version = '10';
+    } else if (versionArg === 'legacy') {
+      version = '8';
+    } else {
+      version = versionArg;
+    }
+    if (await nvmAvailable.promise) {
+      await bash(`nvm install ${version} && nvm alias default ${version}`);
+      logger.log('success', `Node version ${version} successfully installed!`);
+    } else {
+      logger.log('warn', 'Nvm not in path so staying at installed node version!');
+    }
+    logger.log('info', 'now installing latest npm version');
+    await bash('npm install -g npm');
+    await bash('node -v');
+    await bash('npm -v');
+    await bash(`npm config set cache ${paths.NpmciCacheDir}  --global `);
+
+    // lets look for further config
+    const config = await this.npmciRef.npmciConfig.getConfig();
+    logger.log('info', 'Now checking for needed global npm tools...');
+    for (const npmTool of config.npmGlobalTools) {
+      logger.log('info', `Checking for global "${npmTool}"`);
+      const whichOutput: string = await bashNoError(`which ${npmTool}`);
+      const toolAvailable: boolean = !(/not\sfound/.test(whichOutput) || whichOutput === '');
+      if (toolAvailable) {
+        logger.log('info', `Tool ${npmTool} is available`);
+      } else {
+        logger.log('info', `globally installing ${npmTool} from npm`);
+        await bash(`npm install ${npmTool} -q -g`);
+      }
+    }
+    logger.log('success', 'all global npm tools specified in npmextra.json are now available!');
+  }
+}
--- a/ts/manager.npm/index.ts
+++ b/ts/manager.npm/index.ts
@@ -0,0 +1,162 @@
+import * as plugins from './mod.plugins';
+
+import { logger } from '../npmci.logging';
+import { bash, bashNoError, nvmAvailable } from '../npmci.bash';
+import { Npmci } from '../npmci.classes.npmci';
+
+export class NpmciNpmManager {
+  public npmciRef: Npmci;
+
+  constructor(npmciRefArg) {
+    this.npmciRef = npmciRefArg;
+  }
+
+  /**
+   * handle cli input
+   * @param argvArg
+   */
+  public async handleCli(argvArg) {
+    if (argvArg._.length >= 2) {
+      const action: string = argvArg._[1];
+      switch (action) {
+        case 'install':
+          await this.install();
+          break;
+        case 'prepare':
+          await this.prepare();
+          break;
+        case 'test':
+          await this.test();
+          break;
+        case 'publish':
+          await this.publish();
+          break;
+        default:
+          logger.log('error', `>>npmci npm ...<< action >>${action}<< not supported`);
+          process.exit(1);
+      }
+    } else {
+      logger.log(
+        'info',
+        `>>npmci npm ...<< cli arguments invalid... Please read the documentation.`
+      );
+      process.exit(1);
+    }
+  }
+
+  /**
+   * authenticates npm with token from env var
+   */
+  public async prepare() {
+    const config = this.npmciRef.npmciConfig.getConfig();
+    let npmrcFileString: string = '';
+    await plugins.smartparam.forEachMinimatch(process.env, 'NPMCI_TOKEN_NPM*', npmEnvArg => {
+      const npmRegistryUrl = npmEnvArg.split('|')[0];
+      const npmToken = npmEnvArg.split('|')[1];
+      npmrcFileString += `//${npmRegistryUrl}/:_authToken="${plugins.smartstring.base64.decode(
+        npmToken
+      )}"\n`;
+    });
+    logger.log('info', `setting default npm registry to ${config.npmRegistryUrl}`);
+    npmrcFileString += `registry=https://${config.npmRegistryUrl}\n`;
+
+    // final check
+    if (npmrcFileString.length > 0) {
+      logger.log('info', 'found one or more access tokens');
+    } else {
+      logger.log('error', 'no access token found! Exiting!');
+      process.exit(1);
+    }
+
+    // lets save it to disk
+    plugins.smartfile.memory.toFsSync(npmrcFileString, '/root/.npmrc');
+    return;
+  }
+
+  /**
+   * publish a package to npm
+   */
+  public async publish() {
+    const buildPublishCommand = async () => {
+      let npmAccessCliString = ``;
+      let npmRegistryCliString = ``;
+      let publishVerdaccioAsWell = false;
+      const config = this.npmciRef.npmciConfig.getConfig();
+      const availableRegistries: string[] = [];
+      await plugins.smartparam.forEachMinimatch(process.env, 'NPMCI_TOKEN_NPM*', npmEnvArg => {
+        availableRegistries.push(npmEnvArg.split('|')[0]);
+      });
+
+      // -> configure package access level
+      if (config.npmAccessLevel) {
+        npmAccessCliString = `--access=${config.npmAccessLevel}`;
+        if (config.npmAccessLevel === 'public') {
+          publishVerdaccioAsWell = true;
+        }
+      } else {
+        throw new Error('You need to set a npmAccessLevel!!!');
+      }
+      // -> configure registry url
+      if (config.npmRegistryUrl) {
+        npmRegistryCliString = `--registry=https://${config.npmRegistryUrl}`;
+      } else {
+        logger.log('error', `no registry url specified. Can't publish!`);
+        process.exit(1);
+      }
+
+      let publishCommand = `npm publish ${npmAccessCliString} ${npmRegistryCliString} `;
+
+      // publishEverywhere
+      if (publishVerdaccioAsWell) {
+        const verdaccioRegistry = availableRegistries.find(registryString =>
+          registryString.startsWith('verdaccio')
+        );
+        if (verdaccioRegistry) {
+          logger.log(
+            'info',
+            `package is public and verdaccio registry is specified. Also publishing to Verdaccio!`
+          );
+          publishCommand = `${publishCommand} && npm publish ${npmAccessCliString} --registry=https://${verdaccioRegistry}`;
+        } else {
+          logger.log(
+            'error',
+            `This package should also be published to Verdaccio, however there is no Verdaccio registry data available!`
+          );
+        }
+      }
+      return publishCommand;
+    };
+
+    // -> preparing
+    logger.log('info', `now preparing environment:`);
+    this.prepare();
+    await bash(`npm -v`);
+
+    // -> build it
+    await bash(`npm install`);
+    await bash(`npm run build`);
+
+    logger.log('success', `Nice!!! The build for the publication was successfull!`);
+    logger.log('info', `Lets clean up so we don't publish any packages that don't belong to us:`);
+    // -> clean up before we publish stuff
+    await bashNoError(`rm -r ./.npmci_cache`);
+    await bash(`rm -r ./node_modules`);
+
+    logger.log('success', `Cleaned up!:`);
+
+    // -> publish it
+    logger.log('info', `now invoking npm to publish the package!`);
+    await bash(await buildPublishCommand());
+    logger.log('success', `Package was successfully published!`);
+  }
+
+  public async install(): Promise<void> {
+    logger.log('info', 'now installing dependencies:');
+    await bash('npm install');
+  }
+
+  public async test(): Promise<void> {
+    logger.log('info', 'now starting tests:');
+    await bash('npm test');
+  }
+}
--- a/ts/manager.npm/mod.plugins.ts
+++ b/ts/manager.npm/mod.plugins.ts
--- a/ts/mod_cloudflare/index.ts
+++ b/ts/mod_cloudflare/index.ts
@@ -1,31 +0,0 @@
-import * as plugins from './mod.plugins';
-
-let npmciCflare = new plugins.cflare.CflareAccount();
-
-/**
- * handle cli input
- * @param argvArg
- */
-export let handleCli = async argvArg => {
-  if (argvArg._.length >= 2) {
-    let action: string = argvArg._[1];
-    switch (action) {
-      default:
-        plugins.beautylog.error(`>>npmci cloudflare ...<< action >>${action}<< not supported`);
-        process.exit(1);
-    }
-  } else {
-    plugins.beautylog.log(
-      `>>npmci cloudflare ...<< cli arguments invalid... Please read the documentation.`
-    );
-    process.exit(1);
-  }
-};
-
-export let purge = async argvArg => {
-  npmciCflare.auth({
-    email: '',
-    key: ''
-  });
-  npmciCflare.purgeZone(argvArg._[1]);
-};
--- a/ts/mod_cloudflare/mod.plugins.ts
+++ b/ts/mod_cloudflare/mod.plugins.ts
@@ -1,5 +0,0 @@
-export * from '../npmci.plugins';
-
-import * as cflare from 'cflare';
-
-export { cflare };
--- a/ts/mod_docker/index.ts
+++ b/ts/mod_docker/index.ts
@@ -1,142 +0,0 @@
-import * as plugins from './mod.plugins';
-import * as paths from '../npmci.paths';
-import { bash } from '../npmci.bash';
-
-import * as helpers from './mod.helpers';
-
-// classes
-import { Dockerfile } from './mod.classes.dockerfile';
-import { DockerRegistry } from './mod.classes.dockerregistry';
-import { RegistryStorage } from './mod.classes.registrystorage';
-
-// instances
-let npmciRegistryStorage = new RegistryStorage();
-
-export { Dockerfile, helpers };
-
-export let modArgvArg; // will be set through the build command
-
-/**
- * handle cli input
- * @param argvArg
- */
-export let handleCli = async argvArg => {
-  modArgvArg = argvArg;
-  if (argvArg._.length >= 2) {
-    let action: string = argvArg._[1];
-    switch (action) {
-      case 'build':
-        await build();
-        break;
-      case 'login':
-      case 'prepare':
-        await login();
-        break;
-      case 'test':
-        await test();
-        break;
-      case 'push':
-        await push(argvArg);
-        break;
-      case 'pull':
-        await pull(argvArg);
-        break;
-      default:
-        plugins.beautylog.error(`>>npmci docker ...<< action >>${action}<< not supported`);
-    }
-  } else {
-    plugins.beautylog.log(
-      `>>npmci docker ...<< cli arguments invalid... Please read the documentation.`
-    );
-  }
-};
-
-/**
- * builds a cwd of Dockerfiles by triggering a promisechain
- */
-export let build = async () => {
-  await prepare();
-  plugins.beautylog.log('now building Dockerfiles...');
-  await helpers
-    .readDockerfiles()
-    .then(helpers.sortDockerfiles)
-    .then(helpers.mapDockerfiles)
-    .then(helpers.buildDockerfiles);
-};
-
-/**
- * login to the DockerRegistries
- */
-export let login = async () => {
-  await prepare();
-  await npmciRegistryStorage.loginAll();
-};
-
-/**
- * logs in docker
- */
-export let prepare = async () => {
-  // Always login to GitLab Registry
-  if (!process.env.CI_BUILD_TOKEN || process.env.CI_BUILD_TOKEN === '') {
-    plugins.beautylog.error('No registry token specified by gitlab!');
-    process.exit(1);
-  }
-  npmciRegistryStorage.addRegistry(
-    new DockerRegistry({
-      registryUrl: 'registry.gitlab.com',
-      username: 'gitlab-ci-token',
-      password: process.env.CI_BUILD_TOKEN
-    })
-  );
-
-  // handle registries
-  await plugins.smartparam.forEachMinimatch(process.env, 'NPMCI_LOGIN_DOCKER*', async envString => {
-    npmciRegistryStorage.addRegistry(DockerRegistry.fromEnvString(envString));
-  });
-  return;
-};
-
-export let push = async argvArg => {
-  await prepare();
-  let registryUrlArg = argvArg._[2];
-  let suffix = null;
-  if (argvArg._.length >= 4) {
-    suffix = argvArg._[3];
-  }
-  let dockerfileArray = await helpers
-    .readDockerfiles()
-    .then(helpers.sortDockerfiles)
-    .then(helpers.mapDockerfiles);
-  let localDockerRegistry = npmciRegistryStorage.getRegistryByUrl(registryUrlArg);
-  if (!localDockerRegistry) {
-    plugins.beautylog.error(
-      `Cannot push to registry ${registryUrlArg}, because it was not found in the authenticated registry list.`
-    );
-    process.exit(1);
-  }
-  for (let dockerfile of dockerfileArray) {
-    await dockerfile.push(localDockerRegistry, suffix);
-  }
-};
-
-export let pull = async argvArg => {
-  await prepare();
-  let registryUrlArg = argvArg._[2];
-  let suffix = null;
-  if (argvArg._.length >= 4) {
-    suffix = argvArg._[3];
-  }
-  let localDockerRegistry = npmciRegistryStorage.getRegistryByUrl(registryUrlArg);
-  let dockerfileArray = await helpers
-    .readDockerfiles()
-    .then(helpers.sortDockerfiles)
-    .then(helpers.mapDockerfiles);
-  for (let dockerfile of dockerfileArray) {
-    await dockerfile.pull(localDockerRegistry, suffix);
-  }
-};
-
-export let test = async () => {
-  await prepare();
-  return await helpers.readDockerfiles().then(helpers.testDockerfiles);
-};
--- a/ts/mod_docker/mod.classes.dockerfile.ts
+++ b/ts/mod_docker/mod.classes.dockerfile.ts
@@ -1,109 +0,0 @@
-import * as plugins from './mod.plugins';
-import * as NpmciEnv from '../npmci.env';
-import { bash } from '../npmci.bash';
-import * as paths from '../npmci.paths';
-
-import { DockerRegistry } from './mod.classes.dockerregistry';
-import * as helpers from './mod.helpers';
-
-/**
- * class Dockerfile represents a Dockerfile on disk in npmci
- */
-export class Dockerfile {
-  filePath: string;
-  repo: string;
-  version: string;
-  cleanTag: string;
-  buildTag: string;
-  containerName: string;
-  content: string;
-  baseImage: string;
-  localBaseImageDependent: boolean;
-  localBaseDockerfile: Dockerfile;
-  constructor(options: { filePath?: string; fileContents?: string | Buffer; read?: boolean }) {
-    this.filePath = options.filePath;
-    this.repo = NpmciEnv.repo.user + '/' + NpmciEnv.repo.repo;
-    this.version = helpers.dockerFileVersion(plugins.path.parse(options.filePath).base);
-    this.cleanTag = this.repo + ':' + this.version;
-    this.buildTag = this.cleanTag;
-
-    this.containerName = 'dockerfile-' + this.version;
-    if (options.filePath && options.read) {
-      this.content = plugins.smartfile.fs.toStringSync(plugins.path.resolve(options.filePath));
-    }
-    this.baseImage = helpers.dockerBaseImage(this.content);
-    this.localBaseImageDependent = false;
-  }
-
-  /**
-   * builds the Dockerfile
-   */
-  async build() {
-    plugins.beautylog.info('now building Dockerfile for ' + this.cleanTag);
-    let buildArgsString = await helpers.getDockerBuildArgs();
-    let buildCommand = `docker build -t ${this.buildTag} -f ${this.filePath} ${buildArgsString} .`;
-    await bash(buildCommand);
-    return;
-  }
-
-  /**
-   * pushes the Dockerfile to a registry
-   */
-  async push(dockerRegistryArg: DockerRegistry, versionSuffix: string = null) {
-    let pushTag = helpers.getDockerTagString(
-      dockerRegistryArg.registryUrl,
-      this.repo,
-      this.version,
-      versionSuffix
-    );
-    await bash(`docker tag ${this.buildTag} ${pushTag}`);
-    await bash(`docker push ${pushTag}`);
-  }
-
-  /**
-   * pulls the Dockerfile from a registry
-   */
-  async pull(registryArg: DockerRegistry, versionSuffixArg: string = null) {
-    let pullTag = helpers.getDockerTagString(
-      registryArg.registryUrl,
-      this.repo,
-      this.version,
-      versionSuffixArg
-    );
-    await bash(`docker pull ${pullTag}`);
-    await bash(`docker tag ${pullTag} ${this.buildTag}`);
-  }
-
-  /**
-   * tests the Dockerfile;
-   */
-  async test() {
-    let testFile: string = plugins.path.join(paths.NpmciTestDir, 'test_' + this.version + '.sh');
-    let testFileExists: boolean = plugins.smartfile.fs.fileExistsSync(testFile);
-    if (testFileExists) {
-      // run tests
-      await bash(
-        `docker run --name npmci_test_container --entrypoint="bash" ${
-          this.buildTag
-        } -c "mkdir /npmci_test"`
-      );
-      await bash(`docker cp ${testFile} npmci_test_container:/npmci_test/test.sh`);
-      await bash(`docker commit npmci_test_container npmci_test_image`);
-      await bash(`docker run --entrypoint="bash" npmci_test_image -x /npmci_test/test.sh`);
-      await bash(`docker rm npmci_test_container`);
-      await bash(`docker rmi --force npmci_test_image`);
-    } else {
-      plugins.beautylog.warn(
-        'skipping tests for ' + this.cleanTag + ' because no testfile was found!'
-      );
-    }
-  }
-
-  /**
-   * gets the id of a Dockerfile
-   */
-  async getId() {
-    let containerId = await bash('docker inspect --type=image --format="{{.Id}}" ' + this.buildTag);
-    return containerId;
-  }
-}
--- a/ts/mod_docker/mod.helpers.ts
+++ b/ts/mod_docker/mod.helpers.ts
@@ -1,186 +0,0 @@
-import * as plugins from './mod.plugins';
-import * as paths from '../npmci.paths';
-import * as NpmciEnv from '../npmci.env';
-import * as NpmciConfig from '../npmci.config';
-import { bash } from '../npmci.bash';
-
-import { Dockerfile } from './mod.classes.dockerfile';
-
-/**
- * creates instance of class Dockerfile for all Dockerfiles in cwd
- * @returns Promise<Dockerfile[]>
- */
-export let readDockerfiles = async (): Promise<Dockerfile[]> => {
-  let fileTree = await plugins.smartfile.fs.listFileTree(paths.cwd, 'Dockerfile*');
-
-  // create the Dockerfile array
-  let readDockerfilesArray: Dockerfile[] = [];
-  plugins.beautylog.info(`found ${fileTree.length} Dockerfiles:`);
-  console.log(fileTree);
-  for (let dockerfilePath of fileTree) {
-    let myDockerfile = new Dockerfile({
-      filePath: dockerfilePath,
-      read: true
-    });
-    readDockerfilesArray.push(myDockerfile);
-  }
-
-  return readDockerfilesArray;
-};
-
-/**
- * sorts Dockerfiles into a dependency chain
- * @param sortableArrayArg an array of instances of class Dockerfile
- * @returns Promise<Dockerfile[]>
- */
-export let sortDockerfiles = (sortableArrayArg: Dockerfile[]): Promise<Dockerfile[]> => {
-  let done = plugins.q.defer<Dockerfile[]>();
-  plugins.beautylog.info('sorting Dockerfiles:');
-  let sortedArray: Dockerfile[] = [];
-  let cleanTagsOriginal = cleanTagsArrayFunction(sortableArrayArg, sortedArray);
-  let sorterFunctionCounter: number = 0;
-  let sorterFunction = function() {
-    sortableArrayArg.forEach(dockerfileArg => {
-      let cleanTags = cleanTagsArrayFunction(sortableArrayArg, sortedArray);
-      if (
-        cleanTags.indexOf(dockerfileArg.baseImage) === -1 &&
-        sortedArray.indexOf(dockerfileArg) === -1
-      ) {
-        sortedArray.push(dockerfileArg);
-      }
-      if (cleanTagsOriginal.indexOf(dockerfileArg.baseImage) !== -1) {
-        dockerfileArg.localBaseImageDependent = true;
-      }
-    });
-    if (sortableArrayArg.length === sortedArray.length) {
-      let counter = 1;
-      for (let dockerfile of sortedArray) {
-        plugins.beautylog.log(`tag ${counter}: -> ${dockerfile.cleanTag}`);
-        counter++;
-      }
-      done.resolve(sortedArray);
-    } else if (sorterFunctionCounter < 10) {
-      sorterFunctionCounter++;
-      sorterFunction();
-    }
-  };
-  sorterFunction();
-  return done.promise;
-};
-
-/**
- * maps local Dockerfiles dependencies to the correspoding Dockerfile class instances
- */
-export let mapDockerfiles = async (sortedArray: Dockerfile[]): Promise<Dockerfile[]> => {
-  sortedArray.forEach(dockerfileArg => {
-    if (dockerfileArg.localBaseImageDependent) {
-      sortedArray.forEach((dockfile2: Dockerfile) => {
-        if (dockfile2.cleanTag === dockerfileArg.baseImage) {
-          dockerfileArg.localBaseDockerfile = dockfile2;
-        }
-      });
-    }
-  });
-  return sortedArray;
-};
-
-/**
- * builds the correspoding real docker image for each Dockerfile class instance
- */
-export let buildDockerfiles = async (sortedArrayArg: Dockerfile[]) => {
-  for (let dockerfileArg of sortedArrayArg) {
-    await dockerfileArg.build();
-  }
-  return sortedArrayArg;
-};
-
-/**
- * tests all Dockerfiles in by calling class Dockerfile.test();
- * @param sortedArrayArg Dockerfile[] that contains all Dockerfiles in cwd
- */
-export let testDockerfiles = async (sortedArrayArg: Dockerfile[]) => {
-  for (let dockerfileArg of sortedArrayArg) {
-    await dockerfileArg.test();
-  }
-  return sortedArrayArg;
-};
-
-/**
- * returns a version for a docker file
- * @execution SYNC
- */
-export let dockerFileVersion = (dockerfileNameArg: string): string => {
-  let versionString: string;
-  let versionRegex = /Dockerfile_([a-zA-Z0-9\.]*)$/;
-  let regexResultArray = versionRegex.exec(dockerfileNameArg);
-  if (regexResultArray && regexResultArray.length === 2) {
-    versionString = regexResultArray[1];
-  } else {
-    versionString = 'latest';
-  }
-  return versionString;
-};
-
-/**
- * returns the docker base image for a Dockerfile
- */
-export let dockerBaseImage = function(dockerfileContentArg: string) {
-  let baseImageRegex = /FROM\s([a-zA-z0-9\/\-\:]*)\n?/;
-  let regexResultArray = baseImageRegex.exec(dockerfileContentArg);
-  return regexResultArray[1];
-};
-
-/**
- * returns the docker tag
- */
-export let getDockerTagString = (
-  registryArg: string,
-  repoArg: string,
-  versionArg: string,
-  suffixArg?: string
-): string => {
-  // determine wether the repo should be mapped accordingly to the registry
-  let mappedRepo = NpmciConfig.configObject.dockerRegistryRepoMap[registryArg];
-  let repo = (() => {
-    if (mappedRepo) {
-      return mappedRepo;
-    } else {
-      return repoArg;
-    }
-  })();
-
-  // determine wether the version contais a suffix
-  let version = versionArg;
-  if (suffixArg) {
-    version = versionArg + '_' + suffixArg;
-  }
-
-  let tagString = `${registryArg}/${repo}:${version}`;
-  return tagString;
-};
-
-export let getDockerBuildArgs = async (): Promise<string> => {
-  plugins.beautylog.info('checking for env vars to be supplied to the docker build');
-  let buildArgsString: string = '';
-  for (let key in NpmciConfig.configObject.dockerBuildargEnvMap) {
-    let targetValue = process.env[NpmciConfig.configObject.dockerBuildargEnvMap[key]];
-    buildArgsString = `${buildArgsString} --build-arg ${key}=${targetValue}`;
-  }
-  return buildArgsString;
-};
-
-/**
- *
- */
-export let cleanTagsArrayFunction = function(
-  dockerfileArrayArg: Dockerfile[],
-  trackingArrayArg: Dockerfile[]
-): string[] {
-  let cleanTagsArray: string[] = [];
-  dockerfileArrayArg.forEach(function(dockerfileArg) {
-    if (trackingArrayArg.indexOf(dockerfileArg) === -1) {
-      cleanTagsArray.push(dockerfileArg.cleanTag);
-    }
-  });
-  return cleanTagsArray;
-};
--- a/ts/mod_git/index.ts
+++ b/ts/mod_git/index.ts
@@ -1,45 +0,0 @@
-import * as plugins from './mod.plugins';
-import { bash } from '../npmci.bash';
-import { repo } from '../npmci.env';
-
-/**
- * handle cli input
- * @param argvArg
- */
-export let handleCli = async argvArg => {
-  if (argvArg._.length >= 2) {
-    let action: string = argvArg._[1];
-    switch (action) {
-      case 'mirror':
-        await mirror();
-        break;
-      default:
-        plugins.beautylog.error(`>>npmci git ...<< action >>${action}<< not supported`);
-    }
-  } else {
-    plugins.beautylog.log(
-      `>>npmci git ...<< cli arguments invalid... Please read the documentation.`
-    );
-  }
-};
-
-export let mirror = async () => {
-  let githubToken = process.env.NPMCI_GIT_GITHUBTOKEN;
-  let githubUser = process.env.NPMCI_GIT_GITHUBGROUP || repo.user;
-  let githubRepo = process.env.NPMCI_GIT_GITHUB || repo.repo;
-  if (githubToken) {
-    plugins.beautylog.info('found github token.');
-    plugins.beautylog.log('attempting the mirror the repository to GitHub');
-    // add the mirror
-    await bash(
-      `git remote add mirror https://${githubToken}@github.com/${githubUser}/${githubRepo}.git`
-    );
-    await bash(`git push mirror --all`);
-    plugins.beautylog.ok('pushed all branches to mirror!');
-    await bash(`git push mirror --tags`);
-    plugins.beautylog.ok('pushed all tags to mirror!');
-  } else {
-    plugins.beautylog.error(`cannot find NPMCI_GIT_GITHUBTOKEN env var!`);
-    process.exit(1);
-  }
-};
--- a/ts/mod_node/index.ts
+++ b/ts/mod_node/index.ts
@@ -1,72 +0,0 @@
-import * as plugins from '../npmci.plugins';
-import * as npmciConfig from '../npmci.config';
-import { bash, bashNoError, nvmAvailable, yarnAvailable } from '../npmci.bash';
-
-/**
- * handle cli input
- * @param argvArg
- */
-export let handleCli = async argvArg => {
-  if (argvArg._.length >= 3) {
-    let action: string = argvArg._[1];
-    switch (action) {
-      case 'install':
-        await install(argvArg._[2]);
-        break;
-      default:
-        plugins.beautylog.error(`>>npmci node ...<< action >>${action}<< not supported`);
-        process.exit(1);
-    }
-  } else {
-    plugins.beautylog.error(
-      `>>npmci node ...<< cli arguments invalid... Please read the documentation.`
-    );
-    process.exit(1);
-  }
-};
-
-/**
- * Install a specific version of node
- * @param versionArg
- */
-export let install = async versionArg => {
-  plugins.beautylog.log(`now installing node version ${versionArg}`);
-  let version: string;
-  if (versionArg === 'stable') {
-    version = '9';
-  } else if (versionArg === 'lts') {
-    version = '8';
-  } else if (versionArg === 'legacy') {
-    version = '8';
-  } else {
-    version = versionArg;
-  }
-  if (await nvmAvailable.promise) {
-    await bash(`nvm install ${version} && nvm alias default ${version}`);
-    plugins.beautylog.success(`Node version ${version} successfully installed!`);
-  } else {
-    plugins.beautylog.warn('Nvm not in path so staying at installed node version!');
-  }
-  await bash('node -v');
-  await bash('npm -v');
-  // lets look for further config
-  await npmciConfig.getConfig().then(async configArg => {
-    plugins.beautylog.log('Now checking for needed global npm tools...');
-    for (let npmTool of configArg.npmGlobalTools) {
-      plugins.beautylog.info(`Checking for global "${npmTool}"`);
-      let whichOutput: string = await bashNoError(`which ${npmTool}`);
-      let toolAvailable: boolean = !(/not\sfound/.test(whichOutput) || whichOutput === '');
-      if (toolAvailable) {
-        plugins.beautylog.log(`Tool ${npmTool} is available`);
-      } else {
-        plugins.beautylog.info(`globally installing ${npmTool} from npm`);
-        if (await yarnAvailable.promise) {
-          await bash(`yarn global add ${npmTool}`);
-        } else {
-          await bash(`npm install ${npmTool} -q -g`);
-        }
-      }
-    }
-    plugins.beautylog.success('all global npm tools specified in npmextra.json are now available!');
-  });
-};
--- a/ts/mod_npm/index.ts
+++ b/ts/mod_npm/index.ts
@@ -1,92 +0,0 @@
-import * as plugins from './mod.plugins';
-import * as configModule from '../npmci.config';
-import { bash, bashNoError, nvmAvailable, yarnAvailable } from '../npmci.bash';
-
-/**
- * handle cli input
- * @param argvArg
- */
-export let handleCli = async argvArg => {
-  if (argvArg._.length >= 2) {
-    let action: string = argvArg._[1];
-    switch (action) {
-      case 'install':
-        await install();
-        break;
-      case 'prepare':
-        await prepare();
-        break;
-      case 'test':
-        await test();
-        break;
-      case 'publish':
-        await publish();
-        break;
-      default:
-        plugins.beautylog.error(`>>npmci npm ...<< action >>${action}<< not supported`);
-        process.exit(1);
-    }
-  } else {
-    plugins.beautylog.log(
-      `>>npmci npm ...<< cli arguments invalid... Please read the documentation.`
-    );
-    process.exit(1);
-  }
-};
-
-/**
- * authenticates npm with token from env var
- */
-let prepare = async () => {
-  let npmrcPrefix: string = '//registry.npmjs.org/:_authToken=';
-  let npmToken: string = process.env.NPMCI_TOKEN_NPM;
-  let npmrcFileString: string = npmrcPrefix + npmToken;
-  if (npmToken) {
-    plugins.beautylog.info('found access token');
-  } else {
-    plugins.beautylog.error('no access token found! Exiting!');
-    process.exit(1);
-  }
-  plugins.smartfile.memory.toFsSync(npmrcFileString, '/root/.npmrc');
-  return;
-};
-
-/**
- * publish a package to npm
- */
-let publish = async () => {
-  let npmAccessCliString = ``;
-  const config = await configModule.getConfig();
-
-  // -> configure package access level
-  if (
-    config.npmAccessLevel &&
-    (config.npmAccessLevel === 'public' || config.npmAccessLevel === 'private')
-  ) {
-    npmAccessCliString = `--access=${config.npmAccessLevel}`;
-  }
-
-  // -> build it
-  await bash(`yarn install`);
-  await bash(`yarn run build`);
-
-  // -> make sure npm is authenticated
-  prepare();
-
-  // -> publish it
-  await bash(`npm publish ${npmAccessCliString}`);
-};
-
-let install = async (): Promise<void> => {
-  plugins.beautylog.info('now installing dependencies:');
-  if (await yarnAvailable.promise) {
-    await bash('yarn install');
-  } else {
-    await bash('npm install');
-  }
-};
-
-export let test = async (): Promise<void> => {
-  plugins.beautylog.info('now starting tests:');
-  await bash('yarn test');
-};
--- a/ts/mod_npm/mod.plugins.ts
+++ b/ts/mod_npm/mod.plugins.ts
@@ -1 +0,0 @@
-export * from '../npmci.plugins';
--- a/ts/mod_ssh/index.ts
+++ b/ts/mod_ssh/index.ts
@@ -1,19 +1,20 @@
+import { logger } from '../npmci.logging';
 import * as plugins from './mod.plugins';
 let sshInstance: plugins.smartssh.SshInstance;

 export let handleCli = async argvArg => {
  if (argvArg._.length >= 2) {
-    let action: string = argvArg._[1];
+    const action: string = argvArg._[1];
    switch (action) {
      case 'prepare':
        await prepare();
        break;
      default:
-        plugins.beautylog.error(`action >>${action}<< not supported`);
+        logger.log('error', `action >>${action}<< not supported`);
        process.exit(1);
    }
  } else {
-    plugins.beautylog.error(`>>npmci ssh ...<< please specify an action!`);
+    logger.log('error', `>>npmci ssh ...<< please specify an action!`);
    process.exit(1);
  }
 };
@@ -21,7 +22,7 @@ export let handleCli = async argvArg => {
 /**
 * checks if not undefined
 */
-let notUndefined = (stringArg: string) => {
+const notUndefined = (stringArg: string) => {
  return stringArg && stringArg !== 'undefined' && stringArg !== '##';
 };

@@ -34,27 +35,27 @@ export let prepare = async () => {
  if (!process.env.NPMTS_TEST) {
    sshInstance.writeToDisk();
  } else {
-    plugins.beautylog.log('In test mode, so not storing SSH keys to disk!');
+    logger.log('info', 'In test mode, so not storing SSH keys to disk!');
  }
 };

 /**
 * gets called for each found SSH ENV Var and deploys it
 */
-let evaluateSshEnv = async (sshkeyEnvVarArg: string) => {
-  let sshEnvArray = sshkeyEnvVarArg.split('|');
-  let sshKey = new plugins.smartssh.SshKey();
-  plugins.beautylog.info('Found SSH identity for ' + sshEnvArray[1]);
+const evaluateSshEnv = async (sshkeyEnvVarArg: string) => {
+  const sshEnvArray = sshkeyEnvVarArg.split('|');
+  const sshKey = new plugins.smartssh.SshKey();
+  logger.log('info', 'Found SSH identity for ' + sshEnvArray[1]);
  if (notUndefined(sshEnvArray[0])) {
-    plugins.beautylog.log('---> host defined!');
+    logger.log('info', '---> host defined!');
    sshKey.host = sshEnvArray[0];
  }
  if (notUndefined(sshEnvArray[1])) {
-    plugins.beautylog.log('---> privKey defined!');
+    logger.log('info', '---> privKey defined!');
    sshKey.privKeyBase64 = sshEnvArray[1];
  }
  if (notUndefined(sshEnvArray[2])) {
-    plugins.beautylog.log('---> pubKey defined!');
+    logger.log('info', '---> pubKey defined!');
    sshKey.pubKeyBase64 = sshEnvArray[2];
  }

--- a/ts/mod_trigger/index.ts
+++ b/ts/mod_trigger/index.ts
@@ -1,28 +1,42 @@
 import * as plugins from './mod.plugins';
 import { bash } from '../npmci.bash';
+import { logger } from '../npmci.logging';

-let triggerValueRegex = /^([a-zA-Z0-9\.]*)\|([a-zA-Z0-9\.]*)\|([a-zA-Z0-9\.]*)\|([a-zA-Z0-9\.]*)\|?([a-zA-Z0-9\.\-\/]*)/;
+const triggerValueRegex = /^([a-zA-Z0-9\.]*)\|([a-zA-Z0-9\.]*)\|([a-zA-Z0-9\.]*)\|([a-zA-Z0-9\.]*)\|?([a-zA-Z0-9\.\-\/]*)/;

 export let trigger = async () => {
-  plugins.beautylog.info('now running triggers');
-  plugins.smartparam.forEachMinimatch(process.env, 'NPMCI_TRIGGER_*', evaluateTrigger);
+  logger.log('info', 'now running triggers');
+  await plugins.smartparam.forEachMinimatch(process.env, 'NPMCI_TRIGGER_*', evaluateTrigger);
 };

-let evaluateTrigger = async triggerEnvVarArg => {
-  let triggerRegexResultArray = triggerValueRegex.exec(triggerEnvVarArg);
-  let regexDomain = triggerRegexResultArray[1];
-  let regexProjectId = triggerRegexResultArray[2];
-  let regexProjectTriggerToken = triggerRegexResultArray[3];
-  let regexRefName = triggerRegexResultArray[4];
+const evaluateTrigger = async triggerEnvVarArg => {
+  const triggerRegexResultArray = triggerValueRegex.exec(triggerEnvVarArg);
+  const regexDomain = triggerRegexResultArray[1];
+  const regexProjectId = triggerRegexResultArray[2];
+  const regexProjectTriggerToken = triggerRegexResultArray[3];
+  const regexRefName = triggerRegexResultArray[4];
  let regexTriggerName;
  if (triggerRegexResultArray.length === 6) {
    regexTriggerName = triggerRegexResultArray[5];
  } else {
    regexTriggerName = 'Unnamed Trigger';
  }
-  plugins.beautylog.info('Found Trigger!');
-  plugins.beautylog.log('triggering build for ref ' + regexRefName + ' of ' + regexTriggerName);
-  plugins.request.post('https://gitlab.com/api/v3/projects/' + regexProjectId + '/trigger/builds', {
-    form: { token: regexProjectTriggerToken, ref: regexRefName }
-  });
+  logger.log('info', 'Found Trigger!');
+  logger.log('info', 'triggering build for ref ' + regexRefName + ' of ' + regexTriggerName);
+  plugins.smartrequest.postFormData(
+    'https://gitlab.com/api/v3/projects/' + regexProjectId + '/trigger/builds',
+    {},
+    [
+      {
+        name: 'token',
+        payload: regexProjectTriggerToken,
+        type: 'string'
+      },
+      {
+        name: 'ref',
+        payload: regexRefName,
+        type: 'string'
+      }
+    ]
+  );
 };
--- a/ts/npmci.bash.ts
+++ b/ts/npmci.bash.ts
@@ -1,17 +1,17 @@
+import { logger } from './npmci.logging';
 import * as plugins from './npmci.plugins';
 import * as paths from './npmci.paths';

-import * as smartq from 'smartq';
+import * as smartpromise from '@pushrocks/smartpromise';

 /**
 * wether nvm is available or not
 */
-export let nvmAvailable = smartq.defer<boolean>();
-export let yarnAvailable = smartq.defer<boolean>();
+export let nvmAvailable = smartpromise.defer<boolean>();
 /**
 * the smartshell instance for npmci
 */
-let npmciSmartshell = new plugins.smartshell.Smartshell({
+const npmciSmartshell = new plugins.smartshell.Smartshell({
  executor: 'bash',
  sourceFilePaths: []
 });
@@ -19,38 +19,24 @@ let npmciSmartshell = new plugins.smartshell.Smartshell({
 /**
 * check for tools.
 */
-let checkToolsAvailable = async () => {
+const checkToolsAvailable = async () => {
  // check for nvm
  if (!process.env.NPMTS_TEST) {
    if (
-      (await plugins.smartshell.execSilent(`bash -c "source /usr/local/nvm/nvm.sh"`)).exitCode === 0
+      (await npmciSmartshell.execSilent(`bash -c "source /usr/local/nvm/nvm.sh"`)).exitCode === 0
    ) {
-      npmciSmartshell.addSourceFiles([`/usr/local/nvm/nvm.sh`]);
+      npmciSmartshell.shellEnv.addSourceFiles([`/usr/local/nvm/nvm.sh`]);
      nvmAvailable.resolve(true);
    } else if (
-      (await plugins.smartshell.execSilent(`bash -c "source ~/.nvm/nvm.sh"`)).exitCode === 0
+      (await npmciSmartshell.execSilent(`bash -c "source ~/.nvm/nvm.sh"`)).exitCode === 0
    ) {
-      npmciSmartshell.addSourceFiles([`~/.nvm/nvm.sh`]);
+      npmciSmartshell.shellEnv.addSourceFiles([`~/.nvm/nvm.sh`]);
      nvmAvailable.resolve(true);
    } else {
      nvmAvailable.resolve(false);
    }
-
-    // check for yarn
-    await plugins.smartshell.which('yarn').then(
-      async () => {
-        await plugins.smartshell.exec(
-          `yarn config set cache-folder ${plugins.path.join(paths.cwd, '.yarn')}`
-        );
-        yarnAvailable.resolve(true);
-      },
-      () => {
-        yarnAvailable.resolve(false);
-      }
-    );
  } else {
    nvmAvailable.resolve(true);
-    yarnAvailable.resolve(true);
  }
 };
 checkToolsAvailable();
@@ -83,21 +69,19 @@ export let bash = async (commandArg: string, retryArg: number = 2): Promise<stri
      if (execResult.exitCode !== 0 && i === retryArg) {
        // something went wrong and retries are exhausted
        if (failOnError) {
-          plugins.beautylog.error('something went wrong and retries are exhausted');
+          logger.log('error', 'something went wrong and retries are exhausted');
          process.exit(1);
        }
      } else if (execResult.exitCode === 0) {
        // everything went fine, or no error wanted
        i = retryArg + 1; // retry +1 breaks for loop, if everything works out ok retrials are not wanted
      } else {
-        plugins.beautylog.warn(
-          'Something went wrong! Exit Code: ' + execResult.exitCode.toString()
-        );
-        plugins.beautylog.info('Retry ' + (i + 1).toString() + ' of ' + retryArg.toString());
+        logger.log('warn', 'Something went wrong! Exit Code: ' + execResult.exitCode.toString());
+        logger.log('info', 'Retry ' + (i + 1).toString() + ' of ' + retryArg.toString());
      }
    }
  } else {
-    plugins.beautylog.log('ShellExec would be: ' + commandArg);
+    logger.log('info', 'ShellExec would be: ' + commandArg);
    execResult = {
      exitCode: 0,
      stdout: 'testOutput'
--- a/ts/npmci.classes.npmci.ts
+++ b/ts/npmci.classes.npmci.ts
@@ -0,0 +1,55 @@
+import * as plugins from './npmci.plugins';
+
+import { CloudlyConnector } from './connector.cloudly/cloudlyconnector';
+
+import { NpmciInfo } from './npmci.classes.npmciinfo';
+import { NpmciCli } from './npmci.classes.npmcicli';
+import { NpmciConfig } from './npmci.classes.npmciconfig';
+
+// mods
+import { NpmciDockerManager } from './manager.docker';
+import { NpmciGitManager } from './manager.git';
+import { NpmciNodeJsManager } from './manager.nodejs';
+import { NpmciNpmManager } from './manager.npm';
+import { NpmciEnv } from './npmci.classes.npmcienv';
+
+export class Npmci {
+  public analytics: plugins.smartanalytics.Analytics;
+  public cloudlyConnector: CloudlyConnector;
+
+  public npmciEnv: NpmciEnv;
+  public npmciInfo: NpmciInfo;
+  public npmciConfig: NpmciConfig;
+  public npmciCli: NpmciCli;
+
+  // managers
+  public dockerManager: NpmciDockerManager;
+  public gitManager: NpmciGitManager;
+  public nodejsManager: NpmciNodeJsManager;
+  public npmManager: NpmciNpmManager;
+
+  constructor() {
+    this.analytics = new plugins.smartanalytics.Analytics({
+      apiEndPoint: 'https://pubapi.lossless.one/analytics',
+      projectId: 'gitzone',
+      appName: 'npmci'
+    });
+    this.cloudlyConnector = new CloudlyConnector();
+    this.npmciEnv = new NpmciEnv(this);
+    this.npmciInfo = new NpmciInfo(this);
+    this.npmciCli = new NpmciCli(this);
+    this.npmciConfig = new NpmciConfig(this);
+
+    // managers
+    this.dockerManager = new NpmciDockerManager(this);
+    this.gitManager = new NpmciGitManager(this);
+    this.nodejsManager = new NpmciNodeJsManager(this);
+    this.npmManager = new NpmciNpmManager(this);
+  }
+
+  public async start() {
+    await this.npmciInfo.printToConsole();
+    await this.npmciConfig.init();
+    this.npmciCli.startParse();
+  }
+}
--- a/ts/npmci.classes.npmcicli.ts
+++ b/ts/npmci.classes.npmcicli.ts
@@ -0,0 +1,110 @@
+import { logger } from './npmci.logging';
+import * as plugins from './npmci.plugins';
+import * as paths from './npmci.paths';
+import { Npmci } from './npmci.classes.npmci';
+
+export class NpmciCli {
+  public npmciRef: Npmci;
+  public smartcli: plugins.smartcli.Smartcli;
+
+  constructor(npmciArg: Npmci) {
+    this.npmciRef = npmciArg;
+    this.smartcli = new plugins.smartcli.Smartcli();
+    this.smartcli.addVersion(this.npmciRef.npmciInfo.projectInfo.version);
+
+    // clean
+    this.smartcli.addCommand('clean').subscribe(
+      async argv => {
+        const modClean = await import('./mod_clean/index');
+        await modClean.clean();
+      },
+      err => {
+        console.log(err);
+        process.exit(1);
+      }
+    );
+
+    // command
+    this.smartcli.addCommand('command').subscribe(
+      async argv => {
+        const modCommand = await import('./mod_command/index');
+        await modCommand.command();
+      },
+      err => {
+        console.log(err);
+        process.exit(1);
+      }
+    );
+
+    // command
+    this.smartcli.addCommand('git').subscribe(
+      async argvArg => {
+        await this.npmciRef.gitManager.handleCli(argvArg);
+      },
+      err => {
+        console.log(err);
+        process.exit(1);
+      }
+    );
+
+    // build
+    this.smartcli.addCommand('docker').subscribe(
+      async argvArg => {
+        await this.npmciRef.dockerManager.handleCli(argvArg);
+      },
+      err => {
+        console.log(err);
+        process.exit(1);
+      }
+    );
+
+    // node
+    this.smartcli.addCommand('node').subscribe(
+      async argvArg => {
+        await this.npmciRef.nodejsManager.handleCli(argvArg);
+      },
+      err => {
+        console.log(err);
+        process.exit(1);
+      }
+    );
+
+    // npm
+    this.smartcli.addCommand('npm').subscribe(
+      async argvArg => {
+        await this.npmciRef.npmManager.handleCli(argvArg);
+      },
+      err => {
+        console.log(err);
+      }
+    );
+
+    // trigger
+    this.smartcli.addCommand('ssh').subscribe(
+      async argvArg => {
+        const modSsh = await import('./mod_ssh/index');
+        await modSsh.handleCli(argvArg);
+      },
+      err => {
+        console.log(err);
+        process.exit(1);
+      }
+    );
+
+    // trigger
+    this.smartcli.addCommand('trigger').subscribe(
+      async argv => {
+        const modTrigger = await import('./mod_trigger/index');
+        await modTrigger.trigger();
+      },
+      err => {
+        console.log(err);
+        process.exit(1);
+      }
+    );
+  }
+
+  public startParse = () => {
+    this.smartcli.startParse();
+  }
+}
--- a/ts/npmci.classes.npmciconfig.ts
+++ b/ts/npmci.classes.npmciconfig.ts
@@ -0,0 +1,73 @@
+import * as plugins from './npmci.plugins';
+import * as paths from './npmci.paths';
+
+import { logger } from './npmci.logging';
+import { Npmci } from './npmci.classes.npmci';
+
+/**
+ * the main config interface for npmci
+ */
+export interface INpmciOptions {
+  projectInfo: plugins.projectinfo.ProjectInfo;
+
+  // npm
+  npmGlobalTools: string[];
+  npmAccessLevel?: 'private' | 'public';
+  npmRegistryUrl: string;
+
+  // docker
+  dockerRegistries: string[];
+  dockerRegistryRepoMap: { [key: string]: string };
+  dockerBuildargEnvMap: { [key: string]: string };
+
+  // urls
+  urlCloudly: string;
+}
+
+/**
+ * a config class for Npmci
+ */
+export class NpmciConfig {
+  public npmciRef: Npmci;
+
+  public npmciNpmextra: plugins.npmextra.Npmextra;
+  public kvStorage: plugins.npmextra.KeyValueStore;
+  public npmciQenv: plugins.qenv.Qenv;
+
+  private configObject: INpmciOptions;
+
+  constructor(npmciRefArg: Npmci) {
+    this.npmciRef = npmciRefArg;
+
+    this.npmciNpmextra = new plugins.npmextra.Npmextra(paths.cwd);
+    this.kvStorage = new plugins.npmextra.KeyValueStore(
+      'custom',
+      `${this.npmciRef.npmciEnv.repo.user}_${this.npmciRef.npmciEnv.repo.repo}`
+    );
+    this.npmciQenv = new plugins.qenv.Qenv(
+      paths.NpmciProjectDir,
+      paths.NpmciProjectNogitDir,
+      false,
+      logger
+    );
+
+    this.configObject  = {
+      projectInfo: new plugins.projectinfo.ProjectInfo(paths.cwd),
+      npmGlobalTools: [],
+      dockerRegistries: [],
+      dockerRegistryRepoMap: {},
+      npmAccessLevel: 'private',
+      npmRegistryUrl: 'registry.npmjs.org',
+      dockerBuildargEnvMap: {},
+      urlCloudly: this.npmciQenv.getEnvVarOnDemand('NPMCI_URL_CLOUDLY')
+    };
+  }
+
+  public async init() {
+    this.configObject = this.npmciNpmextra.dataFor<INpmciOptions>('npmci', this.configObject);
+  }
+
+  public getConfig(): INpmciOptions {
+    return this.configObject;
+  }
+}
--- a/ts/npmci.classes.npmcienv.ts
+++ b/ts/npmci.classes.npmcienv.ts
@@ -0,0 +1,18 @@
+import * as plugins from './npmci.plugins';
+import { Npmci } from './npmci.classes.npmci';
+
+export class NpmciEnv {
+  public npmciRef: Npmci;
+
+  public repoString: string;
+  public repo: plugins.smartstring.GitRepo;
+
+  constructor(npmciRefArg: Npmci) {
+    this.npmciRef = npmciRefArg;
+    this.repoString = process.env.CI_REPOSITORY_URL;
+    if (!this.repoString) {
+      this.repoString = 'https://undefined:undefined@github.com/undefined/undefined.git';
+    }
+    this.repo = new plugins.smartstring.GitRepo(this.repoString);
+  }
+}
--- a/ts/npmci.classes.npmciinfo.ts
+++ b/ts/npmci.classes.npmciinfo.ts
@@ -0,0 +1,18 @@
+import * as plugins from './npmci.plugins';
+import * as paths from './npmci.paths';
+import { logger } from "./npmci.logging";
+import { Npmci } from './npmci.classes.npmci';
+
+export class NpmciInfo {
+
+  public npmciRef: Npmci;
+  public projectInfo = new plugins.projectinfo.ProjectinfoNpm(paths.NpmciPackageRoot);
+
+  constructor(npmciArg: Npmci) {
+    this.npmciRef = npmciArg;
+  }
+
+  public printToConsole () {
+    logger.log('info', `npmci version: ${this.projectInfo.version}`);
+  }
+}
--- a/ts/npmci.cli.ts
+++ b/ts/npmci.cli.ts
@@ -1,122 +0,0 @@
-import * as plugins from './npmci.plugins';
-import * as paths from './npmci.paths';
-import * as npmciMonitor from './npmci.monitor';
-npmciMonitor.run();
-
-// Get Info about npmci itself
-let npmciInfo = new plugins.projectinfo.ProjectinfoNpm(paths.NpmciPackageRoot);
-plugins.beautylog.log('npmci version: ' + npmciInfo.version);
-
-import * as NpmciEnv from './npmci.env';
-
-import * as npmciMods from './npmci.mods';
-
-let smartcli = new plugins.smartcli.Smartcli();
-smartcli.addVersion(npmciInfo.version);
-
-// clean
-smartcli
-  .addCommand('clean')
-  .then(async argv => {
-    let modClean = await npmciMods.modClean.load();
-    await modClean.clean();
-  })
-  .catch(err => {
-    console.log(err);
-    process.exit(1);
-  });
-
-// cloudflare
-smartcli
-  .addCommand('cloudflare')
-  .then(async argvArg => {
-    let modPurge = await npmciMods.modCloudflare.load();
-    await modPurge.handleCli(argvArg);
-  })
-  .catch(err => {
-    console.log(err);
-  });
-
-// command
-smartcli
-  .addCommand('command')
-  .then(async argv => {
-    let modCommand = await npmciMods.modCommand.load();
-    await modCommand.command();
-  })
-  .catch(err => {
-    console.log(err);
-    process.exit(1);
-  });
-
-// command
-smartcli
-  .addCommand('git')
-  .then(async argvArg => {
-    let modGit = await npmciMods.modGit.load();
-    await modGit.handleCli(argvArg);
-  })
-  .catch(err => {
-    console.log(err);
-    process.exit(1);
-  });
-
-// build
-smartcli
-  .addCommand('docker')
-  .then(async argvArg => {
-    let modDocker = await npmciMods.modDocker.load();
-    await modDocker.handleCli(argvArg);
-  })
-  .catch(err => {
-    console.log(err);
-    process.exit(1);
-  });
-
-// node
-smartcli
-  .addCommand('node')
-  .then(async argvArg => {
-    let modNode = await npmciMods.modNode.load();
-    await modNode.handleCli(argvArg);
-  })
-  .catch(err => {
-    console.log(err);
-  });
-
-// npm
-smartcli
-  .addCommand('npm')
-  .then(async argvArg => {
-    let modNpm = await npmciMods.modNpm.load();
-    await modNpm.handleCli(argvArg);
-  })
-  .catch(err => {
-    console.log(err);
-  });
-
-// trigger
-smartcli
-  .addCommand('ssh')
-  .then(async argvArg => {
-    let modSsh = await npmciMods.modSsh.load();
-    await modSsh.handleCli(argvArg);
-  })
-  .catch(err => {
-    console.log(err);
-    process.exit(1);
-  });
-
-// trigger
-smartcli
-  .addCommand('trigger')
-  .then(async argv => {
-    let modTrigger = await npmciMods.modTrigger.load();
-    await modTrigger.trigger();
-  })
-  .catch(err => {
-    console.log(err);
-    process.exit(1);
-  });
-
-smartcli.startParse();
--- a/ts/npmci.config.ts
+++ b/ts/npmci.config.ts
@@ -1,34 +0,0 @@
-import * as q from 'q';
-
-import * as plugins from './npmci.plugins';
-import * as paths from './npmci.paths';
-
-import { repo } from './npmci.env';
-
-import { KeyValueStore } from 'npmextra';
-
-export interface INpmciOptions {
-  npmGlobalTools: string[];
-  npmAccessLevel?: 'private' | 'public';
-  dockerRegistryRepoMap: any;
-  dockerBuildargEnvMap: any;
-}
-
-// instantiate a kvStorage for the current directory
-export let kvStorage = new KeyValueStore('custom', `${repo.user}_${repo.repo}`);
-
-// handle config retrival
-let npmciNpmextra = new plugins.npmextra.Npmextra(paths.cwd);
-let defaultConfig: INpmciOptions = {
-  npmGlobalTools: [],
-  dockerRegistryRepoMap: {},
-  dockerBuildargEnvMap: {}
-};
-export let configObject = npmciNpmextra.dataFor<INpmciOptions>('npmci', defaultConfig);
-
-/**
- * gets the npmci portion of the npmextra.json file
- */
-export let getConfig = async (): Promise<INpmciOptions> => {
-  return configObject;
-};
--- a/ts/npmci.env.ts
+++ b/ts/npmci.env.ts
@@ -1,13 +0,0 @@
-import * as plugins from './npmci.plugins';
-import * as paths from './npmci.paths';
-import { GitRepo } from 'smartstring';
-import { Dockerfile } from './mod_docker/index';
-
-/**
- * a info instance about the git respoitory at cwd :)
- */
-let repoString: string = process.env.CI_REPOSITORY_URL;
-if (!repoString) {
-  repoString = 'https://undefined:undefined@github.com/undefined/undefined.git';
-}
-export let repo = new GitRepo(repoString);
--- a/ts/npmci.logging.ts
+++ b/ts/npmci.logging.ts
@@ -0,0 +1,14 @@
+import * as plugins from './npmci.plugins';
+
+export const logger = new plugins.smartlog.Smartlog({
+  logContext: {
+    company: 'Some Company',
+    companyunit: 'Some Unit',
+    containerName: 'Some ContainerName',
+    environment: 'test',
+    runtime: 'node',
+    zone: 'Some Zone'
+  }
+});
+
+logger.addLogDestination(new plugins.smartlogDestinationLocal.DestinationLocal());
--- a/ts/npmci.mods.ts
+++ b/ts/npmci.mods.ts
@@ -1,24 +0,0 @@
-import * as _modClean from './mod_clean/index';
-import * as _modCloudflare from './mod_cloudflare/index';
-import * as _modCommand from './mod_command/index';
-import * as _modDocker from './mod_docker/index';
-import * as _modGit from './mod_git/index';
-import * as _modNpm from './mod_npm/index';
-import * as _modNode from './mod_node/index';
-import * as _modSsh from './mod_ssh/index';
-import * as _modTrigger from './mod_trigger/index';
-
-import { LazyModule } from 'smartsystem';
-
-export let modClean = new LazyModule<typeof _modClean>('./mod_clean/index', __dirname);
-export let modCloudflare = new LazyModule<typeof _modCloudflare>(
-  './mod_cloudflare/index',
-  __dirname
-);
-export let modCommand = new LazyModule<typeof _modCommand>('./mod_command/index', __dirname);
-export let modGit = new LazyModule<typeof _modGit>('./mod_git/index', __dirname);
-export let modDocker = new LazyModule<typeof _modDocker>('./mod_docker/index', __dirname);
-export let modNode = new LazyModule<typeof _modNode>('./mod_node/index', __dirname);
-export let modNpm = new LazyModule<typeof _modNpm>('./mod_npm/index', __dirname);
-export let modSsh = new LazyModule<typeof _modSsh>('./mod_ssh/index', __dirname);
-export let modTrigger = new LazyModule<typeof _modTrigger>('./mod_trigger/index', __dirname);
--- a/ts/npmci.monitor.ts
+++ b/ts/npmci.monitor.ts
@@ -1,22 +0,0 @@
-import * as plugins from './npmci.plugins';
-import * as env from './npmci.env';
-
-import { Analytics } from 'smartanalytics';
-
-export let npmciAnalytics = new Analytics({
-  apiEndPoint: 'https://pubapi.lossless.one/analytics',
-  projectId: 'gitzone',
-  appName: 'npmci'
-});
-
-export let run = async () => {
-  npmciAnalytics
-    .recordEvent('npmToolExecution', {
-      host: env.repo.host,
-      user: env.repo.user,
-      repo: env.repo.repo
-    })
-    .catch(err => {
-      plugins.beautylog.warn('Lossless Analytics API not available...');
-    });
-};
--- a/ts/npmci.paths.ts
+++ b/ts/npmci.paths.ts
@@ -1,8 +1,13 @@
 import * as plugins from './npmci.plugins';

-export let cwd = process.cwd();
+export const cwd = process.cwd();

-export let NpmciPackageRoot = plugins.path.join(__dirname, '../');
-export let NpmciPackageConfig = plugins.path.join(NpmciPackageRoot, './config.json');
-export let NpmciProjectDir = cwd;
-export let NpmciTestDir = plugins.path.join(cwd, './test');
+// package paths
+export const NpmciPackageRoot = plugins.path.join(__dirname, '../');
+export const NpmciPackageConfig = plugins.path.join(NpmciPackageRoot, './config.json');
+
+// project paths
+export const NpmciProjectDir = cwd;
+export const NpmciProjectNogitDir = plugins.path.join(NpmciProjectDir, './.nogit');
+export const NpmciTestDir = plugins.path.join(cwd, './test');
+export const NpmciCacheDir = plugins.path.join(cwd, './.npmci_cache');
--- a/ts/npmci.plugins.ts
+++ b/ts/npmci.plugins.ts
@@ -1,19 +1,52 @@
-export import beautylog = require('beautylog');
-export import lodash = require('lodash');
-export import npmextra = require('npmextra');
-export import path = require('path');
-export import projectinfo = require('projectinfo');
-export import q = require('smartq');
-export let request = require('request');
-export import smartcli = require('smartcli');
-export import smartdelay = require('smartdelay');
-export import smartfile = require('smartfile');
-export import shelljs = require('shelljs');
-export import smartparam = require('smartparam');
-export import smartq = require('smartq');
-export import smartshell = require('smartshell');
-export import smartsocket = require('smartsocket');
-export import smartsystem = require('smartsystem');
-export import smartssh = require('smartssh');
-export import smartstring = require('smartstring');
-export import through2 = require('through2');
+// node native
+import * as path from 'path';
+
+export { path };
+
+// @servezone
+import * as servezoneInterfaces from '@servezone/servezone-interfaces';
+
+export {
+  servezoneInterfaces
+};
+
+// @pushrocks
+import * as npmextra from '@pushrocks/npmextra';
+import * as projectinfo from '@pushrocks/projectinfo';
+import * as qenv from '@pushrocks/qenv';
+import * as smartanalytics from '@pushrocks/smartanalytics';
+import * as smartdelay from '@pushrocks/smartdelay';
+import * as smartfile from '@pushrocks/smartfile';
+import * as smartcli from '@pushrocks/smartcli';
+import * as smartlog from '@pushrocks/smartlog';
+import * as smartlogDestinationLocal from '@pushrocks/smartlog-destination-local';
+import * as smartparam from '@pushrocks/smartparam';
+import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartrequest from '@pushrocks/smartrequest';
+import * as smartshell from '@pushrocks/smartshell';
+import * as smartsocket from '@pushrocks/smartsocket';
+import * as smartssh from '@pushrocks/smartssh';
+import * as smartstring from '@pushrocks/smartstring';
+
+export {
+  npmextra,
+  projectinfo,
+  qenv,
+  smartanalytics,
+  smartdelay,
+  smartfile,
+  smartcli,
+  smartlog,
+  smartlogDestinationLocal,
+  smartparam,
+  smartpromise,
+  smartrequest,
+  smartshell,
+  smartsocket,
+  smartssh,
+  smartstring
+};
+
+import * as through2 from 'through2';
+
+export { through2 };
--- a/tslint.json
+++ b/tslint.json
@@ -1,3 +1,17 @@
 {
-    "extends": "tslint-config-standard"
+  "extends": ["tslint:latest", "tslint-config-prettier"],
+  "rules": {
+    "semicolon": [true, "always"],
+    "no-console": false,
+    "ordered-imports": false,
+    "object-literal-sort-keys": false,
+    "member-ordering": {
+      "options":{
+        "order": [
+          "static-method"
+        ]
+      }
+    }
+  },
+  "defaultSeverity": "warning"
 }
--- a/yarn.lock
+++ b/yarn.lock
Author	SHA1	Message	Date
Phil Kunz	6dd537fe43	3.1.42	2019-08-29 20:26:24 +02:00
Phil Kunz	7191b172a4	fix(core): update	2019-08-29 20:26:23 +02:00
Phil Kunz	9a4611b70f	3.1.41	2019-08-27 16:45:47 +02:00
Phil Kunz	189dbc3654	fix(core): update	2019-08-27 16:45:46 +02:00
Phil Kunz	fc95fc96ed	3.1.40	2019-08-23 17:04:29 +02:00
Phil Kunz	467eed57d7	fix(core): update	2019-08-23 17:04:29 +02:00
Phil Kunz	a5ca5444a0	3.1.39	2019-08-23 16:48:53 +02:00
Phil Kunz	17610cb834	fix(core): update	2019-08-23 16:48:52 +02:00
Phil Kunz	e1f2b5c6fe	3.1.38	2019-08-23 16:42:55 +02:00
Phil Kunz	edbbae0bd0	fix(core): update	2019-08-23 16:42:55 +02:00
Phil Kunz	0e820bec27	3.1.37	2019-07-18 14:42:15 +02:00
Phil Kunz	91a3d612c6	fix(core): update	2019-07-18 14:42:14 +02:00
Phil Kunz	c696730e55	3.1.36	2019-07-17 17:57:21 +02:00
Phil Kunz	38d38ce246	fix(core): update	2019-07-17 17:57:20 +02:00
Phil Kunz	adfdf68c38	3.1.35	2019-07-17 17:55:03 +02:00
Phil Kunz	d4a4d69941	fix(core): update	2019-07-17 17:55:02 +02:00
Phil Kunz	c1fed2c758	3.1.34	2019-07-17 17:04:10 +02:00
Phil Kunz	9918d81f59	fix(core): update	2019-07-17 17:04:10 +02:00
Phil Kunz	59d8338f6e	3.1.33	2019-06-19 14:00:24 +02:00
Phil Kunz	a4f8bd3320	fix(core): update	2019-06-19 14:00:24 +02:00
Phil Kunz	7c2fdb7224	3.1.32	2019-06-19 11:36:05 +02:00
Phil Kunz	37384aeb57	fix(core): update	2019-06-19 11:36:04 +02:00
Phil Kunz	60efda263f	3.1.31	2019-06-19 11:35:19 +02:00
Phil Kunz	19831037ec	fix(core): update	2019-06-19 11:35:19 +02:00
Phil Kunz	a1d52af813	3.1.30	2019-06-19 10:41:58 +02:00
Phil Kunz	0a49ff9b03	fix(core): update	2019-06-19 10:41:58 +02:00
Phil Kunz	ca62326b46	3.1.29	2019-06-18 22:24:53 +02:00
Phil Kunz	e1de0ee479	fix(core): update	2019-06-18 22:24:53 +02:00
Phil Kunz	0dea101c07	3.1.28	2019-06-18 22:24:12 +02:00
Phil Kunz	380a49c59f	fix(core): update	2019-06-18 22:24:12 +02:00
Phil Kunz	5133651e34	3.1.27	2019-06-18 17:30:05 +02:00
Phil Kunz	c8f26c7c48	fix(core): update	2019-06-18 17:30:04 +02:00
Phil Kunz	3bb5912046	3.1.26	2019-06-18 16:19:07 +02:00
Phil Kunz	d75258d9dd	fix(core): update	2019-06-18 16:19:07 +02:00
Phil Kunz	b1577e7542	3.1.25	2019-05-08 22:50:57 +02:00
Phil Kunz	d5cdeffd17	fix(core): update	2019-05-08 22:50:57 +02:00
Phil Kunz	c62ce415e9	3.1.24	2019-05-08 22:44:34 +02:00
Phil Kunz	99014da1e8	fix(core): update	2019-05-08 22:44:34 +02:00
Phil Kunz	0b5dada524	3.1.23	2019-05-08 22:43:49 +02:00
Phil Kunz	40bddba3b5	fix(core): update	2019-05-08 22:43:48 +02:00
Phil Kunz	6f6ee6d799	3.1.22	2019-02-24 22:50:12 +01:00
Phil Kunz	e30cc3f5a0	fix(core): update	2019-02-24 22:50:12 +01:00
Phil Kunz	a4562d4d1b	3.1.21	2018-12-24 02:13:05 +01:00
Phil Kunz	524b405773	fix(core): update	2018-12-24 02:13:04 +01:00
Phil Kunz	0d19c1c68d	3.1.20	2018-12-23 18:57:15 +01:00
Phil Kunz	cff79bc3b4	fix(mirror): now refusing to mirror for private code	2018-12-23 18:57:15 +01:00
Phil Kunz	28541a838d	3.1.19	2018-12-23 18:54:17 +01:00
Phil Kunz	c3ab527341	fix(core): update	2018-12-23 18:54:16 +01:00
Phil Kunz	52cc249098	3.1.18	2018-12-23 17:29:25 +01:00
Phil Kunz	2e189b0660	fix(core): update	2018-12-23 17:29:25 +01:00
Phil Kunz	f876c7414b	3.1.17	2018-12-12 22:29:59 +01:00
Phil Kunz	08b7585cfc	fix(core): update	2018-12-12 22:29:59 +01:00
Phil Kunz	76311fab72	3.1.16	2018-12-11 01:02:22 +01:00
Phil Kunz	1b73df64f5	fix(core): update	2018-12-11 01:02:21 +01:00
Phil Kunz	701cee573b	3.1.15	2018-12-11 00:25:40 +01:00
Phil Kunz	3dd086f711	fix(core): update	2018-12-11 00:25:39 +01:00
Phil Kunz	67ff5d09d4	3.1.14	2018-12-09 16:48:33 +01:00
Phil Kunz	5cb8a79b6a	fix(core): update	2018-12-09 16:48:33 +01:00
Phil Kunz	2dcbca2362	3.1.13	2018-12-09 16:26:28 +01:00
Phil Kunz	bd63194f4b	fix(core): update	2018-12-09 16:26:28 +01:00
Phil Kunz	2763fdef5f	3.1.12	2018-12-09 15:53:39 +01:00
Phil Kunz	bbedde01b9	fix(core): update	2018-12-09 15:53:38 +01:00
Phil Kunz	f26606f757	3.1.11	2018-12-09 15:22:20 +01:00
Phil Kunz	99b03aa796	fix(core): update	2018-12-09 15:22:20 +01:00
Phil Kunz	f30dd3da65	3.1.10	2018-12-09 14:59:51 +01:00
Phil Kunz	d4decddb4b	fix(core): update	2018-12-09 14:59:51 +01:00
Phil Kunz	5c2880da1a	3.1.9	2018-12-09 14:53:44 +01:00
Phil Kunz	bfffc5b130	3.1.8	2018-12-09 14:39:25 +01:00
Phil Kunz	8900a13c6b	fix(core): update	2018-12-09 14:39:24 +01:00
Phil Kunz	d42acf737f	3.1.7	2018-12-09 02:51:04 +01:00
Phil Kunz	77e3b2912d	fix(core): update	2018-12-09 02:51:03 +01:00
Phil Kunz	103e470eb4	3.1.6	2018-12-09 02:50:00 +01:00
Phil Kunz	74c1324e55	fix(core): update	2018-12-09 02:50:00 +01:00
Phil Kunz	a1876963a8	3.1.5	2018-11-28 21:06:12 +01:00
Phil Kunz	5d88e25c99	fix(dependencies): update	2018-11-28 21:06:12 +01:00
Phil Kunz	b3c47546e2	3.1.4	2018-11-26 18:01:55 +01:00
Phil Kunz	6316e81958	fix(core): update	2018-11-26 18:01:54 +01:00
Phil Kunz	ff10afbee4	3.1.3	2018-11-24 15:12:55 +01:00
Phil Kunz	9dbfa77084	fix(ci): remove npmts build dependency	2018-11-24 15:12:55 +01:00
Phil Kunz	46dbd61d89	3.1.2	2018-11-24 15:10:56 +01:00
Phil Kunz	713df1867a	fix(core): update	2018-11-24 15:10:55 +01:00
Phil Kunz	23886c1ed3	3.1.1	2018-11-24 15:08:08 +01:00
Phil Kunz	0c46b627be	fix(core): update	2018-11-24 15:08:07 +01:00
Phil Kunz	622ccd8dd9	3.1.0	2018-11-24 15:00:19 +01:00
Phil Kunz	0079addfc5	feat(logging): use smartlog	2018-11-24 15:00:19 +01:00
Phil Kunz	8604c63d37	3.0.59	2018-09-22 15:18:21 +02:00
Phil Kunz	db0b38bd7b	fix(cli): update cli files to be in line with gitzone cli template	2018-09-22 15:18:21 +02:00
Phil Kunz	edde87b6be	3.0.58	2018-09-22 14:36:26 +02:00
Phil Kunz	5085d664cb	fix(fix request package usage): update	2018-09-22 14:36:25 +02:00
Phil Kunz	5d468fc840	3.0.57	2018-09-22 14:13:26 +02:00
Phil Kunz	e2ac6cdcc9	fix(dependencies): update	2018-09-22 14:13:25 +02:00
Phil Kunz	fcd04415be	3.0.56	2018-07-16 00:04:24 +02:00
Phil Kunz	1fd1899099	fix(ci): update to latest standards	2018-07-16 00:04:24 +02:00
Phil Kunz	7df7f882d1	3.0.55	2018-07-16 00:02:30 +02:00
Phil Kunz	348b4d60fd	fix(security): snyk	2018-07-16 00:02:29 +02:00
Phil Kunz	37589fb5e5	3.0.54	2018-07-15 23:58:43 +02:00
Phil Kunz	3dd115fe42	fix(ci): adjust to newer build system	2018-07-15 23:58:43 +02:00
Phil Kunz	01c88a6a6c	3.0.53	2018-07-15 23:49:38 +02:00
Phil Kunz	f5cacb7400	fix(core): update	2018-07-15 23:49:37 +02:00
Phil Kunz	887da51d78	3.0.52	2018-07-02 23:15:25 +02:00
Phil Kunz	585703fc55	fix(core): switch to @pushrocks/smartpromise	2018-07-02 23:15:24 +02:00
Phil Kunz	ec3e296d73	3.0.51	2018-07-02 23:09:52 +02:00
Phil Kunz	33f234cf73	fix(core): update to latest standards	2018-07-02 23:09:52 +02:00
Phil Kunz	e7ec765ed5	3.0.50	2018-05-27 15:43:50 +02:00
Phil Kunz	2f46197864	fix(structure): removed .npmignore	2018-05-27 15:43:50 +02:00
Phil Kunz	da44233263	3.0.49	2018-05-27 15:41:58 +02:00
Phil Kunz	cb2430f7b2	fix(build): improved asset handling	2018-05-27 15:41:58 +02:00
Phil Kunz	5fe9134f4a	3.0.48	2018-05-27 14:34:42 +02:00
Phil Kunz	7681f09d38	feat(npm) switch to npm as default package manager	2018-05-27 14:34:38 +02:00
Phil Kunz	d55c77560a	3.0.47	2018-05-07 10:51:45 +02:00
Phil Kunz	0e337a3574	fix(ci): update .gitlab.yml to latest gitzone version	2018-05-07 10:51:45 +02:00
Phil Kunz	94c5567b75	3.0.46	2018-05-05 02:28:26 +02:00
Phil Kunz	7b37506d4e	update .npmignore	2018-05-05 02:28:02 +02:00
Phil Kunz	a401633b73	3.0.45	2018-05-05 02:27:29 +02:00
Phil Kunz	948a8e64d7	3.0.44	2018-05-04 15:58:18 +02:00
Phil Kunz	9e8fbac573	update to better smartcli parsing	2018-05-04 15:58:11 +02:00
Phil Kunz	362740a55f	3.0.43	2018-05-04 00:48:32 +02:00
Phil Kunz	3edc08b0ed	update snyk policy	2018-05-04 00:48:25 +02:00
Phil Kunz	15d7e6cbfc	3.0.42	2018-05-04 00:42:53 +02:00
Phil Kunz	6824210da0	3.0.41	2018-05-04 00:23:23 +02:00
Phil Kunz	41d2d04958	update dependencies	2018-05-04 00:23:21 +02:00
Phil Kunz	e490c6f730	3.0.40	2018-05-04 00:22:10 +02:00
Phil Kunz	bdf4815145	3.0.39	2018-05-03 23:52:55 +02:00
Phil Kunz	84fdf8b139	now cleans up before publishing	2018-05-03 23:52:51 +02:00
Phil Kunz	545896821d	3.0.38	2018-05-03 21:29:38 +02:00
Phil Kunz	c7516458bd	update .gitignore	2018-05-03 21:29:35 +02:00
Phil Kunz	c2f92e63c5	3.0.37	2018-05-03 20:40:29 +02:00
Phil Kunz	d4116aefdb	update npm	2018-05-03 20:40:26 +02:00
Phil Kunz	0f5f1f7772	3.0.36	2018-05-03 20:08:00 +02:00
Phil Kunz	7722187ea5	update ci	2018-05-03 20:07:49 +02:00
Phil Kunz	734a21c925	update publishing process	2018-05-03 19:56:38 +02:00
Phil Kunz	bb36beb682	3.0.35	2018-05-03 19:48:03 +02:00
Phil Kunz	3417ca83ed	3.0.34	2018-05-03 19:12:22 +02:00
Phil Kunz	dea6264c34	update ci	2018-05-03 19:12:17 +02:00
Phil Kunz	b6ca597ca5	3.0.33	2018-05-03 19:05:12 +02:00
Phil Kunz	1539d49426	update publish process	2018-05-03 19:05:09 +02:00
Phil Kunz	51fbc906a0	3.0.32	2018-04-29 17:40:18 +02:00
Phil Kunz	0e3732cade	update	2018-04-29 17:40:14 +02:00
Phil Kunz	4f968472c8	update	2018-04-29 17:37:59 +02:00
Phil Kunz	68aa8d1302	3.0.31	2018-04-29 17:37:06 +02:00
Phil Kunz	cbfe992ffc	update	2018-04-29 17:37:04 +02:00
Phil Kunz	6614b1c3d3	3.0.30	2018-04-29 16:37:38 +02:00
Phil Kunz	20fd6a8d7b	update gitlab-ci	2018-04-29 16:37:33 +02:00