3.1.22

update purge

See merge request !4

.gitignore

@@ -1,3 +1,7 @@
+dist/
 node_modules/
 coverage/
-docs/
+public/
+config.json
+.yarn/
+.npmci_cache

.gitlab-ci.yml

@@ -1,28 +1,150 @@
-image: hosttoday/ht-docker-node:latest
+# gitzone standard
+image: hosttoday/ht-docker-node:npmci
+
+cache:
+  paths:
+  - .npmci_cache/
+  key: "$CI_BUILD_STAGE"
 
 stages:
+- security
 - test
 - release
+- metadata
+
+# ====================
+# security stage
+# ====================
+mirror:
+  stage: security
+  script:
+  - npmci git mirror
+  tags:
+  - docker
+  - notpriv
+
+snyk:
+  stage: security
+  script:
+    - npmci npm prepare
+    - npmci command npm install -g snyk
+    - npmci command npm install --ignore-scripts
+    - npmci command snyk test
+  tags:
+  - docker
+  - notpriv
+
+sast:
+  stage: security
+  image: registry.gitlab.com/hosttoday/ht-docker-dbase:npmci
+  variables:
+    DOCKER_DRIVER: overlay2
+  allow_failure: true
+  services:
+    - docker:stable-dind
+  script:
+    - npmci npm prepare
+    - npmci npm install
+    - npmci command npm run build
+    - export SP_VERSION=$(echo "$CI_SERVER_VERSION" | sed 's/^\([0-9]*\)\.\([0-9]*\).*/\1-\2-stable/')
+    - docker run
+        --env SAST_CONFIDENCE_LEVEL="${SAST_CONFIDENCE_LEVEL:-3}"
+        --volume "$PWD:/code"
+        --volume /var/run/docker.sock:/var/run/docker.sock
+        "registry.gitlab.com/gitlab-org/security-products/sast:$SP_VERSION" /app/bin/run /code
+  artifacts:
+    reports:
+      sast: gl-sast-report.json
+  tags:
+  - docker
+  - priv
+
+# ====================
+# test stage
+# ====================
 
 testLTS:
   stage: test
   script:
-    - npmci test lts
+  - npmci npm prepare
+  - npmci node install lts
+  - npmci npm install
+  - npmci npm test
+  coverage: /\d+.?\d+?\%\s*coverage/
   tags:
-    - docker
+  - docker
+  - notpriv
     
 testSTABLE:
   stage: test
   script:
-    - npmci test stable
+  - npmci npm prepare
+  - npmci node install stable
+  - npmci npm install
+  - npmci npm test
+  coverage: /\d+.?\d+?\%\s*coverage/
   tags:
-    - docker
+  - docker
+  - notpriv
 
 release:
   stage: release
   script:
-    - npmci publish
+  - npmci node install stable
+  - npmci npm publish
   only:
-    - tags
+  - tags
+  tags:
+  - docker
+  - notpriv
+
+# ====================
+# metadata stage
+# ====================
+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/')
+    - docker run
+        --env SOURCE_CODE="$PWD"
+        --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
+
+trigger:
+  stage: metadata
+  script:
+  - npmci trigger
+  only:
+  - tags
+  tags:
+  - docker
+  - notpriv
+
+pages:
+  image: hosttoday/ht-docker-node:npmci
+  stage: metadata
+  script:
+    - npmci command npm install -g typedoc typescript
+    - npmci npm prepare
+    - npmci npm install
+    - npmci command typedoc --module "commonjs" --target "ES2016" --out public/ ts/
   tags:
     - docker
+    - notpriv
+  only:
+    - tags
+  artifacts:
+    expire_in: 1 week
+    paths:
+    - public
+  allow_failure: true

.npmignore

@@ -1,2 +0,0 @@
-docs/
-coverage/

.snyk

@@ -0,0 +1,4 @@
+# Snyk (https://snyk.io) policy file, patches or ignores known vulnerabilities.
+version: v1.13.1
+ignore: {}
+patch: {}

README.md

@@ -1,4 +0,0 @@
-# NPMCI
-
-npmci is your friend when it comes to handling npm packages during CI builds.
-It is designed to work hand in hand with npmts

appveyor.yml

@@ -1,10 +0,0 @@
-environment:
-  nodejs_version: "4"
-install:
-  - ps: Install-Product node $env:nodejs_version
-  - npm install
-test_script:
-  - node --version
-  - npm --version
-  - npm test
-build: off

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

dist/index.d.ts

@@ -1 +0,0 @@
-import "typings-global";

dist/index.js

@@ -1,37 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-require("typings-global");
-var plugins = require("./npmci.plugins");
-var packJson = require("../package.json");
-plugins.beautylog.log("npmci in version" + packJson.version);
-var npmci_install_1 = require("./npmci.install");
-var npmci_test_1 = require("./npmci.test");
-var npmci_publish_1 = require("./npmci.publish");
-var command;
-var commandOption;
-plugins.commander
-    .arguments('<commandarg> [commandoptionarg]')
-    .action(function (commandarg, commandoptionarg) {
-    command = commandarg;
-    commandOption = commandoptionarg;
-});
-plugins.commander.parse(process.argv);
-if (typeof command === 'undefined') {
-    console.error('no command given!');
-    process.exit(1);
-}
-switch (command) {
-    case "install":
-        npmci_install_1.install(commandOption);
-        break;
-    case "test":
-        npmci_test_1.test(commandOption);
-        break;
-    case "publish":
-        npmci_publish_1.publish();
-        break;
-    default:
-        break;
-}
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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

dist/npmci.bash.d.ts

@@ -1,2 +0,0 @@
-import "typings-global";
-export declare let bash: (commandArg: any) => void;

dist/npmci.bash.js

