3.1.33

.gitignore

@@ -1,7 +1,22 @@
-dist/
+.nogit/
-node_modules/
+
+# artifacts
 coverage/
 public/
-config.json
+pages/
+
+# installs
+node_modules/
+
+# caches
 .yarn/
-.npmci_cache
+.cache/
+.rpt2_cache
+
+# builds
+dist/
+dist_web/
+dist_serve/
+dist_ts_web/
+
+# custom

.gitlab-ci.yml

@@ -1,9 +1,9 @@
-# gitzone standard
+# gitzone ci_default
-image: hosttoday/ht-docker-node:npmci
+image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
 
 cache:
   paths:
-  - .yarn/
+  - .npmci_cache/
   key: "$CI_BUILD_STAGE"
 
 stages:
@@ -26,8 +26,9 @@ mirror:
 snyk:
   stage: security
   script:
-    - npmci command yarn global add snyk
+    - npmci npm prepare
-    - npmci command yarn install --ignore-scripts
+    - npmci command npm install -g snyk
+    - npmci command npm install --ignore-scripts
     - npmci command snyk test
   tags:
   - docker
@@ -36,21 +37,11 @@ snyk:
 # ====================
 # test stage
 # ====================
-testLEGACY:
-  stage: test
-  script:
-  - npmci node install legacy
-  - npmci npm install
-  - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-  - docker
-  - notpriv
-  allow_failure: true
 
 testLTS:
   stage: test
   script:
+  - npmci npm prepare
   - npmci node install lts
   - npmci npm install
   - npmci npm test
@@ -59,21 +50,10 @@ testLTS:
   - docker
   - notpriv
 
-testSTABLE:
-  stage: test
-  script:
-  - npmci node install stable
-  - npmci npm install
-  - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-  - docker
-  - notpriv
-
 release:
   stage: release
   script:
-  - npmci node install stable
+  - npmci node install lts
   - npmci npm publish
   only:
   - tags
@@ -86,19 +66,11 @@ release:
 # ====================
 codequality:
   stage: metadata
-  image: docker:stable
   allow_failure: true
-  services:
-    - docker:stable-dind
   script:
-    - export SP_VERSION=$(echo "$CI_SERVER_VERSION" | sed 's/^\([0-9]*\)\.\([0-9]*\).*/\1-\2-stable/')
+    - npmci command npm install -g tslint typescript
-    - docker run
+    - npmci npm install
-        --env SOURCE_CODE="$PWD"
+    - npmci command "tslint -c tslint.json ./ts/**/*.ts"
-        --volume "$PWD":/code
-        --volume /var/run/docker.sock:/var/run/docker.sock
-        "registry.gitlab.com/gitlab-org/security-products/codequality:$SP_VERSION" /code
-  artifacts:
-    paths: [codeclimate.json]
   tags:
   - docker
   - priv
@@ -117,8 +89,10 @@ pages:
   image: hosttoday/ht-docker-node:npmci
   stage: metadata
   script:
-    - npmci command yarn global add npmpage
+    - npmci command npm install -g @gitzone/tsdoc
-    - npmci command npmpage
+    - npmci npm prepare
+    - npmci npm install
+    - npmci command tsdoc
   tags:
     - docker
     - notpriv
@@ -128,3 +102,4 @@ pages:
     expire_in: 1 week
     paths:
     - public
+  allow_failure: true

.snyk

@@ -1,15 +1,4 @@
 # Snyk (https://snyk.io) policy file, patches or ignores known vulnerabilities.
-version: v1.12.0
+version: v1.13.1
-# ignores vulnerabilities until expiry date; change duration by modifying expiry date
+ignore: {}
-ignore:
-  'npm:shelljs:20140723':
-    - shelljs:
-        reason: None given
-        expires: '2018-06-02T22:48:10.660Z'
-    - smartshell > shelljs:
-        reason: None given
-        expires: '2018-06-02T22:48:10.660Z'
-    - smartssh > shelljs:
-        reason: None given
-        expires: '2018-06-02T22:48:10.660Z'
 patch: {}

cli.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+process.env.CLI_CALL = 'true';
+require('./dist/index');

cli.ts.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+process.env.CLI_CALL = 'true';
+require('@gitzone/tsrun');
+require('./ts/index');

npmextra.json

@@ -1,17 +1,26 @@
 {
-    "npmts":{
+  "npmts": {
-        "mode":"default",
+    "mode": "default",
-        "coverageTreshold": "70",
+    "coverageTreshold": "70",
-        "cli": true
+    "cli": true
-    },
+  },
-    "npmci": {
+  "npmci": {
-        "npmGlobalTools": [
+    "npmGlobalTools": [],
-            "@gitzone/npmts"
+    "npmAccessLevel": "public",
-        ],
+    "npmRegistryUrl": "registry.npmjs.org"
-        "npmAccessLevel": "public"
+  },
-    },
+  "npmdocker": {
-    "npmdocker":{
+    "baseImage": "hosttoday/ht-docker-node:npmci",
-        "baseImage":"hosttoday/ht-docker-node:npmci",
+    "command": "npmci test stable"
-        "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"
     }
+  }
 }

package.json

