4.1.35

fix(docker): Fix Dockerfile dependency sorting and enhance environment variable handling for GitHub repos
4.1.34
2024-11-17 00:32:56 +01:00 · 2024-11-17 00:32:56 +01:00 · 2024-11-05 02:39:53 +01:00 · 2024-11-05 02:39:53 +01:00 · 2024-11-05 02:38:21 +01:00 · 2024-11-05 02:38:21 +01:00
55 changed files with 11029 additions and 28096 deletions
--- a/.gitea/workflows/default_nottags.yaml
+++ b/.gitea/workflows/default_nottags.yaml
@@ -0,0 +1,66 @@
+name: Default (not tags)
+
+on:
+  push:
+    tags-ignore:
+      - '**'
+
+env:
+  IMAGE: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
+  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
+  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
+
+jobs:
+
+  security:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Install pnpm and npmci
+      run: |
+        pnpm install -g pnpm
+        pnpm install -g @shipzone/npmci
+
+    - name: Run npm prepare
+      run: npmci npm prepare
+
+    - name: Audit production dependencies
+      run: |
+        npmci command npm config set registry https://registry.npmjs.org
+        npmci command pnpm audit --audit-level=high --prod
+      continue-on-error: true
+
+    - name: Audit development dependencies
+      run: |
+        npmci command npm config set registry https://registry.npmjs.org
+        npmci command pnpm audit --audit-level=high --dev
+      continue-on-error: true
+
+  test:
+    if: ${{ always() }}
+    needs: security
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Test stable
+      run: |
+        npmci node install stable
+        npmci npm install
+        npmci npm test
+
+    - name: Test build
+      run: |
+        npmci node install stable
+        npmci npm install
+        npmci npm build
--- a/.gitea/workflows/default_tags.yaml
+++ b/.gitea/workflows/default_tags.yaml
@@ -0,0 +1,108 @@
+name: Default (tags)
+
+on:
+  push:
+    tags:
+      - '*'
+
+env:
+  IMAGE: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
+  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  NPMCI_LOGIN_DOCKER_GITEA: ${{secrets.NPMCI_DOCKER_REGISTRYURL_DEFAULT}}|${{ gitea.repository_owner }}|${{ secrets.GITEA_TOKEN }}
+
+jobs:
+
+  security:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Install pnpm and npmci
+      run: |
+        pnpm install -g pnpm
+        pnpm install -g @shipzone/npmci
+
+    - name: Run npm prepare
+      run: npmci npm prepare
+
+    - name: Audit production dependencies
+      run: |
+        npmci command npm config set registry https://registry.npmjs.org
+        npmci command pnpm audit --audit-level=high --prod
+      continue-on-error: true
+
+    - name: Audit development dependencies
+      run: |
+        npmci command npm config set registry https://registry.npmjs.org
+        npmci command pnpm audit --audit-level=high --dev
+      continue-on-error: true
+
+  test:
+    if: ${{ always() }}
+    needs: security
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Test stable
+      run: |
+        npmci node install stable
+        npmci npm install
+        npmci npm test
+
+    - name: Test build
+      run: |
+        npmci node install stable
+        npmci npm install
+        npmci npm build
+
+  release:
+    needs: test
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Release
+      run: |
+        npmci node install stable
+        npmci npm publish
+
+  metadata:
+    needs: test
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+    continue-on-error: true
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Code quality
+      run: |
+        npmci command npm install -g typescript
+        npmci npm prepare
+        npmci npm install
+
+    - name: Trigger
+      run: npmci trigger
+
+    - name: Build docs and upload artifacts
+      run: |
+        npmci node install stable
+        npmci npm install
+        pnpm install -g @git.zone/tsdoc
+        npmci command tsdoc
+      continue-on-error: true
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,141 +0,0 @@
-# gitzone ci_default
-image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-
-cache:
-  paths:
-    - .npmci_cache/
-  key: '$CI_BUILD_STAGE'
-
-stages:
-  - security
-  - test
-  - release
-  - metadata
-
-before_script:
-  - npm install -g @shipzone/npmci
-
-# ====================
-# security stage
-# ====================
-mirror:
-  stage: security
-  script:
-    - npmci git mirror
-  only:
-    - tags
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-auditProductionDependencies:
-  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-  stage: security
-  script:
-    - npmci npm prepare
-    - npmci command npm install --production --ignore-scripts
-    - npmci command npm config set registry https://registry.npmjs.org
-    - npmci command npm audit --audit-level=high --only=prod --production
-  tags:
-    - docker
-  allow_failure: true
-
-auditDevDependencies:
-  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-  stage: security
-  script:
-    - npmci npm prepare
-    - npmci command npm install --ignore-scripts
-    - npmci command npm config set registry https://registry.npmjs.org
-    - npmci command npm audit --audit-level=high --only=dev
-  tags:
-    - docker
-  allow_failure: true
-
-# ====================
-# test stage
-# ====================
-
-testStable:
-  stage: test
-  script:
-    - npmci npm prepare
-    - npmci node install stable
-    - npmci npm install
-    - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-    - docker
-
-testBuild:
-  stage: test
-  script:
-    - npmci npm prepare
-    - npmci node install stable
-    - npmci npm install
-    - npmci command npm run build
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-    - docker
-
-release:
-  stage: release
-  script:
-    - npmci node install stable
-    - npmci npm publish
-  only:
-    - tags
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-# ====================
-# metadata stage
-# ====================
-codequality:
-  stage: metadata
-  allow_failure: true
-  only:
-    - tags
-  script:
-    - npmci command npm install -g tslint typescript
-    - npmci npm prepare
-    - npmci npm install
-    - npmci command "tslint -c tslint.json ./ts/**/*.ts"
-  tags:
-    - lossless
-    - docker
-    - priv
-
-trigger:
-  stage: metadata
-  script:
-    - npmci trigger
-  only:
-    - tags
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-pages:
-  stage: metadata
-  script:
-    - npmci node install lts
-    - npmci command npm install -g @gitzone/tsdoc
-    - npmci npm prepare
-    - npmci npm install
-    - npmci command tsdoc
-  tags:
-    - lossless
-    - docker
-    - notpriv
-  only:
-    - tags
-  artifacts:
-    expire_in: 1 week
-    paths:
-      - public
-  allow_failure: true
--- a/changelog.md
+++ b/changelog.md
@@ -0,0 +1,81 @@
+# Changelog
+
+## 2024-11-17 - 4.1.35 - fix(docker)
+Fix Dockerfile dependency sorting and enhance environment variable handling for GitHub repos
+
+- Refined the algorithm for sorting Dockerfiles based on dependencies to ensure proper build order.
+- Enhanced environment variable handling in the NpmciEnv class to support conditional assignments.
+- Updated various dependencies in package.json for improved performance and compatibility.
+- Added error handling to circular dependency detection in Dockerfile sorting.
+
+## 2024-11-05 - 4.1.34 - fix(connector)
+Remove unused typedrequest implementation in cloudlyconnector
+
+- Removed commented out code that initialized typedrequest in CloudlyConnector.
+
+## 2024-11-05 - 4.1.33 - fix(core)
+Updated dependencies and improved npm preparation logic.
+
+- Updated @git.zone/tsbuild from ^2.1.84 to ^2.2.0.
+- Updated @git.zone/tsrun from ^1.2.49 to ^1.3.3.
+- Updated @types/node from ^22.7.9 to ^22.8.7.
+- Updated @serve.zone/api from ^1.2.1 to ^4.3.1.
+- Improved npm preparation logic to handle empty tokens gracefully.
+
+## 2024-10-23 - 4.1.32 - fix(dependencies)
+Update project dependencies to latest versions
+
+- Updated development dependencies, including @git.zone/tsbuild and @git.zone/tsrun.
+- Updated production dependencies such as @api.global/typedrequest and @push.rocks/smartfile.
+
+## 2022-10-24 - 4.0.11 - prerelease
+now includes a precheck for more generic runner execution
+
+- Implemented a precheck feature for runners.
+
+## 2022-10-09 to 2022-10-11 - 4.0.0 to 4.0.10 - migration
+internal migrations and fixes
+
+- Major switch to ESM style module: **BREAKING CHANGE**.
+- Multiple fixes in core functionalities and module updates.
+
+## 2019-11-26 - 3.1.73 - fixes
+correctly setting npm cache and other updates
+
+- Ensured correct npm cache setting during preparation.
+- Various core updates.
+
+## 2018-12-23 - 3.1.19 - privacy updates
+enhanced mirroring controls for private code
+
+- Now refusing to mirror private code.
+
+## 2018-11-24 - 3.1.2 - ci improvement
+removed unnecessary build dependency
+
+- Removed npmts build dependency in CI pipeline.
+
+## 2018-09-22 - 3.0.59 - enhancement
+integrated smartlog for improved logging
+
+- Logs now utilize smartlog for better management.
+
+## 2017-09-08 - 3.0.14 - analytics
+added analytics features
+
+- Enabled analytics throughout the system.
+
+## 2017-08-29 - 3.0.9 - docker enhancements
+docker improvements and build args implementation
+
+- Implemented working `dockerBuildArgEnvMap`.
+
+## 2017-07-27 - 2.4.0 - stability improvements
+various updates to stabilize the environment
+
+- Fixed npmci versioning issues.
+
+## 2016-11-25 - 2.3.24 - global tools
+improved handling for global tool installations
+
+- Improved install handling for needed global tools.
--- a/cli.child.ts
+++ b/cli.child.ts
@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+process.env.CLI_CALL = 'true';
+import * as cliTool from './ts/index.js';
+cliTool.runCli();
--- a/cli.js
+++ b/cli.js
@@ -1,4 +1,4 @@
 #!/usr/bin/env node
 process.env.CLI_CALL = 'true';
-const cliTool = require('./dist_ts/index');
+const cliTool = await import('./dist_ts/index.js');
 cliTool.runCli();
--- a/cli.ts.js
+++ b/cli.ts.js
@@ -1,5 +1,5 @@
 #!/usr/bin/env node
 process.env.CLI_CALL = 'true';