@@ -1,13 +0,0 @@
-"use strict";
-require("typings-global");
-var plugins = require("./npmci.plugins");
-exports.bash = function (commandArg) {
-    var exitCode = plugins.shelljs.exec("bash -c \"source /usr/local/nvm/nvm.sh &&" +
-        commandArg +
-        "\"").code;
-    if (exitCode !== 0) {
-        process.exit(1);
-    }
-};
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIm5wbWNpLmJhc2gudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLFFBQU8sZ0JBQWdCLENBQUMsQ0FBQTtBQUN4QixJQUFZLE9BQU8sV0FBTSxpQkFBaUIsQ0FBQyxDQUFBO0FBQ2hDLFlBQUksR0FBRyxVQUFDLFVBQVU7SUFDekIsSUFBSSxRQUFRLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQy9CLDJDQUEyQztRQUMzQyxVQUFVO1FBQ1YsSUFBSSxDQUNQLENBQUMsSUFBSSxDQUFDO0lBQ1AsRUFBRSxDQUFBLENBQUMsUUFBUSxLQUFLLENBQUMsQ0FBQyxDQUFBLENBQUM7UUFDZixPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ3BCLENBQUM7QUFDTCxDQUFDLENBQUEiLCJmaWxlIjoibnBtY2kuYmFzaC5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBcInR5cGluZ3MtZ2xvYmFsXCI7XHJcbmltcG9ydCAqIGFzIHBsdWdpbnMgZnJvbSBcIi4vbnBtY2kucGx1Z2luc1wiO1xyXG5leHBvcnQgbGV0IGJhc2ggPSAoY29tbWFuZEFyZykgPT4ge1xyXG4gICAgbGV0IGV4aXRDb2RlID0gcGx1Z2lucy5zaGVsbGpzLmV4ZWMoXHJcbiAgICAgICAgXCJiYXNoIC1jIFxcXCJzb3VyY2UgL3Vzci9sb2NhbC9udm0vbnZtLnNoICYmXCIgK1xyXG4gICAgICAgIGNvbW1hbmRBcmcgK1xyXG4gICAgICAgIFwiXFxcIlwiXHJcbiAgICApLmNvZGU7XHJcbiAgICBpZihleGl0Q29kZSAhPT0gMCl7XHJcbiAgICAgICAgcHJvY2Vzcy5leGl0KDEpO1xyXG4gICAgfVxyXG59Il19

dist/npmci.install.d.ts

@@ -1,2 +0,0 @@
-import "typings-global";
-export declare let install: (versionArg: any) => any;

dist/npmci.install.js

@@ -1,25 +0,0 @@
-"use strict";
-require("typings-global");
-var plugins = require("./npmci.plugins");
-var npmci_bash_1 = require("./npmci.bash");
-exports.install = function (versionArg) {
-    var done = plugins.q.defer();
-    var version;
-    if (versionArg = "lts") {
-        version = "4";
-    }
-    else {
-        version = versionArg;
-    }
-    ;
-    plugins.beautylog.log("now installing " + "node ".green + ("version " + version).yellow);
-    npmci_bash_1.bash("nvm install " + version +
-        " && nvm alias default " + version);
-    plugins.beautylog.success("Node version " + version + " successfully installed!");
-    npmci_bash_1.bash("node -v");
-    npmci_bash_1.bash("npm -v");
-    done.resolve();
-    return done.promise;
-};
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,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

dist/npmci.plugins.d.ts

@@ -1,6 +0,0 @@
-import "typings-global";
-export import beautylog = require("beautylog");
-export declare let commander: any;
-export declare let q: any;
-export declare let shelljs: any;
-export import smartfile = require("smartfile");

dist/npmci.plugins.js

@@ -1,9 +0,0 @@
-"use strict";
-require("typings-global");
-exports.beautylog = require("beautylog");
-exports.commander = require("commander");
-exports.q = require("q");
-exports.shelljs = require("shelljs");
-exports.smartfile = require("smartfile");
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIm5wbWNpLnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLFFBQU8sZ0JBQWdCLENBQUMsQ0FBQTtBQUNWLGlCQUFTLFdBQVcsV0FBVyxDQUFDLENBQUM7QUFDcEMsaUJBQVMsR0FBRyxPQUFPLENBQUMsV0FBVyxDQUFDLENBQUM7QUFDakMsU0FBQyxHQUFHLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNqQixlQUFPLEdBQUcsT0FBTyxDQUFDLFNBQVMsQ0FBQyxDQUFDO0FBQzFCLGlCQUFTLFdBQVcsV0FBVyxDQUFDLENBQUMiLCJmaWxlIjoibnBtY2kucGx1Z2lucy5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBcInR5cGluZ3MtZ2xvYmFsXCI7XHJcbmV4cG9ydCBpbXBvcnQgYmVhdXR5bG9nID0gcmVxdWlyZShcImJlYXV0eWxvZ1wiKTtcclxuZXhwb3J0IGxldCBjb21tYW5kZXIgPSByZXF1aXJlKFwiY29tbWFuZGVyXCIpO1xyXG5leHBvcnQgbGV0IHEgPSByZXF1aXJlKFwicVwiKTtcclxuZXhwb3J0IGxldCBzaGVsbGpzID0gcmVxdWlyZShcInNoZWxsanNcIik7XHJcbmV4cG9ydCBpbXBvcnQgc21hcnRmaWxlID0gcmVxdWlyZShcInNtYXJ0ZmlsZVwiKTsiXX0=

dist/npmci.publish.d.ts

@@ -1,2 +0,0 @@
-import "typings-global";
-export declare let publish: () => any;

dist/npmci.publish.js