@@ -1,16 +1,17 @@
 {
   "name": "@shipzone/npmci",
-  "version": "3.0.52",
+  "version": "3.1.33",
+  "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)",
+    "test": "(rm -f config.json) && tstest test/",
-    "build": "(rm -f config.json) && (npmts) && (npm run testVersion)",
+    "build": "(rm -f config.json) && tsbuild && (npm run testVersion)",
-    "testVersion": "(cd test/assets/ && node ../../dist/cli.js -v)"
+    "testVersion": "(cd test/assets/ && node ../../cli.js -v)"
   },
   "repository": {
     "type": "git",
@@ -23,32 +24,43 @@
   },
   "homepage": "https://gitlab.com/gitzone/npmci#README",
   "devDependencies": {
-    "tapbundle": "^2.0.2"
+    "@gitzone/tsbuild": "^2.1.11",
+    "@gitzone/tsrun": "^1.2.6",
+    "@gitzone/tstest": "^1.0.24",
+    "@pushrocks/tapbundle": "^3.0.9",
+    "@types/node": "^12.0.8",
+    "tslint": "^5.17.0",
+    "tslint-config-prettier": "^1.18.0"
   },
   "dependencies": {
-    "@pushrocks/smartcli": "^3.0.2",
+    "@pushrocks/lik": "^3.0.5",
-    "@pushrocks/smartpromise": "^2.0.2",
+    "@pushrocks/npmextra": "^3.0.5",
-    "@types/lodash": "^4.14.110",
+    "@pushrocks/projectinfo": "^4.0.2",
-    "@types/shelljs": "^0.8.0",
+    "@pushrocks/smartanalytics": "^2.0.15",
-    "@types/through2": "^2.0.33",
+    "@pushrocks/smartcli": "^3.0.7",
-    "beautylog": "^6.1.10",
+    "@pushrocks/smartdelay": "^2.0.3",
-    "cflare": "^1.0.5",
+    "@pushrocks/smartfile": "^7.0.2",
-    "lik": "^2.0.5",
+    "@pushrocks/smartlog": "^2.0.19",
-    "lodash": "^4.17.10",
+    "@pushrocks/smartlog-destination-local": "^8.0.2",
-    "npmextra": "^2.0.9",
+    "@pushrocks/smartparam": "^1.0.4",
-    "projectinfo": "^3.0.4",
+    "@pushrocks/smartpromise": "^3.0.2",
-    "request": "^2.87.0",
+    "@pushrocks/smartrequest": "^1.1.16",
-    "shelljs": "^0.8.2",
+    "@pushrocks/smartshell": "^2.0.23",
-    "smartanalytics": "^2.0.9",
+    "@pushrocks/smartsocket": "^1.1.38",
-    "smartdelay": "^1.0.4",
+    "@pushrocks/smartssh": "^1.2.3",
-    "smartfile": "^4.2.20",
+    "@pushrocks/smartstring": "^3.0.10",
-    "smartparam": "^1.0.2",
+    "@types/shelljs": "^0.8.5",
-    "smartshell": "^1.0.19",
+    "@types/through2": "^2.0.34",
-    "smartsocket": "^1.1.19",
+    "through2": "^3.0.1"
-    "smartssh": "^1.2.2",
-    "smartstring": "^2.0.28",
-    "smartsystem": "^2.0.2",
-    "through2": "^2.0.3"
   },
-  "private": false
+  "files": [
+    "ts/*",
+    "ts_web/*",
+    "dist/*",
+    "dist_web/*",
+    "assets/*",
+    "cli.js",
+    "npmextra.json",
+    "readme.md"
+  ]
 }

readme.md

@@ -1,25 +1,20 @@
-# npmci
+# @shipzone/npmci
-
 node and docker in gitlab ci on steroids
 