-require('@gitzone/tsrun');
-const cliTool = require('./ts/index');
-cliTool.runCli();
+
+import * as tsrun from '@git.zone/tsrun';
+tsrun.runPath('./cli.child.js', import.meta.url);
--- a/0
+++ b/0
--- a/npmextra.json
+++ b/npmextra.json
@@ -12,11 +12,28 @@
    "projectType": "npm",
    "module": {
      "githost": "gitlab.com",
-      "gitscope": "shipzone",
+      "gitscope": "ship.zone",
      "gitrepo": "npmci",
-      "shortDescription": "node and docker in gitlab ci on steroids",
-      "npmPackagename": "@shipzone/npmci",
-      "license": "MIT"
+      "description": "A tool to streamline Node.js and Docker workflows within CI environments, particularly GitLab CI, providing various CI/CD utilities.",
+      "npmPackagename": "@ship.zone/npmci",
+      "license": "MIT",
+      "keywords": [
+        "Node.js",
+        "Docker",
+        "GitLab CI",
+        "GitHub CI",
+        "Gitea CI",
+        "CI/CD",
+        "automation",
+        "npm",
+        "TypeScript",
+        "cloud",
+        "SSH",
+        "registry",
+        "container management",
+        "continuous integration",
+        "continuous deployment"
+      ]
    }
  }
 }
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -1,17 +1,19 @@
 {
-  "name": "@shipzone/npmci",
-  "version": "3.1.80",
+  "name": "@ship.zone/npmci",
+  "version": "4.1.35",
  "private": false,
-  "description": "node and docker in gitlab ci on steroids",
+  "description": "A tool to streamline Node.js and Docker workflows within CI environments, particularly GitLab CI, providing various CI/CD utilities.",
  "main": "dist_ts/index.js",
  "typings": "dist_ts/index.d.ts",
+  "type": "module",
  "bin": {
    "npmci": "cli.js"
  },
  "scripts": {
    "test": "tstest test/",
-    "build": "tsbuild && (npm run testVersion)",
-    "testVersion": "(cd test/assets/ && node ../../cli.js -v)"
+    "build": "tsbuild --allowimplicitany && (npm run testVersion)",
+    "testVersion": "(cd test/assets/ && node ../../cli.js -v)",
+    "buildDocs": "tsdoc"
  },
  "repository": {
    "type": "git",
@@ -24,37 +26,37 @@
  },
  "homepage": "https://gitlab.com/gitzone/npmci#README",
  "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.28",
-    "@gitzone/tsrun": "^1.2.18",
-    "@gitzone/tstest": "^1.0.59",
-    "@pushrocks/tapbundle": "^3.2.14",
-    "@types/node": "^16.11.6",
-    "tslint": "^6.1.3",
-    "tslint-config-prettier": "^1.18.0"
+    "@git.zone/tsbuild": "^2.2.0",
+    "@git.zone/tsrun": "^1.3.3",
+    "@git.zone/tstest": "^1.0.77",
+    "@push.rocks/tapbundle": "^5.5.0",
+    "@types/node": "^22.9.0"
  },
  "dependencies": {
-    "@apiglobal/typedrequest": "^1.0.58",
-    "@pushrocks/lik": "^5.0.0",
-    "@pushrocks/npmextra": "^3.0.9",
-    "@pushrocks/projectinfo": "^4.0.5",
-    "@pushrocks/qenv": "^4.0.10",
-    "@pushrocks/smartanalytics": "^2.0.15",
-    "@pushrocks/smartcli": "^3.0.14",
-    "@pushrocks/smartdelay": "^2.0.13",
-    "@pushrocks/smartfile": "^8.0.10",
-    "@pushrocks/smartgit": "^2.0.1",
-    "@pushrocks/smartlog": "^2.0.44",
-    "@pushrocks/smartlog-destination-local": "^8.0.8",
-    "@pushrocks/smartparam": "^1.1.6",
-    "@pushrocks/smartpromise": "^3.1.6",
-    "@pushrocks/smartrequest": "^1.1.52",
-    "@pushrocks/smartshell": "^2.0.28",
-    "@pushrocks/smartsocket": "^1.2.8",
-    "@pushrocks/smartssh": "^1.2.3",
-    "@pushrocks/smartstring": "^3.0.24",
-    "@servezone/interfaces": "^1.0.3",
-    "@tsclass/tsclass": "^3.0.36",
-    "@types/through2": "^2.0.36",
+    "@api.global/typedrequest": "^3.1.10",
+    "@push.rocks/lik": "^6.1.0",
+    "@push.rocks/npmextra": "^5.1.2",
+    "@push.rocks/projectinfo": "^5.0.2",
+    "@push.rocks/qenv": "^6.0.2",
+    "@push.rocks/smartanalytics": "^2.0.15",
+    "@push.rocks/smartcli": "^4.0.11",
+    "@push.rocks/smartdelay": "^3.0.5",
+    "@push.rocks/smartenv": "^5.0.5",
+    "@push.rocks/smartfile": "^11.0.21",
+    "@push.rocks/smartgit": "^3.1.1",
+    "@push.rocks/smartlog": "^3.0.7",
+    "@push.rocks/smartlog-destination-local": "^9.0.0",
+    "@push.rocks/smartobject": "^1.0.12",
+    "@push.rocks/smartpath": "^5.0.11",
+    "@push.rocks/smartpromise": "^4.0.4",
+    "@push.rocks/smartrequest": "^2.0.23",
+    "@push.rocks/smartshell": "^3.0.6",
+    "@push.rocks/smartsocket": "^2.0.22",
+    "@push.rocks/smartssh": "^2.0.1",
+    "@push.rocks/smartstring": "^4.0.8",
+    "@serve.zone/api": "^4.3.11",
+    "@tsclass/tsclass": "^4.1.2",
+    "@types/through2": "^2.0.38",
    "through2": "^4.0.2"
  },
  "files": [
@@ -71,5 +73,22 @@
  ],
  "browserslist": [
    "last 1 chrome versions"
+  ],
+  "keywords": [
+    "Node.js",
+    "Docker",
+    "GitLab CI",
+    "GitHub CI",
+    "Gitea CI",
+    "CI/CD",
+    "automation",
+    "npm",
+    "TypeScript",
+    "cloud",
+    "SSH",
+    "registry",
+    "container management",
+    "continuous integration",
+    "continuous deployment"
  ]
 }
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- a/readme.hints.md
+++ b/readme.hints.md
@@ -0,0 +1,2 @@
+- focus on cli usage in CI environments.
+- show Gitlab CI, GitHub CI and Gitea CI examples.
--- a/readme.md
+++ b/readme.md
@@ -1,112 +1,494 @@
-# @shipzone/npmci
-node and docker in gitlab ci on steroids
+# @ship.zone/npmci
+A tool to enhance Node.js and Docker workflows within GitLab CI, providing various CI/CD utilities.

-## 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/)
+## Install

-## Status for master
+To install `@ship.zone/npmci`, you can use npm or yarn:

-Status Category | Status Badge
-- | --
-GitLab Pipelines | [![pipeline status](https://gitlab.com/shipzone/npmci/badges/master/pipeline.svg)](https://lossless.cloud)
-GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/shipzone/npmci/badges/master/coverage.svg)](https://lossless.cloud)
-npm | [![npm downloads per month](https://badgen.net/npm/dy/@shipzone/npmci)](https://lossless.cloud)
-Snyk | [![Known Vulnerabilities](https://badgen.net/snyk/shipzone/npmci)](https://lossless.cloud)
-TypeScript Support | [![TypeScript](https://badgen.net/badge/TypeScript/>=%203.x/blue?icon=typescript)](https://lossless.cloud)
-node Support | [![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
-Code Style | [![Code Style](https://badgen.net/badge/style/prettier/purple)](https://lossless.cloud)
-PackagePhobia (total standalone install weight) | [![PackagePhobia](https://badgen.net/packagephobia/install/@shipzone/npmci)](https://lossless.cloud)
-PackagePhobia (package size on registry) | [![PackagePhobia](https://badgen.net/packagephobia/publish/@shipzone/npmci)](https://lossless.cloud)
-BundlePhobia (total size when bundled) | [![BundlePhobia](https://badgen.net/bundlephobia/minzip/@shipzone/npmci)](https://lossless.cloud)
-Platform support | [![Supports Windows 10](https://badgen.net/badge/supports%20Windows%2010/yes/green?icon=windows)](https://lossless.cloud) [![Supports Mac OS X](https://badgen.net/badge/supports%20Mac%20OS%20X/yes/green?icon=apple)](https://lossless.cloud)
+```sh
+# Using npm
+npm install @ship.zone/npmci
+
+# Using yarn
+yarn add @ship.zone/npmci
+```

 ## Usage

-Use TypeScript for best in class instellisense.
+`npmci` is designed to streamline CI/CD processes, particularly in Docker and Node.js environments. The following sections illustrate its usage in various scenarios, from handling Node versions to building Docker images and more.

-npmci is designed to work in docker CI environments. The following docker images come with npmci presinstalled:
+### 1. Integration with GitLab CI, GitHub CI, and Gitea CI

-Docker Hub:
+#### GitLab CI

- [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
+An example of integrating `npmci` into a GitLab CI configuration could look like this:

-npmci can be called from commandline and handle a lot of tasks durug ci:
+```yaml
+image: hosttoday/ht-docker-node:npmci

-```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.
+stages:
+  - prepare
+  - build
+  - test
+  - deploy

-# 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
+default:
+  before_script:
+    - npmci node install stable
+    - npmci npm install

-# handle docker tasks
-npmci docker prepare
-## npmci test docker will look at all Dockerfiles and look for according tags on GitLab container registry
+prepare:
+  stage: prepare
+  script:
+    - npmci prepare npm
+    - npmci prepare docker

+build:
+  stage: build
+  script:
+    - npmci docker build

-# 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
+test:
+  stage: test
+  script:
+    - npmci npm test

-# 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"
+deploy:
+  stage: deploy
+  script:
+    - npmci publish npm
+    - npmci docker push

-# 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
+  environment:
+    name: production
+    url: http://example.com
 ```

-## Configuration
+#### GitHub Actions

-npmci supports the use of npmextra.
+Similarly, you can set up `npmci` in GitHub Actions:

-To configure npmci create a `npmextra.json` file at the root of your project
+```yaml
+name: CI Pipeline

-```json
-{
-  "npmci": {
-    "globalNpmTools": ["npm-check-updates", "protractor", "npmts", "gitzone"]
-  }
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  prepare:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Node.js
+        uses: actions/setup-node@v2
+        with:
+          node-version: '14'
+      - run: npm install -g @ship.zone/npmci
+      - run: npmci node install stable
+      - run: npmci npm install
+
+  build:
+    runs-on: ubuntu-latest
+    needs: prepare
+    steps:
+      - run: npmci docker build
+
+  test:
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - run: npmci npm test
+
+  deploy:
+    runs-on: ubuntu-latest
+    needs: test
+    steps:
+      - run: npmci publish npm
+      - run: npmci docker push
+```
+
+#### Gitea CI
+
+Lastly, for Gitea CI:
+
+```yaml
+image: hosttoday/ht-docker-node:npmci
+
+pipelines:
+  default:
+    - step:
+        name: Prepare
+        image: hosttoday/ht-docker-node:npmci
+        commands:
+          - npmci node install stable
+          - npmci npm install
+          - npmci prepare npm
+          - npmci prepare docker
+
+    - step:
+        name: Build
+        image: hosttoday/ht-docker-node:npmci
+        commands:
+          - npmci docker build
+
+    - step:
+        name: Test
+        image: hosttoday/ht-docker-node:npmci
+        commands:
+          - npmci npm test
+
+    - step:
+        name: Deploy
+        image: hosttoday/ht-docker-node:npmci
+        commands:
+          - npmci publish npm
+          - npmci docker push
+```
+
+### 2. Handle Node Versions
+
+One of the core features of `npmci` is managing Node versions in your CI environment. You can specify which version of Node to install:
+
+```typescript
+import { Npmci } from '@ship.zone/npmci';
+
+async function manageNodeVersions() {
+  const npmciInstance = new Npmci();
+  await npmciInstance.start();
+
+  await npmciInstance.nodejsManager.handleCli({
+    _: ['node', 'install', 'stable'] // Installs the latest stable version
+  });
+
+  await npmciInstance.nodejsManager.handleCli({
+    _: ['node', 'install', 'lts'] // Installs the Long-Term Support (LTS) version
+  });
+
+  await npmciInstance.nodejsManager.handleCli({
+    _: ['node', 'install', 'legacy'] // Installs a legacy version
+  });
+
+  await npmciInstance.nodejsManager.handleCli({
+    _: ['node', 'install', '14.17.0'] // Install a specific version of Node
+  });
 }
+
+manageNodeVersions().then(() => console.log('Node versions managed successfully.'));
 ```

-**Available options**
+### 3. Handling npm and Yarn Tasks

-| setting        | example                       | description                                                                                       |
-| -------------- | ----------------------------- | ------------------------------------------------------------------------------------------------- |
-| globalNpmTools | "globalNpmTools": ["gitbook"] | Will look for the specified package names locally and (if not yet present) install them from npm. |
+`npmci` provides numerous utilities to streamline npm and yarn workflow tasks within a CI/CD pipeline.

-For further information read the linked docs at the top of this README.
+```typescript
+import { Npmci } from '@ship.zone/npmci';

-Use TypeScript for best in class instellisense.
+async function manageNpmTasks() {
+  const npmciInstance = new Npmci();
+  await npmciInstance.start();

-## Contribution
+  await npmciInstance.npmManager.handleCli({ _: ['npm', 'install'] }); // Installs dependencies
+  await npmciInstance.npmManager.handleCli({ _: ['npm', 'test'] }); // Runs tests
+  await npmciInstance.npmManager.handleCli({ _: ['npm', 'publish'] }); // Publishes the package
+}

-We are always happy for code contributions. If you are not the code contributing type that is ok. Still, maintaining Open Source repositories takes considerable time and thought. If you like the quality of what we do and our modules are useful to you we would appreciate a little monthly contribution: You can [contribute one time](https://lossless.link/contribute-onetime) or [contribute monthly](https://lossless.link/contribute). :)
+manageNpmTasks().then(() => console.log('Npm tasks handled successfully.'));
+```

-For further information read the linked docs at the top of this readme.
+### 4. Docker Task Handling

-> MIT licensed | **&copy;** [Lossless GmbH](https://lossless.gmbh)
-| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
+`npmci` simplifies Docker operations, particularly in building, testing, and publishing Docker images.

-[![repo-footer](https://lossless.gitlab.io/publicrelations/repofooter.svg)](https://maintainedby.lossless.com)
+**Prepare Docker Environment:**
+
+```typescript
+import { Npmci } from '@ship.zone/npmci';
+
+async function prepareDocker() {
+  const npmciInstance = new Npmci();
+  await npmciInstance.start();
+
+  await npmciInstance.dockerManager.handleCli({ _: ['docker', 'prepare'] }); // Prepares Docker environment
+}
+
+prepareDocker().then(() => console.log('Docker environment prepared successfully.'));
+```
+
+**Building Docker Images:**
+
+```typescript
+import { Npmci } from '@ship.zone/npmci';
+
+async function buildDockerImages() {
+  const npmciInstance = new Npmci();
+  await npmciInstance.start();
+
+  await npmciInstance.dockerManager.handleCli({ _: ['docker', 'build'] }); // Builds Docker images
+}
+
+buildDockerImages().then(() => console.log('Docker images built successfully.'));
+```
+
+**Testing Docker Images:**
+
+```typescript
+import { Npmci } from '@ship.zone/npmci';
+
+async function testDockerImages() {
+  const npmciInstance = new Npmci();
+  await npmciInstance.start();
+
+  await npmciInstance.dockerManager.handleCli({ _: ['docker', 'test'] }); // Tests Docker images
+}
+
+testDockerImages().then(() => console.log('Docker images tested successfully.'));
+```
+
+**Publishing Docker Images:**
+
+```typescript
+import { Npmci } from '@ship.zone/npmci';
+
+async function pushDockerImages() {
+  const npmciInstance = new Npmci();
+  await npmciInstance.start();
+
+  await npmciInstance.dockerManager.handleCli({ _: ['docker', 'push'] }); // Pushes Docker images to registry
+}
+
+pushDockerImages().then(() => console.log('Docker images pushed successfully.'));
+```
+
+### 5. Managing Docker Registries
+
+`npmci` can handle multiple Docker registries and allows for easy integration within your CI pipeline.
+
+**Logging in to Docker Registries:**
+
+```typescript
+import { Npmci } from '@ship.zone/npmci';
+
+async function loginToDockerRegistries() {
+  const npmciInstance = new Npmci();
+  await npmciInstance.start();
+
+  await npmciInstance.dockerManager.handleCli({ _: ['docker', 'login'] }); // Logs into all configured Docker registries
+}
+
+loginToDockerRegistries().then(() => console.log('Logged into Docker registries.'));
+```
+
+**Pulling Docker Images:**
+
+```typescript
+import { Npmci } from '@ship.zone/npmci';
+
+async function pullDockerImages() {
+  const npmciInstance = new Npmci();
+  await npmciInstance.start();
+
+  await npmciInstance.dockerManager.handleCli({ _: ['docker', 'pull', 'registry.gitlab.com/mygroup/myrepo'] }); // Pulls Docker images from a registry
+}
+
+pullDockerImages().then(() => console.log('Docker images pulled successfully.'));
+```
+
+### 6. SSH Key Management
+
+`npmci` also simplifies the management of SSH keys, which is crucial for accessing private repositories and servers.
+
+**Preparing SSH Keys:**
+
+```typescript
+import { Npmci } from '@ship.zone/npmci';
+
+async function prepareSshKeys() {
+  const npmciInstance = new Npmci();
+  await npmciInstance.start();
+
+  await npmciInstance.sshManager.handleCli({ _: ['ssh', 'prepare'] }); // Prepares SSH keys from environment variables
+}
+
+prepareSshKeys().then(() => console.log('SSH keys prepared successfully.'));
+```
+
+### 7. Cloudron Integration
+
+For users deploying applications on Cloudron, `npmci` provides a set of utilities for automating Cloudron tasks.
+
+**Deploying to Cloudron:**
+
+```typescript
+import { Npmci } from '@ship.zone/npmci';
+
+async function deployToCloudron() {
+  const npmciInstance = new Npmci();
+  await npmciInstance.start();
+
+  await npmciInstance.cloudronManager.handleCli({
+    _: ['cloudron', 'deploy']
+  }); // Deploys application to Cloudron platform
+}
+
+deployToCloudron().then(() => console.log('Deployment to Cloudron completed.'));
+```
+
+**Preparing Cloudron Manifest:**
+Before deployment, replace version placeholders in the Cloudron Manifest:
+
+```typescript
+import { Npmci } from '@ship.zone/npmci';
+import * as fs from 'fs';
+import * as path from 'path';
+
+async function prepareCloudronManifest(version: string) {
+  const manifestPath = path.join(process.cwd(), "CloudronManifest.json");
+  let manifestFile = fs.readFileSync(manifestPath, { encoding: 'utf-8' });
+  manifestFile = manifestFile.replace(/##version##/g, version);
+  fs.writeFileSync(manifestPath, manifestFile);
+  console.log('CloudronManifest prepared');
+}
+
+async function deployWithPreparedManifest() {
+  const npmciInstance = new Npmci();
+  await npmciInstance.start();
+  
+  await prepareCloudronManifest('1.0.0');
+  await npmciInstance.cloudronManager.handleCli({
+    _: ['cloudron', 'deploy']
+  }); // Deploys application to Cloudron platform
+}
+
+deployWithPreparedManifest().then(() => console.log('Deployment to Cloudron with manifest preparation completed.'));
+```
+
+### 8. Webhook Triggers
+
+`npmci` supports webhook triggers, allowing you to trigger builds and other activities based on various conditions.
+
+**Triggering Webhooks:**
+
+```typescript
+import { Npmci } from '@ship.zone/npmci';
+
+async function triggerWebhooks() {
+  const npmciInstance = new Npmci();
+  await npmciInstance.start();
+
+  await npmciInstance.triggerManager.handleCli({
+    _: ['trigger']
+  }); // Triggers webhooks based on environment variables
+}
+
+triggerWebhooks().then(() => console.log('Webhooks triggered successfully.'));
+```
+
+### 9. Using the bash Helper
+
+`npmci` includes a bash helper for executing commands within a bash shell, useful for various custom tasks.
+
+**Using bash to Execute Commands:**
+
+```typescript
+import { bash } from '@ship.zone/npmci';
+
+async function runCustomBashCommand(command: string) {
+  const output = await bash(command);
+  console.log('Command output:', output);
+}
+
+runCustomBashCommand('echo Hello World').then(() => console.log('Custom command executed successfully.'));
+```
+
+### Full Features and Use Cases
+
+Below is a comprehensive set of features and use cases supported by `npmci`. This section ensures you can take full advantage of the library's capabilities in multiple scenarios.
+
+### Comprehensive Docker Workflow
+
+**Step-by-step Docker Image Handling:**
+
+1. **Detect and Build All Dockerfiles:**
+
+   ```typescript
+   import { Npmci } from '@ship.zone/npmci';
+
+   async function detectAndBuildDockerfiles() {
+     const npmciInstance = new Npmci();
+     await npmciInstance.start();
+     const dockerfiles = await npmciInstance.dockerManager.getDockerfiles();
+     console.log('Dockerfiles detected:', dockerfiles.map(d => d.filePath));
+     
+     await npmciInstance.dockerManager.handleCli({ _: ['docker', 'build'] });
+     console.log('Dockerfiles built successfully.');
+   }
+
+   detectAndBuildDockerfiles().then(() => console.log('Docker detection and build process completed.'));
+   ```
+
+2. **Test All Dockerfiles:**
+
+   ```typescript
+   import { Npmci } from '@ship.zone/npmci';
+
+   async function testAllDockerfiles() {
+     const npmciInstance = new Npmci();
+     await npmciInstance.start();
+     await npmciInstance.dockerManager.handleCli({ _: ['docker', 'test'] });
+     console.log('Dockerfiles tested successfully.');
+   }
+
+   testAllDockerfiles().then(() => console.log('Docker testing process completed.'));
+   ```
+
+3. **Push Dockerfiles to a Registry:**
+
+   ```typescript
+   import { Npmci } from '@ship.zone/npmci';
+
+   async function pushDockerfilesToRegistry() {
+     const npmciInstance = new Npmci();
+     await npmciInstance.start();
+     
+     await npmciInstance.dockerManager.handleCli({ _: ['docker', 'push'] });
+     console.log('Dockerfiles pushed to registry successfully.');
+   }
+
+   pushDockerfilesToRegistry().then(() => console.log('Docker push process completed.'));
+   ```
+
+**Dockerfile Class Example:**
+
+Here's a snippet showcasing how the `Dockerfile` class can be used to handle Dockerfile-specific operations:
+
+```typescript
+import { Dockerfile } from '@ship.zone/npmci';
+
+async function handleDockerfileOperations() {
+  // Initialize Dockerfile instances
+  const dockerfile1 = new Dockerfile(/* required parameters */);
+  const dockerfile2 = new Dockerfile(/* required parameters */);
+
+  // Read and sort Dockerfiles
+  const dockerfiles = await Dockerfile.readDockerfiles(/* required parameters */);
+  const sortedDockerfiles = await Dockerfile.sortDockerfiles(dockerfiles);
+
+  // Build and Test Dockerfiles
+  await Dockerfile.buildDockerfiles(sortedDockerfiles);
+  await Dockerfile.testDockerfiles(sortedDockerfiles);
+
+  // Push Dockerfile images to a registry
+  for (const dockerfile of sortedDockerfiles) {
+    await dockerfile.push(/* registry and tag parameters */);
+  }
+
+  console.log('Dockerfile operations completed successfully.');
+}
+
+handleDockerfileOperations().then(() => console.log('Dockerfile processing flow completed.'));
+```
+
+This completes the comprehensive guide to `@ship.zone/npmci`. With the examples and explanations provided, you should be able to harness the full power and flexibility of the library to streamline your CI/CD processes effectively.
+undefined
--- a/test/assets/Dockerfile_hello_##version##
+++ b/test/assets/Dockerfile_hello_##version##
@@ -0,0 +1,2 @@
+FROM mygroup/myrepo:sometag2
+RUN apt-get update
--- a/test/assets/npmextra.json
+++ b/test/assets/npmextra.json
@@ -1 +1,9 @@
-{}
+{
+  "gitzone": {
+    "module": {
+      "githost": "code.foss.global",
+      "gitscope": "mygroup",
+      "gitrepo": "myrepo"
+    }
+  }
+}
--- a/test/test.cloudly.ts
+++ b/test/test.cloudly.ts
@@ -0,0 +1,26 @@
+process.env['NODE_TLS_REJECT_UNAUTHORIZED'] = '0';
+import { tap, expect } from '@push.rocks/tapbundle';
+
+import * as cloudlyConnectorMod from '../ts/connector.cloudly/cloudlyconnector.js';
+
+tap.test('should be able to announce a container to cloudly', async () => {
+  const cloudlyConnector = new cloudlyConnectorMod.CloudlyConnector(null);
+  await cloudlyConnector.announceDockerContainer(
+    {
+      registryUrl: 'registry.losssless.com',
+      tag: 'testcontainer',
+      version: 'x.x.x',
+      labels: [],
+    },
+    'cloudly.lossless.one'
+  );
+});
+
+tap.test('should close the program despite socket timeout', async (toolsArg) => {
+  // TODO: remove when unreffed timeouts in webrequest have been solved.
+  toolsArg.delayFor(0).then(() => {
+    process.exit();
+  });
+});
+
+tap.start();
--- a/test/test.ts
+++ b/test/test.ts
@@ -1,7 +1,9 @@
-import { tap, expect } from '@pushrocks/tapbundle';
+import { tap, expect } from '@push.rocks/tapbundle';
 import * as path from 'path';
+import * as smartpath from '@push.rocks/smartpath';

 process.env.NPMTS_TEST = 'true';
+process.env.NPMCI_URL_CLOUDLY = 'localhost';

 // set up environment
 process.env.CI_REPOSITORY_URL = 'https://yyyyyy:xxxxxxxx@gitlab.com/mygroup/myrepo.git';
@@ -14,21 +16,23 @@ process.env.NPMCI_LOGIN_DOCKER = 'docker.io|someuser|somepass';
 process.env.NPMCI_SSHKEY_1 = 'hostString|somePrivKey|##';

 process.cwd = () => {
-  return path.join(__dirname, 'assets/');
+  return path.join(smartpath.get.dirnameFromImportMetaUrl(import.meta.url), 'assets/');
 };

-import * as npmci from '../ts';
+import type * as npmciTypes from '../ts/index.js';
+const npmci = await import('../ts/index.js');

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

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

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

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

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

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

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

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

 tap.test('should login docker daemon', async () => {
  const npmciInstance = new npmci.Npmci();
+  await npmciInstance.start();
  return npmciInstance.dockerManager.handleCli({
    _: ['docker', 'login'],
  });
@@ -91,7 +100,7 @@ tap.test('should login docker daemon', async () => {
 // SSH
 // ===
 tap.test('should prepare SSH keys', async () => {
-  const npmciModSsh = await import('../ts/mod_ssh');
+  const npmciModSsh = await import('../ts/mod_ssh/index.js');
  return await npmciModSsh.handleCli({
    _: ['ssh', 'prepare'],
  });
@@ -102,6 +111,7 @@ tap.test('should prepare SSH keys', async () => {
 // ====
 tap.test('should install a certain version of node', async () => {
  const npmciInstance = new npmci.Npmci();
+  await npmciInstance.start();
  await npmciInstance.nodejsManager.handleCli({
    _: ['node', 'install', 'stable'],
  });
--- a/ts/00_commitinfo_data.ts
+++ b/ts/00_commitinfo_data.ts
@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@ship.zone/npmci',
+  version: '4.1.35',
+  description: 'A tool to streamline Node.js and Docker workflows within CI environments, particularly GitLab CI, providing various CI/CD utilities.'
+}
--- a/ts/connector.cloudly/cloudlyconnector.ts
+++ b/ts/connector.cloudly/cloudlyconnector.ts
@@ -1,7 +1,7 @@
-import * as plugins from '../npmci.plugins';
+import * as plugins from '../npmci.plugins.js';

-import { Npmci } from '../npmci.classes.npmci';
-import { logger } from '../npmci.logging';
+import { Npmci } from '../npmci.classes.npmci.js';
+import { logger } from '../npmci.logging.js';

 /**
 * connects to cloudly
@@ -14,9 +14,10 @@ export class CloudlyConnector {
  }

  public async announceDockerContainer(
-    optionsArg: plugins.tsclass.container.IContainer
+    optionsArg: plugins.tsclass.container.IContainer,
+    testCloudlyUrlArg?: string
  ) {
-    const cloudlyUrl = this.npmciRef.npmciConfig.getConfig().urlCloudly;
+    const cloudlyUrl = testCloudlyUrlArg || this.npmciRef.npmciConfig.getConfig().urlCloudly;
    if (!cloudlyUrl) {
      logger.log(
        'warn',
@@ -25,14 +26,6 @@ export class CloudlyConnector {
      return;
    }

-    const typedrequest =
-      new plugins.typedrequest.TypedRequest<plugins.servezoneInterfaces.requests.IRequest_InformAboutNewContainerImage>(
-        `https://${cloudlyUrl}/typedrequest`,
-        'servezonestandard_InformAboutNewContainerVersion'
-      );
-
-    const response = await typedrequest.fire({
-      containerImageInfo: optionsArg
-    });
+    // lets push to cloudly here
  }
 }
--- a/ts/index.ts
+++ b/ts/index.ts
@@ -1,10 +1,10 @@
-import { Npmci } from './npmci.classes.npmci';
-import { Dockerfile } from './manager.docker/mod.classes.dockerfile';
+import { Npmci } from './npmci.classes.npmci.js';
+import { Dockerfile } from './manager.docker/mod.classes.dockerfile.js';

 export const npmciInstance = new Npmci();

 export { Dockerfile, Npmci };

 export const runCli = async () => {
-  npmciInstance.start();
+  await npmciInstance.start();
 };
--- a/ts/manager.cloudron/index.ts
+++ b/ts/manager.cloudron/index.ts
@@ -0,0 +1,67 @@
+import { logger } from '../npmci.logging.js';
+import * as plugins from './mod.plugins.js';
+import * as paths from '../npmci.paths.js';
+import { bash } from '../npmci.bash.js';
+import { Npmci } from '../npmci.classes.npmci.js';
+
+export class NpmciCloudronManager {
+  public npmciRef: Npmci;
+
+  constructor(npmciArg: Npmci) {
+    this.npmciRef = npmciArg;
+  }
+
+  /**
+   * handle cli input
+   * @param argvArg
+   */
+  public handleCli = async (argvArg: any) => {
+    if (argvArg._.length >= 2) {
+      const action: string = argvArg._[1];
+      switch (action) {
+        case 'deploy':
+          await this.deploy();
+          break;
+        default:
+          logger.log('error', `>>npmci cloudron ...<< action >>${action}<< not supported`);
+      }
+    } else {
+      logger.log(
+        'info',
+        `>>npmci cloudron ...<< cli arguments invalid... Please read the documentation.`
+      );
+    }
+  };
+
+  /**
+   * Replaces the version string in CloudronManifest file
+   * @param versionArg
+   */
+  public deploy = async () => {
+    logger.log('info', 'now deploying to cloudron...');
+    logger.log('info', 'installing cloudron cli...');
+    await bash(`pnpm install -g cloudron`);
+    logger.log('ok', 'cloudron cli installed');
+
+    // lets set the version in the CloudronManifest file
+    await this.prepareCloudronManifest(this.npmciRef.npmciConfig.getConfig().projectInfo.npm.version);
+    logger.log('ok', 'CloudronManifest prepared');
+
+    // lets figure out the docker image tag
+    const dockerImageTag = await this.npmciRef.npmciConfig.kvStorage.readKey('latestPushedDockerTag');
+    const appName = this.npmciRef.npmciConfig.getConfig().cloudronAppName;
+    
+    const cloudronEnvVar = process.env.NPMCI_LOGIN_CLOUDRON;
+    const cloudronServer = cloudronEnvVar.split('|')[0];
+    const cloudronToken = cloudronEnvVar.split('|')[1];
+    await bash(`cloudron update --server ${cloudronServer} --token ${cloudronToken} --image ${dockerImageTag} --app ${appName}`);
+  };
+
+  private prepareCloudronManifest = async (versionArg: string) => {
+    const manifestPath = plugins.path.join(paths.cwd, 'CloudronManifest.json');
+    let manifestFile = plugins.smartfile.fs.toStringSync(manifestPath);
+    manifestFile = manifestFile.replace(/##version##/g, versionArg);
+    plugins.smartfile.memory.toFsSync(manifestFile, manifestPath);
+    logger.log('info', 'Version replaced in CloudronManifest file');
+  }
+}
--- a/ts/manager.cloudron/mod.plugins.ts
+++ b/ts/manager.cloudron/mod.plugins.ts
@@ -0,0 +1 @@
+export * from '../npmci.plugins.js';
--- a/ts/manager.docker/index.ts
+++ b/ts/manager.docker/index.ts
@@ -1,13 +1,13 @@
-import { logger } from '../npmci.logging';
-import * as plugins from './mod.plugins';
-import * as paths from '../npmci.paths';
-import { bash } from '../npmci.bash';
+import { logger } from '../npmci.logging.js';
+import * as plugins from './mod.plugins.js';
+import * as paths from '../npmci.paths.js';
+import { bash } from '../npmci.bash.js';

 // classes
-import { Npmci } from '../npmci.classes.npmci';
-import { Dockerfile } from './mod.classes.dockerfile';
-import { DockerRegistry } from './mod.classes.dockerregistry';
-import { RegistryStorage } from './mod.classes.registrystorage';
+import { Npmci } from '../npmci.classes.npmci.js';
+import { Dockerfile } from './mod.classes.dockerfile.js';
+import { DockerRegistry } from './mod.classes.dockerregistry.js';
+import { RegistryStorage } from './mod.classes.registrystorage.js';

 export class NpmciDockerManager {
  public npmciRef: Npmci;
@@ -77,20 +77,23 @@ export class NpmciDockerManager {
   */
  public prepare = async () => {
    // Always login to GitLab Registry
-    if (!process.env.CI_BUILD_TOKEN || process.env.CI_BUILD_TOKEN === '') {
-      logger.log('error', 'No registry token specified by gitlab!');
-      process.exit(1);
+    if (process.env.GITLAB_CI) {
+      console.log('gitlab ci detected');
+      if (!process.env.CI_JOB_TOKEN || process.env.CI_JOB_TOKEN === '') {
+        logger.log('error', 'Running in Gitlab CI, but no registry token specified by gitlab!');
+        process.exit(1);
+      }
+      this.npmciRegistryStorage.addRegistry(
+        new DockerRegistry({
+          registryUrl: 'registry.gitlab.com',
+          username: 'gitlab-ci-token',
+          password: process.env.CI_JOB_TOKEN,
+        })
+      );
    }
-    this.npmciRegistryStorage.addRegistry(
-      new DockerRegistry({
-        registryUrl: 'registry.gitlab.com',
-        username: 'gitlab-ci-token',
-        password: process.env.CI_BUILD_TOKEN,
-      })
-    );

    // handle registries
-    await plugins.smartparam.forEachMinimatch(
+    await plugins.smartobject.forEachMinimatch(
      process.env,
      'NPMCI_LOGIN_DOCKER*',
      async (envString: string) => {
@@ -176,4 +179,12 @@ export class NpmciDockerManager {
    await this.prepare();
    return await Dockerfile.readDockerfiles(this).then(Dockerfile.testDockerfiles);
  };
+
+  /**
+   * can be used to get the Dockerfiles in the directory
+   */
+  getDockerfiles = async () => {
+    const dockerfiles = await Dockerfile.readDockerfiles(this);
+    return dockerfiles;
+  }
 }
--- a/ts/manager.docker/mod.classes.dockerfile.ts
+++ b/ts/manager.docker/mod.classes.dockerfile.ts
@@ -1,13 +1,13 @@
-import * as plugins from './mod.plugins';
-import * as paths from '../npmci.paths';
+import * as plugins from './mod.plugins.js';
+import * as paths from '../npmci.paths.js';

-import { logger } from '../npmci.logging';
-import { bash } from '../npmci.bash';
+import { logger } from '../npmci.logging.js';
+import { bash } from '../npmci.bash.js';

-import { DockerRegistry } from './mod.classes.dockerregistry';
-import * as helpers from './mod.helpers';
-import { NpmciDockerManager } from '.';
-import { Npmci } from '../npmci.classes.npmci';
+import { DockerRegistry } from './mod.classes.dockerregistry.js';
+import * as helpers from './mod.helpers.js';
+import { NpmciDockerManager } from './index.js';
+import { Npmci } from '../npmci.classes.npmci.js';

 /**
 * class Dockerfile represents a Dockerfile on disk in npmci
@@ -40,43 +40,72 @@ export class Dockerfile {
  }

  /**
-   * sorts Dockerfiles into a dependency chain
-   * @param sortableArrayArg an array of instances of class Dockerfile
-   * @returns Promise<Dockerfile[]>
+   * Sorts Dockerfiles into a build order based on dependencies.
+   * @param dockerfiles An array of Dockerfile instances.
+   * @returns A Promise that resolves to a sorted array of Dockerfiles.
   */
-  public static async sortDockerfiles(sortableArrayArg: Dockerfile[]): Promise<Dockerfile[]> {
-    const done = plugins.smartpromise.defer<Dockerfile[]>();
-    logger.log('info', 'sorting Dockerfiles:');
-    const sortedArray: Dockerfile[] = [];
-    const cleanTagsOriginal = Dockerfile.cleanTagsArrayFunction(sortableArrayArg, sortedArray);
-    let sorterFunctionCounter: number = 0;
-    const sorterFunction = () => {
-      sortableArrayArg.forEach((dockerfileArg) => {
-        const cleanTags = Dockerfile.cleanTagsArrayFunction(sortableArrayArg, sortedArray);
-        if (
-          cleanTags.indexOf(dockerfileArg.baseImage) === -1 &&
-          sortedArray.indexOf(dockerfileArg) === -1
-        ) {
-          sortedArray.push(dockerfileArg);
-        }
-        if (cleanTagsOriginal.indexOf(dockerfileArg.baseImage) !== -1) {
-          dockerfileArg.localBaseImageDependent = true;
-        }
-      });
-      if (sortableArrayArg.length === sortedArray.length) {
-        let counter = 1;
-        for (const dockerfile of sortedArray) {
-          logger.log('info', `tag ${counter}: -> ${dockerfile.cleanTag}`);
-          counter++;
-        }
-        done.resolve(sortedArray);
-      } else if (sorterFunctionCounter < 10) {
-        sorterFunctionCounter++;
-        sorterFunction();
+  public static async sortDockerfiles(dockerfiles: Dockerfile[]): Promise<Dockerfile[]> {
+    logger.log('info', 'Sorting Dockerfiles based on dependencies...');
+
+    // Map from cleanTag to Dockerfile instance for quick lookup
+    const tagToDockerfile = new Map<string, Dockerfile>();
+    dockerfiles.forEach((dockerfile) => {
+      tagToDockerfile.set(dockerfile.cleanTag, dockerfile);
+    });
+
+    // Build the dependency graph
+    const graph = new Map<Dockerfile, Dockerfile[]>();
+    dockerfiles.forEach((dockerfile) => {
+      const dependencies: Dockerfile[] = [];
+      const baseImage = dockerfile.baseImage;
+
+      // Check if the baseImage is among the local Dockerfiles
+      if (tagToDockerfile.has(baseImage)) {
+        const baseDockerfile = tagToDockerfile.get(baseImage);
+        dependencies.push(baseDockerfile);
+        dockerfile.localBaseImageDependent = true;
+        dockerfile.localBaseDockerfile = baseDockerfile;
+      }
+
+      graph.set(dockerfile, dependencies);
+    });
+
+    // Perform topological sort
+    const sortedDockerfiles: Dockerfile[] = [];
+    const visited = new Set<Dockerfile>();
+    const tempMarked = new Set<Dockerfile>();
+
+    const visit = (dockerfile: Dockerfile) => {
+      if (tempMarked.has(dockerfile)) {
+        throw new Error(`Circular dependency detected involving ${dockerfile.cleanTag}`);
+      }
+      if (!visited.has(dockerfile)) {
+        tempMarked.add(dockerfile);
+        const dependencies = graph.get(dockerfile) || [];
+        dependencies.forEach((dep) => visit(dep));
+        tempMarked.delete(dockerfile);
+        visited.add(dockerfile);
+        sortedDockerfiles.push(dockerfile);
      }
    };
-    sorterFunction();
-    return done.promise;
+
+    try {
+      dockerfiles.forEach((dockerfile) => {
+        if (!visited.has(dockerfile)) {
+          visit(dockerfile);
+        }
+      });
+    } catch (error) {
+      logger.log('error', error.message);
+      throw error;
+    }
+
+    // Log the sorted order
+    sortedDockerfiles.forEach((dockerfile, index) => {
+      logger.log('info', `Build order ${index + 1}: ${dockerfile.cleanTag}`);
+    });
+
+    return sortedDockerfiles;
  }

  /**
@@ -120,15 +149,23 @@ export class Dockerfile {
   * returns a version for a docker file
   * @execution SYNC
   */
-  public static dockerFileVersion(dockerfileNameArg: string): string {
+  public static dockerFileVersion(
+    dockerfileInstanceArg: Dockerfile,
+    dockerfileNameArg: string
+  ): string {
    let versionString: string;
-    const versionRegex = /Dockerfile_([a-zA-Z0-9\.]*)$/;
+    const versionRegex = /Dockerfile_(.+)$/;
    const regexResultArray = versionRegex.exec(dockerfileNameArg);
    if (regexResultArray && regexResultArray.length === 2) {
      versionString = regexResultArray[1];
    } else {
      versionString = 'latest';
    }
+    versionString = versionString.replace(
+      '##version##',
+      dockerfileInstanceArg.npmciDockerManagerRef.npmciRef.npmciConfig.getConfig().projectInfo.npm
+        .version
+    );
    return versionString;
  }

@@ -177,34 +214,21 @@ export class Dockerfile {
  ): Promise<string> {
    logger.log('info', 'checking for env vars to be supplied to the docker build');
    let buildArgsString: string = '';
-    for (const key of Object.keys(
+    for (const dockerArgKey of Object.keys(
      npmciDockerManagerRef.npmciRef.npmciConfig.getConfig().dockerBuildargEnvMap
    )) {
-      const targetValue =
-        process.env[
-          npmciDockerManagerRef.npmciRef.npmciConfig.getConfig().dockerBuildargEnvMap[key]
-        ];
-      buildArgsString = `${buildArgsString} --build-arg ${key}="${targetValue}"`;
+      const dockerArgOuterEnvVar =
+        npmciDockerManagerRef.npmciRef.npmciConfig.getConfig().dockerBuildargEnvMap[dockerArgKey];
+      logger.log(
+        'note',
+        `docker ARG "${dockerArgKey}" maps to outer env var "${dockerArgOuterEnvVar}"`
+      );
+      const targetValue = process.env[dockerArgOuterEnvVar];
+      buildArgsString = `${buildArgsString} --build-arg ${dockerArgKey}="${targetValue}"`;
    }
    return buildArgsString;
  }

-  /**
-   *
-   */
-  public static cleanTagsArrayFunction(
-    dockerfileArrayArg: Dockerfile[],
-    trackingArrayArg: Dockerfile[]
-  ): string[] {
-    const cleanTagsArray: string[] = [];
-    dockerfileArrayArg.forEach((dockerfileArg) => {
-      if (trackingArrayArg.indexOf(dockerfileArg) === -1) {
-        cleanTagsArray.push(dockerfileArg.cleanTag);
-      }
-    });
-    return cleanTagsArray;
-  }
-
  // INSTANCE
  public npmciDockerManagerRef: NpmciDockerManager;

@@ -230,7 +254,7 @@ export class Dockerfile {
      this.npmciDockerManagerRef.npmciRef.npmciEnv.repo.user +
      '/' +
      this.npmciDockerManagerRef.npmciRef.npmciEnv.repo.repo;
-    this.version = Dockerfile.dockerFileVersion(plugins.path.parse(options.filePath).base);
+    this.version = Dockerfile.dockerFileVersion(this, plugins.path.parse(options.filePath).base);
    this.cleanTag = this.repo + ':' + this.version;
    this.buildTag = this.cleanTag;

@@ -276,9 +300,12 @@ export class Dockerfile {
      registryUrl: this.pushTag,
      tag: this.buildTag,
      labels: [],
-      version:
-        this.npmciDockerManagerRef.npmciRef.npmciConfig.getConfig().projectInfo.npm.version,
+      version: this.npmciDockerManagerRef.npmciRef.npmciConfig.getConfig().projectInfo.npm.version,
    });
+    await this.npmciDockerManagerRef.npmciRef.npmciConfig.kvStorage.writeKey(
+      'latestPushedDockerTag',
+      this.pushTag
+    );
  }

  /**
--- a/ts/manager.docker/mod.classes.dockerregistry.ts
+++ b/ts/manager.docker/mod.classes.dockerregistry.ts
@@ -1,6 +1,6 @@
-import { logger } from '../npmci.logging';
-import * as plugins from './mod.plugins';
-import { bash } from '../npmci.bash';
+import { logger } from '../npmci.logging.js';
+import * as plugins from './mod.plugins.js';
+import { bash } from '../npmci.bash.js';

 export interface IDockerRegistryConstructorOptions {
  registryUrl: string;
@@ -26,7 +26,7 @@ export class DockerRegistry {
      process.exit(1);
      return;
    }
-    const registryUrl = dockerRegexResultArray[0];
+    const registryUrl = dockerRegexResultArray[0].replace('https://', '').replace('http://', '');
    const username = dockerRegexResultArray[1];
    const password = dockerRegexResultArray[2];
    return new DockerRegistry({
--- a/ts/manager.docker/mod.classes.registrystorage.ts
+++ b/ts/manager.docker/mod.classes.registrystorage.ts
@@ -1,11 +1,10 @@
-import { logger } from '../npmci.logging';
-import * as plugins from './mod.plugins';
-import { ObjectMap } from '@pushrocks/lik';
+import { logger } from '../npmci.logging.js';
+import * as plugins from './mod.plugins.js';

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

 export class RegistryStorage {
-  objectMap = new ObjectMap<DockerRegistry>();
+  objectMap = new plugins.lik.ObjectMap<DockerRegistry>();
  constructor() {
    // Nothing here
  }
--- a/ts/manager.docker/mod.helpers.ts
+++ b/ts/manager.docker/mod.helpers.ts
@@ -1,5 +1,5 @@
-import { logger } from '../npmci.logging';
-import * as plugins from './mod.plugins';
-import * as paths from '../npmci.paths';
+import { logger } from '../npmci.logging.js';
+import * as plugins from './mod.plugins.js';
+import * as paths from '../npmci.paths.js';

-import { Dockerfile } from './mod.classes.dockerfile';
+import { Dockerfile } from './mod.classes.dockerfile.js';
--- a/ts/manager.docker/mod.plugins.ts
+++ b/ts/manager.docker/mod.plugins.ts
@@ -1 +1 @@
-export * from '../npmci.plugins';
+export * from '../npmci.plugins.js';
--- a/ts/manager.git/index.ts
+++ b/ts/manager.git/index.ts
@@ -1,7 +1,7 @@
-import { logger } from '../npmci.logging';
-import * as plugins from './mod.plugins';
-import { bash, bashNoError } from '../npmci.bash';
-import { Npmci } from '../npmci.classes.npmci';
+import { logger } from '../npmci.logging.js';
+import * as plugins from './mod.plugins.js';
+import { bash, bashNoError } from '../npmci.bash.js';
+import { Npmci } from '../npmci.classes.npmci.js';

 export class NpmciGitManager {
  public npmciRef: Npmci;
--- a/ts/manager.git/mod.plugins.ts
+++ b/ts/manager.git/mod.plugins.ts
@@ -1 +1 @@
-export * from '../npmci.plugins';
+export * from '../npmci.plugins.js';
--- a/ts/manager.nodejs/index.ts
+++ b/ts/manager.nodejs/index.ts
@@ -1,9 +1,9 @@
-import * as plugins from '../npmci.plugins';
-import * as paths from '../npmci.paths';
+import * as plugins from '../npmci.plugins.js';
+import * as paths from '../npmci.paths.js';

-import { logger } from '../npmci.logging';
-import { bash, bashNoError, nvmAvailable } from '../npmci.bash';
-import { Npmci } from '../npmci.classes.npmci';
+import { logger } from '../npmci.logging.js';
+import { bash, bashNoError, nvmAvailable } from '../npmci.bash.js';
+import { Npmci } from '../npmci.classes.npmci.js';

 export class NpmciNodeJsManager {
  public npmciRef: Npmci;
@@ -44,11 +44,11 @@ export class NpmciNodeJsManager {
    logger.log('info', `now installing node version ${versionArg}`);
    let version: string;
    if (versionArg === 'stable') {
-      version = '16';
+      version = '18';
    } else if (versionArg === 'lts') {
-      version = '14';
+      version = '16';
    } else if (versionArg === 'legacy') {
-      version = '12';
+      version = '14';
    } else {
      version = versionArg;
    }
--- a/ts/manager.npm/index.ts
+++ b/ts/manager.npm/index.ts
@@ -1,9 +1,9 @@
-import * as plugins from './mod.plugins';
-import * as paths from '../npmci.paths';
+import * as plugins from './mod.plugins.js';
+import * as paths from '../npmci.paths.js';

-import { logger } from '../npmci.logging';
-import { bash, bashNoError, nvmAvailable } from '../npmci.bash';
-import { Npmci } from '../npmci.classes.npmci';
+import { logger } from '../npmci.logging.js';
+import { bash, bashNoError, nvmAvailable } from '../npmci.bash.js';
+import { Npmci } from '../npmci.classes.npmci.js';

 export class NpmciNpmManager {
  public npmciRef: Npmci;
@@ -52,13 +52,19 @@ export class NpmciNpmManager {
   * authenticates npm with token from env var
   */
  public async prepare() {
+    logger.log('info', 'running >>npm prepare<<');
    const config = this.npmciRef.npmciConfig.getConfig();
    let npmrcFileString: string = '';
-    await plugins.smartparam.forEachMinimatch(
+    await plugins.smartobject.forEachMinimatch(
      process.env,
      'NPMCI_TOKEN_NPM*',
      (npmEnvArg: string) => {
+        if (!npmEnvArg) {
+          logger.log('note','found empty token...');
+          return;
+        }
        const npmRegistryUrl = npmEnvArg.split('|')[0];
+        logger.log('ok', `found token for ${npmRegistryUrl}`);
        let npmToken = npmEnvArg.split('|')[1];
        if (npmEnvArg.split('|')[2] && npmEnvArg.split('|')[2] === 'plain') {
          logger.log('ok', 'npm token not base64 encoded.');
@@ -99,7 +105,7 @@ export class NpmciNpmManager {
      let publishVerdaccioAsWell = false;
      const config = this.npmciRef.npmciConfig.getConfig();
      const availableRegistries: string[] = [];
-      await plugins.smartparam.forEachMinimatch(
+      await plugins.smartobject.forEachMinimatch(
        process.env,
        'NPMCI_TOKEN_NPM*',
        (npmEnvArg: string) => {
@@ -151,6 +157,7 @@ export class NpmciNpmManager {
    logger.log('info', `now preparing environment:`);
    this.prepare();
    await bash(`npm -v`);
+    await bash(`pnpm -v`);

    // -> build it
    await this.install();
@@ -172,16 +179,16 @@ export class NpmciNpmManager {

  public async install(): Promise<void> {
    logger.log('info', 'now installing dependencies:');
-    await bash('npm ci');
+    await bash('pnpm install');
  }

  public async build(): Promise<void> {
    logger.log('info', 'now building the project:');
-    await bash('npm run build');
+    await bash('pnpm run build');
  }

  public async test(): Promise<void> {
    logger.log('info', 'now starting tests:');
-    await bash('npm test');
+    await bash('pnpm test');
  }
 }
--- a/ts/manager.npm/mod.plugins.ts
+++ b/ts/manager.npm/mod.plugins.ts
@@ -1 +1 @@
-export * from '../npmci.plugins';
+export * from '../npmci.plugins.js';
--- a/ts/mod_clean/index.ts
+++ b/ts/mod_clean/index.ts
@@ -1,5 +1,5 @@
-import * as plugins from './mod.plugins';
-import * as paths from '../npmci.paths';
+import * as plugins from './mod.plugins.js';
+import * as paths from '../npmci.paths.js';

 /**
 * cleans npmci config files
--- a/ts/mod_clean/mod.plugins.ts
+++ b/ts/mod_clean/mod.plugins.ts
@@ -1 +1 @@
-export * from '../npmci.plugins';
+export * from '../npmci.plugins.js';
--- a/ts/mod_command/index.ts
+++ b/ts/mod_command/index.ts
@@ -1,5 +1,5 @@
-import * as plugins from './mod.plugins';
-import { bash } from '../npmci.bash';
+import * as plugins from './mod.plugins.js';
+import { bash } from '../npmci.bash.js';

 export let command = async () => {
  let wrappedCommand: string = '';
--- a/ts/mod_command/mod.plugins.ts
+++ b/ts/mod_command/mod.plugins.ts
@@ -1 +1 @@
-export * from '../npmci.plugins';
+export * from '../npmci.plugins.js';
--- a/ts/mod_precheck/index.ts
+++ b/ts/mod_precheck/index.ts
@@ -0,0 +1,24 @@
+import * as plugins from './plugins.js';
+import * as paths from '../npmci.paths.js';
+import { logger } from '../npmci.logging.js';
+import { Npmci } from '../npmci.classes.npmci.js';
+
+export const handleCli = async (npmciRefArg: Npmci, argvArg: any) => {
+  logger.log('info', 'checking execution context');
+  const presentRunnerTags = process.env.CI_RUNNER_TAGS.split(',').map((stringArg) =>
+    stringArg.trim()
+  );
+  let allDesiredGitlabRunnerTagsPresent = true;
+  for (const desiredRunnerTag of npmciRefArg.npmciConfig.getConfig().gitlabRunnerTags) {
+    if (!presentRunnerTags.includes(desiredRunnerTag)) {
+      allDesiredGitlabRunnerTagsPresent = false;
+      logger.log(
+        'error',
+        `Desired runnerRag ${desiredRunnerTag} is missing in current execution context.`
+      );
+    }
+  }
+  if (!allDesiredGitlabRunnerTagsPresent) {
+    process.exit(1);
+  }
+};
--- a/ts/mod_precheck/plugins.ts
+++ b/ts/mod_precheck/plugins.ts
@@ -0,0 +1 @@
+export * from '../npmci.plugins.js';
--- a/ts/mod_ssh/index.ts
+++ b/ts/mod_ssh/index.ts
@@ -1,5 +1,5 @@
-import { logger } from '../npmci.logging';
-import * as plugins from './mod.plugins';
+import { logger } from '../npmci.logging.js';
+import * as plugins from './mod.plugins.js';
 let sshInstance: plugins.smartssh.SshInstance;

 export let handleCli = async (argvArg: any) => {
@@ -31,7 +31,7 @@ const notUndefined = (stringArg: string) => {
 */
 export let prepare = async () => {
  sshInstance = new plugins.smartssh.SshInstance(); // init ssh instance
-  plugins.smartparam.forEachMinimatch(process.env, 'NPMCI_SSHKEY_*', evaluateSshEnv);
+  plugins.smartobject.forEachMinimatch(process.env, 'NPMCI_SSHKEY_*', evaluateSshEnv);
  if (!process.env.NPMTS_TEST) {
    sshInstance.writeToDisk();
  } else {
--- a/ts/mod_ssh/mod.plugins.ts
+++ b/ts/mod_ssh/mod.plugins.ts
@@ -1 +1 @@
-export * from '../npmci.plugins';
+export * from '../npmci.plugins.js';
--- a/ts/mod_trigger/index.ts
+++ b/ts/mod_trigger/index.ts
@@ -1,13 +1,13 @@
-import * as plugins from './mod.plugins';
-import { bash } from '../npmci.bash';
-import { logger } from '../npmci.logging';
+import * as plugins from './mod.plugins.js';
+import { bash } from '../npmci.bash.js';
+import { logger } from '../npmci.logging.js';

 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);
+  await plugins.smartobject.forEachMinimatch(process.env, 'NPMCI_TRIGGER_*', evaluateTrigger);
 };

 const evaluateTrigger = async (triggerEnvVarArg) => {
--- a/ts/mod_trigger/mod.plugins.ts
+++ b/ts/mod_trigger/mod.plugins.ts
@@ -1 +1 @@
-export * from '../npmci.plugins';
+export * from '../npmci.plugins.js';
--- a/ts/npmci.bash.ts
+++ b/ts/npmci.bash.ts
@@ -1,13 +1,11 @@
-import { logger } from './npmci.logging';
-import * as plugins from './npmci.plugins';
-import * as paths from './npmci.paths';
-
-import * as smartpromise from '@pushrocks/smartpromise';
+import { logger } from './npmci.logging.js';
+import * as plugins from './npmci.plugins.js';
+import * as paths from './npmci.paths.js';

 /**
 * wether nvm is available or not
 */
-export let nvmAvailable = smartpromise.defer<boolean>();
+export let nvmAvailable = plugins.smartpromise.defer<boolean>();
 /**
 * the smartshell instance for npmci
 */
--- a/ts/npmci.classes.npmci.ts
+++ b/ts/npmci.classes.npmci.ts
@@ -1,17 +1,21 @@
-import * as plugins from './npmci.plugins';
+import * as plugins from './npmci.plugins.js';

-import { CloudlyConnector } from './connector.cloudly/cloudlyconnector';

-import { NpmciInfo } from './npmci.classes.npmciinfo';
-import { NpmciCli } from './npmci.classes.npmcicli';
-import { NpmciConfig } from './npmci.classes.npmciconfig';
+// env
+import { NpmciEnv } from './npmci.classes.npmcienv.js';
+import { NpmciInfo } from './npmci.classes.npmciinfo.js';
+import { NpmciCli } from './npmci.classes.npmcicli.js';
+import { NpmciConfig } from './npmci.classes.npmciconfig.js';

-// mods
-import { NpmciDockerManager } from './manager.docker';
-import { NpmciGitManager } from './manager.git';
-import { NpmciNodeJsManager } from './manager.nodejs';
-import { NpmciNpmManager } from './manager.npm';
-import { NpmciEnv } from './npmci.classes.npmcienv';
+// connectors
+import { CloudlyConnector } from './connector.cloudly/cloudlyconnector.js';
+
+// managers
+import { NpmciCloudronManager } from './manager.cloudron/index.js';
+import { NpmciDockerManager } from './manager.docker/index.js';
+import { NpmciGitManager } from './manager.git/index.js';
+import { NpmciNodeJsManager } from './manager.nodejs/index.js';
+import { NpmciNpmManager } from './manager.npm/index.js';

 export class Npmci {
  public analytics: plugins.smartanalytics.Analytics;
@@ -23,6 +27,7 @@ export class Npmci {
  public npmciCli: NpmciCli;

  // managers
+  public cloudronManager: NpmciCloudronManager;
  public dockerManager: NpmciDockerManager;
  public gitManager: NpmciGitManager;
  public nodejsManager: NpmciNodeJsManager;
@@ -34,22 +39,23 @@ export class Npmci {
      projectId: 'gitzone',
      appName: 'npmci',
    });
+  }
+
+  public async start() {
    this.cloudlyConnector = new CloudlyConnector(this);
    this.npmciEnv = new NpmciEnv(this);
    this.npmciInfo = new NpmciInfo(this);
+    await this.npmciInfo.printToConsole();
    this.npmciCli = new NpmciCli(this);
    this.npmciConfig = new NpmciConfig(this);
+    await this.npmciConfig.init();

    // managers
+    this.cloudronManager = new NpmciCloudronManager(this);
    this.dockerManager = new NpmciDockerManager(this);
    this.gitManager = new NpmciGitManager(this);
    this.nodejsManager = new NpmciNodeJsManager(this);
    this.npmManager = new NpmciNpmManager(this);
-  }
-
-  public async start() {
-    await this.npmciInfo.printToConsole();
-    await this.npmciConfig.init();
    this.npmciCli.startParse();
  }
 }
--- a/ts/npmci.classes.npmcicli.ts
+++ b/ts/npmci.classes.npmcicli.ts
@@ -1,7 +1,7 @@
-import { logger } from './npmci.logging';
-import * as plugins from './npmci.plugins';
-import * as paths from './npmci.paths';
-import { Npmci } from './npmci.classes.npmci';
+import { logger } from './npmci.logging.js';
+import * as plugins from './npmci.plugins.js';
+import * as paths from './npmci.paths.js';
+import { Npmci } from './npmci.classes.npmci.js';

 export class NpmciCli {
  public npmciRef: Npmci;
@@ -15,7 +15,7 @@ export class NpmciCli {
    // clean
    this.smartcli.addCommand('clean').subscribe(
      async (argv) => {
-        const modClean = await import('./mod_clean/index');
+        const modClean = await import('./mod_clean/index.js');
        await modClean.clean();
      },
      (err) => {
@@ -24,10 +24,21 @@ export class NpmciCli {
      }
    );

+    // cloudron
+    this.smartcli.addCommand('cloudron').subscribe(
+      async (argv) => {
+        await this.npmciRef.cloudronManager.handleCli(argv);
+      },
+      (err) => {
+        console.log(err);
+        process.exit(1);
+      }
+    );
+
    // command
    this.smartcli.addCommand('command').subscribe(
      async (argv) => {
-        const modCommand = await import('./mod_command/index');
+        const modCommand = await import('./mod_command/index.js');
        await modCommand.command();
      },
      (err) => {
@@ -36,7 +47,7 @@ export class NpmciCli {
      }
    );

-    // command
+    // git
    this.smartcli.addCommand('git').subscribe(
      async (argvArg) => {
        await this.npmciRef.gitManager.handleCli(argvArg);
@@ -79,22 +90,21 @@ export class NpmciCli {
      }
    );

+    this.smartcli.addCommand('precheck').subscribe(async (argvArg) => {
+      const modPrecheck = await import('./mod_precheck/index.js');
+      await modPrecheck.handleCli(this.npmciRef, argvArg);
+    });
+
    // trigger
-    this.smartcli.addCommand('ssh').subscribe(
-      async (argvArg) => {
-        const modSsh = await import('./mod_ssh/index');
-        await modSsh.handleCli(argvArg);
-      },
-      (err) => {
-        console.log(err);
-        process.exit(1);
-      }
-    );
+    this.smartcli.addCommand('ssh').subscribe(async (argvArg) => {
+      const modSsh = await import('./mod_ssh/index.js');
+      await modSsh.handleCli(argvArg);
+    });

    // trigger
    this.smartcli.addCommand('trigger').subscribe(
      async (argv) => {
-        const modTrigger = await import('./mod_trigger/index');
+        const modTrigger = await import('./mod_trigger/index.js');
        await modTrigger.trigger();
      },
      (err) => {
--- a/ts/npmci.classes.npmciconfig.ts
+++ b/ts/npmci.classes.npmciconfig.ts
@@ -1,8 +1,8 @@
-import * as plugins from './npmci.plugins';
-import * as paths from './npmci.paths';
+import * as plugins from './npmci.plugins.js';
+import * as paths from './npmci.paths.js';

-import { logger } from './npmci.logging';
-import { Npmci } from './npmci.classes.npmci';
+import { logger } from './npmci.logging.js';
+import { Npmci } from './npmci.classes.npmci.js';

 /**
 * the main config interface for npmci
@@ -20,8 +20,14 @@ export interface INpmciOptions {
  dockerRegistryRepoMap: { [key: string]: string };
  dockerBuildargEnvMap: { [key: string]: string };

+  // gitlab
+  gitlabRunnerTags: string[];
+
  // urls
  urlCloudly: string;
+
+  // cloudron
+  cloudronAppName?: string;
 }

 /**
@@ -38,12 +44,14 @@ export class NpmciConfig {

  constructor(npmciRefArg: Npmci) {
    this.npmciRef = npmciRefArg;
+  }

+  public async init() {
    this.npmciNpmextra = new plugins.npmextra.Npmextra(paths.cwd);
-    this.kvStorage = new plugins.npmextra.KeyValueStore(
-      'custom',
-      `${this.npmciRef.npmciEnv.repo.user}_${this.npmciRef.npmciEnv.repo.repo}`
-    );
+    this.kvStorage = new plugins.npmextra.KeyValueStore({
+      typeArg: 'userHomeDir',
+      identityArg: `.npmci_${this.npmciRef.npmciEnv.repo.user}_${this.npmciRef.npmciEnv.repo.repo}`,
+    });
    this.npmciQenv = new plugins.qenv.Qenv(
      paths.NpmciProjectDir,
      paths.NpmciProjectNogitDir,
@@ -57,12 +65,10 @@ export class NpmciConfig {
      dockerRegistryRepoMap: {},
      npmAccessLevel: 'private',
      npmRegistryUrl: 'registry.npmjs.org',
+      gitlabRunnerTags: [],
      dockerBuildargEnvMap: {},
-      urlCloudly: this.npmciQenv.getEnvVarOnDemand('NPMCI_URL_CLOUDLY'),
+      urlCloudly: await this.npmciQenv.getEnvVarOnDemand('NPMCI_URL_CLOUDLY'),
    };
-  }
-
-  public async init() {
    this.configObject = this.npmciNpmextra.dataFor<INpmciOptions>('npmci', this.configObject);
  }

--- a/ts/npmci.classes.npmcienv.ts
+++ b/ts/npmci.classes.npmcienv.ts
@@ -1,5 +1,5 @@
-import * as plugins from './npmci.plugins';
-import { Npmci } from './npmci.classes.npmci';
+import * as plugins from './npmci.plugins.js';
+import { Npmci } from './npmci.classes.npmci.js';

 export class NpmciEnv {
  public npmciRef: Npmci;
@@ -9,7 +9,12 @@ export class NpmciEnv {

  constructor(npmciRefArg: Npmci) {
    this.npmciRef = npmciRefArg;
-    this.repoString = process.env.CI_REPOSITORY_URL;
+    if (!this.repoString && process.env.GITLAB_CI) {
+      this.repoString = process.env.CI_REPOSITORY_URL;
+    }
+    if (!this.repoString && process.env.NPMCI_COMPUTED_REPOURL) {
+      this.repoString = process.env.NPMCI_COMPUTED_REPOURL;
+    }
    if (!this.repoString) {
      this.repoString = 'https://undefined:undefined@github.com/undefined/undefined.git';
    }
--- a/ts/npmci.classes.npmciinfo.ts
+++ b/ts/npmci.classes.npmciinfo.ts
@@ -1,7 +1,7 @@
-import * as plugins from './npmci.plugins';
-import * as paths from './npmci.paths';
-import { logger } from './npmci.logging';
-import { Npmci } from './npmci.classes.npmci';
+import * as plugins from './npmci.plugins.js';
+import * as paths from './npmci.paths.js';
+import { logger } from './npmci.logging.js';
+import { Npmci } from './npmci.classes.npmci.js';

 export class NpmciInfo {
  public npmciRef: Npmci;
@@ -11,7 +11,7 @@ export class NpmciInfo {
    this.npmciRef = npmciArg;
  }

-  public printToConsole() {
-    logger.log('info', `npmci version: ${this.projectInfo.version}`);
+  public async printToConsole() {
+    await logger.log('info', `npmci version: ${this.projectInfo.version}`);
  }
 }
--- a/ts/npmci.logging.ts
+++ b/ts/npmci.logging.ts
@@ -1,4 +1,4 @@
-import * as plugins from './npmci.plugins';
+import * as plugins from './npmci.plugins.js';

 export const logger = new plugins.smartlog.Smartlog({
  logContext: {
--- a/ts/npmci.paths.ts
+++ b/ts/npmci.paths.ts
@@ -1,9 +1,12 @@
-import * as plugins from './npmci.plugins';
+import * as plugins from './npmci.plugins.js';

 export const cwd = process.cwd();

 // package paths
-export const NpmciPackageRoot = plugins.path.join(__dirname, '../');
+export const NpmciPackageRoot = plugins.path.join(
+  plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url),
+  '../'
+);
 export const NpmciPackageConfig = plugins.path.join(NpmciPackageRoot, './config.json');

 // project paths
--- a/ts/npmci.plugins.ts
+++ b/ts/npmci.plugins.ts
@@ -4,45 +4,50 @@ import * as path from 'path';
 export { path };

 // @apiglobal
-import * as typedrequest from '@apiglobal/typedrequest';
+import * as typedrequest from '@api.global/typedrequest';

 export { typedrequest };

 // @servezone
-import * as servezoneInterfaces from '@servezone/interfaces';
+import * as servezoneApi from '@serve.zone/api';

-export { servezoneInterfaces };
+export { servezoneApi };

-// @pushrocks
-import * as npmextra from '@pushrocks/npmextra';
-import * as projectinfo from '@pushrocks/projectinfo';
-import * as qenv from '@pushrocks/qenv';
-import * as smartanalytics from '@pushrocks/smartanalytics';
-import * as smartdelay from '@pushrocks/smartdelay';
-import * as smartfile from '@pushrocks/smartfile';
-import * as smartcli from '@pushrocks/smartcli';
-import * as smartgit from '@pushrocks/smartgit';
-import * as smartlog from '@pushrocks/smartlog';
-import * as smartlogDestinationLocal from '@pushrocks/smartlog-destination-local';
-import * as smartparam from '@pushrocks/smartparam';
-import * as smartpromise from '@pushrocks/smartpromise';
-import * as smartrequest from '@pushrocks/smartrequest';
-import * as smartshell from '@pushrocks/smartshell';
-import * as smartsocket from '@pushrocks/smartsocket';
-import * as smartssh from '@pushrocks/smartssh';
-import * as smartstring from '@pushrocks/smartstring';
+// @push.rocks
+import * as lik from '@push.rocks/lik';
+import * as npmextra from '@push.rocks/npmextra';
+import * as projectinfo from '@push.rocks/projectinfo';
+import * as qenv from '@push.rocks/qenv';
+import * as smartanalytics from '@push.rocks/smartanalytics';
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartfile from '@push.rocks/smartfile';
+import * as smartcli from '@push.rocks/smartcli';
+import * as smartgit from '@push.rocks/smartgit';
+import * as smartlog from '@push.rocks/smartlog';
+import * as smartlogDestinationLocal from '@push.rocks/smartlog-destination-local';
+import * as smartobject from '@push.rocks/smartobject';
+import * as smartpath from '@push.rocks/smartpath';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartrequest from '@push.rocks/smartrequest';
+import * as smartshell from '@push.rocks/smartshell';
+import * as smartsocket from '@push.rocks/smartsocket';
+import * as smartssh from '@push.rocks/smartssh';
+import * as smartstring from '@push.rocks/smartstring';

 export {
+  lik,
  npmextra,
  projectinfo,
  qenv,
  smartanalytics,
  smartdelay,
  smartfile,
+  smartgit,
  smartcli,
  smartlog,
  smartlogDestinationLocal,
-  smartparam,
+  smartobject,
+  smartpath,
  smartpromise,
  smartrequest,
  smartshell,
@@ -54,9 +59,7 @@ export {
 // @tsclass scope
 import * as tsclass from '@tsclass/tsclass';

-export {
-  tsclass
-}
+export { tsclass };

 // third party
 import * as through2 from 'through2';
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "useDefineForClassFields": false,
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "verbatimModuleSyntax": true
+  },
+  "exclude": [
+    "dist_*/**/*.d.ts"
+  ]
+}
--- a/tslint.json
+++ b/tslint.json
@@ -1,17 +0,0 @@
-{
-  "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"
-}
Author	SHA1	Message	Date
Philipp Kunz	00f324e151	4.1.35 Some checks failed Default (tags) / security (push) Failing after 16s Details Default (tags) / test (push) Successful in 1m32s Details Default (tags) / metadata (push) Failing after 10s Details Default (tags) / release (push) Failing after 21s Details	2024-11-17 00:32:56 +01:00
Philipp Kunz	e38cc40f11	fix(docker): Fix Dockerfile dependency sorting and enhance environment variable handling for GitHub repos	2024-11-17 00:32:56 +01:00
Philipp Kunz	e9e8acafe4	4.1.34	2024-11-05 02:39:53 +01:00
Philipp Kunz	c763db40bb	fix(connector): Remove unused typedrequest implementation in cloudlyconnector	2024-11-05 02:39:53 +01:00
Philipp Kunz	01256480c4	4.1.33	2024-11-05 02:38:21 +01:00
Philipp Kunz	c6918399bf	fix(core): Updated dependencies and improved npm preparation logic.	2024-11-05 02:38:21 +01:00
Philipp Kunz	66d28e5081	4.1.32	2024-10-23 21:50:30 +02:00
Philipp Kunz	9de77139ea	fix(dependencies): Update project dependencies to latest versions	2024-10-23 21:50:30 +02:00
Philipp Kunz	7b4bf10cc0	4.1.31	2024-05-24 15:54:33 +02:00
Philipp Kunz	9eaa6347c1	fix(core): update	2024-05-24 15:54:32 +02:00
Philipp Kunz	6e4c967917	4.1.30	2024-05-24 00:17:31 +02:00
Philipp Kunz	52a8f42fc9	fix(core): update	2024-05-24 00:17:31 +02:00
Philipp Kunz	8e9a61bbb2	4.1.29	2024-05-23 21:47:07 +02:00
Philipp Kunz	dc809a6023	fix(core): update	2024-05-23 21:47:06 +02:00
Philipp Kunz	7eeca992b0	4.1.28	2024-05-17 16:23:48 +02:00
Philipp Kunz	d018102014	fix(core): update	2024-05-17 16:23:47 +02:00
Philipp Kunz	838f2d6959	4.1.27	2023-08-24 17:25:56 +02:00
Philipp Kunz	0d42e5f6eb	fix(core): update	2023-08-24 17:25:55 +02:00
Philipp Kunz	f96de8cdc3	4.1.26	2023-08-09 11:26:22 +02:00
Philipp Kunz	965833916f	fix(core): update	2023-08-09 11:26:22 +02:00
Philipp Kunz	81ec1391e3	4.1.25	2023-08-09 11:23:57 +02:00
Philipp Kunz	bbbca44640	fix(core): update	2023-08-09 11:23:56 +02:00
Philipp Kunz	7ba7dc54a1	4.1.24	2023-08-08 23:32:08 +02:00
Philipp Kunz	4f98eeec2a	fix(core): update	2023-08-08 23:32:07 +02:00
Philipp Kunz	419a6b9e5f	4.1.23	2023-07-13 16:00:47 +02:00
Philipp Kunz	9c040c34f5	fix(core): update	2023-07-13 16:00:47 +02:00
Philipp Kunz	50d3f2d795	4.1.22	2023-07-12 18:23:32 +02:00
Philipp Kunz	305856b9e1	fix(core): update	2023-07-12 18:23:31 +02:00
Philipp Kunz	3683743f3c	4.1.21	2023-07-12 15:35:39 +02:00
Philipp Kunz	41237e0e5f	fix(core): update	2023-07-12 15:35:38 +02:00
Philipp Kunz	bce84a0e74	4.1.20	2023-07-02 00:10:28 +02:00
Philipp Kunz	79bed919d8	fix(core): update	2023-07-02 00:10:27 +02:00
Philipp Kunz	4b202ce00e	4.1.19	2023-07-01 22:09:54 +02:00
Philipp Kunz	16ca787314	fix(core): update	2023-07-01 22:09:54 +02:00
Philipp Kunz	3a9b6f658a	4.1.18	2023-07-01 22:05:44 +02:00
Philipp Kunz	5c5dbf303f	fix(core): update	2023-07-01 22:05:43 +02:00
Philipp Kunz	4c07131e51	4.1.17	2023-07-01 19:23:17 +02:00
Philipp Kunz	ba039469ff	fix(core): update	2023-07-01 19:23:17 +02:00
Philipp Kunz	49f2498ecd	4.1.16	2023-07-01 19:02:07 +02:00
Philipp Kunz	1060060366	fix(core): update	2023-07-01 19:02:06 +02:00
Philipp Kunz	0fa3a579f7	4.1.15	2023-06-26 10:09:25 +02:00
Philipp Kunz	0e4556d59e	fix(core): update	2023-06-26 10:09:24 +02:00
Philipp Kunz	e2e7967fba	4.1.14	2023-06-26 09:28:19 +02:00
Philipp Kunz	45b8d67abf	fix(core): update	2023-06-26 09:28:19 +02:00
Philipp Kunz	0a69aa5d62	4.1.13	2023-06-26 02:43:45 +02:00
Philipp Kunz	dfbab1a1df	fix(core): update	2023-06-26 02:43:45 +02:00
Philipp Kunz	e58f009a24	4.1.12	2023-06-26 01:03:44 +02:00
Philipp Kunz	2afd9cddc5	fix(core): update	2023-06-26 01:03:44 +02:00
Philipp Kunz	d79c5366ef	4.1.11	2023-06-26 00:09:56 +02:00
Philipp Kunz	8e4f7ad244	fix(core): update	2023-06-26 00:09:54 +02:00
Philipp Kunz	39de3a1601	4.1.10	2023-06-25 23:59:26 +02:00
Philipp Kunz	cb3d2964d1	fix(core): update	2023-06-25 23:59:25 +02:00
Philipp Kunz	6b5390cef8	4.1.9	2023-06-25 23:26:25 +02:00
Philipp Kunz	2736b85de3	fix(core): update	2023-06-25 23:26:25 +02:00
Philipp Kunz	82d7778f59	4.1.8	2023-06-25 23:18:23 +02:00
Philipp Kunz	8c99cc0491	fix(core): update	2023-06-25 23:18:23 +02:00
Philipp Kunz	955e3d0dbe	4.1.7	2023-06-25 23:16:29 +02:00
Philipp Kunz	702ae8bed8	fix(core): update	2023-06-25 23:16:29 +02:00
Philipp Kunz	b6f0723b75	4.1.6	2023-06-25 22:23:31 +02:00
Philipp Kunz	8a2fb30e59	fix(core): update	2023-06-25 22:23:30 +02:00
Philipp Kunz	95b4030120	4.1.5	2023-06-25 21:15:51 +02:00
Philipp Kunz	5c77cfbdc2	fix(core): update	2023-06-25 21:15:50 +02:00
Philipp Kunz	5ea42320a9	4.1.4	2023-05-07 22:35:19 +02:00
Philipp Kunz	d07ebfc9c6	fix(core): update	2023-05-07 22:35:18 +02:00
Philipp Kunz	bbb5718184	4.1.3	2023-05-07 21:30:59 +02:00
Philipp Kunz	0d8b54637c	fix(core): update	2023-05-07 21:30:58 +02:00
Philipp Kunz	e51b2e28b9	4.1.2	2022-11-02 18:57:47 +01:00
Philipp Kunz	f767140cc8	fix(core): update	2022-11-02 18:57:47 +01:00
Philipp Kunz	0d4d69f072	4.1.1	2022-11-02 16:43:54 +01:00
Philipp Kunz	a3e628c43f	fix(core): update	2022-11-02 16:43:54 +01:00
Philipp Kunz	a58fa135c1	4.1.0	2022-10-24 21:23:14 +02:00
Philipp Kunz	93c7af6c91	feat(precheck): now includes a precheck for more generic runner execution	2022-10-24 21:23:14 +02:00
Philipp Kunz	ad0e12bf7b	4.0.11	2022-10-23 17:19:42 +02:00
Philipp Kunz	498dd6eff6	fix(core): update	2022-10-23 17:19:41 +02:00
Philipp Kunz	b3aa964739	4.0.10	2022-10-11 14:26:43 +02:00
Philipp Kunz	03eb9d2657	fix(core): update	2022-10-11 14:26:42 +02:00
Philipp Kunz	373a838a6a	4.0.9	2022-10-11 14:08:00 +02:00
Philipp Kunz	960e3f4675	fix(core): update	2022-10-11 14:07:59 +02:00
Philipp Kunz	09bf676b58	4.0.8	2022-10-11 13:59:40 +02:00
Philipp Kunz	76ba8e2ab9	fix(core): update	2022-10-11 13:59:39 +02:00
Philipp Kunz	aaaaca2d19	4.0.7	2022-10-11 13:59:16 +02:00
Philipp Kunz	71b27eda17	fix(core): update	2022-10-11 13:59:15 +02:00
Philipp Kunz	2d00882fd7	4.0.6	2022-10-11 13:58:48 +02:00
Philipp Kunz	ba5e69041f	fix(core): update	2022-10-11 13:58:48 +02:00
Philipp Kunz	d2871d601a	4.0.5	2022-10-11 13:40:26 +02:00
Philipp Kunz	9c66d88dc0	fix(core): update	2022-10-11 13:40:25 +02:00
Philipp Kunz	fb4c84e1de	4.0.4	2022-10-11 13:38:40 +02:00
Philipp Kunz	57aca36f11	fix(core): update	2022-10-11 13:38:40 +02:00
Philipp Kunz	905f594af1	4.0.3	2022-10-11 13:26:50 +02:00
Philipp Kunz	b788b7f96b	fix(core): update	2022-10-11 13:26:49 +02:00
Philipp Kunz	319a2dc41a	4.0.2	2022-10-11 13:08:10 +02:00
Philipp Kunz	e01a998f0e	fix(core): update	2022-10-11 13:08:10 +02:00
Philipp Kunz	e40606d97b	4.0.1	2022-10-11 10:53:12 +02:00
Philipp Kunz	449c7b2c04	fix(core): update	2022-10-11 10:53:12 +02:00
Philipp Kunz	006782b57f	4.0.0	2022-10-09 18:15:37 +02:00
Philipp Kunz	d643da29b0	BREAKING CHANGE(core): switch to esm style module	2022-10-09 18:15:37 +02:00
Philipp Kunz	635f92d2bc	3.1.83	2022-01-18 18:10:28 +01:00
Philipp Kunz	9a2cb56094	fix(core): update	2022-01-18 18:10:27 +01:00
Philipp Kunz	5886283002	3.1.82	2021-11-10 12:42:42 +01:00
Philipp Kunz	f886194c9c	3.1.81	2021-11-10 12:40:13 +01:00
Philipp Kunz	e4efec89d9	fix(core): update	2021-11-10 12:40:12 +01:00