@@ -1,17 +0,0 @@
-"use strict";
-require("typings-global");
-var plugins = require("./npmci.plugins");
-var npmci_bash_1 = require("./npmci.bash");
-var npmrcPrefix = "//registry.npmjs.org/:_authToken=";
-var npmToken = process.env.NPMCITOKEN;
-var npmrcFileString = npmrcPrefix + npmToken;
-exports.publish = function () {
-    var done = plugins.q.defer();
-    plugins.beautylog.ok("Tests passed, now publishing to npm!");
-    plugins.smartfile.memory.toFs(npmrcFileString, { fileName: ".npmrc", filePath: "/usr/local/" });
-    npmci_bash_1.bash("npm publish");
-    plugins.beautylog.ok("Done!");
-    return done.promise;
-};
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIm5wbWNpLnB1Ymxpc2gudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLFFBQU8sZ0JBQWdCLENBQUMsQ0FBQTtBQUN4QixJQUFZLE9BQU8sV0FBTSxpQkFBaUIsQ0FBQyxDQUFBO0FBQzNDLDJCQUFtQixjQUFjLENBQUMsQ0FBQTtBQUVsQyxJQUFJLFdBQVcsR0FBVSxtQ0FBbUMsQ0FBQztBQUM3RCxJQUFJLFFBQVEsR0FBVSxPQUFPLENBQUMsR0FBRyxDQUFDLFVBQVUsQ0FBQztBQUM3QyxJQUFJLGVBQWUsR0FBRyxXQUFXLEdBQUcsUUFBUSxDQUFDO0FBR2xDLGVBQU8sR0FBRztJQUNqQixJQUFJLElBQUksR0FBRyxPQUFPLENBQUMsQ0FBQyxDQUFDLEtBQUssRUFBRSxDQUFDO0lBQzdCLE9BQU8sQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDLHNDQUFzQyxDQUFDLENBQUM7SUFDN0QsT0FBTyxDQUFDLFNBQVMsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLGVBQWUsRUFBQyxFQUFDLFFBQVEsRUFBQyxRQUFRLEVBQUMsUUFBUSxFQUFDLGFBQWEsRUFBQyxDQUFDLENBQUM7SUFDMUYsaUJBQUksQ0FBQyxhQUFhLENBQUMsQ0FBQztJQUNwQixPQUFPLENBQUMsU0FBUyxDQUFDLEVBQUUsQ0FBQyxPQUFPLENBQUMsQ0FBQTtJQUM3QixNQUFNLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQztBQUN4QixDQUFDLENBQUMiLCJmaWxlIjoibnBtY2kucHVibGlzaC5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBcInR5cGluZ3MtZ2xvYmFsXCI7XHJcbmltcG9ydCAqIGFzIHBsdWdpbnMgZnJvbSBcIi4vbnBtY2kucGx1Z2luc1wiO1xyXG5pbXBvcnQge2Jhc2h9IGZyb20gXCIuL25wbWNpLmJhc2hcIjtcclxuXHJcbmxldCBucG1yY1ByZWZpeDpzdHJpbmcgPSBcIi8vcmVnaXN0cnkubnBtanMub3JnLzpfYXV0aFRva2VuPVwiO1xyXG5sZXQgbnBtVG9rZW46c3RyaW5nID0gcHJvY2Vzcy5lbnYuTlBNQ0lUT0tFTjtcclxubGV0IG5wbXJjRmlsZVN0cmluZyA9IG5wbXJjUHJlZml4ICsgbnBtVG9rZW47XHJcblxyXG5cclxuZXhwb3J0IGxldCBwdWJsaXNoID0gKCkgPT4ge1xyXG4gICAgbGV0IGRvbmUgPSBwbHVnaW5zLnEuZGVmZXIoKTtcclxuICAgIHBsdWdpbnMuYmVhdXR5bG9nLm9rKFwiVGVzdHMgcGFzc2VkLCBub3cgcHVibGlzaGluZyB0byBucG0hXCIpO1xyXG4gICAgcGx1Z2lucy5zbWFydGZpbGUubWVtb3J5LnRvRnMobnBtcmNGaWxlU3RyaW5nLHtmaWxlTmFtZTpcIi5ucG1yY1wiLGZpbGVQYXRoOlwiL3Vzci9sb2NhbC9cIn0pO1xyXG4gICAgYmFzaChcIm5wbSBwdWJsaXNoXCIpO1xyXG4gICAgcGx1Z2lucy5iZWF1dHlsb2cub2soXCJEb25lIVwiKVxyXG4gICAgcmV0dXJuIGRvbmUucHJvbWlzZTtcclxufTsiXX0=

dist/npmci.test.d.ts

@@ -1,2 +0,0 @@
-import "typings-global";
-export declare let test: (versionArg: any) => any;

dist/npmci.test.js

@@ -1,20 +0,0 @@
-"use strict";
-require("typings-global");
-var plugins = require("./npmci.plugins");
-var npmci_bash_1 = require("./npmci.bash");
-var npmci_install_1 = require("./npmci.install");
-exports.test = function (versionArg) {
-    var done = plugins.q.defer();
-    npmci_install_1.install(versionArg)
-        .then(function () {
-        plugins.beautylog.info("now installing dependencies:");
-        npmci_bash_1.bash("npm install");
-        plugins.beautylog.info("now starting tests:");
-        npmci_bash_1.bash("npm test");
-        plugins.beautylog.success("test finished");
-        done.resolve();
-    });
-    return done.promise;
-};
-
-//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIm5wbWNpLnRlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLFFBQU8sZ0JBQWdCLENBQUMsQ0FBQTtBQUN4QixJQUFZLE9BQU8sV0FBTSxpQkFBaUIsQ0FBQyxDQUFBO0FBQzNDLDJCQUFtQixjQUFjLENBQUMsQ0FBQTtBQUNsQyw4QkFBc0IsaUJBQWlCLENBQUMsQ0FBQTtBQUU3QixZQUFJLEdBQUcsVUFBQyxVQUFVO0lBQ3pCLElBQUksSUFBSSxHQUFHLE9BQU8sQ0FBQyxDQUFDLENBQUMsS0FBSyxFQUFFLENBQUM7SUFDN0IsdUJBQU8sQ0FBQyxVQUFVLENBQUM7U0FDZCxJQUFJLENBQUM7UUFDRixPQUFPLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyw4QkFBOEIsQ0FBQyxDQUFDO1FBQ3ZELGlCQUFJLENBQUMsYUFBYSxDQUFDLENBQUM7UUFDcEIsT0FBTyxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMscUJBQXFCLENBQUMsQ0FBQztRQUM5QyxpQkFBSSxDQUFDLFVBQVUsQ0FBQyxDQUFDO1FBQ2pCLE9BQU8sQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLGVBQWUsQ0FBQyxDQUFDO1FBQzNDLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUNuQixDQUFDLENBQUMsQ0FBQTtJQUNOLE1BQU0sQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDO0FBQ3hCLENBQUMsQ0FBQSIsImZpbGUiOiJucG1jaS50ZXN0LmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IFwidHlwaW5ncy1nbG9iYWxcIjtcclxuaW1wb3J0ICogYXMgcGx1Z2lucyBmcm9tIFwiLi9ucG1jaS5wbHVnaW5zXCI7XHJcbmltcG9ydCB7YmFzaH0gZnJvbSBcIi4vbnBtY2kuYmFzaFwiO1xyXG5pbXBvcnQge2luc3RhbGx9IGZyb20gXCIuL25wbWNpLmluc3RhbGxcIjtcclxuXHJcbmV4cG9ydCBsZXQgdGVzdCA9ICh2ZXJzaW9uQXJnKSA9PiB7XHJcbiAgICBsZXQgZG9uZSA9IHBsdWdpbnMucS5kZWZlcigpO1xyXG4gICAgaW5zdGFsbCh2ZXJzaW9uQXJnKVxyXG4gICAgICAgIC50aGVuKGZ1bmN0aW9uKCl7XHJcbiAgICAgICAgICAgIHBsdWdpbnMuYmVhdXR5bG9nLmluZm8oXCJub3cgaW5zdGFsbGluZyBkZXBlbmRlbmNpZXM6XCIpO1xyXG4gICAgICAgICAgICBiYXNoKFwibnBtIGluc3RhbGxcIik7XHJcbiAgICAgICAgICAgIHBsdWdpbnMuYmVhdXR5bG9nLmluZm8oXCJub3cgc3RhcnRpbmcgdGVzdHM6XCIpO1xyXG4gICAgICAgICAgICBiYXNoKFwibnBtIHRlc3RcIik7XHJcbiAgICAgICAgICAgIHBsdWdpbnMuYmVhdXR5bG9nLnN1Y2Nlc3MoXCJ0ZXN0IGZpbmlzaGVkXCIpO1xyXG4gICAgICAgICAgICBkb25lLnJlc29sdmUoKTtcclxuICAgICAgICB9KVxyXG4gICAgcmV0dXJuIGRvbmUucHJvbWlzZTtcclxufSJdfQ==