-## Availabililty
+## Availabililty and Links
-
+* [npmjs.org (npm package)](https://www.npmjs.com/package/@shipzone/npmci)
-[![npm](https://shipzone.gitlab.io/assets/repo-button-npm.svg)](https://www.npmjs.com/package/@shipzone/npmci)
+* [gitlab.com (source)](https://gitlab.com/shipzone/npmci)
-[![git](https://shipzone.gitlab.io/assets/repo-button-git.svg)](https://GitLab.com/shipzone/npmci)
+* [github.com (source mirror)](https://github.com/shipzone/npmci)
-[![git](https://shipzone.gitlab.io/assets/repo-button-mirror.svg)](https://github.com/shipzone/npmci)
+* [docs (typedoc)](https://shipzone.gitlab.io/npmci/)
-[![docs](https://shipzone.gitlab.io/assets/repo-button-docs.svg)](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)
-[![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)
-[![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)
-[![npm downloads per month](https://img.shields.io/npm/dm/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)
-[![Dependency Status](https://david-dm.org/shipzone/npmci.svg)](https://david-dm.org/shipzone/npmci)
+[![TypeScript](https://img.shields.io/badge/TypeScript->=%203.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
-[![bitHound Dependencies](https://www.bithound.io/github/shipzone/npmci/badges/dependencies.svg)](https://www.bithound.io/github/shipzone/npmci/master/dependencies/npm)
+[![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
-[![bitHound Code](https://www.bithound.io/github/shipzone/npmci/badges/code.svg)](https://www.bithound.io/github/shipzone/npmci)
+[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-prettier-ff69b4.svg)](https://prettier.io/)
-[![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
 
@@ -29,9 +24,9 @@ npmci is designed to work in docker CI environments. The following docker images
 
 Docker Hub:
 
-* [hosttoday/ht-docker-node:npmci](https://hub.docker.com/r/hosttoday/ht-docker-node/)  
+- [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/)  
+- [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:
@@ -98,9 +93,9 @@ For further information read the linked docs at the top of this README.
 
 Use TypeScript for best in class instellisense.
 
-For further information read the linked docs at the top of this README.
+For further information read the linked docs at the top of this readme.
 
 > MIT licensed | **©** [Lossless GmbH](https://lossless.gmbh)
-> | By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy.html)
+| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy.html)
 
-[![repo-footer](https://shipzone.gitlab.io/assets/repo-footer.svg)](https://push.rocks)
+[![repo-footer](https://shipzone.gitlab.io/assets/repo-footer.svg)](https://maintainedby.lossless.com)

test/test.ts

@@ -1,4 +1,4 @@
-import { tap, expect } from 'tapbundle';
+import { tap, expect } from '@pushrocks/tapbundle';
 import * as path from 'path';
 
 // Setup test

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]);
-};

ts/mod_cloudflare/mod.plugins.ts

@@ -1,5 +0,0 @@
-export * from '../npmci.plugins';
-
-import * as cflare from 'cflare';
-
-export { cflare };

ts/mod_docker/index.ts

@@ -1,3 +1,4 @@
+import { logger } from '../npmci.logging';
 import * as plugins from './mod.plugins';
 import * as paths from '../npmci.paths';
 import { bash } from '../npmci.bash';
@@ -9,8 +10,11 @@ import { Dockerfile } from './mod.classes.dockerfile';
 import { DockerRegistry } from './mod.classes.dockerregistry';
 import { RegistryStorage } from './mod.classes.registrystorage';
 
+// config
+import { configObject } from '../npmci.config';
+
 // instances
-let npmciRegistryStorage = new RegistryStorage();
+const npmciRegistryStorage = new RegistryStorage();
 
 export { Dockerfile, helpers };
 
@@ -20,10 +24,10 @@ export let modArgvArg; // will be set through the build command
  * handle cli input
  * @param argvArg
  */
-export let handleCli = async argvArg => {
+export const handleCli = async argvArg => {
   modArgvArg = argvArg;
   if (argvArg._.length >= 2) {
-    let action: string = argvArg._[1];
+    const action: string = argvArg._[1];
     switch (action) {
       case 'build':
         await build();
@@ -42,10 +46,11 @@ export let handleCli = async argvArg => {
         await pull(argvArg);
         break;
       default:
-        plugins.beautylog.error(`>>npmci docker ...<< action >>${action}<< not supported`);
+        logger.log('error', `>>npmci docker ...<< action >>${action}<< not supported`);
     }
   } else {
-    plugins.beautylog.log(
+    logger.log(
+      'info',
       `>>npmci docker ...<< cli arguments invalid... Please read the documentation.`
     );
   }
@@ -54,9 +59,9 @@ export let handleCli = async argvArg => {
 /**
  * builds a cwd of Dockerfiles by triggering a promisechain
  */
-export let build = async () => {
+export const build = async () => {
   await prepare();
-  plugins.beautylog.log('now building Dockerfiles...');
+  logger.log('info', 'now building Dockerfiles...');
   await helpers
     .readDockerfiles()
     .then(helpers.sortDockerfiles)
@@ -67,7 +72,7 @@ export let build = async () => {
 /**
  * login to the DockerRegistries
  */
-export let login = async () => {
+export const login = async () => {
   await prepare();
   await npmciRegistryStorage.loginAll();
 };
@@ -75,10 +80,10 @@ export let login = async () => {
 /**
  * logs in docker
  */
-export let prepare = async () => {
+export const 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!');
+    logger.log('error', 'No registry token specified by gitlab!');
     process.exit(1);
   }
   npmciRegistryStorage.addRegistry(
@@ -96,47 +101,74 @@ export let prepare = async () => {
   return;
 };
 
-export let push = async argvArg => {
+/**
+ * pushes an image towards a registry
+ * @param argvArg
+ */
+export const push = async argvArg => {
   await prepare();
-  let registryUrlArg = argvArg._[2];
+  let dockerRegistryUrls: string[] = [];
+
+  // lets parse the input of cli and npmextra
+  if (argvArg._.length >= 3 && argvArg._[2] !== 'npmextra') {
+    dockerRegistryUrls.push(argvArg._[2]);
+  } else {
+    if (configObject.dockerRegistries.length === 0) {
+      logger.log(
+        'warn',
+        `There are no docker registries listed in npmextra.json! This is strange!`
+      );
+    }
+    dockerRegistryUrls = dockerRegistryUrls.concat(configObject.dockerRegistries);
+  }
+
+  // lets determine the suffix
   let suffix = null;
   if (argvArg._.length >= 4) {
     suffix = argvArg._[3];
   }
-  let dockerfileArray = await helpers
+
-    .readDockerfiles()
+  // lets push to the registries
-    .then(helpers.sortDockerfiles)
+  for (const dockerRegistryUrl of dockerRegistryUrls) {
-    .then(helpers.mapDockerfiles);
+    const dockerfileArray = await helpers
-  let localDockerRegistry = npmciRegistryStorage.getRegistryByUrl(registryUrlArg);
+      .readDockerfiles()
-  if (!localDockerRegistry) {
+      .then(helpers.sortDockerfiles)
-    plugins.beautylog.error(
+      .then(helpers.mapDockerfiles);
-      `Cannot push to registry ${registryUrlArg}, because it was not found in the authenticated registry list.`
+    const dockerRegistryToPushTo = npmciRegistryStorage.getRegistryByUrl(dockerRegistryUrl);
-    );
+    if (!dockerRegistryToPushTo) {
-    process.exit(1);
+      logger.log(
-  }
+        'error',
-  for (let dockerfile of dockerfileArray) {
+        `Cannot push to registry ${dockerRegistryUrl}, because it was not found in the authenticated registry list.`
-    await dockerfile.push(localDockerRegistry, suffix);
+      );
+      process.exit(1);
+    }
+    for (const dockerfile of dockerfileArray) {
+      await dockerfile.push(dockerRegistryToPushTo, suffix);
+    }
   }
 };
 
-export let pull = async argvArg => {
+export const pull = async argvArg => {
   await prepare();
-  let registryUrlArg = argvArg._[2];
+  const registryUrlArg = argvArg._[2];
   let suffix = null;
   if (argvArg._.length >= 4) {
     suffix = argvArg._[3];
   }
-  let localDockerRegistry = npmciRegistryStorage.getRegistryByUrl(registryUrlArg);
+  const localDockerRegistry = npmciRegistryStorage.getRegistryByUrl(registryUrlArg);
-  let dockerfileArray = await helpers
+  const dockerfileArray = await helpers
     .readDockerfiles()
     .then(helpers.sortDockerfiles)
     .then(helpers.mapDockerfiles);
-  for (let dockerfile of dockerfileArray) {
+  for (const dockerfile of dockerfileArray) {
     await dockerfile.pull(localDockerRegistry, suffix);
   }
 };
 
-export let test = async () => {
+/**
+ * tests docker files
+ */
+export const test = async () => {
   await prepare();
   return await helpers.readDockerfiles().then(helpers.testDockerfiles);
 };

ts/mod_docker/mod.classes.dockerfile.ts

@@ -1,3 +1,4 @@
+import { logger } from '../npmci.logging';
 import * as plugins from './mod.plugins';
 import * as NpmciEnv from '../npmci.env';
 import { bash } from '../npmci.bash';
@@ -10,16 +11,16 @@ import * as helpers from './mod.helpers';
  * class Dockerfile represents a Dockerfile on disk in npmci
  */
 export class Dockerfile {
-  filePath: string;
+  public filePath: string;
-  repo: string;
+  public repo: string;
-  version: string;
+  public version: string;
-  cleanTag: string;
+  public cleanTag: string;
-  buildTag: string;
+  public buildTag: string;
-  containerName: string;
+  public containerName: string;
-  content: string;
+  public content: string;
-  baseImage: string;
+  public baseImage: string;
-  localBaseImageDependent: boolean;
+  public localBaseImageDependent: boolean;
-  localBaseDockerfile: Dockerfile;
+  public localBaseDockerfile: Dockerfile;
   constructor(options: { filePath?: string; fileContents?: string | Buffer; read?: boolean }) {
     this.filePath = options.filePath;
     this.repo = NpmciEnv.repo.user + '/' + NpmciEnv.repo.repo;
@@ -38,10 +39,10 @@ export class Dockerfile {
   /**
    * builds the Dockerfile
    */
-  async build() {
+  public async build() {
-    plugins.beautylog.info('now building Dockerfile for ' + this.cleanTag);
+    logger.log('info', 'now building Dockerfile for ' + this.cleanTag);
-    let buildArgsString = await helpers.getDockerBuildArgs();
+    const buildArgsString = await helpers.getDockerBuildArgs();
-    let buildCommand = `docker build -t ${this.buildTag} -f ${this.filePath} ${buildArgsString} .`;
+    const buildCommand = `docker build -t ${this.buildTag} -f ${this.filePath} ${buildArgsString} .`;
     await bash(buildCommand);
     return;
   }
@@ -49,8 +50,8 @@ export class Dockerfile {
   /**
    * pushes the Dockerfile to a registry
    */
-  async push(dockerRegistryArg: DockerRegistry, versionSuffix: string = null) {
+  public async push(dockerRegistryArg: DockerRegistry, versionSuffix: string = null) {
-    let pushTag = helpers.getDockerTagString(
+    const pushTag = helpers.getDockerTagString(
       dockerRegistryArg.registryUrl,
       this.repo,
       this.version,
@@ -63,8 +64,8 @@ export class Dockerfile {
   /**
    * pulls the Dockerfile from a registry
    */
-  async pull(registryArg: DockerRegistry, versionSuffixArg: string = null) {
+  public async pull(registryArg: DockerRegistry, versionSuffixArg: string = null) {
-    let pullTag = helpers.getDockerTagString(
+    const pullTag = helpers.getDockerTagString(
       registryArg.registryUrl,
       this.repo,
       this.version,
@@ -77,15 +78,13 @@ export class Dockerfile {
   /**
    * tests the Dockerfile;
    */
-  async test() {
+  public async test() {
-    let testFile: string = plugins.path.join(paths.NpmciTestDir, 'test_' + this.version + '.sh');
+    const testFile: string = plugins.path.join(paths.NpmciTestDir, 'test_' + this.version + '.sh');
-    let testFileExists: boolean = plugins.smartfile.fs.fileExistsSync(testFile);
+    const testFileExists: boolean = plugins.smartfile.fs.fileExistsSync(testFile);
     if (testFileExists) {
       // run tests
       await bash(
-        `docker run --name npmci_test_container --entrypoint="bash" ${
+        `docker run --name npmci_test_container --entrypoint="bash" ${this.buildTag} -c "mkdir /npmci_test"`
-          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`);
@@ -93,17 +92,17 @@ export class Dockerfile {
       await bash(`docker rm npmci_test_container`);
       await bash(`docker rmi --force npmci_test_image`);
     } else {
-      plugins.beautylog.warn(
+      logger.log('warn', 'skipping tests for ' + this.cleanTag + ' because no testfile was found!');
-        'skipping tests for ' + this.cleanTag + ' because no testfile was found!'
-      );
     }
   }
 
   /**
    * gets the id of a Dockerfile
    */
-  async getId() {
+  public async getId() {
-    let containerId = await bash('docker inspect --type=image --format="{{.Id}}" ' + this.buildTag);
+    const containerId = await bash(
+      'docker inspect --type=image --format="{{.Id}}" ' + this.buildTag
+    );
     return containerId;
   }
 }

ts/mod_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;
+  public registryUrl: string;
-  username: string;
+  public username: string;
-  password: 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 {
+  public static fromEnvString(envString: string): DockerRegistry {
-    let dockerRegexResultArray = envString.split('|');
+    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];
+    const registryUrl = dockerRegexResultArray[0];
-    let username = dockerRegexResultArray[1];
+    const username = dockerRegexResultArray[1];
-    let password = dockerRegexResultArray[2];
+    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}!`);
   }
 }

ts/mod_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!');
   }
 }

ts/mod_docker/mod.helpers.ts

@@ -1,3 +1,4 @@
+import { logger } from '../npmci.logging';
 import * as plugins from './mod.plugins';
 import * as paths from '../npmci.paths';
 import * as NpmciEnv from '../npmci.env';
@@ -11,14 +12,14 @@ import { Dockerfile } from './mod.classes.dockerfile';
  * @returns Promise<Dockerfile[]>
  */
 export let readDockerfiles = async (): Promise<Dockerfile[]> => {
-  let fileTree = await plugins.smartfile.fs.listFileTree(paths.cwd, 'Dockerfile*');
+  const fileTree = await plugins.smartfile.fs.listFileTree(paths.cwd, 'Dockerfile*');
 
   // create the Dockerfile array
-  let readDockerfilesArray: Dockerfile[] = [];
+  const readDockerfilesArray: Dockerfile[] = [];
-  plugins.beautylog.info(`found ${fileTree.length} Dockerfiles:`);
+  logger.log('info', `found ${fileTree.length} Dockerfiles:`);
   console.log(fileTree);
-  for (let dockerfilePath of fileTree) {
+  for (const dockerfilePath of fileTree) {
-    let myDockerfile = new Dockerfile({
+    const myDockerfile = new Dockerfile({
       filePath: dockerfilePath,
       read: true
     });
@@ -34,14 +35,14 @@ export let readDockerfiles = async (): Promise<Dockerfile[]> => {
  * @returns Promise<Dockerfile[]>
  */
 export let sortDockerfiles = (sortableArrayArg: Dockerfile[]): Promise<Dockerfile[]> => {
-  let done = plugins.q.defer<Dockerfile[]>();
+  const done = plugins.smartpromise.defer<Dockerfile[]>();
-  plugins.beautylog.info('sorting Dockerfiles:');
+  logger.log('info', 'sorting Dockerfiles:');
-  let sortedArray: Dockerfile[] = [];
+  const sortedArray: Dockerfile[] = [];
-  let cleanTagsOriginal = cleanTagsArrayFunction(sortableArrayArg, sortedArray);
+  const cleanTagsOriginal = cleanTagsArrayFunction(sortableArrayArg, sortedArray);
   let sorterFunctionCounter: number = 0;
-  let sorterFunction = function() {
+  const sorterFunction = () => {
     sortableArrayArg.forEach(dockerfileArg => {
-      let cleanTags = cleanTagsArrayFunction(sortableArrayArg, sortedArray);
+      const cleanTags = cleanTagsArrayFunction(sortableArrayArg, sortedArray);
       if (
         cleanTags.indexOf(dockerfileArg.baseImage) === -1 &&
         sortedArray.indexOf(dockerfileArg) === -1
@@ -54,8 +55,8 @@ export let sortDockerfiles = (sortableArrayArg: Dockerfile[]): Promise<Dockerfil
     });
     if (sortableArrayArg.length === sortedArray.length) {
       let counter = 1;
-      for (let dockerfile of sortedArray) {
+      for (const dockerfile of sortedArray) {
-        plugins.beautylog.log(`tag ${counter}: -> ${dockerfile.cleanTag}`);
+        logger.log('info', `tag ${counter}: -> ${dockerfile.cleanTag}`);
         counter++;
       }
       done.resolve(sortedArray);
@@ -88,7 +89,7 @@ export let mapDockerfiles = async (sortedArray: Dockerfile[]): Promise<Dockerfil
  * builds the correspoding real docker image for each Dockerfile class instance
  */
 export let buildDockerfiles = async (sortedArrayArg: Dockerfile[]) => {
-  for (let dockerfileArg of sortedArrayArg) {
+  for (const dockerfileArg of sortedArrayArg) {
     await dockerfileArg.build();
   }
   return sortedArrayArg;
@@ -99,7 +100,7 @@ export let buildDockerfiles = async (sortedArrayArg: Dockerfile[]) => {
  * @param sortedArrayArg Dockerfile[] that contains all Dockerfiles in cwd
  */
 export let testDockerfiles = async (sortedArrayArg: Dockerfile[]) => {
-  for (let dockerfileArg of sortedArrayArg) {
+  for (const dockerfileArg of sortedArrayArg) {
     await dockerfileArg.test();
   }
   return sortedArrayArg;
@@ -111,8 +112,8 @@ export let testDockerfiles = async (sortedArrayArg: Dockerfile[]) => {
  */
 export let dockerFileVersion = (dockerfileNameArg: string): string => {
   let versionString: string;
-  let versionRegex = /Dockerfile_([a-zA-Z0-9\.]*)$/;
+  const versionRegex = /Dockerfile_([a-zA-Z0-9\.]*)$/;
-  let regexResultArray = versionRegex.exec(dockerfileNameArg);
+  const regexResultArray = versionRegex.exec(dockerfileNameArg);
   if (regexResultArray && regexResultArray.length === 2) {
     versionString = regexResultArray[1];
   } else {
@@ -124,9 +125,9 @@ export let dockerFileVersion = (dockerfileNameArg: string): string => {
 /**
  * returns the docker base image for a Dockerfile
  */
-export let dockerBaseImage = function(dockerfileContentArg: string) {
+export let dockerBaseImage = (dockerfileContentArg: string) => {
-  let baseImageRegex = /FROM\s([a-zA-z0-9\/\-\:]*)\n?/;
+  const baseImageRegex = /FROM\s([a-zA-z0-9\/\-\:]*)\n?/;
-  let regexResultArray = baseImageRegex.exec(dockerfileContentArg);
+  const regexResultArray = baseImageRegex.exec(dockerfileContentArg);
   return regexResultArray[1];
 };
 
@@ -140,8 +141,8 @@ export let getDockerTagString = (
   suffixArg?: string
 ): string => {
   // determine wether the repo should be mapped accordingly to the registry
-  let mappedRepo = NpmciConfig.configObject.dockerRegistryRepoMap[registryArg];
+  const mappedRepo = NpmciConfig.configObject.dockerRegistryRepoMap[registryArg];
-  let repo = (() => {
+  const repo = (() => {
     if (mappedRepo) {
       return mappedRepo;
     } else {
@@ -155,16 +156,16 @@ export let getDockerTagString = (
     version = versionArg + '_' + suffixArg;
   }
 
-  let tagString = `${registryArg}/${repo}:${version}`;
+  const 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');
+  logger.log('info', 'checking for env vars to be supplied to the docker build');
   let buildArgsString: string = '';
-  for (let key in NpmciConfig.configObject.dockerBuildargEnvMap) {
+  for (const key in NpmciConfig.configObject.dockerBuildargEnvMap) {
-    let targetValue = process.env[NpmciConfig.configObject.dockerBuildargEnvMap[key]];
+    const targetValue = process.env[NpmciConfig.configObject.dockerBuildargEnvMap[key]];
-    buildArgsString = `${buildArgsString} --build-arg ${key}=${targetValue}`;
+    buildArgsString = `${buildArgsString} --build-arg ${key}="${targetValue}"`;
   }
   return buildArgsString;
 };
@@ -172,12 +173,12 @@ export let getDockerBuildArgs = async (): Promise<string> => {
 /**
  *
  */
-export let cleanTagsArrayFunction = function(
+export let cleanTagsArrayFunction = (
   dockerfileArrayArg: Dockerfile[],
   trackingArrayArg: Dockerfile[]
-): string[] {
+): string[] => {
-  let cleanTagsArray: string[] = [];
+  const cleanTagsArray: string[] = [];
-  dockerfileArrayArg.forEach(function(dockerfileArg) {
+  dockerfileArrayArg.forEach(dockerfileArg => {
     if (trackingArrayArg.indexOf(dockerfileArg) === -1) {
       cleanTagsArray.push(dockerfileArg.cleanTag);
     }

ts/mod_git/index.ts

@@ -1,45 +1,56 @@
+import { logger } from '../npmci.logging';
 import * as plugins from './mod.plugins';
 import { bash } from '../npmci.bash';
 import { repo } from '../npmci.env';
 
+import { configObject } from '../npmci.config';
+
 /**
  * handle cli input
  * @param argvArg
  */
 export let handleCli = async argvArg => {
   if (argvArg._.length >= 2) {
-    let action: string = argvArg._[1];
+    const action: string = argvArg._[1];
     switch (action) {
       case 'mirror':
         await mirror();
         break;
       default:
-        plugins.beautylog.error(`>>npmci git ...<< action >>${action}<< not supported`);
+        logger.log('error', `npmci git -> action >>${action}<< not supported!`);
     }
   } else {
-    plugins.beautylog.log(
+    logger.log('info', `npmci git -> cli arguments invalid! Please read the documentation.`);
-      `>>npmci git ...<< cli arguments invalid... Please read the documentation.`
-    );
   }
 };
 
 export let mirror = async () => {
-  let githubToken = process.env.NPMCI_GIT_GITHUBTOKEN;
+  const githubToken = process.env.NPMCI_GIT_GITHUBTOKEN;
-  let githubUser = process.env.NPMCI_GIT_GITHUBGROUP || repo.user;
+  const githubUser = process.env.NPMCI_GIT_GITHUBGROUP || repo.user;
-  let githubRepo = process.env.NPMCI_GIT_GITHUB || repo.repo;
+  const githubRepo = process.env.NPMCI_GIT_GITHUB || repo.repo;
+  if (
+    configObject.projectInfo.npm.packageJson.private === true ||
+    configObject.npmAccessLevel === 'private'
+  ) {
+    logger.log(
+      'warn',
+      `refusing to mirror due to private property use a private mirror location instead`
+    );
+    return;
+  }
   if (githubToken) {
-    plugins.beautylog.info('found github token.');
+    logger.log('info', 'found github token.');
-    plugins.beautylog.log('attempting the mirror the repository to GitHub');
+    logger.log('info', '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!');
+    logger.log('ok', 'pushed all branches to mirror!');
     await bash(`git push mirror --tags`);
-    plugins.beautylog.ok('pushed all tags to mirror!');
+    logger.log('ok', 'pushed all tags to mirror!');
   } else {
-    plugins.beautylog.error(`cannot find NPMCI_GIT_GITHUBTOKEN env var!`);
+    logger.log('error', `cannot find NPMCI_GIT_GITHUBTOKEN env var!`);
     process.exit(1);
   }
 };

ts/mod_node/index.ts

@@ -1,3 +1,4 @@
+import { logger } from '../npmci.logging';
 import * as plugins from '../npmci.plugins';
 import * as paths from '../npmci.paths';
 import * as npmciConfig from '../npmci.config';
@@ -9,17 +10,18 @@ import { bash, bashNoError, nvmAvailable } from '../npmci.bash';
  */
 export let handleCli = async argvArg => {
   if (argvArg._.length >= 3) {
-    let action: string = argvArg._[1];
+    const action: string = argvArg._[1];
     switch (action) {
       case 'install':
         await install(argvArg._[2]);
         break;
       default:
-        plugins.beautylog.error(`>>npmci node ...<< action >>${action}<< not supported`);
+        logger.log('error', `>>npmci node ...<< action >>${action}<< not supported`);
         process.exit(1);
     }
   } else {
-    plugins.beautylog.error(
+    logger.log(
+      'error',
       `>>npmci node ...<< cli arguments invalid... Please read the documentation.`
     );
     process.exit(1);
@@ -31,40 +33,40 @@ export let handleCli = async argvArg => {
  * @param versionArg
  */
 export let install = async versionArg => {
-  plugins.beautylog.log(`now installing node version ${versionArg}`);
+  logger.log('info', `now installing node version ${versionArg}`);
   let version: string;
   if (versionArg === 'stable') {
-    version = '10';
+    version = '12';
   } else if (versionArg === 'lts') {
-    version = '8';
+    version = '10';
   } else if (versionArg === 'legacy') {
-    version = '9';
+    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!`);
+    logger.log('success', `Node version ${version} successfully installed!`);
   } else {
-    plugins.beautylog.warn('Nvm not in path so staying at installed node version!');
+    logger.log('warn', 'Nvm not in path so staying at installed node version!');
   }
   await bash('node -v');
   await bash('npm -v');
   await bash(`npm config set cache ${paths.NpmciCacheDir}  --global `);
   // lets look for further config
   await npmciConfig.getConfig().then(async configArg => {
-    plugins.beautylog.log('Now checking for needed global npm tools...');
+    logger.log('info', 'Now checking for needed global npm tools...');
-    for (let npmTool of configArg.npmGlobalTools) {
+    for (const npmTool of configArg.npmGlobalTools) {
-      plugins.beautylog.info(`Checking for global "${npmTool}"`);
+      logger.log('info', `Checking for global "${npmTool}"`);
-      let whichOutput: string = await bashNoError(`which ${npmTool}`);
+      const whichOutput: string = await bashNoError(`which ${npmTool}`);
-      let toolAvailable: boolean = !(/not\sfound/.test(whichOutput) || whichOutput === '');
+      const toolAvailable: boolean = !(/not\sfound/.test(whichOutput) || whichOutput === '');
       if (toolAvailable) {
-        plugins.beautylog.log(`Tool ${npmTool} is available`);
+        logger.log('info', `Tool ${npmTool} is available`);
       } else {
-        plugins.beautylog.info(`globally installing ${npmTool} from npm`);
+        logger.log('info', `globally installing ${npmTool} from npm`);
         await bash(`npm install ${npmTool} -q -g`);
       }
     }
-    plugins.beautylog.success('all global npm tools specified in npmextra.json are now available!');
+    logger.log('success', 'all global npm tools specified in npmextra.json are now available!');
   });
 };

ts/mod_npm/index.ts

@@ -1,3 +1,4 @@
+import { logger } from '../npmci.logging';
 import * as plugins from './mod.plugins';
 import * as configModule from '../npmci.config';
 import { bash, bashNoError, nvmAvailable } from '../npmci.bash';
@@ -8,7 +9,7 @@ import { bash, bashNoError, nvmAvailable } from '../npmci.bash';
  */
 export let handleCli = async argvArg => {
   if (argvArg._.length >= 2) {
-    let action: string = argvArg._[1];
+    const action: string = argvArg._[1];
     switch (action) {
       case 'install':
         await install();
@@ -23,13 +24,11 @@ export let handleCli = async argvArg => {
         await publish();
         break;
       default:
-        plugins.beautylog.error(`>>npmci npm ...<< action >>${action}<< not supported`);
+        logger.log('error', `>>npmci npm ...<< action >>${action}<< not supported`);
         process.exit(1);
     }
   } else {
-    plugins.beautylog.log(
+    logger.log('info', `>>npmci npm ...<< cli arguments invalid... Please read the documentation.`);
-      `>>npmci npm ...<< cli arguments invalid... Please read the documentation.`
-    );
     process.exit(1);
   }
 };
@@ -37,16 +36,28 @@ export let handleCli = async argvArg => {
 /**
  * authenticates npm with token from env var
  */
-let prepare = async () => {
+const prepare = async () => {
-  let npmrcPrefix: string = '//registry.npmjs.org/:_authToken=';
+  const config = await configModule.getConfig();
-  let npmToken: string = process.env.NPMCI_TOKEN_NPM;
+  let npmrcFileString: string = '';
-  let npmrcFileString: string = npmrcPrefix + npmToken;
+  await plugins.smartparam.forEachMinimatch(process.env, 'NPMCI_TOKEN_NPM*', npmEnvArg => {
-  if (npmToken) {
+    const npmRegistryUrl = npmEnvArg.split('|')[0];
-    plugins.beautylog.info('found access token');
+    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 {
-    plugins.beautylog.error('no access token found! Exiting!');
+    logger.log('error', 'no access token found! Exiting!');
     process.exit(1);
   }
+
+  // lets save it to disk
   plugins.smartfile.memory.toFsSync(npmrcFileString, '/root/.npmrc');
   return;
 };
@@ -54,8 +65,9 @@ let prepare = async () => {
 /**
  * publish a package to npm
  */
-let publish = async () => {
+const publish = async () => {
   let npmAccessCliString = ``;
+  let npmRegistryCliString = ``;
   const config = await configModule.getConfig();
 
   // -> configure package access level
@@ -66,8 +78,16 @@ let publish = async () => {
     npmAccessCliString = `--access=${config.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);
+  }
+
   // -> preparing
-  plugins.beautylog.log(`now preparing environment:`);
+  logger.log('info', `now preparing environment:`);
   prepare();
   await bash(`npm -v`);
 
@@ -75,26 +95,26 @@ let publish = async () => {
   await bash(`npm install`);
   await bash(`npm run build`);
 
-  plugins.beautylog.success(`Nice!!! The build for the publication was successfull!`);
+  logger.log('success', `Nice!!! The build for the publication was successfull!`);
-  plugins.beautylog.log(`Lets clean up so we don't publish any packages that don't belong to us:`);
+  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`);
 
-  plugins.beautylog.success(`Cleaned up!:`);
+  logger.log('success', `Cleaned up!:`);
 
   // -> publish it
-  plugins.beautylog.log(`now invoking npm to publish the package!`);
+  logger.log('info', `now invoking npm to publish the package!`);
-  await bash(`npm publish ${npmAccessCliString}`);
+  await bash(`npm publish ${npmAccessCliString} ${npmRegistryCliString}`);
-  plugins.beautylog.success(`Package was successfully published!`);
+  logger.log('success', `Package was successfully published!`);
 };
 
-let install = async (): Promise<void> => {
+const install = async (): Promise<void> => {
-  plugins.beautylog.info('now installing dependencies:');
+  logger.log('info', 'now installing dependencies:');
   await bash('npm install');
 };
 
 export let test = async (): Promise<void> => {
-  plugins.beautylog.info('now starting tests:');
+  logger.log('info', 'now starting tests:');
   await bash('npm test');
 };

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) => {
+const evaluateSshEnv = async (sshkeyEnvVarArg: string) => {
-  let sshEnvArray = sshkeyEnvVarArg.split('|');
+  const sshEnvArray = sshkeyEnvVarArg.split('|');
-  let sshKey = new plugins.smartssh.SshKey();
+  const sshKey = new plugins.smartssh.SshKey();
-  plugins.beautylog.info('Found SSH identity for ' + sshEnvArray[1]);
+  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];
   }
 

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');
+  logger.log('info', 'now running triggers');
-  plugins.smartparam.forEachMinimatch(process.env, 'NPMCI_TRIGGER_*', evaluateTrigger);
+  await plugins.smartparam.forEachMinimatch(process.env, 'NPMCI_TRIGGER_*', evaluateTrigger);
 };
 
-let evaluateTrigger = async triggerEnvVarArg => {
+const evaluateTrigger = async triggerEnvVarArg => {
-  let triggerRegexResultArray = triggerValueRegex.exec(triggerEnvVarArg);
+  const triggerRegexResultArray = triggerValueRegex.exec(triggerEnvVarArg);
-  let regexDomain = triggerRegexResultArray[1];
+  const regexDomain = triggerRegexResultArray[1];
-  let regexProjectId = triggerRegexResultArray[2];
+  const regexProjectId = triggerRegexResultArray[2];
-  let regexProjectTriggerToken = triggerRegexResultArray[3];
+  const regexProjectTriggerToken = triggerRegexResultArray[3];
-  let regexRefName = triggerRegexResultArray[4];
+  const regexRefName = triggerRegexResultArray[4];
   let regexTriggerName;
   if (triggerRegexResultArray.length === 6) {
     regexTriggerName = triggerRegexResultArray[5];
   } else {
     regexTriggerName = 'Unnamed Trigger';
   }
-  plugins.beautylog.info('Found Trigger!');
+  logger.log('info', 'Found Trigger!');
-  plugins.beautylog.log('triggering build for ref ' + regexRefName + ' of ' + regexTriggerName);
+  logger.log('info', 'triggering build for ref ' + regexRefName + ' of ' + regexTriggerName);
-  plugins.request.post('https://gitlab.com/api/v3/projects/' + regexProjectId + '/trigger/builds', {
+  plugins.smartrequest.postFormData(
-    form: { token: regexProjectTriggerToken, ref: regexRefName }
+    'https://gitlab.com/api/v3/projects/' + regexProjectId + '/trigger/builds',
-  });
+    {},
+    [
+      {
+        name: 'token',
+        payload: regexProjectTriggerToken,
+        type: 'string'
+      },
+      {
+        name: 'ref',
+        payload: regexRefName,
+        type: 'string'
+      }
+    ]
+  );
 };

ts/npmci.bash.ts

@@ -1,3 +1,4 @@
+import { logger } from './npmci.logging';
 import * as plugins from './npmci.plugins';
 import * as paths from './npmci.paths';
 
@@ -10,7 +11,7 @@ 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: []
 });
@@ -18,18 +19,18 @@ 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);
@@ -68,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(
+        logger.log('warn', 'Something went wrong! Exit Code: ' + execResult.exitCode.toString());
-          'Something went wrong! Exit Code: ' + execResult.exitCode.toString()
+        logger.log('info', 'Retry ' + (i + 1).toString() + ' of ' + retryArg.toString());
-        );
-        plugins.beautylog.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'

ts/npmci.cli.ts

@@ -1,23 +1,22 @@
+import { logger } from './npmci.logging';
 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);
+const npmciInfo = new plugins.projectinfo.ProjectinfoNpm(paths.NpmciPackageRoot);
-plugins.beautylog.log('npmci version: ' + npmciInfo.version);
+logger.log('info', 'npmci version: ' + npmciInfo.version);
 
 import * as NpmciEnv from './npmci.env';
 
-import * as npmciMods from './npmci.mods';
-
 const npmciSmartcli = new plugins.smartcli.Smartcli();
 npmciSmartcli.addVersion(npmciInfo.version);
 
 // clean
 npmciSmartcli.addCommand('clean').subscribe(
   async argv => {
-    let modClean = await npmciMods.modClean.load();
+    const modClean = await import('./mod_clean/index');
     await modClean.clean();
   },
   err => {
@@ -26,21 +25,10 @@ npmciSmartcli.addCommand('clean').subscribe(
   }
 );
 
-// cloudflare
-npmciSmartcli.addCommand('cloudflare').subscribe(
-  async argvArg => {
-    let modPurge = await npmciMods.modCloudflare.load();
-    await modPurge.handleCli(argvArg);
-  },
-  err => {
-    console.log(err);
-  }
-);
-
 // command
 npmciSmartcli.addCommand('command').subscribe(
   async argv => {
-    let modCommand = await npmciMods.modCommand.load();
+    const modCommand = await import('./mod_command/index');
     await modCommand.command();
   },
   err => {
@@ -52,7 +40,7 @@ npmciSmartcli.addCommand('command').subscribe(
 // command
 npmciSmartcli.addCommand('git').subscribe(
   async argvArg => {
-    let modGit = await npmciMods.modGit.load();
+    const modGit = await import('./mod_git/index');
     await modGit.handleCli(argvArg);
   },
   err => {
@@ -64,7 +52,7 @@ npmciSmartcli.addCommand('git').subscribe(
 // build
 npmciSmartcli.addCommand('docker').subscribe(
   async argvArg => {
-    let modDocker = await npmciMods.modDocker.load();
+    const modDocker = await import('./mod_docker/index');
     await modDocker.handleCli(argvArg);
   },
   err => {
@@ -76,7 +64,7 @@ npmciSmartcli.addCommand('docker').subscribe(
 // node
 npmciSmartcli.addCommand('node').subscribe(
   async argvArg => {
-    let modNode = await npmciMods.modNode.load();
+    const modNode = await import('./mod_node/index');
     await modNode.handleCli(argvArg);
   },
   err => {
@@ -88,7 +76,7 @@ npmciSmartcli.addCommand('node').subscribe(
 // npm
 npmciSmartcli.addCommand('npm').subscribe(
   async argvArg => {
-    let modNpm = await npmciMods.modNpm.load();
+    const modNpm = await import('./mod_npm/index');
     await modNpm.handleCli(argvArg);
   },
   err => {
@@ -99,7 +87,7 @@ npmciSmartcli.addCommand('npm').subscribe(
 // trigger
 npmciSmartcli.addCommand('ssh').subscribe(
   async argvArg => {
-    let modSsh = await npmciMods.modSsh.load();
+    const modSsh = await import('./mod_ssh/index');
     await modSsh.handleCli(argvArg);
   },
   err => {
@@ -111,7 +99,7 @@ npmciSmartcli.addCommand('ssh').subscribe(
 // trigger
 npmciSmartcli.addCommand('trigger').subscribe(
   async argv => {
-    let modTrigger = await npmciMods.modTrigger.load();
+    const modTrigger = await import('./mod_trigger/index');
     await modTrigger.trigger();
   },
   err => {

ts/npmci.config.ts

@@ -1,27 +1,39 @@
-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';
+import { KeyValueStore } from '@pushrocks/npmextra';
 
+/**
+ * the main config interface for npmci
+ */
 export interface INpmciOptions {
+  projectInfo: plugins.projectinfo.ProjectInfo;
+
+  // npm
   npmGlobalTools: string[];
   npmAccessLevel?: 'private' | 'public';
-  dockerRegistryRepoMap: any;
+  npmRegistryUrl: string;
-  dockerBuildargEnvMap: any;
+
+  // docker
+  dockerRegistries: string[];
+  dockerRegistryRepoMap: { [key: string]: string };
+  dockerBuildargEnvMap: { [key: string]: string };
 }
 
 // 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);
+const npmciNpmextra = new plugins.npmextra.Npmextra(paths.cwd);
-let defaultConfig: INpmciOptions = {
+const defaultConfig: INpmciOptions = {
+  projectInfo: new plugins.projectinfo.ProjectInfo(paths.cwd),
   npmGlobalTools: [],
+  dockerRegistries: [],
   dockerRegistryRepoMap: {},
+  npmAccessLevel: 'private',
+  npmRegistryUrl: 'registry.npmjs.org',
   dockerBuildargEnvMap: {}
 };
 export let configObject = npmciNpmextra.dataFor<INpmciOptions>('npmci', defaultConfig);

ts/npmci.env.ts

@@ -1,6 +1,6 @@
 import * as plugins from './npmci.plugins';
 import * as paths from './npmci.paths';
-import { GitRepo } from 'smartstring';
+import { GitRepo } from '@pushrocks/smartstring';
 import { Dockerfile } from './mod_docker/index';
 
 /**

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());

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);

ts/npmci.monitor.ts

@@ -1,7 +1,8 @@
+import { logger } from './npmci.logging';
 import * as plugins from './npmci.plugins';
 import * as env from './npmci.env';
 
-import { Analytics } from 'smartanalytics';
+import { Analytics } from '@pushrocks/smartanalytics';
 
 export let npmciAnalytics = new Analytics({
   apiEndPoint: 'https://pubapi.lossless.one/analytics',
@@ -17,6 +18,6 @@ export let run = async () => {
       repo: env.repo.repo
     })
     .catch(err => {
-      plugins.beautylog.warn('Lossless Analytics API not available...');
+      logger.log('warn', 'Lossless Analytics API not available...');
     });
 };

ts/npmci.plugins.ts

@@ -1,19 +1,41 @@
-export import beautylog = require('beautylog');
+// node native
-export import lodash = require('lodash');
+import * as path from 'path';
-export import npmextra = require('npmextra');
+
-export import path = require('path');
+export { path };
-export import projectinfo = require('projectinfo');
+
-export import q = require('smartq');
+// @pushrocks
-export let request = require('request');
+import * as projectinfo from '@pushrocks/projectinfo';
-export import smartcli = require('@pushrocks/smartcli');
+import * as npmextra from '@pushrocks/npmextra';
-export import smartdelay = require('smartdelay');
+import * as smartdelay from '@pushrocks/smartdelay';
-export import smartfile = require('smartfile');
+import * as smartfile from '@pushrocks/smartfile';
-export import shelljs = require('shelljs');
+import * as smartcli from '@pushrocks/smartcli';
-export import smartparam = require('smartparam');
+import * as smartlog from '@pushrocks/smartlog';
-export import smartpromise = require('@pushrocks/smartpromise');
+import * as smartlogDestinationLocal from '@pushrocks/smartlog-destination-local';
-export import smartshell = require('smartshell');
+import * as smartparam from '@pushrocks/smartparam';
-export import smartsocket = require('smartsocket');
+import * as smartpromise from '@pushrocks/smartpromise';
-export import smartsystem = require('smartsystem');
+import * as smartrequest from '@pushrocks/smartrequest';
-export import smartssh = require('smartssh');
+import * as smartshell from '@pushrocks/smartshell';
-export import smartstring = require('smartstring');
+import * as smartsocket from '@pushrocks/smartsocket';
-export import through2 = require('through2');
+import * as smartssh from '@pushrocks/smartssh';
+import * as smartstring from '@pushrocks/smartstring';
+
+export {
+  projectinfo,
+  npmextra,
+  smartdelay,
+  smartfile,
+  smartcli,
+  smartlog,
+  smartlogDestinationLocal,
+  smartparam,
+  smartpromise,
+  smartrequest,
+  smartshell,
+  smartsocket,
+  smartssh,
+  smartstring
+};
+
+import * as through2 from 'through2';
+
+export { through2 };

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"
 }