6.2.0

feat(handlers): Add in-memory HTTP-01 challenge handler and rename file-based handler to Http01Webroot
6.1.3
2025-04-30 14:55:03 +00:00 · 2025-04-30 14:55:03 +00:00 · 2025-04-30 12:59:20 +00:00 · 2025-04-30 12:59:20 +00:00 · 2025-04-27 14:51:22 +00:00 · 2025-04-27 14:51:22 +00:00
43 changed files with 12169 additions and 3158 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: code.foss.global/host.today/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@/${{gitea.repository}}.git
+  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 @ship.zone/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,124 @@
+name: Default (tags)
+
+on:
+  push:
+    tags:
+      - '*'
+
+env:
+  IMAGE: code.foss.global/host.today/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@/${{gitea.repository}}.git
+  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: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @ship.zone/npmci
+          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: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @ship.zone/npmci
+          npmci npm prepare
+
+      - 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: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @ship.zone/npmci
+          npmci npm prepare
+
+      - 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: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @ship.zone/npmci
+          npmci npm prepare
+
+      - name: Code quality
+        run: |
+          npmci command npm install -g typescript
+          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/.gitignore
+++ b/.gitignore
@ -1,5 +1,19 @@
-node_modules/
+.nogit/
+
+# artifacts
 coverage/
 public/