npmextra.json

@@ -0,0 +1,26 @@
+{
+  "npmts": {
+    "mode": "default",
+    "coverageTreshold": "70",
+    "cli": true
+  },
+  "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"
+    }
+  }
+}

package.json

@@ -1,33 +1,58 @@
 {
-  "name": "npmci",
+  "name": "@shipzone/npmci",
-  "version": "1.0.14",
+  "version": "3.1.22",
-  "description": "",
+  "private": false,
+  "description": "node and docker in gitlab ci on steroids",
   "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
   "bin": {
-    "npmci": "dist/index.js"
+    "npmci": "cli.js"
   },
   "scripts": {
-    "test": "(npmts)"
+    "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",
-    "url": "git+ssh://git@github.com/pushrocks/npmci.git"
+    "url": "git+ssh://git@gitlab.com/gitzone/npmci.git"
   },
   "author": "Lossless GmbH",
   "license": "MIT",
   "bugs": {
-    "url": "https://gitlab.com/pushrocks/npmci/issues"
+    "url": "https://gitlab.com/gitzone/npmci/issues"
   },
-  "homepage": "https://gitlab.com/pushrocks/npmci#README",
+  "homepage": "https://gitlab.com/gitzone/npmci#README",
   "devDependencies": {
-    "npmts": "^5.1.18"
+    "@gitzone/tsbuild": "^2.0.22",
+    "@gitzone/tsrun": "^1.1.13",
+    "@gitzone/tstest": "^1.0.15",
+    "@pushrocks/tapbundle": "^3.0.7",
+    "@types/node": "^10.12.10",
+    "tslint": "^5.11.0",
+    "tslint-config-prettier": "^1.17.0"
   },
   "dependencies": {
-    "beautylog": "^5.0.6",
+    "@pushrocks/lik": "^3.0.2",
-    "commander": "^2.9.0",
+    "@pushrocks/npmextra": "^3.0.1",
-    "q": "^1.4.1",
+    "@pushrocks/projectinfo": "^4.0.2",
-    "shelljs": "^0.7.0",
+    "@pushrocks/smartcli": "^3.0.6",
-    "smartfile": "^3.0.10",
+    "@pushrocks/smartdelay": "^2.0.2",
-    "typings-global": "^1.0.3"
+    "@pushrocks/smartfile": "^6.0.11",
+    "@pushrocks/smartlog": "^2.0.9",
+    "@pushrocks/smartlog-destination-local": "^7.0.5",
+    "@pushrocks/smartparam": "^1.0.4",
+    "@pushrocks/smartpromise": "^2.0.5",
+    "@pushrocks/smartrequest": "^1.1.14",
+    "@pushrocks/smartshell": "^2.0.11",
+    "@pushrocks/smartssh": "^1.2.3",
+    "@pushrocks/smartstring": "^3.0.5",
+    "@types/lodash": "^4.14.118",
+    "@types/shelljs": "^0.8.0",
+    "@types/through2": "^2.0.34",
+    "lodash": "^4.17.11",
+    "smartanalytics": "^2.0.9",
+    "smartsocket": "^1.1.19",
+    "through2": "^3.0.0"
   }
 }

readme.md

@@ -0,0 +1,101 @@
+# @shipzone/npmci
+node and docker in gitlab ci on steroids
+
+## 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/@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.
+
+Use TypeScript for best in class instellisense.
+
+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)
+
+[![repo-footer](https://shipzone.gitlab.io/assets/repo-footer.svg)](https://maintainedby.lossless.com)

test/assets/Dockerfile

@@ -0,0 +1,2 @@
+FROM ubuntu
+RUN apt-get update

test/assets/Dockerfile_sometag1

@@ -0,0 +1,2 @@
+FROM mygroup/myrepo:sometag2
+RUN apt-get update

test/assets/Dockerfile_sometag2

@@ -0,0 +1 @@
+FROM mygroup/myrepo:latest

test/assets/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "sandbox-npmts",
+  "version": "1.0.1",
+  "description": "a cool test repo for npmts",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "directories": {
+    "test": "test"
+  },
+  "scripts": {
+    "test": "(npmts)",
+    "testDev": "node ../../pushrocks/npmts/dist/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@gitlab.com/sandboxzone/sandbox-npmts.git"
+  },
+  "author": "Lossless GmbH",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://gitlab.com/sandboxzone/sandbox-npmts/issues"
+  },
+  "homepage": "https://gitlab.com/sandboxzone/sandbox-npmts#README",
+  "dependencies": {
+    "smartchai": "^1.0.3",
+    "smartci": "^1.0.2",
+    "smartq": "^1.1.6"
+  },
+  "devDependencies": {
+    "qenv": "^1.1.7",
+    "tapbundle": "^1.1.1"
+  }
+}

test/assets/test/test_latest.sh

@@ -0,0 +1,2 @@
+npm -v
+node -v

test/test.ts

@@ -0,0 +1,116 @@
+import { tap, expect } from '@pushrocks/tapbundle';
+import * as path from 'path';
+
+// Setup test
+process.env.NPMTS_TEST = 'true';
+
+// set up environment
+process.env.CI_REPOSITORY_URL = 'https://yyyyyy:xxxxxxxx@gitlab.com/mygroup/myrepo.git';
+process.env.CI_BUILD_TOKEN = 'kjlkjfiudofiufs';
+
+// Docker
+process.env.NPMCI_LOGIN_DOCKER = 'docker.io|someuser|somepass';
+
+// SSH env
+process.env.NPMCI_SSHKEY_1 = 'hostString|somePrivKey|##';
+
+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');
+
+// ======
+// Docker
+// ======
+
+let dockerfile1: npmciModDocker.Dockerfile;
+let dockerfile2: npmciModDocker.Dockerfile;
+let sortableArray: npmciModDocker.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 });
+  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[]) => {
+      sortableArray = readDockerfilesArrayArg;
+      return expect(readDockerfilesArrayArg[1].version).to.equal('sometag1');
+    });
+});
+
+tap.test('should sort an array of Dockerfiles', async () => {
+  return npmciModDocker.helpers
+    .sortDockerfiles(sortableArray)
+    .then(async (sortedArrayArg: npmciModDocker.Dockerfile[]) => {
+      console.log(sortedArrayArg);
+    });
+});
+
+tap.test('should build all Dockerfiles', async () => {
+  return npmciModDocker.handleCli({
+    _: ['docker', 'build']
+  });
+});
+
+tap.test('should test all Dockerfiles', async () => {
+  return await npmciModDocker.handleCli({
+    _: ['docker', 'test']
+  });
+});
+
+tap.test('should test dockerfiles', async () => {
+  return await npmciModDocker.handleCli({
+    _: ['docker', 'test']
+  });
+});
+
+tap.test('should login docker daemon', async () => {
+  return await npmciModDocker.handleCli({
+    _: ['docker', 'login']
+  });
+});
+
+// ===
+// SSH
+// ===
+tap.test('should prepare SSH keys', async () => {
+  return await npmciModSsh.handleCli({
+    _: ['ssh', 'prepare']
+  });
+});
+
+// ====
+// node
+// ====
+tap.test('should install a certain version of node', async () => {
+  await npmciModNode.handleCli({
+    _: ['node', 'install', 'stable']
+  });
+  await npmciModNode.handleCli({
+    _: ['node', 'install', 'lts']
+  });
+  await npmciModNode.handleCli({
+    _: ['node', 'install', 'legacy']
+  });
+});
+
+// make sure test ends all right
+tap.test('reset paths', async () => {
+  process.cwd = () => {
+    return path.join(__dirname, '../');
+  };
+});
+
+tap.start();

ts/index.ts

@@ -1,44 +1 @@
-#!/usr/bin/env node
+import './npmci.cli';
-import "typings-global";
-import * as plugins from "./npmci.plugins";
-
-let packJson = require("../package.json");
-
-plugins.beautylog.log("npmci in version" + packJson.version);
-
-import {install} from "./npmci.install";
-import {test} from "./npmci.test";
-import {publish} from "./npmci.publish";
-
-
-let command;
-let commandOption;
-
-plugins.commander
-    .arguments('<commandarg> [commandoptionarg]')
-    .action(function (commandarg, commandoptionarg) {
-        command = commandarg;
-        commandOption = commandoptionarg;
-    });
- 
-plugins.commander.parse(process.argv);
- 
-if (typeof command === 'undefined') {
-    console.error('no command given!');
-    process.exit(1);
-}
-
-switch (command){
-    case "install":
-        install(commandOption);
-        break;
-    case "test":
-        test(commandOption);
-        break;
-    case "publish":
-        publish();
-        break;
-    default:
-        break;
-}
-

ts/mod_clean/index.ts

@@ -0,0 +1,10 @@
+import * as plugins from './mod.plugins';
+import * as paths from '../npmci.paths';
+
+/**
+ * cleans npmci config files
+ */
+export let clean = async (): Promise<void> => {
+  plugins.smartfile.fs.removeSync(paths.NpmciPackageConfig);
+  return;
+};

ts/mod_clean/mod.plugins.ts

@@ -0,0 +1 @@
+export * from '../npmci.plugins';

ts/mod_command/index.ts

@@ -0,0 +1,15 @@
+import * as plugins from './mod.plugins';
+import { bash } from '../npmci.bash';
+
+export let command = async () => {
+  let wrappedCommand: string = '';
+  let argvArray = process.argv;
+  for (let i = 3; i < argvArray.length; i++) {
+    wrappedCommand = wrappedCommand + argvArray[i];
+    if (i + 1 !== argvArray.length) {
+      wrappedCommand = wrappedCommand + ' ';
+    }
+  }
+  await bash(wrappedCommand);
+  return;
+};

ts/mod_command/mod.plugins.ts

@@ -0,0 +1 @@
+export * from '../npmci.plugins';

ts/mod_docker/index.ts