-pages/
-.nogit/
+
+# installs
+node_modules/
+
+# caches
+.yarn/
+.cache/
+.rpt2_cache
+
+# builds
+dist/
+dist_*/
+
+#------# custom
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@ -1,150 +0,0 @@
-# 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 npm prepare
-  - npmci node install lts
-  - npmci npm install
-  - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-  - docker
-  - notpriv
-    
-testSTABLE:
-  stage: test
-  script:
-  - npmci npm prepare
-  - npmci node install stable
-  - npmci npm install
-  - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-  - docker
-  - notpriv
-
-release:
-  stage: release
-  script:
-  - npmci node install stable
-  - npmci npm publish
-  only:
-  - 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
--- a/.snyk
+++ b/.snyk
@ -1,12 +0,0 @@
-# Snyk (https://snyk.io) policy file, patches or ignores known vulnerabilities.
-version: v1.12.0
-# ignores vulnerabilities until expiry date; change duration by modifying expiry date
-ignore:
-  'npm:node-forge:20180226':
-    - rsa-compat > node-forge:
-        reason: None given
-        expires: '2018-09-11T19:17:24.148Z'
-    - acme-v2 > rsa-compat > node-forge:
-        reason: None given
-        expires: '2018-09-11T19:17:24.148Z'
-patch: {}
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@ -0,0 +1,11 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "command": "npm test",
+      "name": "Run npm test",
+      "request": "launch",
+      "type": "node-terminal"
+    }
+  ]
+}
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@ -0,0 +1,26 @@
+{
+  "json.schemas": [
+    {
+      "fileMatch": ["/npmextra.json"],
+      "schema": {
+        "type": "object",
+        "properties": {
+          "npmci": {
+            "type": "object",
+            "description": "settings for npmci"
+          },
+          "gitzone": {
+            "type": "object",
+            "description": "settings for gitzone",
+            "properties": {
+              "projectType": {
+                "type": "string",
+                "enum": ["website", "element", "service", "npm", "wcc"]
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
+}
--- a/README.md
+++ b/README.md
@ -1,63 +0,0 @@
-# smartacme
-
-acme implementation in TypeScript
-
-## Availabililty
-
-[![npm](https://umbrellazone.gitlab.io/assets/repo-button-npm.svg)](https://www.npmjs.com/package/smartacme)
-[![git](https://umbrellazone.gitlab.io/assets/repo-button-git.svg)](https://GitLab.com/umbrellazone/smartacme)
-[![git](https://umbrellazone.gitlab.io/assets/repo-button-mirror.svg)](https://github.com/umbrellazone/smartacme)
-[![docs](https://umbrellazone.gitlab.io/assets/repo-button-docs.svg)](https://umbrellazone.gitlab.io/smartacme/)
-
-## Status for master
-
-[![build status](https://GitLab.com/umbrellazone/smartacme/badges/master/build.svg)](https://GitLab.com/umbrellazone/smartacme/commits/master)
-[![coverage report](https://GitLab.com/umbrellazone/smartacme/badges/master/coverage.svg)](https://GitLab.com/umbrellazone/smartacme/commits/master)
-[![npm downloads per month](https://img.shields.io/npm/dm/smartacme.svg)](https://www.npmjs.com/package/smartacme)
-[![Dependency Status](https://david-dm.org/umbrellazone/smartacme.svg)](https://david-dm.org/umbrellazone/smartacme)
-[![bitHound Dependencies](https://www.bithound.io/github/umbrellazone/smartacme/badges/dependencies.svg)](https://www.bithound.io/github/umbrellazone/smartacme/master/dependencies/npm)
-[![bitHound Code](https://www.bithound.io/github/umbrellazone/smartacme/badges/code.svg)](https://www.bithound.io/github/umbrellazone/smartacme)
-[![TypeScript](https://img.shields.io/badge/TypeScript-2.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
-[![node](https://img.shields.io/badge/node->=%206.x.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
-[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-standard-brightgreen.svg)](http://standardjs.com/)
-
-## Usage
-
-Use TypeScript for best in class instellisense.
-
-```javascript
-import { SmartAcme } from 'smartacme';
-
-let smac = new SmartAcme()(async () => {
-  // learn async/await, it'll make your life easier
-
-  // optionally accepts a filePath Arg with a stored acmeaccount.json
-  // will create an account and
-  let myAccount = await smac.createAcmeAccount();
-
-  // will return a dnsHash to set in your DNS record
-  let myCert = await myAccount.createAcmeCert('example.com');
-
-  // gets and accepts the specified challenge
-  // first argument optional, defaults to dns-01 (which is the cleanest method for production use)
-  let myChallenge = await myCert.getChallenge('dns-01');
-
-  /* ----------
-    Now you need to set the challenge in your DNS
-    myChallenge.domainNamePrefixed is the address for the record
-    myChallenge.dnsKeyHash is the ready to use txt record value expected by letsencrypt
-    -------------*/
-})();
-```
-
-## Other relevant npm modules
-
-| module name | description                                                         |
-| ----------- | ------------------------------------------------------------------- |
-| cert        | a higlevel production module that uses smartacme to manage certs    |
-| smartnginx  | a highlevel production tool for docker environments to manage nginx |
-
-> MIT licensed | **&copy;** [Lossless GmbH](https://lossless.gmbh)
-> | By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy.html)
-
-[![repo-footer](https://umbrellazone.gitlab.io/assets/repo-footer.svg)](https://umbrella.zone
--- a/changelog.md
+++ b/changelog.md
@ -0,0 +1,171 @@
+# Changelog
+
+## 2025-04-30 - 6.2.0 - feat(handlers)
+Add in-memory HTTP-01 challenge handler and rename file-based handler to Http01Webroot
+
+- Renamed Http01Handler to Http01Webroot in both implementation and documentation
+- Introduced Http01MemoryHandler for diskless HTTP-01 challenges
+- Updated tests and README examples to reflect handler name changes and new feature
+
+## 2025-04-30 - 6.1.3 - fix(Dns01Handler)
+Update dependency versions and refine Dns01Handler implementation
+
+- Bump '@apiclient.xyz/cloudflare' to ^6.4.1 and '@tsclass/tsclass' to ^9.1.0 in package.json
+- Remove duplicate Cloudflare import in smartacme.plugins.ts
+- Refactor Dns01Handler to use IConvenientDnsProvider and add checkWetherDomainIsSupported method
+- Align devDependencies versions for improved consistency
+
+## 2025-04-27 - 6.1.2 - fix(repo)
+Update repository metadata by replacing the LICENSE file with a license.md file for improved consistency.
+
+- Removed the old LICENSE file.
+- Introduced license.md as the new license documentation file.
+
+## 2025-04-27 - 6.1.1 - fix(readme)
+Fix license link reference in documentation
+
+- Updated the license link from [license](license) to [license.md](license.md) in the License and Legal Information section
+
+## 2025-04-27 - 6.1.0 - feat(readme)
+Update documentation with detailed built-in challenge handlers and custom handler examples
+
+- Expanded readme to include sections on Dns01Handler and Http01Handler usage
+- Added examples for creating and registering custom ACME challenge handlers
+- Improved clarity of ACME certificate management instructions using SmartAcme
+
+## 2025-04-27 - 6.0.1 - fix(readme)
+Remove extraneous code fence markers from license section in readme
+
+- Removed unnecessary triple backticks wrapping the license information
+- Improved clarity of the license section in the documentation
+
+## 2025-04-27 - 6.0.0 - BREAKING CHANGE(SmartAcme)
+Refactor challenge handling by removing legacy setChallenge/removeChallenge in favor of pluggable challengeHandlers and update documentation and tests accordingly
+
+- Removed legacy challenge methods and introduced new 'challengeHandlers' and 'challengePriority' options
+- Updated readme examples to demonstrate usage with DNS-01 (and HTTP-01) handlers
+- Refactored internal SmartAcme flow to select and process challenges via the new handler interface
+- Adjusted tests (including integration tests) to align with the updated challenge handling mechanism
+
+## 2025-04-27 - 5.1.0 - feat(smartacme)
+Implement exponential backoff retry logic and graceful shutdown handling in SmartAcme; update acme-client dependency to v5.4.0
+
+- Added retry helper with exponential backoff for ACME client operations
+- Introduced retryOptions in ISmartAcmeOptions for configurable retry parameters
+- Enhanced graceful shutdown handling by cleaning up pending DNS challenges on signal
+- Updated acme-client dependency from v4.2.5 to v5.4.0
+
+## 2025-04-26 - 5.0.1 - fix(build)
+Update CI workflows, bump dependency versions, and refine import and TypeScript configuration
+
+- Changed CI workflow image and npmci package from '@shipzone/npmci' to '@ship.zone/npmci', and updated repository URLs
+- Bumped several dependency versions in package.json (e.g. @api.global/typedserver, @push.rocks/lik, @push.rocks/smartdata, @push.rocks/smartdns, @tsclass/tsclass) to newer releases
+- Adjusted smartdns import to use the smartdnsClient module for proper module resolution
+- Updated tsconfig.json to add emitDecoratorMetadata and baseUrl settings
+- Minor markdown and formatting tweaks in readme and gitignore files, and slight improvements in test async handling
+
+## 2024-06-16 - 5.0.0 - No significant changes  
+This release contains no user‑facing changes.
+
+## 2024-06-16 - 4.0.8 - Structure and configuration updates  
+- BREAKING CHANGE(structure): renamed classes to avoid confusion  
+- update description  
+- update tsconfig  
+- update npmextra.json: githost
+
+## 2024-01-28 - 4.0.7–4.0.6 - Internal fixes and updates  
+- A series of releases with routine bug fixes and maintenance updates.
+
+## 2023-07-21 - 4.0.5–4.0.4 - Internal fixes and updates  
+- Multiple releases addressing internal issues and maintenance improvements.
+
+## 2023-07-10 - 4.0.3 - Organizational changes  
+- switch to new org scheme
+
+## 2022-09-27 - 4.0.0–4.0.2 - Internal fixes and updates  
+- Routine maintenance and internal bug fixes.
+
+## 2022-09-27 - 3.0.15 - Breaking changes  
+- BREAKING CHANGE(core): update
+
+## 2021-01-22 - 3.0.9–3.0.14 - Internal fixes and updates  
+- A range of releases focused on routine internal updates.
+
+## 2020-11-18 - 3.0.0–3.0.8 - Internal fixes and updates  
+- Routine maintenance and internal bug fixes.
+
+## 2020-02-10 - 2.1.2 - Breaking changes  
+- BREAKING CHANGE(core): streamline scope to certificate retrieval using dns challenge
+
+## 2020-02-10 - 2.1.0–2.1.1 - Internal fixes and updates  
+- Routine fixes and updates.
+
+## 2019-02-06 - 2.0.36 - New feature  
+- feat(Cert): now has validity check
+
+## 2019-01-18 - 2.0.2–2.0.35 - Internal fixes and updates  
+- Routine internal updates and maintenance.
+
+## 2018-10-07 - 2.0.0–2.0.1 - Internal fixes and updates  
+- Routine internal updates and maintenance.
+
+## 2018-10-07 - 1.1.4 - Breaking changes  
+- BREAKING CHANGE(scope): change to @pushrocks
+
+## 2018-08-12 - 1.1.1 - NPM publishing fix  
+- fix(npm publishing): update
+
+## 2018-08-11 - 1.1.0 - Certificate issuance update  
+- fix(core): now creating certs all right
+
+## 2018-08-11 - 1.0.11 - Feature update  
+- feat(swaitch to acme-v2): switch to letsencrypt v2
+
+## 2017-04-28 - 1.0.10 - CI improvements  
+- add updated ci config
+
+## 2017-04-28 - 1.0.9 - Standards update  
+- update to latest standards
+
+## 2017-01-27 - 1.0.8 - Basic functionality  
+- basic functionality
+
+## 2017-01-25 - 1.0.7 - Response and validation improvements  
+- now getting a valid response  
+- update validation  
+- improve README
+
+## 2017-01-15 - 1.0.6 - Async and documentation improvements  
+- improve README  
+- add async checkDNS
+
+## 2017-01-15 - 1.0.5 - Standards and process updates  
+- update to new standards  
+- now has working requestValidation method  
+- fix som things  
+- start better segregation of concerns  
+- start with certificate signing process
+
+## 2017-01-01 - 1.0.4 - Certificate acquisition improvements  
+- now getting certificates  
+- can now agree to TOS  
+- remove test keys
+
+## 2017-01-01 - 1.0.3 - NPM extra configuration  
+- add npmextra.json
+
+## 2017-01-01 - 1.0.2 - README and integration update  
+- add better readme  
+- switch to rawacme for more basic letsencrypt access
+
+## 2016-11-17 - 1.0.1 - Promise fix  
+- fix promise
+
+## 2016-11-17 - 1.0.0 - Major initial release changes  
+- remove superflouous key creation  
+- switch to acme core  
+- prepare switch to le‑acme‑core  
+- improve upon keyCreation  
+- update to use more promises  
+- add README  
+- first version
--- a/license.md
+++ b/license.md
@ -1,4 +1,4 @@
-Copyright (C) 2016, Lossless GmbH
+Copyright (C) 2016, Task Venture Capital GmbH

 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
--- a/npmextra.json
+++ b/npmextra.json
@ -1,6 +1,38 @@
 {
+  "gitzone": {
+    "projectType": "npm",
+    "module": {
+      "githost": "code.foss.global",
+      "gitscope": "push.rocks",
+      "gitrepo": "smartacme",
+      "description": "A TypeScript-based ACME client for LetsEncrypt certificate management with a focus on simplicity and power.",
+      "npmPackagename": "@push.rocks/smartacme",
+      "license": "MIT",
+      "projectDomain": "push.rocks",
+      "keywords": [
+        "ACME",
+        "LetsEncrypt",
+        "TypeScript",
+        "certificate management",
+        "DNS challenges",
+        "SSL/TLS",
+        "secure communication",
+        "domain validation",
+        "automation",
+        "crypto",
+        "MongoDB",
+        "dns-01 challenge",
+        "token-based challenges",
+        "certificate renewal",
+        "wildcard certificates"
+      ]
+    }
+  },
  "npmci": {
    "npmGlobalTools": [],
    "npmAccessLevel": "public"
+  },
+  "tsdoc": {
+    "legal": "\n## License and Legal Information\n\nThis repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH  \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
  }
 }
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@ -1,50 +1,84 @@
 {
-  "name": "@pushrocks/smartacme",
-  "version": "2.0.15",
+  "name": "@push.rocks/smartacme",
+  "version": "6.2.0",
  "private": false,
-  "description": "acme implementation in TypeScript",
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "description": "A TypeScript-based ACME client for LetsEncrypt certificate management with a focus on simplicity and power.",
+  "main": "dist_ts/index.js",
+  "typings": "dist_ts/index.d.ts",
+  "type": "module",
  "scripts": {
    "test": "(tstest test/)",
-    "build": "(tsbuild)"
+    "build": "(tsbuild --web --allowimplicitany)",
+    "buildDocs": "tsdoc"
  },
  "repository": {
    "type": "git",
-    "url": "git+ssh://git@gitlab.com/umbrellazone/smartacme.git"
+    "url": "https://code.foss.global/push.rocks/smartacme.git"
  },
  "keywords": [
+    "ACME",
+    "LetsEncrypt",
    "TypeScript",
-    "acme",
-    "letsencrypt"
+    "certificate management",
+    "DNS challenges",
+    "SSL/TLS",
+    "secure communication",
+    "domain validation",
+    "automation",
+    "crypto",
+    "MongoDB",
+    "dns-01 challenge",
+    "token-based challenges",
+    "certificate renewal",
+    "wildcard certificates"
  ],
-  "author": "Lossless GmbH",
+  "author": "Task Venture Capital GmbH",
  "license": "MIT",
  "bugs": {
-    "url": "https://gitlab.com/umbrellazone/smartacme/issues"
+    "url": "https://code.foss.global/push.rocks/smartacme/issues"
  },
-  "homepage": "https://gitlab.com/umbrellazone/smartacme#README",
+  "homepage": "https://code.foss.global/push.rocks/smartacme#readme",
  "dependencies": {
-    "@pushrocks/lik": "^3.0.4",
-    "@pushrocks/smartdata": "^3.1.13",
-    "@pushrocks/smartdelay": "^2.0.2",
-    "@pushrocks/smartdns": "^3.0.8",
-    "@pushrocks/smartexpress": "^3.0.0",
-    "@pushrocks/smartpromise": "^2.0.5",
-    "@pushrocks/smartrequest": "^1.1.14",
-    "@pushrocks/smarttime": "^3.0.5",
-    "@pushrocks/smartunique": "^3.0.1",
-    "acme-client": "^2.2.2"
+    "@api.global/typedserver": "^3.0.74",
+    "@apiclient.xyz/cloudflare": "^6.4.1",
+    "@push.rocks/lik": "^6.2.2",
+    "@push.rocks/smartdata": "^5.15.1",
+    "@push.rocks/smartdelay": "^3.0.5",
+    "@push.rocks/smartdns": "^6.2.2",
+    "@push.rocks/smartlog": "^3.0.7",
+    "@push.rocks/smartpromise": "^4.2.3",
+    "@push.rocks/smartrequest": "^2.1.0",
+    "@push.rocks/smartstring": "^4.0.15",
+    "@push.rocks/smarttime": "^4.1.1",
+    "@push.rocks/smartunique": "^3.0.9",
+    "@tsclass/tsclass": "^9.1.0",
+    "acme-client": "^5.4.0"
  },
  "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.4",
-    "@gitzone/tsrun": "^1.1.17",
-    "@gitzone/tstest": "^1.0.18",
-    "@mojoio/cloudflare": "^2.0.0",
-    "@pushrocks/qenv": "^3.0.2",
-    "@pushrocks/tapbundle": "^3.0.7",
-    "@types/node": "^10.12.18",
-    "tslint": "^5.12.0",
-    "tslint-config-prettier": "^1.17.0"
+    "@git.zone/tsbuild": "^2.3.2",
+    "@git.zone/tsrun": "^1.3.3",
+    "@git.zone/tstest": "^1.0.96",
+    "@push.rocks/qenv": "^6.1.0",
+    "@push.rocks/tapbundle": "^6.0.0",
+    "@types/node": "^22.15.3"
+  },
+  "files": [
+    "ts/**/*",
+    "ts_web/**/*",
+    "dist/**/*",
+    "dist_*/**/*",
+    "dist_ts/**/*",
+    "dist_ts_web/**/*",
+    "assets/**/*",
+    "cli.js",
+    "npmextra.json",
+    "readme.md"
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
+  ],
+  "packageManager": "pnpm@10.7.0+sha512.6b865ad4b62a1d9842b61d674a393903b871d9244954f652b8842c2b553c72176b278f64c463e52d40fff8aba385c235c8c9ecf5cc7de4fd78b8bb6d49633ab6",
+  "pnpm": {
+    "overrides": {}
  }
 }
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- a/qenv.yml
+++ b/qenv.yml
@ -1,6 +1,5 @@
 required:
-  - CF_EMAIL
-  - CF_KEY
+  - CF_TOKEN
  - MONGODB_URL
  - MONGODB_PASSWORD
  - MONGODB_DATABASE
--- a/readme.hints.md
+++ b/readme.hints.md
@ -0,0 +1,2 @@
+ - this repo is dependent on letsencrypt and its limits
+ - to simpify the outside API, smartacme is stateful, meaning it works with a mongodb and a collection called 'SmartacmeCert'.
--- a/readme.md
+++ b/readme.md
@ -0,0 +1,338 @@
+# @push.rocks/smartacme
+
+A TypeScript-based ACME client with an easy yet powerful interface for LetsEncrypt certificate management.
+
+## Install
+
+To install `@push.rocks/smartacme`, you can use npm or yarn. Run one of the following commands in your project directory:
+
+```bash
+npm install @push.rocks/smartacme --save
+```
+
+or
+
+```bash
+yarn add @push.rocks/smartacme
+```
+
+Make sure your project is set up to use TypeScript and supports ECMAScript Modules (ESM).
+
+## Usage
+
+This guide will walk you through using `@push.rocks/smartacme` to set up and manage ACME (Automated Certificate Management Environment) certificates with a focus on the Let's Encrypt service, which provides free SSL certificates. The library provides an easy yet powerful TypeScript interface to automate the process of obtaining, renewing, and installing your SSL certificates.
+
+### Table of Contents
+
+1. [Setting Up Your Project](#setting-up-your-project)
+2. [Creating a SmartAcme Instance](#creating-a-smartacme-instance)
+3. [Initializing SmartAcme](#initializing-smartacme)
+4. [Obtaining a Certificate for a Domain](#obtaining-a-certificate-for-a-domain)
+5. [Automating DNS Challenges](#automating-dns-challenges)
+6. [Managing Certificates](#managing-certificates)
+7. [Environmental Considerations](#environmental-considerations)
+8. [Complete Example](#complete-example)
+
+### Setting Up Your Project
+
+Ensure your project includes the necessary TypeScript configuration and dependencies. You'll need to have TypeScript installed and configured for ECMAScript Modules. If you are new to TypeScript, review its [documentation](https://www.typescriptlang.org/docs/) to get started.
+
+### Creating a SmartAcme Instance
+
+Start by importing the `SmartAcme` class and any built-in handlers you plan to use. For example, to use DNS-01 via Cloudflare:
+
+```typescript
+import { SmartAcme } from '@push.rocks/smartacme';
+import * as cloudflare from '@apiclient.xyz/cloudflare';
+import { Dns01Handler } from '@push.rocks/smartacme/ts/handlers/Dns01Handler.js';
+
+// Create a Cloudflare account client with your API token
+const cfAccount = new cloudflare.CloudflareAccount('YOUR_CF_TOKEN');
+
+// Instantiate SmartAcme with one or more ACME challenge handlers
+const smartAcmeInstance = new SmartAcme({
+  accountEmail: 'youremail@example.com',
+  mongoDescriptor: {
+    mongoDbUrl: 'mongodb://yourmongoURL',
+    mongoDbName: 'yourDbName',
+    mongoDbPass: 'yourDbPassword',
+  },
+  environment: 'integration', // 'production' to request real certificates
+  retryOptions: {},         // optional retry/backoff settings
+  challengeHandlers: [
+    new Dns01Handler(cfAccount),
+    // you can add more handlers, e.g. Http01Webroot
+  ],
+  challengePriority: ['dns-01'], // optional ordering of challenge types
+});
+```
+
+### Initializing SmartAcme
+
+Before proceeding to request certificates, start your SmartAcme instance:
+
+```typescript
+await smartAcmeInstance.start();
+```
+
+### Obtaining a Certificate for a Domain
+
+To obtain a certificate for a specific domain, use the `getCertificateForDomain` method. This function ensures that if a valid certificate is already present, it will be reused; otherwise, a new certificate is obtained:
+
+```typescript
+const myDomain = 'example.com';
+const myCert = await smartAcmeInstance.getCertificateForDomain(myDomain);
+console.log('Certificate:', myCert);
+```
+
+### Automating DNS Challenges
+
+SmartAcme uses pluggable ACME challenge handlers (see built-in handlers below) to automate domain validation. You configure handlers via the `challengeHandlers` array when creating the instance, and SmartAcme will invoke each handler’s `prepare`, optional `verify`, and `cleanup` methods during the ACME order flow.
+
+### Managing Certificates
+
+The library automatically handles fetching, renewing, and storing your certificates in a MongoDB database specified in your configuration. Ensure your MongoDB instance is accessible and properly configured for use with SmartAcme.
+
+```typescript
+const mongoDescriptor = {
+  mongoDbUrl: 'mongodb://yourmongoURL',
+  mongoDbName: 'yourDbName',
+  mongoDbPass: 'yourDbPassword',
+};
+```
+
+### Environmental Considerations
+
+When creating an instance of `SmartAcme`, you can specify an `environment` option. This is particularly useful for testing, as you can use the `integration` environment to avoid hitting rate limits and for testing your setup without issuing real certificates. Switch to `production` when you are ready to obtain actual certificates.
+
+### Complete Example
+
+Below is a complete example demonstrating how to use `@push.rocks/smartacme` to obtain and manage an ACME certificate with Let's Encrypt using a DNS-01 handler:
+
+```typescript
+import { SmartAcme } from '@push.rocks/smartacme';
+import * as cloudflare from '@apiclient.xyz/cloudflare';
+import { Qenv } from '@push.rocks/qenv';
+
+const qenv = new Qenv('./', './.nogit/');
+const cloudflareAccount = new cloudflare.CloudflareAccount(qenv.getEnvVarOnDemand('CF_TOKEN'));
+
+async function main() {
+  const smartAcmeInstance = new SmartAcme({
+    accountEmail: 'youremail@example.com',
+    mongoDescriptor: {
+      mongoDbUrl: qenv.getEnvVarRequired('MONGODB_URL'),
+      mongoDbName: qenv.getEnvVarRequired('MONGODB_DATABASE'),
+      mongoDbPass: qenv.getEnvVarRequired('MONGODB_PASSWORD'),
+    },
+    environment: 'integration',
+    challengeHandlers: [ new Dns01Handler(cloudflareAccount) ],
+  });
+
+  await smartAcmeInstance.start();
+
+  const myDomain = 'example.com';
+  const myCert = await smartAcmeInstance.getCertificateForDomain(myDomain);
+  console.log('Certificate:', myCert);
+
+  await smartAcmeInstance.stop();
+}
+
+ main().catch(console.error);
+ ```
+ 
+ ## Built-in Challenge Handlers
+ 
+ This module includes three out-of-the-box ACME challenge handlers:
+ 
+ - **Dns01Handler**
+   - Uses a Cloudflare account (from `@apiclient.xyz/cloudflare`) and Smartdns client to set and remove DNS TXT records, then wait for propagation.
+   - Import path:
+     ```typescript
+     import { Dns01Handler } from '@push.rocks/smartacme/ts/handlers/Dns01Handler.js';
+     ```
+   - Example:
+     ```typescript
+     import * as cloudflare from '@apiclient.xyz/cloudflare';
+     const cfAccount = new cloudflare.CloudflareAccount('CF_TOKEN');
+     const dnsHandler = new Dns01Handler(cfAccount);
+     ```
+ 
+ - **Http01Webroot**
+   - Writes ACME HTTP-01 challenge files under a file-system webroot (`/.well-known/acme-challenge/`), and removes them on cleanup.
+   - Import path:
+     ```typescript
+     import { Http01Webroot } from '@push.rocks/smartacme/ts/handlers/Http01Handler.js';
+     ```
+   - Example:
+     ```typescript
+     const httpHandler = new Http01Webroot({ webroot: '/var/www/html' });
+     ```
+ 
+ - **Http01MemoryHandler**
+   - In-memory HTTP-01 challenge handler that stores and serves ACME tokens without disk I/O.
+   - Import path:
+     ```typescript
+     import { Http01MemoryHandler } from '@push.rocks/smartacme/ts/handlers/Http01MemoryHandler.js';
+     ```
+   - Example (Express integration):
+     ```typescript
+     import { Http01MemoryHandler } from '@push.rocks/smartacme/ts/handlers/Http01MemoryHandler.js';
+     const memoryHandler = new Http01MemoryHandler();
+     app.use((req, res, next) => memoryHandler.handleRequest(req, res, next));
+     ```
+  
+ All handlers implement the `IChallengeHandler<T>` interface and can be combined in the `challengeHandlers` array.
+ 
+ ## Creating Custom Handlers
+ 
+ To support additional challenge types or custom validation flows, implement the `IChallengeHandler<T>` interface:
+ 
+ ```typescript
+ import type { IChallengeHandler } from '@push.rocks/smartacme/ts/handlers/IChallengeHandler.js';
+ 
+ // Define your custom challenge payload type
+ interface MyChallenge { type: string; /* ... */ }
+ 
+ class MyCustomHandler implements IChallengeHandler<MyChallenge> {
+   getSupportedTypes(): string[] {
+     return ['my-01'];
+   }
+ 
+   // Prepare the challenge (set DNS records, start servers, etc.)
+   async prepare(ch: MyChallenge): Promise<void> {
+     // preparation logic
+   }
+ 
+   // Optional verify step after prepare
+   async verify?(ch: MyChallenge): Promise<void> {
+     // verification logic
+   }
+ 
+   // Cleanup after challenge (remove records, stop servers)
+   async cleanup(ch: MyChallenge): Promise<void> {
+     // cleanup logic
+   }
+ }
+ 
+ // Then register your handler:
+ const customInstance = new SmartAcme({
+   /* other options */, 
+   challengeHandlers: [ new MyCustomHandler() ],
+   challengePriority: ['my-01'],
+ });
+
+In this example, `Qenv` is used to manage environment variables, and `cloudflare` library is used to handle DNS challenges required by Let's Encrypt ACME protocol. The `setChallenge` and `removeChallenge` methods are essential for automating the DNS challenge process, which is a key part of domain validation.
+
+## Additional Details
+
+### Certificate Object
+
+The certificate object obtained from the `getCertificateForDomain` method has the following properties:
+
+- `id`: Unique identifier for the certificate.
+- `domainName`: The domain name for which the certificate is issued.
+- `created`: Timestamp of when the certificate was created.
+- `privateKey`: The private key associated with the certificate.
+- `publicKey`: The public key or certificate itself.
+- `csr`: Certificate Signing Request (CSR) used to obtain the certificate.
+- `validUntil`: Timestamp indicating the expiration date of the certificate.
+
+### Methods Summary
+
+- **start()**: Initializes the SmartAcme instance, sets up the ACME client, and registers the account with Let's Encrypt.
+- **stop()**: Closes the MongoDB connection and performs any necessary cleanup.
+- **getCertificateForDomain(domainArg: string)**: Retrieves or obtains a certificate for the specified domain name. If a valid certificate exists in the database, it is returned. Otherwise, a new certificate is requested and stored.
+- **setChallenge(dnsChallenge: any)**: Automates the process of setting DNS challenge records.
+- **removeChallenge(dnsChallenge: any)**: Automates the process of removing DNS challenge records.
+
+### Handling Domain Matching
+
+The `SmartacmeCertMatcher` class is responsible for matching certificates with the broadest scope for wildcard certificates. The `getCertificateDomainNameByDomainName` method ensures that domains at various levels are correctly matched.
+
+```typescript
+import { SmartacmeCertMatcher } from '@push.rocks/smartacme';
+
+const certMatcher = new SmartacmeCertMatcher();
+const certDomainName = certMatcher.getCertificateDomainNameByDomainName('subdomain.example.com');
+console.log('Certificate Domain Name:', certDomainName); // Output: example.com
+```
+
+### Testing
+
+Automated tests can be added to ensure that the setup and functions work as expected. Using a testing framework such as `tap` and mock services for DNS providers (e.g., Cloudflare), you can simulate the process of obtaining and managing certificates without the need for actual domain ownership.
+
+```typescript
+import { tap, expect } from '@push.rocks/tapbundle';
+import { Qenv } from '@push.rocks/qenv';
+import * as cloudflare from '@apiclient.xyz/cloudflare';
+import * as smartacme from '@push.rocks/smartacme';
+
+const testQenv = new Qenv('./', './.nogit/');
+const testCloudflare = new cloudflare.CloudflareAccount(testQenv.getEnvVarOnDemand('CF_TOKEN'));
+
+let smartAcmeInstance: smartacme.SmartAcme;
+
+tap.test('should create a valid instance of SmartAcme', async () => {
+  smartAcmeInstance = new smartacme.SmartAcme({
+    accountEmail: 'domains@lossless.org',
+    accountPrivateKey: null,
+    mongoDescriptor: {
+      mongoDbName: testQenv.getEnvVarRequired('MONGODB_DATABASE'),
+      mongoDbPass: testQenv.getEnvVarRequired('MONGODB_PASSWORD'),
+      mongoDbUrl: testQenv.getEnvVarRequired('MONGODB_URL'),
+    },
+    setChallenge: async (dnsChallenge) => {
+      await testCloudflare.convenience.acmeSetDnsChallenge(dnsChallenge);
+    },
+    removeChallenge: async (dnsChallenge) => {
+      await testCloudflare.convenience.acmeRemoveDnsChallenge(dnsChallenge);
+    },
+    environment: 'integration',
+  });
+  await smartAcmeInstance.init();
+  expect(smartAcmeInstance).toBeInstanceOf(smartacme.SmartAcme);
+});
+
+tap.test('should get a domain certificate', async () => {
+  const certificate = await smartAcmeInstance.getCertificateForDomain('example.com');
+  console.log('Certificate:', certificate);
+  expect(certificate).toHaveProperty('domainName', 'example.com');
+});
+
+tap.test('certmatcher should correctly match domains', async () => {
+  const certMatcher = new smartacme.SmartacmeCertMatcher();
+  const matchedCert = certMatcher.getCertificateDomainNameByDomainName('subdomain.example.com');
+  expect(matchedCert).toBe('example.com');
+});
+
+tap.test('should stop correctly', async () => {
+  await smartAcmeInstance.stop();
+  expect(smartAcmeInstance).toHaveProperty('client', null);
+});
+
+tap.start();
+```
+
+This comprehensive guide ensures you can set up, manage, and test ACME certificates efficiently and effectively using `@push.rocks/smartacme`.
+
+---
+
+## License and Legal Information
+
+This repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license.md](license.md) file within this repository.
+
+**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.
+
+### Trademarks
+
+This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.
+
+### Company Information
+
+Task Venture Capital GmbH
+Registered at District court Bremen HRB 35230 HB, Germany
+
+For any legal inquiries or if you require further information, please contact us via email at hello@task.vc.
+
+By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.
--- a/readme.plan.md
+++ b/readme.plan.md
@ -0,0 +1,44 @@
+# Plan: Diskless HTTP-01 Handler and Renaming Existing Handler
+
+This plan outlines steps to rename the existing filesystem-based HTTP-01 handler to `Http01Webroot`
+and introduce a new diskless (in-memory) HTTP-01 handler for integration with arbitrary HTTP servers
+(e.g., Express).
+
+## 1. Rename existing handler to Http01Webroot
+- In `ts/handlers/Http01Handler.ts`:
+  - Rename `Http01HandlerOptions` to `Http01WebrootOptions`.
+  - Rename class `Http01Handler` to `Http01Webroot`.
+  - Remove the legacy alias; rename the handler directly.
+  - In `ts/handlers/index.ts`:
+    - Export `Http01Webroot` under its new name.
+    - Remove any `Http01Handler` export.
+    - Update existing tests (e.g., `test.handlers-http01.ts`) to import `Http01Webroot` instead of `Http01Handler`.
+
+## 2. Add new diskless (in-memory) HTTP-01 handler
+- Create `ts/handlers/Http01MemoryHandler.ts`:
+  - Implement `IChallengeHandler<{ token: string; keyAuthorization: string; webPath: string }>`, storing challenges in a private `Map<string, string>`.
+  - `prepare()`: add token→keyAuthorization mapping.
+  - `verify()`: no-op.
+  - `cleanup()`: remove mapping.
+  - Add `handleRequest(req, res, next?)` method:
+    - Parse `/.well-known/acme-challenge/:token` from `req.url`.
+    - If token exists, respond with the key authorization and status 200.
+    - If missing and `next` provided, call `next()`, otherwise respond 404.
+- Export `Http01MemoryHandler` in `ts/handlers/index.ts`.
+
+## 3. Write tests for Http01MemoryHandler
+- Create `test/test.handlers-http01-memory.ts`:
+  - Use `tap` and `expect` to:
+    1. `prepare()` a challenge.
+    2. Invoke `handleRequest()` with a fake `req`/`res` to confirm 200 and correct body.
+    3. `cleanup()` the challenge.
+    4. Confirm `handleRequest()` now yields 404.
+
+## 4. Update documentation
+- Add examples in `readme.md` showing how to use both `Http01Webroot` and the new `Http01MemoryHandler`:
+  - Sample code for Express integration using `handleRequest`.
+
+## 5. Build and test
+- Run `pnpm build` and `pnpm test`, ensuring existing tests are updated for `Http01Webroot` and new tests pass.
+
+Please review and let me know if this plan makes sense before proceeding with implementation.
--- a/test/test.certmatcher.ts
+++ b/test/test.certmatcher.ts
@ -0,0 +1,21 @@
+import { tap, expect } from '@push.rocks/tapbundle';
+import { SmartacmeCertMatcher } from '../ts/smartacme.classes.certmatcher.js';
+
+tap.test('should match 2-level domain', async () => {
+  const matcher = new SmartacmeCertMatcher();
+  expect(matcher.getCertificateDomainNameByDomainName('example.com')).toEqual('example.com');
+});
+
+tap.test('should match 3-level domain', async () => {
+  const matcher = new SmartacmeCertMatcher();
+  expect(matcher.getCertificateDomainNameByDomainName('subdomain.example.com')).toEqual('example.com');
+});
+
+tap.test('should return undefined for deeper domain', async () => {
+  const matcher = new SmartacmeCertMatcher();
+  // domain with 4 or more levels
+  const result = matcher.getCertificateDomainNameByDomainName('a.b.example.com');
+  expect(result).toEqual(undefined);
+});
+
+export default tap.start();
--- a/test/test.handlers-dns01.ts
+++ b/test/test.handlers-dns01.ts
@ -0,0 +1,38 @@
+import { tap, expect } from '@push.rocks/tapbundle';
+import { Dns01Handler } from '../ts/handlers/Dns01Handler.js';
+
+tap.test('Dns01Handler prepare and cleanup calls Cloudflare and DNS functions', async () => {
+  let setCalled = false;
+  let removeCalled = false;
+  // fake Cloudflare API
+  const fakeCF: any = {
+    convenience: {
+      acmeSetDnsChallenge: async (ch: any) => {
+        setCalled = true;
+        expect(ch).toHaveProperty('hostName');
+        expect(ch).toHaveProperty('challenge');
+      },
+      acmeRemoveDnsChallenge: async (ch: any) => {
+        removeCalled = true;
+        expect(ch).toHaveProperty('hostName');
+        expect(ch).toHaveProperty('challenge');
+      },
+    },
+  };
+  // fake DNS checker
+  const fakeDNS: any = {
+    checkUntilAvailable: async (host: string, rr: string, val: string, count: number, interval: number) => {
+      expect(host).toEqual('test.host');
+      expect(rr).toEqual('TXT');
+      expect(val).toEqual('token');
+    },
+  };
+  const handler = new Dns01Handler(fakeCF, fakeDNS);
+  const input = { hostName: 'test.host', challenge: 'token' };
+  await handler.prepare(input);
+  expect(setCalled).toEqual(true);
+  await handler.cleanup(input);
+  expect(removeCalled).toEqual(true);
+});
+
+export default tap.start();
--- a/test/test.handlers-http01-memory.ts
+++ b/test/test.handlers-http01-memory.ts
@ -0,0 +1,58 @@
+import { tap, expect } from '@push.rocks/tapbundle';
+import { Http01MemoryHandler } from '../ts/handlers/Http01MemoryHandler.js';
+
+tap.test('Http01MemoryHandler serves in-memory challenges and cleans up', async () => {
+  const handler = new Http01MemoryHandler();
+  const token = 'testtoken';
+  const keyAuth = 'keyAuthValue';
+  const webPath = `/.well-known/acme-challenge/${token}`;
+  const challenge = { type: 'http-01', token, keyAuthorization: keyAuth, webPath };
+
+  // Prepare challenge (store in memory)
+  await handler.prepare(challenge);
+
+  // Serve existing challenge without next()
+  const req1: any = { url: webPath };
+  const res1: any = {
+    statusCode: 0,
+    headers: {} as Record<string, string>,
+    body: '',
+    setHeader(name: string, value: string) { this.headers[name] = value; },
+    end(body?: string) { this.body = body || ''; },
+  };
+  handler.handleRequest(req1, res1);
+  expect(res1.statusCode).toEqual(200);
+  expect(res1.body).toEqual(keyAuth);
+  expect(res1.headers['content-type']).toEqual('text/plain');
+
+  // Cleanup challenge (remove from memory)
+  await handler.cleanup(challenge);
+
+  // Serve after cleanup without next() should give 404
+  const req2: any = { url: webPath };
+  const res2: any = {
+    statusCode: 0,
+    headers: {} as Record<string, string>,
+    body: '',
+    setHeader(name: string, value: string) { this.headers[name] = value; },
+    end(body?: string) { this.body = body || ''; },
+  };
+  handler.handleRequest(req2, res2);
+  expect(res2.statusCode).toEqual(404);
+
+  // Serve after cleanup with next() should call next
+  const req3: any = { url: webPath };
+  let nextCalled = false;
+  const next = () => { nextCalled = true; };
+  const res3: any = {
+    statusCode: 0,
+    headers: {} as Record<string, string>,
+    body: '',
+    setHeader(name: string, value: string) { this.headers[name] = value; },
+    end(body?: string) { this.body = body || ''; },
+  };
+  handler.handleRequest(req3, res3, next);
+  expect(nextCalled).toEqual(true);
+});
+
+export default tap.start();
--- a/test/test.handlers-http01.ts
+++ b/test/test.handlers-http01.ts
@ -0,0 +1,26 @@
+import { tap, expect } from '@push.rocks/tapbundle';
+import { Http01Webroot } from '../ts/handlers/Http01Handler.js';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import os from 'os';
+
+tap.test('Http01Webroot writes challenge file and removes it on cleanup', async () => {
+  // create temporary webroot directory
+  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'http01-'));
+  const handler = new Http01Webroot({ webroot: tmpDir });
+  const token = 'testtoken';
+  const keyAuth = 'keyAuthValue';
+  const webPath = `/.well-known/acme-challenge/${token}`;
+  const input = { type: 'http-01', token, keyAuthorization: keyAuth, webPath };
+  // prepare should write the file
+  await handler.prepare(input);
+  const filePath = path.join(tmpDir, webPath);
+  const content = await fs.readFile(filePath, 'utf8');
+  expect(content).toEqual(keyAuth);
+  // cleanup should remove the file
+  await handler.cleanup(input);
+  const exists = await fs.stat(filePath).then(() => true).catch(() => false);
+  expect(exists).toEqual(false);
+});
+
+export default tap.start();
--- a/test/test.smartacme.integration.ts
+++ b/test/test.smartacme.integration.ts
@ -0,0 +1,47 @@
+import { tap, expect } from '@push.rocks/tapbundle';
+import { Qenv } from '@push.rocks/qenv';
+import * as cloudflare from '@apiclient.xyz/cloudflare';
+import { SmartAcme } from '../ts/index.js';
+import { Dns01Handler } from '../ts/handlers/Dns01Handler.js';
+
+// Load environment variables for credentials (stored under .nogit/)
+const testQenv = new Qenv('./', './.nogit/');
+// Cloudflare API token for DNS-01 challenge (must be set in .nogit/ or env)
+const cfToken = (await testQenv.getEnvVarOnDemand('CF_TOKEN'))!;
+const cfAccount = new cloudflare.CloudflareAccount(cfToken);
+// MongoDB connection settings for certificate storage (must be set in .nogit/ or env)
+const mongoDbName = (await testQenv.getEnvVarOnDemand('MONGODB_DATABASE'))!;
+const mongoDbPass = (await testQenv.getEnvVarOnDemand('MONGODB_PASSWORD'))!;
+const mongoDbUrl = (await testQenv.getEnvVarOnDemand('MONGODB_URL'))!;
+
+let smartAcmeInstance: SmartAcme;
+
+tap.test('create SmartAcme instance with DNS-01 handler and start', async () => {
+  smartAcmeInstance = new SmartAcme({
+    accountEmail: 'domains@lossless.org',
+    mongoDescriptor: { mongoDbName, mongoDbPass, mongoDbUrl },
+    environment: 'integration',
+    retryOptions: {},
+    challengeHandlers: [new Dns01Handler(cfAccount)],
+    challengePriority: ['dns-01'],
+  });
+  await smartAcmeInstance.start();
+  expect(smartAcmeInstance).toBeInstanceOf(SmartAcme);
+});
+
+tap.test('get a domain certificate via DNS-01 challenge', async () => {
+  // Replace 'bleu.de' with your test domain if different
+  const domain = 'bleu.de';
+  const cert = await smartAcmeInstance.getCertificateForDomain(domain);
+  expect(cert).toHaveProperty('domainName');
+  expect(cert.domainName).toEqual(domain);
+  expect(cert).toHaveProperty('publicKey');
+  expect(typeof cert.publicKey).toEqual('string');
+  expect(cert.publicKey.length).toBeGreaterThan(0);
+});
+
+tap.test('stop SmartAcme instance', async () => {
+  await smartAcmeInstance.stop();
+});
+
+export default tap.start();
--- a/test/test.smartacme.ts
+++ b/test/test.smartacme.ts
@ -0,0 +1,32 @@
+import { tap, expect } from '@push.rocks/tapbundle';
+import { SmartAcme } from '../ts/index.js';
+import type { IChallengeHandler } from '../ts/handlers/IChallengeHandler.js';
+
+// Dummy handler for testing
+class DummyHandler implements IChallengeHandler<any> {
+  getSupportedTypes(): string[] { return ['dns-01']; }
+  async prepare(_: any): Promise<void> { /* no-op */ }
+  async cleanup(_: any): Promise<void> { /* no-op */ }
+}
+
+tap.test('constructor throws without challengeHandlers', async () => {
+  expect(() => new SmartAcme({
+    accountEmail: 'test@example.com',
+    mongoDescriptor: { mongoDbName: 'db', mongoDbPass: 'pass', mongoDbUrl: 'url' },
+    environment: 'integration',
+    retryOptions: {},
+  } as any)).toThrow();
+});
+
+tap.test('constructor accepts valid challengeHandlers', async () => {
+  const sa = new SmartAcme({
+    accountEmail: 'test@example.com',
+    mongoDescriptor: { mongoDbName: 'db', mongoDbPass: 'pass', mongoDbUrl: 'url' },
+    environment: 'integration',
+    retryOptions: {},
+    challengeHandlers: [new DummyHandler()],
+  });
+  expect(sa).toBeInstanceOf(SmartAcme);
+});
+
+export default tap.start();
--- a/test/test.ts
+++ b/test/test.ts
@ -1,33 +0,0 @@
-import { tap, expect } from '@pushrocks/tapbundle';
-import { Qenv } from '@pushrocks/qenv';
-
-const testQenv = new Qenv('./', './.nogit/');
-
-import * as smartacme from '../ts/index';
-
-let smartAcmeInstance: smartacme.SmartAcme;
-
-tap.test('should create a valid instance of SmartAcme', async () => {
-  smartAcmeInstance = new smartacme.SmartAcme({
-    accountEmail: 'domains@lossless.org',
-    accountPrivateKey: null,
-    mongoDescriptor: {
-      mongoDbName: testQenv.getEnvVarOnDemand('MONGODB_DATABASE'),
-      mongoDbPass: testQenv.getEnvVarOnDemand('MONGODB_PASSWORD'),
-      mongoDbUrl: testQenv.getEnvVarOnDemand('MONGODB_URL')
-    },
-    removeChallenge: async (...args) => {
-      console.log(args);
-    },
-    setChallenge: async (...args) => {
-      console.log(args);
-    },
-    validateRemoteRequest: async () => {
-      return true;
-    }
-  });
-  await smartAcmeInstance.init();
-  // await smartAcmeInstance.getCertificateForDomain('bleu.de');
-});
-
-tap.start();
--- 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: '@push.rocks/smartacme',
+  version: '6.2.0',
+  description: 'A TypeScript-based ACME client for LetsEncrypt certificate management with a focus on simplicity and power.'
+}
--- a/ts/handlers/Dns01Handler.ts
+++ b/ts/handlers/Dns01Handler.ts
@ -0,0 +1,44 @@
+import * as plugins from '../smartacme.plugins.js';
+import type { IChallengeHandler } from './IChallengeHandler.js';
+
+/**
+ * DNS-01 challenge handler using CloudflareAccount and Smartdns.
+ */
+export class Dns01Handler implements IChallengeHandler<plugins.tsclass.network.IDnsChallenge> {
+  private cf: plugins.tsclass.network.IConvenientDnsProvider;
+  private smartdns: plugins.smartdnsClient.Smartdns;
+
+  constructor(
+    convenientDnsProvider: plugins.tsclass.network.IConvenientDnsProvider,
+    smartdnsInstance?: plugins.smartdnsClient.Smartdns,
+  ) {
+    this.cf = convenientDnsProvider;
+    this.smartdns = smartdnsInstance ?? new plugins.smartdnsClient.Smartdns({});
+  }
+
+  public getSupportedTypes(): string[] {
+    return ['dns-01'];
+  }
+
+  public async prepare(ch: plugins.tsclass.network.IDnsChallenge): Promise<void> {
+    // set DNS TXT record
+    await this.cf.convenience.acmeSetDnsChallenge(ch);
+    // wait for DNS propagation
+    await this.smartdns.checkUntilAvailable(
+      ch.hostName,
+      'TXT',
+      ch.challenge,
+      100,
+      5000,
+    );
+  }
+
+  public async cleanup(ch: plugins.tsclass.network.IDnsChallenge): Promise<void> {
+    // remove DNS TXT record
+    await this.cf.convenience.acmeRemoveDnsChallenge(ch);
+  }
+
+  public async checkWetherDomainIsSupported(domainArg: string): Promise<boolean> {
+    return this.cf.convenience.isDomainSupported(domainArg);
+  }
+}
--- a/ts/handlers/Http01Handler.ts
+++ b/ts/handlers/Http01Handler.ts
@ -0,0 +1,54 @@
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import type { IChallengeHandler } from './IChallengeHandler.js';
+
+/**
+ * HTTP-01 ACME challenge handler using file-system webroot.
+ * Writes and removes the challenge file under <webroot>/.well-known/acme-challenge/. 
+ */
+export interface Http01WebrootOptions {
+  /**
+   * Directory that serves HTTP requests for /.well-known/acme-challenge
+   */
+  webroot: string;
+}
+
+export class Http01Webroot implements IChallengeHandler<{
+  type: string;
+  token: string;
+  keyAuthorization: string;
+  webPath: string;
+}> {
+  private webroot: string;
+
+  constructor(options: Http01WebrootOptions) {
+    this.webroot = options.webroot;
+  }
+
+  public getSupportedTypes(): string[] {
+    return ['http-01'];
+  }
+
+  public async prepare(ch: { token: string; keyAuthorization: string; webPath: string }): Promise<void> {
+    const relWebPath = ch.webPath.replace(/^\/+/, '');
+    const filePath = path.join(this.webroot, relWebPath);
+    const dir = path.dirname(filePath);
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(filePath, ch.keyAuthorization, 'utf8');
+  }
+
+  public async verify(ch: { webPath: string; keyAuthorization: string }): Promise<void> {
+    // Optional: implement HTTP polling if desired
+    return;
+  }
+
+  public async cleanup(ch: { token: string; webPath: string }): Promise<void> {
+    const relWebPath = ch.webPath.replace(/^\/+/, '');
+    const filePath = path.join(this.webroot, relWebPath);
+    try {
+      await fs.unlink(filePath);
+    } catch {
+      // ignore missing file
+    }
+  }
+}
--- a/ts/handlers/Http01MemoryHandler.ts
+++ b/ts/handlers/Http01MemoryHandler.ts
@ -0,0 +1,67 @@
+import type { IChallengeHandler } from './IChallengeHandler.js';
+
+/**
+ * HTTP-01 ACME challenge handler using in-memory storage.
+ * Stores challenge tokens and key authorizations in memory
+ * and serves them via handleRequest for arbitrary HTTP servers.
+ */
+export interface Http01MemoryHandlerChallenge {
+  type: string;
+  token: string;
+  keyAuthorization: string;
+  webPath: string;
+}
+
+export class Http01MemoryHandler implements IChallengeHandler<Http01MemoryHandlerChallenge> {
+  private store: Map<string, string> = new Map();
+
+  public getSupportedTypes(): string[] {
+    return ['http-01'];
+  }
+
+  public async prepare(ch: Http01MemoryHandlerChallenge): Promise<void> {
+    this.store.set(ch.token, ch.keyAuthorization);
+  }
+
+  public async verify(_ch: Http01MemoryHandlerChallenge): Promise<void> {
+    // No-op
+    return;
+  }
+
+  public async cleanup(ch: Http01MemoryHandlerChallenge): Promise<void> {
+    this.store.delete(ch.token);
+  }
+
+  /**
+   * HTTP request handler for serving ACME HTTP-01 challenges.
+   * @param req HTTP request object (should have url property)
+   * @param res HTTP response object
+   * @param next Optional next() callback for Express-style fallthrough
+   */
+  public handleRequest(req: any, res: any, next?: () => void): void {
+    const url = req.url || '';
+    const prefix = '/.well-known/acme-challenge/';
+    if (!url.startsWith(prefix)) {
+      if (next) {
+        return next();
+      }
+      res.statusCode = 404;
+      return res.end();
+    }
+    const token = url.slice(prefix.length);
+    const keyAuth = this.store.get(token);
+    if (keyAuth !== undefined) {
+      if (typeof res.status === 'function' && typeof res.send === 'function') {
+        return res.status(200).send(keyAuth);
+      }
+      res.statusCode = 200;
+      res.setHeader('content-type', 'text/plain');
+      return res.end(keyAuth);
+    }
+    if (next) {
+      return next();
+    }
+    res.statusCode = 404;
+    return res.end();
+  }
+}
--- a/ts/handlers/IChallengeHandler.ts
+++ b/ts/handlers/IChallengeHandler.ts
@ -0,0 +1,22 @@
+/**
+ * Pluggable interface for ACME challenge handlers.
+ * Supports DNS-01, HTTP-01, TLS-ALPN-01, or custom challenge types.
+ */
+export interface IChallengeHandler<T> {
+  /**
+   * ACME challenge types this handler supports (e.g. ['dns-01']).
+   */
+  getSupportedTypes(): string[];
+  /**
+   * Prepare the challenge: set DNS record, start HTTP/TLS server, etc.
+   */
+  prepare(ch: T): Promise<void>;
+  /**
+   * Optional extra verify step (HTTP GET, ALPN handshake).
+   */
+  verify?(ch: T): Promise<void>;
+  /**
+   * Clean up resources: remove DNS record, stop server.
+   */
+  cleanup(ch: T): Promise<void>;
+}
--- a/ts/handlers/index.ts
+++ b/ts/handlers/index.ts
@ -0,0 +1,5 @@
+export type { IChallengeHandler } from './IChallengeHandler.js';
+// Removed legacy handler adapter
+export { Dns01Handler } from './Dns01Handler.js';
+export { Http01Webroot } from './Http01Handler.js';
+export { Http01MemoryHandler } from './Http01MemoryHandler.js';
--- a/ts/index.ts
+++ b/ts/index.ts
@ -1,3 +1,2 @@
-export * from './smartacme.classes.smartacme';
-
-export * from './smartacme.classes.certremoteclient';
+export * from './smartacme.classes.smartacme.js';
+export { SmartacmeCert as Cert } from './smartacme.classes.cert.js';
--- a/ts/interfaces/cert.ts
+++ b/ts/interfaces/cert.ts
@ -1,9 +0,0 @@
-export type TCertStatus = 'existing' | 'nonexisting' | 'pending' | 'failed';
-
-export interface ICert {
-  domainName: string;
-  created: number;
-  privateKey: string;
-  publicKey: string;
-  csr: string;
-}
--- a/ts/interfaces/certremote.ts
+++ b/ts/interfaces/certremote.ts
@ -1,11 +0,0 @@
-import { ICert, TCertStatus } from './cert';
-
-export interface ICertRemoteRequest {
-  secret: string;
-  domainName: string;
-}
-
-export interface ICertRemoteResponse {
-  status: TCertStatus;
-  certificate?: ICert;
-}
--- a/ts/interfaces/index.ts
+++ b/ts/interfaces/index.ts
@ -1,3 +1 @@
-export * from './accountdata';
-export * from './cert';
-export * from './certremote';
+export * from './accountdata.js';
--- a/ts/smartacme.classes.cert.ts
+++ b/ts/smartacme.classes.cert.ts
@ -1,18 +1,20 @@
-import * as plugins from './smartacme.plugins';
+import * as plugins from './smartacme.plugins.js';

-import * as interfaces from './interfaces';
+import * as interfaces from './interfaces/index.js';

-import { CertManager } from './smartacme.classes.certmanager';
+import { SmartacmeCertManager } from './smartacme.classes.certmanager.js';

-import { Collection, svDb, unI } from '@pushrocks/smartdata';
-import { ICert } from './interfaces';
+import { Collection, svDb, unI } from '@push.rocks/smartdata';

@plugins.smartdata.Collection(() => {
-  return CertManager.activeDB;
+  return SmartacmeCertManager.activeDB;
 })
-export class Cert extends plugins.smartdata.SmartDataDbDoc<Cert> implements interfaces.ICert {
+export class SmartacmeCert
+  extends plugins.smartdata.SmartDataDbDoc<SmartacmeCert, plugins.tsclass.network.ICert>
+  implements plugins.tsclass.network.ICert
+{
  @unI()
-  public index: string;
+  public id: string;

  @svDb()
  public domainName: string;
@ -29,12 +31,34 @@ export class Cert extends plugins.smartdata.SmartDataDbDoc<Cert> implements inte
  @svDb()
  public csr: string;

-  constructor(optionsArg: ICert) {
+  @svDb()
+  public validUntil: number;
+
+  public isStillValid(): boolean {
+    return this.validUntil >= Date.now();
+  }
+
+  public shouldBeRenewed(): boolean {
+    const shouldBeValidAtLeastUntil =
+      Date.now() +
+      plugins.smarttime.getMilliSecondsFromUnits({
+        days: 10,
+      });
+    return !(this.validUntil >= shouldBeValidAtLeastUntil);
+  }
+
+  public update(certDataArg: plugins.tsclass.network.ICert) {
+    Object.keys(certDataArg).forEach((key) => {
+      this[key] = certDataArg[key];
+    });
+  }
+
+  constructor(optionsArg: plugins.tsclass.network.ICert) {
    super();
-    this.created = optionsArg.created;
-    this.domainName = optionsArg.domainName;
-    this.privateKey = optionsArg.privateKey;
-    this.publicKey = optionsArg.publicKey;
-    this.csr = optionsArg.csr;
+    if (optionsArg) {
+      Object.keys(optionsArg).forEach((key) => {
+        this[key] = optionsArg[key];
+      });
+    }
  }
 }
--- a/ts/smartacme.classes.certmanager.ts
+++ b/ts/smartacme.classes.certmanager.ts
@ -1,29 +1,29 @@
-import * as plugins from './smartacme.plugins';
-import { Cert } from './smartacme.classes.cert';
-import { SmartAcme } from './smartacme.classes.smartacme';
+import * as plugins from './smartacme.plugins.js';
+import { SmartacmeCert } from './smartacme.classes.cert.js';
+import { SmartAcme } from './smartacme.classes.smartacme.js';

-import * as interfaces from './interfaces';
-import { ICert } from './interfaces';
+import * as interfaces from './interfaces/index.js';

-
-export class CertManager {
+export class SmartacmeCertManager {
  // =========
  // STATIC
  // =========
  public static activeDB: plugins.smartdata.SmartdataDb;

-  
  // =========
  // INSTANCE
  // =========
  private mongoDescriptor: plugins.smartdata.IMongoDescriptor;
  public smartdataDb: plugins.smartdata.SmartdataDb;

-  public pendingMap: plugins.lik.Stringmap;
+  public interestMap: plugins.lik.InterestMap<string, SmartacmeCert>;

-  constructor(smartAcmeArg: SmartAcme,optionsArg: {
+  constructor(
+    smartAcmeArg: SmartAcme,
+    optionsArg: {
      mongoDescriptor: plugins.smartdata.IMongoDescriptor;
-  }) {
+    },
+  ) {
    this.mongoDescriptor = optionsArg.mongoDescriptor;
  }

@ -31,21 +31,20 @@ export class CertManager {
    // Smartdata DB
    this.smartdataDb = new plugins.smartdata.SmartdataDb(this.mongoDescriptor);
    await this.smartdataDb.init();
-    CertManager.activeDB = this.smartdataDb;
+    SmartacmeCertManager.activeDB = this.smartdataDb;

    // Pending Map
-    this.pendingMap = new plugins.lik.Stringmap();
-  };
+    this.interestMap = new plugins.lik.InterestMap((certName) => certName);
+  }

  /**
   * retrieves a certificate
   * @returns the Cert class or null
-   * @param domainName the domain Name to retrieve the vcertificate for
+   * @param certDomainNameArg the domain Name to retrieve the vcertificate for
   */
-  public async retrieveCertificate(domainName: string): Promise<Cert> {
-    await this.checkCerts();
-    const existingCertificate: Cert = await Cert.getInstance({
-      name: domainName
+  public async retrieveCertificate(certDomainNameArg: string): Promise<SmartacmeCert> {
+    const existingCertificate: SmartacmeCert = await SmartacmeCert.getInstance<SmartacmeCert>({
+      domainName: certDomainNameArg,
    });

    if (existingCertificate) {
@ -53,41 +52,26 @@ export class CertManager {
    } else {
      return null;
    }
-
  }

  /**
-   * stores the certificate with the 
-   * @param publicKeyArg 
-   * @param privateKeyArg 
-   * @param csrArg 
+   * stores the certificate
+   * @param optionsArg
   */
-  public async storeCertificate(optionsArg: ICert) {
-    const cert = new Cert(optionsArg);
-    cert.save();
-  };
-
-  public async deleteCertificate(domainNameArg: string) {
-
+  public async storeCertificate(optionsArg: plugins.tsclass.network.ICert) {
+    const cert = new SmartacmeCert(optionsArg);
+    await cert.save();
+    const interest = this.interestMap.findInterest(cert.domainName);
+    if (interest) {
+      interest.fullfillInterest(cert);
+      interest.markLost();
+    }
  }

-  public async getCertificateStatus(domainNameArg: string): Promise<interfaces.TCertStatus> {
-    const isPending = this.pendingMap.checkString('domainNameArg');
-    if (isPending) {
-      return 'pending';
+  public async deleteCertificate(certDomainNameArg: string) {
+    const cert: SmartacmeCert = await SmartacmeCert.getInstance<SmartacmeCert>({
+      domainName: certDomainNameArg,
+    });
+    await cert.delete();
  }
-
-    // otherwise lets continue
-    const existingCertificate = this.retrieveCertificate(domainNameArg);
-    if (existingCertificate) {
-      return 'existing';
-    }
-
-    return 'nonexisting';
-  }
-
-  /**
-   * checks all certs for expiration
-   */
-  private async checkCerts() {};
 }
--- a/ts/smartacme.classes.certmatcher.ts
+++ b/ts/smartacme.classes.certmatcher.ts
@ -0,0 +1,19 @@
+import * as plugins from './smartacme.plugins.js';
+import * as interfaces from './interfaces/index.js';
+
+/**
+ * certmatcher is responsible for matching certificates
+ */
+export class SmartacmeCertMatcher {
+  /**
+   * creates a domainName for the certificate that will include the broadest scope
+   * for wild card certificates
+   * @param domainNameArg the domainNameArg to create the scope from
+   */
+  public getCertificateDomainNameByDomainName(domainNameArg: string): string {
+    const originalDomain = new plugins.smartstring.Domain(domainNameArg);
+    if (!originalDomain.level4) {
+      return `${originalDomain.level2}.${originalDomain.level1}`;
+    }
+  }
+}
--- a/ts/smartacme.classes.certremoteclient.ts
+++ b/ts/smartacme.classes.certremoteclient.ts
@ -1,47 +0,0 @@
-import * as plugins from './smartacme.plugins';
-import * as interfaces from './interfaces';
-import { ICertRemoteResponse } from './interfaces';
-
-// tslint:disable-next-line: max-classes-per-file
-export class CertRemoteClient {
-  private remoteUrl: string;
-  private secret: string;
-
-  constructor(optionsArg: {
-    remoteUrl: string;
-    secret: string;
-  }) {
-    this.remoteUrl = optionsArg.remoteUrl;
-    this.secret = optionsArg.secret;
-  }
-
-  /**
-   * 
-   * @param domainNameArg 
-   */
-  async getCertificateForDomain(domainNameArg: string): Promise<interfaces.ICert> {
-    let certificate: interfaces.ICert;
-    const doRequestCycle = async (): Promise<interfaces.ICert> => {
-      const response: ICertRemoteResponse = (await plugins.smartrequest.postJson(this.remoteUrl, {
-        requestBody: <interfaces.ICertRemoteRequest>{
-          domainName: domainNameArg,
-          secret: this.secret
-        }
-      })).body;
-      switch(response.status) {
-        case 'pending':
-          await plugins.smartdelay.delayFor(5000);
-          const finalResponse = await doRequestCycle();
-          return finalResponse;
-        case 'existing':
-          return response.certificate;
-        case 'failed':
-        default:
-          console.log(`could not retrieve certificate for ${domainNameArg}`);
-          return null;
-      }
-    };
-    certificate = await doRequestCycle();
-    return certificate;
-  }
-}
--- a/ts/smartacme.classes.smartacme.ts
+++ b/ts/smartacme.classes.smartacme.ts
@ -1,24 +1,45 @@
-import * as plugins from './smartacme.plugins';
-import { CertManager } from './smartacme.classes.certmanager';
-
-import * as interfaces from './interfaces';
-import { request } from 'http';
+import * as plugins from './smartacme.plugins.js';
+import { SmartacmeCert } from './smartacme.classes.cert.js';
+import { SmartacmeCertManager } from './smartacme.classes.certmanager.js';
+import { SmartacmeCertMatcher } from './smartacme.classes.certmatcher.js';
+import { commitinfo } from './00_commitinfo_data.js';

 /**
- *
+ * the options for the class @see SmartAcme
 */
 export interface ISmartAcmeOptions {
  accountPrivateKey?: string;
  accountEmail: string;
  mongoDescriptor: plugins.smartdata.IMongoDescriptor;
-  setChallenge: (domainName: string, keyAuthorization: string) => Promise<any>;
-  removeChallenge: (domainName: string) => Promise<any>;
-  validateRemoteRequest: () => Promise<boolean>;
+  // Removed legacy setChallenge/removeChallenge in favor of `challengeHandlers`
+  environment: 'production' | 'integration';
+  /**
+   * Optional retry/backoff configuration for transient failures
+   */
+  retryOptions?: {
+    /** number of retry attempts */
+    retries?: number;
+    /** backoff multiplier */
+    factor?: number;
+    /** initial delay in milliseconds */
+    minTimeoutMs?: number;
+    /** maximum delay cap in milliseconds */
+    maxTimeoutMs?: number;
+  };
+  /**
+   * Pluggable ACME challenge handlers (DNS-01, HTTP-01, TLS-ALPN-01, etc.)
+   */
+  challengeHandlers?: plugins.handlers.IChallengeHandler<any>[];
+  /**
+   * Order of challenge types to try (e.g. ['http-01','dns-01']).
+   * Defaults to ['dns-01'] or first supported type from handlers.
+   */
+  challengePriority?: string[];
 }

 /**
- * The main SmartAcme class
- * can be used setting up communication with an ACME authority
+ * class SmartAcme
+ * can be used for setting up communication with an ACME authority
 *
 * ```ts
 * const mySmartAcmeInstance = new SmartAcme({
@ -30,162 +51,283 @@ export class SmartAcme {
  private options: ISmartAcmeOptions;

  // the acme client
-  private client: any;
-  private smartdns = new plugins.smartdns.Smartdns();
+  private client: plugins.acme.Client;
+  private smartdns = new plugins.smartdnsClient.Smartdns({});
+  public logger: plugins.smartlog.Smartlog;

  // the account private key
  private privateKey: string;

-  // challenge fullfillment
-  private setChallenge: (domainName: string, keyAuthorization: string) => Promise<any>;
-  private removeChallenge: (domainName: string) => Promise<any>;
-  private validateRemoteRequest: () => Promise<boolean>;

  // certmanager
-  private certmanager: CertManager;
-  private certremoteHandler: plugins.smartexpress.Handler;
+  private certmanager: SmartacmeCertManager;
+  private certmatcher: SmartacmeCertMatcher;
+  // retry/backoff configuration (resolved with defaults)
+  private retryOptions: { retries: number; factor: number; minTimeoutMs: number; maxTimeoutMs: number };
+  // track pending DNS challenges for graceful shutdown
+  private pendingChallenges: plugins.tsclass.network.IDnsChallenge[] = [];
+  // configured pluggable ACME challenge handlers
+  private challengeHandlers: plugins.handlers.IChallengeHandler<any>[];
+  // priority order of challenge types
+  private challengePriority: string[];

  constructor(optionsArg: ISmartAcmeOptions) {
    this.options = optionsArg;
+    this.logger = plugins.smartlog.Smartlog.createForCommitinfo(commitinfo);
+    // enable console output for structured logging
+    this.logger.enableConsole();
+    // initialize retry/backoff options
+    this.retryOptions = {
+      retries: optionsArg.retryOptions?.retries ?? 3,
+      factor: optionsArg.retryOptions?.factor ?? 2,
+      minTimeoutMs: optionsArg.retryOptions?.minTimeoutMs ?? 1000,
+      maxTimeoutMs: optionsArg.retryOptions?.maxTimeoutMs ?? 30000,
+    };
+    // initialize challenge handlers (must provide at least one)
+    if (!optionsArg.challengeHandlers || optionsArg.challengeHandlers.length === 0) {
+      throw new Error(
+        'You must provide at least one ACME challenge handler via options.challengeHandlers',
+      );
+    }
+    this.challengeHandlers = optionsArg.challengeHandlers;
+    // initialize challenge priority
+    this.challengePriority =
+      optionsArg.challengePriority && optionsArg.challengePriority.length > 0
+        ? optionsArg.challengePriority
+        : this.challengeHandlers.map((h) => h.getSupportedTypes()[0]);
  }

  /**
-   * inits the instance
+   * starts the instance
   * ```ts
-   * await myCloudlyInstance.init() // does not support options
+   * await myCloudlyInstance.start() // does not support options
   * ```
   */
-  public async init() {
+  public async start() {
    this.privateKey =
-      this.options.accountPrivateKey || (await plugins.acme.forge.createPrivateKey());
-    this.setChallenge = this.options.setChallenge;
-    this.removeChallenge = this.options.removeChallenge;
+      this.options.accountPrivateKey || (await plugins.acme.forge.createPrivateKey()).toString();

    // CertMangaer
-    this.certmanager = new CertManager(this, {
-      mongoDescriptor: this.options.mongoDescriptor
+    this.certmanager = new SmartacmeCertManager(this, {
+      mongoDescriptor: this.options.mongoDescriptor,
    });
    await this.certmanager.init();

-    // CertRemoteHandler
-    this.certremoteHandler = new plugins.smartexpress.Handler('POST', async (req, res) => {
-      const requestBody: interfaces.ICertRemoteRequest = req.body;
-      const status: interfaces.TCertStatus = await this.certmanager.getCertificateStatus(requestBody.domainName);
-      const existingCertificate = await this.certmanager.retrieveCertificate(
-        requestBody.domainName
-      );
-      let response: interfaces.ICertRemoteResponse;
-      switch (status) {
-         case 'existing':
-          response = {
-            status,
-            certificate: {
-              created: existingCertificate.created,
-              csr: existingCertificate.csr,
-              domainName: existingCertificate.domainName,
-              privateKey: existingCertificate.privateKey,
-              publicKey: existingCertificate.publicKey
-            }
-          };
-          break;
-        default:
-          response = {
-            status
-          };
-          break;
-      }
-      res.status(200);
-      res.send(response);
-      res.end();
-    });
+    // CertMatcher
+    this.certmatcher = new SmartacmeCertMatcher();

    // ACME Client
    this.client = new plugins.acme.Client({
-      directoryUrl: plugins.acme.directory.letsencrypt.staging,
-      accountKey: this.privateKey
+      directoryUrl: (() => {
+        if (this.options.environment === 'production') {
+          return plugins.acme.directory.letsencrypt.production;
+        } else {
+          return plugins.acme.directory.letsencrypt.staging;
+        }
+      })(),
+      accountKey: this.privateKey,
    });

    /* Register account */
    await this.client.createAccount({
      termsOfServiceAgreed: true,
-      contact: [`mailto:${this.options.accountEmail}`]
+      contact: [`mailto:${this.options.accountEmail}`],
+    });
+    // Setup graceful shutdown handlers
+    process.on('SIGINT', () => this.handleSignal('SIGINT'));
+    process.on('SIGTERM', () => this.handleSignal('SIGTERM'));
+  }
+
+    public async stop() {
+      await this.certmanager.smartdataDb.close();
+    }
+    /** Retry helper with exponential backoff */
+    private async retry<T>(operation: () => Promise<T>, operationName: string = 'operation'): Promise<T> {
+      let attempt = 0;
+      let delay = this.retryOptions.minTimeoutMs;
+      while (true) {
+        try {
+          return await operation();
+        } catch (err) {
+          attempt++;
+          if (attempt > this.retryOptions.retries) {
+            await this.logger.log('error', `Operation ${operationName} failed after ${attempt} attempts`, err);
+            throw err;
+          }
+          await this.logger.log('warn', `Operation ${operationName} failed on attempt ${attempt}, retrying in ${delay}ms`, err);
+          await plugins.smartdelay.delayFor(delay);
+          delay = Math.min(delay * this.retryOptions.factor, this.retryOptions.maxTimeoutMs);
+        }
+      }
+    }
+    /** Clean up pending challenges and shut down */
+    private async handleShutdown(): Promise<void> {
+      for (const input of [...this.pendingChallenges]) {
+        const type: string = (input as any).type;
+        const handler = this.challengeHandlers.find((h) => h.getSupportedTypes().includes(type));
+        if (handler) {
+          try {
+            await handler.cleanup(input);
+            await this.logger.log('info', `Removed pending ${type} challenge during shutdown`, input);
+          } catch (err) {
+            await this.logger.log('error', `Failed to remove pending ${type} challenge during shutdown`, err);
+          }
+        } else {
+          await this.logger.log(
+            'warn',
+            `No handler for pending challenge type '${type}' during shutdown; skipping cleanup`,
+            input,
+          );
+        }
+      }
+      this.pendingChallenges = [];
+      await this.stop();
+    }
+    /** Handle process signals for graceful shutdown */
+    private handleSignal(sig: string): void {
+      this.logger.log('info', `Received signal ${sig}, shutting down gracefully`);
+      this.handleShutdown()
+        .then(() => process.exit(0))
+        .catch((err) => {
+          this.logger.log('error', 'Error during shutdown', err).then(() => process.exit(1));
        });
    }

-  public async stop() {};
+  /**
+   * gets a certificate
+   * it runs through the following steps
+   *
+   * * look in the database
+   * * if in the database and still valid return it
+   * * if not in the database announce it
+   * * then get it from letsencrypt
+   * * store it
+   * * remove it from the pending map (which it go onto by announcing it)
+   * * retrieve it from the databse and return it
+   *
+   * @param domainArg
+   */
+  public async getCertificateForDomain(domainArg: string): Promise<SmartacmeCert> {
+    const certDomainName = this.certmatcher.getCertificateDomainNameByDomainName(domainArg);
+    const retrievedCertificate = await this.certmanager.retrieveCertificate(certDomainName);

-  public async getCertificateForDomain(domainArg: string) {
-    const domain = domainArg;
-
-    const retrievedCertificate = await this.certmanager.retrieveCertificate(domain);
-
-    if (retrievedCertificate) {
+    if (
+      !retrievedCertificate &&
+      (await this.certmanager.interestMap.checkInterest(certDomainName))
+    ) {
+      const existingCertificateInterest = this.certmanager.interestMap.findInterest(certDomainName);
+      const certificate = existingCertificateInterest.interestFullfilled;
+      return certificate;
+    } else if (retrievedCertificate && !retrievedCertificate.shouldBeRenewed()) {
      return retrievedCertificate;
+    } else if (retrievedCertificate && retrievedCertificate.shouldBeRenewed()) {
+      await retrievedCertificate.delete();
    }

-    /* Place new order */
-    const order = await this.client.createOrder({
-      identifiers: [{ type: 'dns', value: domain }, { type: 'dns', value: `*.${domain}` }]
-    });
+    // lets make sure others get the same interest
+    const currentDomainInterst = await this.certmanager.interestMap.addInterest(certDomainName);
+
+    /* Place new order with retry */
+    const order = await this.retry(() => this.client.createOrder({
+      identifiers: [
+        { type: 'dns', value: certDomainName },
+        { type: 'dns', value: `*.${certDomainName}` },
+      ],
+    }), 'createOrder');

    /* Get authorizations and select challenges */
-    const authorizations = await this.client.getAuthorizations(order);
+    const authorizations = await this.retry(() => this.client.getAuthorizations(order), 'getAuthorizations');

    for (const authz of authorizations) {
-      console.log(authz);
-      const domainDnsName: string = `_acme-challenge.${authz.identifier.value}`;
-      const dnsChallenge: string = authz.challenges.find(challengeArg => {
-        return challengeArg.type === 'dns-01';
-      });
-      // process.exit(1);
-      const keyAuthorization: string = await this.client.getChallengeKeyAuthorization(dnsChallenge);
-
+      await this.logger.log('debug', 'Authorization received', authz);
+      // select a handler based on configured priority
+      let selectedHandler: { type: string; handler: plugins.handlers.IChallengeHandler<any> } | null = null;
+      let selectedChallengeArg: any = null;
+      for (const type of this.challengePriority) {
+        const candidate = authz.challenges.find((c: any) => c.type === type);
+        if (!candidate) continue;
+        const handler = this.challengeHandlers.find((h) => h.getSupportedTypes().includes(type));
+        if (handler) {
+          selectedHandler = { type, handler };
+          selectedChallengeArg = candidate;
+          break;
+        }
+      }
+      if (!selectedHandler) {
+        throw new Error(`No challenge handler for domain ${authz.identifier.value}: supported types [${this.challengePriority.join(',')}]`);
+      }
+      const { type, handler } = selectedHandler;
+      // build handler input with keyAuthorization
+      let input: any;
+      // retrieve keyAuthorization for challenge
+      const keyAuth = await this.client.getChallengeKeyAuthorization(selectedChallengeArg);
+      if (type === 'dns-01') {
+        input = { type, hostName: `_acme-challenge.${authz.identifier.value}`, challenge: keyAuth };
+      } else if (type === 'http-01') {
+        // HTTP-01 requires serving token at webPath
+        input = {
+          type,
+          token: (selectedChallengeArg as any).token,
+          keyAuthorization: keyAuth,
+          webPath: `/.well-known/acme-challenge/${(selectedChallengeArg as any).token}`,
+        };
+      } else {
+        // generic challenge input: include raw challenge properties
+        input = { type, keyAuthorization: keyAuth, ...selectedChallengeArg };
+      }
+      this.pendingChallenges.push(input);
      try {
-        /* Satisfy challenge */
-        await this.setChallenge(domainDnsName, keyAuthorization);
-        await this.smartdns.checkUntilAvailable(domainDnsName, 'TXT', keyAuthorization, 100, 5000);
-
-        /* Verify that challenge is satisfied */
-        await this.client.verifyChallenge(authz, dnsChallenge);
-
-        /* Notify ACME provider that challenge is satisfied */
-        await this.client.completeChallenge(dnsChallenge);
-
-        /* Wait for ACME provider to respond with valid status */
-        await this.client.waitForValidStatus(dnsChallenge);
+        await this.retry(() => handler.prepare(input), `${type}.prepare`);
+        if (handler.verify) {
+          await this.retry(() => handler.verify!(input), `${type}.verify`);
+        } else {
+          await this.retry(() => this.client.verifyChallenge(authz, selectedChallengeArg), `${type}.verifyChallenge`);
+        }
+        await this.retry(() => this.client.completeChallenge(selectedChallengeArg), `${type}.completeChallenge`);
+        await this.retry(() => this.client.waitForValidStatus(selectedChallengeArg), `${type}.waitForValidStatus`);
      } finally {
-        /* Clean up challenge response */
        try {
-          await this.removeChallenge(domainDnsName);
-        } catch (e) {
-          console.log(e);
+          await this.retry(() => handler.cleanup(input), `${type}.cleanup`);
+        } catch (err) {
+          await this.logger.log('error', `Error during ${type}.cleanup`, err);
+        } finally {
+          this.pendingChallenges = this.pendingChallenges.filter((c) => c !== input);
        }
      }
    }

    /* Finalize order */
    const [key, csr] = await plugins.acme.forge.createCsr({
-      commonName: `*.${domain}`,
-      altNames: [domain]
+      commonName: `*.${certDomainName}`,
+      altNames: [certDomainName],
    });

-    await this.client.finalizeOrder(order, csr);
-    const cert = await this.client.getCertificate(order);
+    await this.retry(() => this.client.finalizeOrder(order, csr), 'finalizeOrder');
+    const cert = await this.retry(() => this.client.getCertificate(order), 'getCertificate');

    /* Done */
-    console.log(`CSR:\n${csr.toString()}`);
-    console.log(`Private key:\n${key.toString()}`);
-    console.log(`Certificate:\n${cert.toString()}`);

    await this.certmanager.storeCertificate({
-      domainName: domainArg,
+      id: plugins.smartunique.shortId(),
+      domainName: certDomainName,
      privateKey: key.toString(),
      publicKey: cert.toString(),
      csr: csr.toString(),
-      created: Date.now()
+      created: Date.now(),
+      validUntil:
+        Date.now() +
+        plugins.smarttime.getMilliSecondsFromUnits({
+          days: 90,
+        }),
    });

-    const newCertificate = await this.certmanager.retrieveCertificate(domainArg);
+    const newCertificate = await this.certmanager.retrieveCertificate(certDomainName);
+    currentDomainInterst.fullfillInterest(newCertificate);
+    currentDomainInterst.destroy();
    return newCertificate;
  }
+
+  public async getAllCertificates(): Promise<SmartacmeCert[]> {
+    return SmartacmeCert.getInstances({});
+  }
 }
--- a/ts/smartacme.plugins.ts
+++ b/ts/smartacme.plugins.ts
@ -1,17 +1,47 @@
+// @apiclient.xyz scope
+import * as cloudflare from '@apiclient.xyz/cloudflare';
+
+export { cloudflare };
+
+// @apiglobal scope
+import * as typedserver from '@api.global/typedserver';
+
+export { typedserver };
+
 // @pushrocks scope
-import * as lik from '@pushrocks/lik';
-import * as smartdata from '@pushrocks/smartdata';
-import * as smartdelay from '@pushrocks/smartdelay';
-import * as smartdns from '@pushrocks/smartdns';
-import * as smartexpress from '@pushrocks/smartexpress';
-import * as smartpromise from '@pushrocks/smartpromise';
-import * as smartrequest from '@pushrocks/smartrequest';
-import * as smartunique from '@pushrocks/smartunique';
-import * as smarttime from '@pushrocks/smarttime';
+import * as lik from '@push.rocks/lik';
+import * as smartdata from '@push.rocks/smartdata';
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartdnsClient from '@push.rocks/smartdns/client';
+import * as smartlog from '@push.rocks/smartlog';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartrequest from '@push.rocks/smartrequest';
+import * as smartunique from '@push.rocks/smartunique';
+import * as smartstring from '@push.rocks/smartstring';
+import * as smarttime from '@push.rocks/smarttime';

-export { lik, smartdata, smartdelay, smartdns, smartexpress, smartpromise, smartrequest, smartunique, smarttime };
+export {
+  lik,
+  smartdata,
+  smartdelay,
+  smartdnsClient,
+  smartlog,
+  smartpromise,
+  smartrequest,
+  smartunique,
+  smartstring,
+  smarttime,
+};

-// thirs party scope
+// @tsclass scope
+import * as tsclass from '@tsclass/tsclass';
+
+export { tsclass };
+
+// third party scope
 import * as acme from 'acme-client';

 export { acme };
+// local handlers for challenge types
+import * as handlers from './handlers/index.js';
+export { handlers };
--- a/tsconfig.json
+++ b/tsconfig.json
@ -1,7 +1,22 @@
 {
  "compilerOptions": {
    "experimentalDecorators": true,
-    "target": "es2017",
-    "module": "commonjs"
-  }
+    "emitDecoratorMetadata": true,
+    "useDefineForClassFields": false,
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "verbatimModuleSyntax": true,
+    "baseUrl": ".",
+    "paths": {}
+  },
+  "include": [
+    "ts/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "test",
+    "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	6a53346d14	6.2.0 Some checks failed Default (tags) / security (push) Successful in 37s Details Default (tags) / test (push) Failing after 54s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-04-30 14:55:03 +00:00
Philipp Kunz	fc420eb615	feat(handlers): Add in-memory HTTP-01 challenge handler and rename file-based handler to Http01Webroot	2025-04-30 14:55:03 +00:00
Philipp Kunz	9f66a0487f	6.1.3 Some checks failed Default (tags) / security (push) Successful in 36s Details Default (tags) / test (push) Failing after 53s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-04-30 12:59:20 +00:00
Philipp Kunz	40cae220d0	fix(Dns01Handler): Update dependency versions and refine Dns01Handler implementation	2025-04-30 12:59:20 +00:00
Philipp Kunz	f7dccb25e4	6.1.2 Some checks failed Default (tags) / security (push) Successful in 22s Details Default (tags) / test (push) Failing after 51s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-04-27 14:51:22 +00:00
Philipp Kunz	da75c52c09	fix(repo): Update repository metadata by replacing the LICENSE file with a license.md file for improved consistency.	2025-04-27 14:51:22 +00:00
Philipp Kunz	708145c550	6.1.1 Some checks failed Default (tags) / security (push) Successful in 32s Details Default (tags) / test (push) Failing after 51s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-04-27 14:50:28 +00:00
Philipp Kunz	0de2178eb5	fix(readme): Fix license link reference in documentation	2025-04-27 14:50:28 +00:00
Philipp Kunz	5183d88b69	6.1.0 Some checks failed Default (tags) / security (push) Successful in 38s Details Default (tags) / test (push) Failing after 50s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-04-27 14:39:59 +00:00
Philipp Kunz	d5e7e11256	feat(readme): Update documentation with detailed built-in challenge handlers and custom handler examples	2025-04-27 14:39:59 +00:00
Philipp Kunz	916ac9ff8c	6.0.1	2025-04-27 14:30:53 +00:00
Philipp Kunz	b7005f360c	fix(readme): Remove extraneous code fence markers from license section in readme	2025-04-27 14:30:53 +00:00
Philipp Kunz	49f5d344a4	6.0.0	2025-04-27 14:28:06 +00:00
Philipp Kunz	58015f0b58	BREAKING CHANGE(SmartAcme): Refactor challenge handling by removing legacy setChallenge/removeChallenge in favor of pluggable challengeHandlers and update documentation and tests accordingly	2025-04-27 14:28:05 +00:00
Philipp Kunz	48018b8955	5.1.0	2025-04-27 13:21:41 +00:00
Philipp Kunz	56a440660b	feat(smartacme): Implement exponential backoff retry logic and graceful shutdown handling in SmartAcme; update acme-client dependency to v5.4.0	2025-04-27 13:21:41 +00:00
Philipp Kunz	82bfc20a6d	5.0.1	2025-04-26 12:48:38 +00:00
Philipp Kunz	b84714b208	fix(build): Update CI workflows, bump dependency versions, and refine import and TypeScript configuration	2025-04-26 12:48:38 +00:00
Philipp Kunz	6425e4a93f	5.0.0	2024-06-16 13:56:31 +02:00
Philipp Kunz	55fa1215ae	BREAKING CHANGE(structure): renamed classes to avoid confusion	2024-06-16 13:56:30 +02:00
Philipp Kunz	3769468b01	update description	2024-05-29 14:11:35 +02:00
Philipp Kunz	6ea919780c	update tsconfig	2024-04-14 17:18:13 +02:00
Philipp Kunz	b5afe8e842	update npmextra.json: githost	2024-04-01 21:33:37 +02:00
Philipp Kunz	942e444d41	update npmextra.json: githost	2024-04-01 19:57:35 +02:00
Philipp Kunz	1ab15c0b72	update npmextra.json: githost	2024-03-30 21:46:32 +01:00
Philipp Kunz	f1db9c1c5d	4.0.8	2024-01-28 16:08:33 +01:00
Philipp Kunz	e3974b3bb1	fix(core): update	2024-01-28 16:08:32 +01:00
Philipp Kunz	016b93ea3a	4.0.7	2024-01-28 02:50:42 +01:00
Philipp Kunz	ab870af0bb	fix(core): update	2024-01-28 02:50:41 +01:00
Philipp Kunz	8cda69b3c2	4.0.6	2023-07-21 19:01:26 +02:00
Philipp Kunz	3641d75e2f	fix(core): update	2023-07-21 19:01:26 +02:00
Philipp Kunz	fd343c1558	4.0.5	2023-07-21 18:59:18 +02:00
Philipp Kunz	76650ac199	fix(core): update	2023-07-21 18:59:17 +02:00
Philipp Kunz	d9ba5f20b1	4.0.4	2023-07-21 18:49:19 +02:00
Philipp Kunz	941923e90f	fix(core): update	2023-07-21 18:49:18 +02:00
Philipp Kunz	e38b4c1215	switch to new org scheme	2023-07-11 00:09:13 +02:00
Philipp Kunz	d405bf63a3	switch to new org scheme	2023-07-10 02:41:58 +02:00
Philipp Kunz	737f5bf5cc	4.0.3	2023-01-06 14:08:18 +01:00
Philipp Kunz	149cdf67bb	fix(core): update	2023-01-06 14:08:18 +01:00
Philipp Kunz	c35ff8d711	4.0.2	2022-09-27 19:55:38 +02:00
Philipp Kunz	f2bd9b65aa	fix(core): update	2022-09-27 19:55:38 +02:00
Philipp Kunz	018a25ba6a	4.0.1	2022-09-27 15:44:06 +02:00
Philipp Kunz	3c052df1e7	fix(core): update	2022-09-27 15:44:06 +02:00
Philipp Kunz	17c85eb8b9	4.0.0	2022-09-27 15:40:55 +02:00
Philipp Kunz	2bcb31e4d6	BREAKING CHANGE(core): update	2022-09-27 15:40:55 +02:00
Phil Kunz	70aef3fe7e	3.0.15	2021-01-22 23:43:22 +00:00
Phil Kunz	734bde4a98	fix(core): update	2021-01-22 23:43:21 +00:00
Phil Kunz	c7d9a42feb	3.0.14	2021-01-22 23:32:34 +00:00
Phil Kunz	f20bc72abb	fix(core): update	2021-01-22 23:32:34 +00:00
Phil Kunz	cd2cfce683	3.0.13	2021-01-22 22:59:28 +00:00
Phil Kunz	44ab180474	fix(core): update	2021-01-22 22:59:27 +00:00
Phil Kunz	15557dfdd6	3.0.12	2021-01-22 20:31:56 +00:00
Phil Kunz	488f616d34	fix(core): update	2021-01-22 20:31:55 +00:00
Phil Kunz	e920406ce9	3.0.11	2021-01-22 18:47:02 +00:00
Phil Kunz	e044fd81bd	fix(core): update	2021-01-22 18:47:01 +00:00
Phil Kunz	edaccc357d	3.0.10	2021-01-22 18:33:53 +00:00
Phil Kunz	67f645ad50	fix(core): update	2021-01-22 18:33:53 +00:00
Phil Kunz	bfeced5f34	3.0.9	2020-11-18 16:52:50 +00:00
Phil Kunz	24b9794a18	fix(core): update	2020-11-18 16:52:49 +00:00
Phil Kunz	a781329a47	3.0.8	2020-08-13 03:10:38 +00:00
Phil Kunz	6b5e0a1207	fix(core): update	2020-08-13 03:10:37 +00:00
Phil Kunz	2455adfbca	3.0.7	2020-08-12 16:36:06 +00:00
Phil Kunz	a2cf86b62f	fix(core): update	2020-08-12 16:36:06 +00:00
Phil Kunz	7277906851	3.0.6	2020-05-17 16:21:26 +00:00
Phil Kunz	9da9ebb01e	fix(core): update	2020-05-17 16:21:25 +00:00
Phil Kunz	f70684b773	3.0.5	2020-02-21 10:48:09 +00:00
Phil Kunz	8b19b206a4	fix(core): update	2020-02-21 10:48:08 +00:00
Phil Kunz	6be2866ddd	3.0.4	2020-02-19 19:17:59 +00:00
Phil Kunz	ab55d3c91a	fix(core): update	2020-02-19 19:17:58 +00:00
Phil Kunz	c7ee7eb774	3.0.3	2020-02-19 18:48:50 +00:00
Phil Kunz	02daa13a2f	fix(core): update	2020-02-19 18:48:49 +00:00
Phil Kunz	28944b1100	3.0.2	2020-02-10 20:36:02 +00:00
Phil Kunz	7ec04d6d3d	fix(core): update	2020-02-10 20:36:01 +00:00
Phil Kunz	595d4d8894	3.0.1	2020-02-10 20:16:50 +00:00
Phil Kunz	04ed28f7d1	fix(core): update	2020-02-10 20:16:49 +00:00
Phil Kunz	6c95cec709	3.0.0	2020-02-10 20:13:07 +00:00
Phil Kunz	59173b3ca8	BREAKING CHANGE(core): streamline scope to certificate retrieval using dns challenge	2020-02-10 20:13:06 +00:00
Phil Kunz	c2036bba90	2.1.2	2020-02-10 11:15:48 +00:00
Phil Kunz	83afea95e6	fix(core): update	2020-02-10 11:15:47 +00:00
Phil Kunz	ac515f5e80	2.1.1	2020-01-19 11:09:32 +00:00
Phil Kunz	6abbf58b83	fix(core): update	2020-01-19 11:09:32 +00:00
Phil Kunz	9c25ecdc02	2.1.0	2019-02-06 14:37:01 +01:00
Phil Kunz	81a15da2d0	feat(Cert): now has validity check	2019-02-06 14:37:00 +01:00
Phil Kunz	86929251ba	update	2019-02-06 09:47:33 +01:00
Phil Kunz	1d8fb2b296	2.0.36	2019-01-18 01:35:00 +01:00
Phil Kunz	9d5f0d7a5d	fix(core): update	2019-01-18 01:34:59 +01:00
Phil Kunz	82b1d68576	2.0.35	2019-01-17 22:50:22 +01:00
Phil Kunz	e04b23aceb	fix(core): update	2019-01-17 22:50:21 +01:00
Phil Kunz	8e255938b5	2.0.34	2019-01-17 22:47:58 +01:00
Phil Kunz	f2eb9666a7	fix(core): update	2019-01-17 22:47:58 +01:00
Phil Kunz	cbdb0c8b08	2.0.33	2019-01-17 22:13:10 +01:00
Phil Kunz	f821f4d9cc	fix(core): update	2019-01-17 22:13:10 +01:00
Phil Kunz	6cfcf21d95	2.0.32	2019-01-17 01:15:22 +01:00
Phil Kunz	a33090bb5e	fix(core): update	2019-01-17 01:15:22 +01:00
Phil Kunz	3151829f85	2.0.31	2019-01-16 22:34:38 +01:00
Phil Kunz	eca63e588c	fix(core): update	2019-01-16 22:34:38 +01:00
Phil Kunz	9d23e205d8	2.0.30	2019-01-16 02:34:48 +01:00
Phil Kunz	5ecdf7c9fd	fix(core): update	2019-01-16 02:34:47 +01:00
Phil Kunz	2817a65e21	2.0.29	2019-01-15 23:59:21 +01:00
Phil Kunz	09a8bc5cb5	fix(core): update	2019-01-15 23:59:21 +01:00
Phil Kunz	a1134cf227	2.0.28	2019-01-15 23:39:31 +01:00
Phil Kunz	4ee1c4b08c	fix(core): update	2019-01-15 23:39:31 +01:00
Phil Kunz	08c3eaa65f	2.0.27	2019-01-14 02:46:36 +01:00
Phil Kunz	2717f08476	fix(core): update	2019-01-14 02:46:36 +01:00
Phil Kunz	f16dbeea32	2.0.26	2019-01-13 21:40:40 +01:00
Phil Kunz	a0c0230419	fix(core): update	2019-01-13 21:40:40 +01:00
Phil Kunz	0d1ebf2d1a	2.0.25	2019-01-13 19:40:32 +01:00
Phil Kunz	6edbf3cb46	fix(core): update	2019-01-13 19:40:32 +01:00
Phil Kunz	b26f7ac3e9	2.0.24	2019-01-13 19:15:04 +01:00
Phil Kunz	5129c5d601	fix(core): update	2019-01-13 19:15:03 +01:00
Phil Kunz	d09b3fd1bc	2.0.23	2019-01-13 02:11:56 +01:00
Phil Kunz	14fccd40d8	fix(core): update	2019-01-13 02:11:56 +01:00
Phil Kunz	c0f45a10e0	2.0.22	2019-01-13 02:10:00 +01:00
Phil Kunz	f9db3d28fe	fix(core): update	2019-01-13 02:10:00 +01:00
Phil Kunz	c3fd8750b2	2.0.21	2019-01-13 00:50:44 +01:00
Phil Kunz	2b3c28c7a1	fix(core): update	2019-01-13 00:50:43 +01:00
Phil Kunz	d6b1f942b3	2.0.20	2019-01-13 00:24:40 +01:00
Phil Kunz	7eff6ea36a	fix(core): update	2019-01-13 00:24:39 +01:00
Phil Kunz	1ef3615a49	2.0.19	2019-01-13 00:06:00 +01:00
Phil Kunz	3653cdc797	fix(core): update	2019-01-13 00:06:00 +01:00
Phil Kunz	c0271648fc	2.0.18	2019-01-12 21:06:29 +01:00
Phil Kunz	5546fa5f49	fix(core): update	2019-01-12 21:06:29 +01:00
Phil Kunz	54fe89860e	2.0.17	2019-01-12 19:12:53 +01:00
Phil Kunz	d1edf75f6f	fix(core): update	2019-01-12 19:12:52 +01:00
Phil Kunz	6f9c644221	2.0.16	2019-01-12 19:11:39 +01:00
Phil Kunz	0b26054687	fix(core): update	2019-01-12 19:11:39 +01:00