@@ -0,0 +1,145 @@
+import { logger } from '../npmci.logging';
+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
+const 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) {
+    const 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:
+        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
+ */
+export let build = async () => {
+  await prepare();
+  logger.log('info', '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 === '') {
+    logger.log('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();
+  const registryUrlArg = argvArg._[2];
+  let suffix = null;
+  if (argvArg._.length >= 4) {
+    suffix = argvArg._[3];
+  }
+  const dockerfileArray = await helpers
+    .readDockerfiles()
+    .then(helpers.sortDockerfiles)
+    .then(helpers.mapDockerfiles);
+  const localDockerRegistry = npmciRegistryStorage.getRegistryByUrl(registryUrlArg);
+  if (!localDockerRegistry) {
+    logger.log(
+      'error',
+      `Cannot push to registry ${registryUrlArg}, because it was not found in the authenticated registry list.`
+    );
+    process.exit(1);
+  }
+  for (const dockerfile of dockerfileArray) {
+    await dockerfile.push(localDockerRegistry, suffix);
+  }
+};
+
+export let pull = async argvArg => {
+  await prepare();
+  const registryUrlArg = argvArg._[2];
+  let suffix = null;
+  if (argvArg._.length >= 4) {
+    suffix = argvArg._[3];
+  }
+  const localDockerRegistry = npmciRegistryStorage.getRegistryByUrl(registryUrlArg);
+  const dockerfileArray = await helpers
+    .readDockerfiles()
+    .then(helpers.sortDockerfiles)
+    .then(helpers.mapDockerfiles);
+  for (const dockerfile of dockerfileArray) {
+    await dockerfile.pull(localDockerRegistry, suffix);
+  }
+};
+
+export let test = async () => {
+  await prepare();
+  return await helpers.readDockerfiles().then(helpers.testDockerfiles);
+};

ts/mod_docker/mod.classes.dockerfile.ts

@@ -0,0 +1,112 @@
+import { logger } from '../npmci.logging';
+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 {
+  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(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
+   */
+  public async build() {
+    logger.log('info', 'now building Dockerfile for ' + this.cleanTag);
+    const buildArgsString = await helpers.getDockerBuildArgs();
+    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 = 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
+   */
+  public async pull(registryArg: DockerRegistry, versionSuffixArg: string = null) {
+    const 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;
+   */
+  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;
+  }
+}

ts/mod_docker/mod.classes.dockerregistry.ts

@@ -0,0 +1,48 @@
+import { logger } from '../npmci.logging';
+import * as plugins from './mod.plugins';
+import { bash } from '../npmci.bash';
+
+export interface IDockerRegistryConstructorOptions {
+  registryUrl: string;
+  username: string;
+  password: string;
+}
+
+export class DockerRegistry {
+  public registryUrl: string;
+  public username: string;
+  public password: string;
+  constructor(optionsArg: IDockerRegistryConstructorOptions) {
+    this.registryUrl = optionsArg.registryUrl;
+    this.username = optionsArg.username;
+    this.password = optionsArg.password;
+    logger.log('info', `created DockerRegistry for ${this.registryUrl}`);
+  }
+
+  public static fromEnvString(envString: string): DockerRegistry {
+    const dockerRegexResultArray = envString.split('|');
+    if (dockerRegexResultArray.length !== 3) {
+      logger.log('error', 'malformed docker env var...');
+      process.exit(1);
+      return;
+    }
+    const registryUrl = dockerRegexResultArray[0];
+    const username = dockerRegexResultArray[1];
+    const password = dockerRegexResultArray[2];
+    return new DockerRegistry({
+      registryUrl: registryUrl,
+      username: username,
+      password: password
+    });
+  }
+
+  public async login() {
+    if (this.registryUrl === 'docker.io') {
+      await bash(`docker login -u ${this.username} -p ${this.password}`);
+      logger.log('info', 'Logged in to standard docker hub');
+    } else {
+      await bash(`docker login -u ${this.username} -p ${this.password} ${this.registryUrl}`);
+    }
+    logger.log('ok', `docker authenticated for ${this.registryUrl}!`);
+  }
+}

ts/mod_docker/mod.classes.registrystorage.ts

@@ -0,0 +1,29 @@
+import { logger } from '../npmci.logging';
+import * as plugins from './mod.plugins';
+import { Objectmap } from '@pushrocks/lik';
+
+import { DockerRegistry } from './mod.classes.dockerregistry';
+
+export class RegistryStorage {
+  objectMap = new Objectmap<DockerRegistry>();
+  constructor() {
+    // Nothing here
+  }
+
+  addRegistry(registryArg: DockerRegistry) {
+    this.objectMap.add(registryArg);
+  }
+
+  getRegistryByUrl(registryUrlArg: string) {
+    return this.objectMap.find(registryArg => {
+      return registryArg.registryUrl === registryUrlArg;
+    });
+  }
+
+  async loginAll() {
+    await this.objectMap.forEach(async registryArg => {
+      await registryArg.login();
+    });
+    logger.log('success', 'logged in successfully into all available DockerRegistries!');
+  }
+}

ts/mod_docker/mod.helpers.ts

@@ -0,0 +1,187 @@
+import { logger } from '../npmci.logging';
+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[]> => {
+  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({
+      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[]> => {
+  const done = plugins.smartpromise.defer<Dockerfile[]>();
+  logger.log('info', 'sorting Dockerfiles:');
+  const sortedArray: Dockerfile[] = [];
+  const cleanTagsOriginal = cleanTagsArrayFunction(sortableArrayArg, sortedArray);
+  let sorterFunctionCounter: number = 0;
+  const sorterFunction = () => {
+    sortableArrayArg.forEach(dockerfileArg => {
+      const 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 (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
+ */
+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 (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
+ */
+export let testDockerfiles = async (sortedArrayArg: Dockerfile[]) => {
+  for (const 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;
+  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
+ */
+export let dockerBaseImage = (dockerfileContentArg: string) => {
+  const baseImageRegex = /FROM\s([a-zA-z0-9\/\-\:]*)\n?/;
+  const 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
+  const mappedRepo = NpmciConfig.configObject.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;
+};
+
+export let getDockerBuildArgs = async (): Promise<string> => {
+  logger.log('info', 'checking for env vars to be supplied to the docker build');
+  let buildArgsString: string = '';
+  for (const key in NpmciConfig.configObject.dockerBuildargEnvMap) {
+    const targetValue = process.env[NpmciConfig.configObject.dockerBuildargEnvMap[key]];
+    buildArgsString = `${buildArgsString} --build-arg ${key}="${targetValue}"`;
+  }
+  return buildArgsString;
+};
+
+/**
+ *
+ */
+export let cleanTagsArrayFunction = (
+  dockerfileArrayArg: Dockerfile[],
+  trackingArrayArg: Dockerfile[]
+): string[] => {
+  const cleanTagsArray: string[] = [];
+  dockerfileArrayArg.forEach(dockerfileArg => {
+    if (trackingArrayArg.indexOf(dockerfileArg) === -1) {
+      cleanTagsArray.push(dockerfileArg.cleanTag);
+    }
+  });
+  return cleanTagsArray;
+};

ts/mod_docker/mod.plugins.ts

@@ -0,0 +1 @@
+export * from '../npmci.plugins';

ts/mod_git/index.ts

@@ -0,0 +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) {
+    const action: string = argvArg._[1];
+    switch (action) {
+      case 'mirror':
+        await 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.`);
+  }
+};
+
+export let mirror = async () => {
+  const githubToken = process.env.NPMCI_GIT_GITHUBTOKEN;
+  const githubUser = process.env.NPMCI_GIT_GITHUBGROUP || repo.user;
+  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) {
+    logger.log('info', 'found github token.');
+    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`);
+    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);
+  }
+};

ts/mod_git/mod.plugins.ts

@@ -0,0 +1 @@
+export * from '../npmci.plugins';

ts/mod_node/index.ts

@@ -0,0 +1,72 @@
+import { logger } from '../npmci.logging';
+import * as plugins from '../npmci.plugins';
+import * as paths from '../npmci.paths';
+import * as npmciConfig from '../npmci.config';
+import { bash, bashNoError, nvmAvailable } from '../npmci.bash';
+
+/**
+ * handle cli input
+ * @param argvArg
+ */
+export let handleCli = async argvArg => {
+  if (argvArg._.length >= 3) {
+    const action: string = argvArg._[1];
+    switch (action) {
+      case 'install':
+        await 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
+ */
+export let install = async versionArg => {
+  logger.log('info', `now installing node version ${versionArg}`);
+  let version: string;
+  if (versionArg === 'stable') {
+    version = '11';
+  } 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!');
+  }
+  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 => {
+    logger.log('info', 'Now checking for needed global npm tools...');
+    for (const npmTool of configArg.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!');
+  });
+};

ts/mod_npm/index.ts

@@ -0,0 +1,120 @@
+import { logger } from '../npmci.logging';
+import * as plugins from './mod.plugins';
+import * as configModule from '../npmci.config';
+import { bash, bashNoError, nvmAvailable } from '../npmci.bash';
+
+/**
+ * handle cli input
+ * @param argvArg
+ */
+export let handleCli = async argvArg => {
+  if (argvArg._.length >= 2) {
+    const 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:
+        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
+ */
+const prepare = async () => {
+  const config = await configModule.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
+ */
+const publish = async () => {
+  let npmAccessCliString = ``;
+  let npmRegistryCliString = ``;
+  const config = await configModule.getConfig();
+
+  // -> configure package access level
+  if (
+    config.npmAccessLevel &&
+    (config.npmAccessLevel === 'public' || config.npmAccessLevel === 'private')
+  ) {
+    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
+  logger.log('info', `now preparing environment:`);
+  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(`npm publish ${npmAccessCliString} ${npmRegistryCliString}`);
+  logger.log('success', `Package was successfully published!`);
+};
+
+const install = async (): Promise<void> => {
+  logger.log('info', 'now installing dependencies:');
+  await bash('npm install');
+};
+
+export let test = async (): Promise<void> => {
+  logger.log('info', 'now starting tests:');
+  await bash('npm test');
+};

ts/mod_npm/mod.plugins.ts

@@ -0,0 +1 @@
+export * from '../npmci.plugins';

ts/mod_ssh/index.ts

@@ -0,0 +1,64 @@
+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) {
+    const action: string = argvArg._[1];
+    switch (action) {
+      case 'prepare':
+        await prepare();
+        break;
+      default:
+        logger.log('error', `action >>${action}<< not supported`);
+        process.exit(1);
+    }
+  } else {
+    logger.log('error', `>>npmci ssh ...<< please specify an action!`);
+    process.exit(1);
+  }
+};
+
+/**
+ * checks if not undefined
+ */
+const notUndefined = (stringArg: string) => {
+  return stringArg && stringArg !== 'undefined' && stringArg !== '##';
+};
+
+/**
+ * checks for ENV vars in form of NPMCI_SSHKEY_* and deploys any found ones
+ */
+export let prepare = async () => {
+  sshInstance = new plugins.smartssh.SshInstance(); // init ssh instance
+  plugins.smartparam.forEachMinimatch(process.env, 'NPMCI_SSHKEY_*', evaluateSshEnv);
+  if (!process.env.NPMTS_TEST) {
+    sshInstance.writeToDisk();
+  } else {
+    logger.log('info', 'In test mode, so not storing SSH keys to disk!');
+  }
+};
+
+/**
+ * gets called for each found SSH ENV Var and deploys it
+ */
+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])) {
+    logger.log('info', '---> host defined!');
+    sshKey.host = sshEnvArray[0];
+  }
+  if (notUndefined(sshEnvArray[1])) {
+    logger.log('info', '---> privKey defined!');
+    sshKey.privKeyBase64 = sshEnvArray[1];
+  }
+  if (notUndefined(sshEnvArray[2])) {
+    logger.log('info', '---> pubKey defined!');
+    sshKey.pubKeyBase64 = sshEnvArray[2];
+  }
+
+  sshInstance.addKey(sshKey);
+  return;
+};

ts/mod_ssh/mod.plugins.ts

@@ -0,0 +1 @@
+export * from '../npmci.plugins';

ts/mod_trigger/index.ts

@@ -0,0 +1,42 @@
+import * as plugins from './mod.plugins';
+import { bash } from '../npmci.bash';
+import { logger } from '../npmci.logging';
+
+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 () => {
+  logger.log('info', 'now running triggers');
+  await plugins.smartparam.forEachMinimatch(process.env, 'NPMCI_TRIGGER_*', evaluateTrigger);
+};
+
+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';
+  }
+  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'
+      }
+    ]
+  );
+};

ts/mod_trigger/mod.plugins.ts

@@ -0,0 +1 @@
+export * from '../npmci.plugins';

ts/npmci.bash.ts

@@ -1,12 +1,98 @@
-import "typings-global";
+import { logger } from './npmci.logging';
-import * as plugins from "./npmci.plugins";
+import * as plugins from './npmci.plugins';
-export let bash = (commandArg) => {
+import * as paths from './npmci.paths';
-    let exitCode = plugins.shelljs.exec(
+
-        "bash -c \"source /usr/local/nvm/nvm.sh &&" +
+import * as smartpromise from '@pushrocks/smartpromise';
-        commandArg +
+
-        "\""
+/**
-    ).code;
+ * wether nvm is available or not
-    if(exitCode !== 0){
+ */
-        process.exit(1);
+export let nvmAvailable = smartpromise.defer<boolean>();
+/**
+ * the smartshell instance for npmci
+ */
+const npmciSmartshell = new plugins.smartshell.Smartshell({
+  executor: 'bash',
+  sourceFilePaths: []
+});
+
+/**
+ * check for tools.
+ */
+const checkToolsAvailable = async () => {
+  // check for nvm
+  if (!process.env.NPMTS_TEST) {
+    if (
+      (await npmciSmartshell.execSilent(`bash -c "source /usr/local/nvm/nvm.sh"`)).exitCode === 0
+    ) {
+      npmciSmartshell.shellEnv.addSourceFiles([`/usr/local/nvm/nvm.sh`]);
+      nvmAvailable.resolve(true);
+    } else if (
+      (await npmciSmartshell.execSilent(`bash -c "source ~/.nvm/nvm.sh"`)).exitCode === 0
+    ) {
+      npmciSmartshell.shellEnv.addSourceFiles([`~/.nvm/nvm.sh`]);
+      nvmAvailable.resolve(true);
+    } else {
+      nvmAvailable.resolve(false);
     }
-}
+  } else {
+    nvmAvailable.resolve(true);
+  }
+};
+checkToolsAvailable();
+
+/**
+ * bash() allows using bash with nvm in path
+ * @param commandArg - The command to execute
+ * @param retryArg - The retryArg: 0 to any positive number will retry, -1 will always succeed, -2 will return undefined
+ */
+export let bash = async (commandArg: string, retryArg: number = 2): Promise<string> => {
+  await nvmAvailable.promise; // make sure nvm check has run
+  let execResult: plugins.smartshell.IExecResult;
+
+  // determine if we fail
+  let failOnError: boolean = true;
+  if (retryArg === -1) {
+    failOnError = false;
+    retryArg = 0;
+  }
+
+  if (!process.env.NPMTS_TEST) {
+    // NPMTS_TEST is used during testing
+    for (let i = 0; i <= retryArg; i++) {
+      if (process.env.DEBUG_NPMCI === 'true') {
+        console.log(commandArg);
+      }
+      execResult = await npmciSmartshell.exec(commandArg);
+
+      // determine how bash reacts to error and success
+      if (execResult.exitCode !== 0 && i === retryArg) {
+        // something went wrong and retries are exhausted
+        if (failOnError) {
+          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 {
+        logger.log('warn', 'Something went wrong! Exit Code: ' + execResult.exitCode.toString());
+        logger.log('info', 'Retry ' + (i + 1).toString() + ' of ' + retryArg.toString());
+      }
+    }
+  } else {
+    logger.log('info', 'ShellExec would be: ' + commandArg);
+    execResult = {
+      exitCode: 0,
+      stdout: 'testOutput'
+    };
+  }
+  return execResult.stdout;
+};
+
+/**
+ * bashNoError allows executing stuff without throwing an error
+ */
+export let bashNoError = async (commandArg: string): Promise<string> => {
+  return await bash(commandArg, -1);
+};

ts/npmci.cli.ts

@@ -0,0 +1,111 @@
+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
+const npmciInfo = new plugins.projectinfo.ProjectinfoNpm(paths.NpmciPackageRoot);
+logger.log('info', 'npmci version: ' + npmciInfo.version);
+
+import * as NpmciEnv from './npmci.env';
+
+const npmciSmartcli = new plugins.smartcli.Smartcli();
+npmciSmartcli.addVersion(npmciInfo.version);
+
+// clean
+npmciSmartcli.addCommand('clean').subscribe(
+  async argv => {
+    const modClean = await import('./mod_clean/index');
+    await modClean.clean();
+  },
+  err => {
+    console.log(err);
+    process.exit(1);
+  }
+);
+
+// command
+npmciSmartcli.addCommand('command').subscribe(
+  async argv => {
+    const modCommand = await import('./mod_command/index');
+    await modCommand.command();
+  },
+  err => {
+    console.log(err);
+    process.exit(1);
+  }
+);
+
+// command
+npmciSmartcli.addCommand('git').subscribe(
+  async argvArg => {
+    const modGit = await import('./mod_git/index');
+    await modGit.handleCli(argvArg);
+  },
+  err => {
+    console.log(err);
+    process.exit(1);
+  }
+);
+
+// build
+npmciSmartcli.addCommand('docker').subscribe(
+  async argvArg => {
+    const modDocker = await import('./mod_docker/index');
+    await modDocker.handleCli(argvArg);
+  },
+  err => {
+    console.log(err);
+    process.exit(1);
+  }
+);
+
+// node
+npmciSmartcli.addCommand('node').subscribe(
+  async argvArg => {
+    const modNode = await import('./mod_node/index');
+    await modNode.handleCli(argvArg);
+  },
+  err => {
+    console.log(err);
+    process.exit(1);
+  }
+);
+
+// npm
+npmciSmartcli.addCommand('npm').subscribe(
+  async argvArg => {
+    const modNpm = await import('./mod_npm/index');
+    await modNpm.handleCli(argvArg);
+  },
+  err => {
+    console.log(err);
+  }
+);
+
+// trigger
+npmciSmartcli.addCommand('ssh').subscribe(
+  async argvArg => {
+    const modSsh = await import('./mod_ssh/index');
+    await modSsh.handleCli(argvArg);
+  },
+  err => {
+    console.log(err);
+    process.exit(1);
+  }
+);
+
+// trigger
+npmciSmartcli.addCommand('trigger').subscribe(
+  async argv => {
+    const modTrigger = await import('./mod_trigger/index');
+    await modTrigger.trigger();
+  },
+  err => {
+    console.log(err);
+    process.exit(1);
+  }
+);
+
+npmciSmartcli.startParse();

ts/npmci.config.ts

@@ -0,0 +1,37 @@
+import * as plugins from './npmci.plugins';
+import * as paths from './npmci.paths';
+
+import { repo } from './npmci.env';
+
+import { KeyValueStore } from '@pushrocks/npmextra';
+
+export interface INpmciOptions {
+  projectInfo: plugins.projectinfo.ProjectInfo;
+  npmGlobalTools: string[];
+  npmAccessLevel?: 'private' | 'public';
+  npmRegistryUrl: string;
+  dockerRegistryRepoMap: any;
+  dockerBuildargEnvMap: any;
+}
+
+// instantiate a kvStorage for the current directory
+export let kvStorage = new KeyValueStore('custom', `${repo.user}_${repo.repo}`);
+
+// handle config retrival
+const npmciNpmextra = new plugins.npmextra.Npmextra(paths.cwd);
+const defaultConfig: INpmciOptions = {
+  projectInfo: new plugins.projectinfo.ProjectInfo(paths.cwd),
+  npmGlobalTools: [],
+  dockerRegistryRepoMap: {},
+  npmAccessLevel: 'private',
+  npmRegistryUrl: 'registry.npmjs.org',
+  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;
+};

ts/npmci.env.ts

@@ -0,0 +1,13 @@
+import * as plugins from './npmci.plugins';
+import * as paths from './npmci.paths';
+import { GitRepo } from '@pushrocks/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);

ts/npmci.install.ts

@@ -1,23 +0,0 @@
-import "typings-global";
-import * as plugins from "./npmci.plugins";
-import {bash} from "./npmci.bash";
-
-export let install = (versionArg) => {
-    let done = plugins.q.defer();
-    let version:string;
-    if(versionArg = "lts"){
-        version = "4";
-    } else {
-        version = versionArg;
-    };
-    plugins.beautylog.log("now installing " + "node ".green + ("version " + version).yellow);
-    bash(
-        "nvm install " + version +
-        " && nvm alias default " + version
-    );
-    plugins.beautylog.success("Node version " + version + " successfully installed!");
-    bash("node -v");
-    bash("npm -v");
-    done.resolve();
-    return done.promise;
-}

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.monitor.ts

@@ -0,0 +1,23 @@
+import { logger } from './npmci.logging';
+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 => {
+      logger.log('warn', 'Lossless Analytics API not available...');
+    });
+};

ts/npmci.paths.ts

@@ -0,0 +1,9 @@
+import * as plugins from './npmci.plugins';
+
+export let 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');
+export let NpmciCacheDir = plugins.path.join(cwd, './.npmci_cache');

ts/npmci.plugins.ts

@@ -1,6 +1,43 @@
-import "typings-global";
+// node native
-export import beautylog = require("beautylog");
+import * as path from 'path';
-export let commander = require("commander");
+
-export let q = require("q");
+export { path };
-export let shelljs = require("shelljs");
+
-export import smartfile = require("smartfile");
+// @pushrocks
+import * as projectinfo from '@pushrocks/projectinfo';
+import * as npmextra from '@pushrocks/npmextra';
+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 'smartsocket';
+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
+};
+
+// third party
+import * as lodash from 'lodash';
+import * as through2 from 'through2';
+
+export { lodash, through2 };

ts/npmci.publish.ts

@@ -1,17 +0,0 @@
-import "typings-global";
-import * as plugins from "./npmci.plugins";
-import {bash} from "./npmci.bash";
-
-let npmrcPrefix:string = "//registry.npmjs.org/:_authToken=";
-let npmToken:string = process.env.NPMCITOKEN;
-let npmrcFileString = npmrcPrefix + npmToken;
-
-
-export let publish = () => {
-    let done = plugins.q.defer();
-    plugins.beautylog.ok("Tests passed, now publishing to npm!");
-    plugins.smartfile.memory.toFs(npmrcFileString,{fileName:".npmrc",filePath:"/usr/local/"});
-    bash("npm publish");
-    plugins.beautylog.ok("Done!")
-    return done.promise;
-};

ts/npmci.test.ts

@@ -1,18 +0,0 @@
-import "typings-global";
-import * as plugins from "./npmci.plugins";
-import {bash} from "./npmci.bash";
-import {install} from "./npmci.install";
-
-export let test = (versionArg) => {
-    let done = plugins.q.defer();
-    install(versionArg)
-        .then(function(){
-            plugins.beautylog.info("now installing dependencies:");
-            bash("npm install");
-            plugins.beautylog.info("now starting tests:");
-            bash("npm test");
-            plugins.beautylog.success("test finished");
-            done.resolve();
-        })
-    return done.promise;
-}

tslint.json

@@ -0,0 +1,17 @@
+{
+  "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"
+}