@push.rocks/smartacme 5.0.0 → 6.0.1

package/LICENSE

@@ -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

package/dist_ts/00_commitinfo_data.d.ts

@@ -1,5 +1,5 @@
 /**
- * autocreated commitinfo by @pushrocks/commitinfo
+ * autocreated commitinfo by @push.rocks/commitinfo
  */
 export declare const commitinfo: {
     name: string;

package/dist_ts/00_commitinfo_data.js

@@ -1,9 +1,9 @@
 /**
- * autocreated commitinfo by @pushrocks/commitinfo
+ * autocreated commitinfo by @push.rocks/commitinfo
  */
 export const commitinfo = {
     name: '@push.rocks/smartacme',
-    version: '5.0.0',
+    version: '6.0.1',
     description: 'A TypeScript-based ACME client for LetsEncrypt certificate management with a focus on simplicity and power.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx1QkFBdUI7SUFDN0IsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLDZHQUE2RztDQUMzSCxDQUFBIn0=

package/dist_ts/handlers/Dns01Handler.d.ts

@@ -0,0 +1,13 @@
+import * as plugins from '../smartacme.plugins.js';
+import type { IChallengeHandler } from './IChallengeHandler.js';
+/**
+ * DNS-01 challenge handler using CloudflareAccount and Smartdns.
+ */
+export declare class Dns01Handler implements IChallengeHandler<plugins.tsclass.network.IDnsChallenge> {
+    private cf;
+    private smartdns;
+    constructor(cloudflareAccount: any, smartdnsInstance?: plugins.smartdnsClient.Smartdns);
+    getSupportedTypes(): string[];
+    prepare(ch: plugins.tsclass.network.IDnsChallenge): Promise<void>;
+    cleanup(ch: plugins.tsclass.network.IDnsChallenge): Promise<void>;
+}

package/dist_ts/handlers/Dns01Handler.js

@@ -0,0 +1,24 @@
+import * as plugins from '../smartacme.plugins.js';
+/**
+ * DNS-01 challenge handler using CloudflareAccount and Smartdns.
+ */
+export class Dns01Handler {
+    constructor(cloudflareAccount, smartdnsInstance) {
+        this.cf = cloudflareAccount;
+        this.smartdns = smartdnsInstance ?? new plugins.smartdnsClient.Smartdns({});
+    }
+    getSupportedTypes() {
+        return ['dns-01'];
+    }
+    async prepare(ch) {
+        // 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);
+    }
+    async cleanup(ch) {
+        // remove DNS TXT record
+        await this.cf.convenience.acmeRemoveDnsChallenge(ch);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRG5zMDFIYW5kbGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvaGFuZGxlcnMvRG5zMDFIYW5kbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0seUJBQXlCLENBQUM7QUFHbkQ7O0dBRUc7QUFDSCxNQUFNLE9BQU8sWUFBWTtJQUl2QixZQUNFLGlCQUFzQixFQUN0QixnQkFBa0Q7UUFFbEQsSUFBSSxDQUFDLEVBQUUsR0FBRyxpQkFBaUIsQ0FBQztRQUM1QixJQUFJLENBQUMsUUFBUSxHQUFHLGdCQUFnQixJQUFJLElBQUksT0FBTyxDQUFDLGNBQWMsQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDOUUsQ0FBQztJQUVNLGlCQUFpQjtRQUN0QixPQUFPLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDcEIsQ0FBQztJQUVNLEtBQUssQ0FBQyxPQUFPLENBQUMsRUFBeUM7UUFDNUQscUJBQXFCO1FBQ3JCLE1BQU0sSUFBSSxDQUFDLEVBQUUsQ0FBQyxXQUFXLENBQUMsbUJBQW1CLENBQUMsRUFBRSxDQUFDLENBQUM7UUFDbEQsMkJBQTJCO1FBQzNCLE1BQU0sSUFBSSxDQUFDLFFBQVEsQ0FBQyxtQkFBbUIsQ0FDckMsRUFBRSxDQUFDLFFBQVEsRUFDWCxLQUFLLEVBQ0wsRUFBRSxDQUFDLFNBQVMsRUFDWixHQUFHLEVBQ0gsSUFBSSxDQUNMLENBQUM7SUFDSixDQUFDO0lBRU0sS0FBSyxDQUFDLE9BQU8sQ0FBQyxFQUF5QztRQUM1RCx3QkFBd0I7UUFDeEIsTUFBTSxJQUFJLENBQUMsRUFBRSxDQUFDLFdBQVcsQ0FBQyxzQkFBc0IsQ0FBQyxFQUFFLENBQUMsQ0FBQztJQUN2RCxDQUFDO0NBQ0YifQ==

package/dist_ts/handlers/Http01Handler.d.ts

@@ -0,0 +1,34 @@
+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 Http01HandlerOptions {
+    /**
+     * Directory that serves HTTP requests for /.well-known/acme-challenge
+     */
+    webroot: string;
+}
+export declare class Http01Handler implements IChallengeHandler<{
+    type: string;
+    token: string;
+    keyAuthorization: string;
+    webPath: string;
+}> {
+    private webroot;
+    constructor(options: Http01HandlerOptions);
+    getSupportedTypes(): string[];
+    prepare(ch: {
+        token: string;
+        keyAuthorization: string;
+        webPath: string;
+    }): Promise<void>;
+    verify(ch: {
+        webPath: string;
+        keyAuthorization: string;
+    }): Promise<void>;
+    cleanup(ch: {
+        token: string;
+        webPath: string;
+    }): Promise<void>;
+}

package/dist_ts/handlers/Http01Handler.js

@@ -0,0 +1,32 @@
+import { promises as fs } from 'fs';
+import * as path from 'path';
+export class Http01Handler {
+    constructor(options) {
+        this.webroot = options.webroot;
+    }
+    getSupportedTypes() {
+        return ['http-01'];
+    }
+    async prepare(ch) {
+        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');
+    }
+    async verify(ch) {
+        // Optional: implement HTTP polling if desired
+        return;
+    }
+    async cleanup(ch) {
+        const relWebPath = ch.webPath.replace(/^\/+/, '');
+        const filePath = path.join(this.webroot, relWebPath);
+        try {
+            await fs.unlink(filePath);
+        }
+        catch {
+            // ignore missing file
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSHR0cDAxSGFuZGxlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL2hhbmRsZXJzL0h0dHAwMUhhbmRsZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsSUFBSSxFQUFFLEVBQUUsTUFBTSxJQUFJLENBQUM7QUFDcEMsT0FBTyxLQUFLLElBQUksTUFBTSxNQUFNLENBQUM7QUFjN0IsTUFBTSxPQUFPLGFBQWE7SUFReEIsWUFBWSxPQUE2QjtRQUN2QyxJQUFJLENBQUMsT0FBTyxHQUFHLE9BQU8sQ0FBQyxPQUFPLENBQUM7SUFDakMsQ0FBQztJQUVNLGlCQUFpQjtRQUN0QixPQUFPLENBQUMsU0FBUyxDQUFDLENBQUM7SUFDckIsQ0FBQztJQUVNLEtBQUssQ0FBQyxPQUFPLENBQUMsRUFBZ0U7UUFDbkYsTUFBTSxVQUFVLEdBQUcsRUFBRSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsTUFBTSxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBQ2xELE1BQU0sUUFBUSxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxVQUFVLENBQUMsQ0FBQztRQUNyRCxNQUFNLEdBQUcsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBQ25DLE1BQU0sRUFBRSxDQUFDLEtBQUssQ0FBQyxHQUFHLEVBQUUsRUFBRSxTQUFTLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztRQUN6QyxNQUFNLEVBQUUsQ0FBQyxTQUFTLENBQUMsUUFBUSxFQUFFLEVBQUUsQ0FBQyxnQkFBZ0IsRUFBRSxNQUFNLENBQUMsQ0FBQztJQUM1RCxDQUFDO0lBRU0sS0FBSyxDQUFDLE1BQU0sQ0FBQyxFQUFpRDtRQUNuRSw4Q0FBOEM7UUFDOUMsT0FBTztJQUNULENBQUM7SUFFTSxLQUFLLENBQUMsT0FBTyxDQUFDLEVBQXNDO1FBQ3pELE1BQU0sVUFBVSxHQUFHLEVBQUUsQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLE1BQU0sRUFBRSxFQUFFLENBQUMsQ0FBQztRQUNsRCxNQUFNLFFBQVEsR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLEVBQUUsVUFBVSxDQUFDLENBQUM7UUFDckQsSUFBSSxDQUFDO1lBQ0gsTUFBTSxFQUFFLENBQUMsTUFBTSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBQzVCLENBQUM7UUFBQyxNQUFNLENBQUM7WUFDUCxzQkFBc0I7UUFDeEIsQ0FBQztJQUNILENBQUM7Q0FDRiJ9

package/dist_ts/handlers/IChallengeHandler.d.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>;
+}

package/dist_ts/handlers/IChallengeHandler.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSUNoYWxsZW5nZUhhbmRsZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9oYW5kbGVycy9JQ2hhbGxlbmdlSGFuZGxlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist_ts/handlers/index.d.ts

@@ -0,0 +1,3 @@
+export type { IChallengeHandler } from './IChallengeHandler.js';
+export { Dns01Handler } from './Dns01Handler.js';
+export { Http01Handler } from './Http01Handler.js';

package/dist_ts/handlers/index.js

@@ -0,0 +1,4 @@
+// Removed legacy handler adapter
+export { Dns01Handler } from './Dns01Handler.js';
+export { Http01Handler } from './Http01Handler.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9oYW5kbGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxpQ0FBaUM7QUFDakMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ2pELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQyJ9

package/dist_ts/smartacme.classes.smartacme.d.ts

@@ -7,9 +7,29 @@ export interface ISmartAcmeOptions {
     accountPrivateKey?: string;
     accountEmail: string;
     mongoDescriptor: plugins.smartdata.IMongoDescriptor;
-    setChallenge: (dnsChallengeArg: plugins.tsclass.network.IDnsChallenge) => Promise<any>;
-    removeChallenge: (dnsChallengeArg: plugins.tsclass.network.IDnsChallenge) => Promise<any>;
     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[];
 }
 /**
  * class SmartAcme
@@ -27,10 +47,12 @@ export declare class SmartAcme {
     private smartdns;
     logger: plugins.smartlog.Smartlog;
     private privateKey;
-    private setChallenge;
-    private removeChallenge;
     private certmanager;
     private certmatcher;
+    private retryOptions;
+    private pendingChallenges;
+    private challengeHandlers;
+    private challengePriority;
     constructor(optionsArg: ISmartAcmeOptions);
     /**
      * starts the instance
@@ -40,6 +62,12 @@ export declare class SmartAcme {
      */
     start(): Promise<void>;
     stop(): Promise<void>;
+    /** Retry helper with exponential backoff */
+    private retry;
+    /** Clean up pending challenges and shut down */
+    private handleShutdown;
+    /** Handle process signals for graceful shutdown */
+    private handleSignal;
     /**
      * gets a certificate
      * it runs through the following steps

package/dist_ts/smartacme.classes.smartacme.js

@@ -15,9 +15,30 @@ import { commitinfo } from './00_commitinfo_data.js';
  */
 export class SmartAcme {
     constructor(optionsArg) {
-        this.smartdns = new plugins.smartdns.Smartdns({});
+        this.smartdns = new plugins.smartdnsClient.Smartdns({});
+        // track pending DNS challenges for graceful shutdown
+        this.pendingChallenges = [];
         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]);
     }
     /**
      * starts the instance
@@ -28,8 +49,6 @@ export class SmartAcme {
     async start() {
         this.privateKey =
             this.options.accountPrivateKey || (await plugins.acme.forge.createPrivateKey()).toString();
-        this.setChallenge = this.options.setChallenge;
-        this.removeChallenge = this.options.removeChallenge;
         // CertMangaer
         this.certmanager = new SmartacmeCertManager(this, {
             mongoDescriptor: this.options.mongoDescriptor,
@@ -54,10 +73,63 @@ export class SmartAcme {
             termsOfServiceAgreed: true,
             contact: [`mailto:${this.options.accountEmail}`],
         });
+        // Setup graceful shutdown handlers
+        process.on('SIGINT', () => this.handleSignal('SIGINT'));
+        process.on('SIGTERM', () => this.handleSignal('SIGTERM'));
     }
     async stop() {
         await this.certmanager.smartdataDb.close();
     }
+    /** Retry helper with exponential backoff */
+    async retry(operation, operationName = 'operation') {
+        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 */
+    async handleShutdown() {
+        for (const input of [...this.pendingChallenges]) {
+            const type = input.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 */
+    handleSignal(sig) {
+        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));
+        });
+    }
     /**
      * gets a certificate
      * it runs through the following steps
@@ -89,50 +161,76 @@ export class SmartAcme {
         }
         // lets make sure others get the same interest
         const currentDomainInterst = await this.certmanager.interestMap.addInterest(certDomainName);
-        /* Place new order */
-        const order = await this.client.createOrder({
+        /* 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 fullHostName = `_acme-challenge.${authz.identifier.value}`;
-            const dnsChallenge = authz.challenges.find((challengeArg) => {
-                return challengeArg.type === 'dns-01';
-            });
-            // process.exit(1);
-            const keyAuthorization = await this.client.getChallengeKeyAuthorization(dnsChallenge);
+            await this.logger.log('debug', 'Authorization received', authz);
+            // select a handler based on configured priority
+            let selectedHandler = null;
+            let selectedChallengeArg = null;
+            for (const type of this.challengePriority) {
+                const candidate = authz.challenges.find((c) => 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;
+            // 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.token,
+                    keyAuthorization: keyAuth,
+                    webPath: `/.well-known/acme-challenge/${selectedChallengeArg.token}`,
+                };
+            }
+            else {
+                // generic challenge input: include raw challenge properties
+                input = { type, keyAuthorization: keyAuth, ...selectedChallengeArg };
+            }
+            this.pendingChallenges.push(input);
             try {
-                /* Satisfy challenge */
-                await this.setChallenge({
-                    hostName: fullHostName,
-                    challenge: keyAuthorization,
-                });
-                await plugins.smartdelay.delayFor(30000);
-                await this.smartdns.checkUntilAvailable(fullHostName, 'TXT', keyAuthorization, 100, 5000);
-                console.log('Cool down an extra 60 second for region availability');
-                await plugins.smartdelay.delayFor(60000);
-                /* 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({
-                        hostName: fullHostName,
-                        challenge: keyAuthorization,
-                    });
+                    await this.retry(() => handler.cleanup(input), `${type}.cleanup`);
+                }
+                catch (err) {
+                    await this.logger.log('error', `Error during ${type}.cleanup`, err);
                 }
-                catch (e) {
-                    console.log(e);
+                finally {
+                    this.pendingChallenges = this.pendingChallenges.filter((c) => c !== input);
                 }
             }
         }
@@ -141,8 +239,8 @@ export class SmartAcme {
             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 */
         await this.certmanager.storeCertificate({
             id: plugins.smartunique.shortId(),
@@ -165,4 +263,4 @@ export class SmartAcme {
         return SmartacmeCert.getInstances({});
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartacme.classes.smartacme.js","sourceRoot":"","sources":["../ts/smartacme.classes.smartacme.ts"],"names":[],"mappings":"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"}

package/dist_ts/smartacme.plugins.d.ts

@@ -3,15 +3,17 @@ export { typedserver };
 import * as lik from '@push.rocks/lik';
 import * as smartdata from '@push.rocks/smartdata';
 import * as smartdelay from '@push.rocks/smartdelay';
-import * as smartdns from '@push.rocks/smartdns';
+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, smartlog, smartpromise, smartrequest, smartunique, smartstring, smarttime, };
+export { lik, smartdata, smartdelay, smartdnsClient, smartlog, smartpromise, smartrequest, smartunique, smartstring, smarttime, };
 import * as tsclass from '@tsclass/tsclass';
 export { tsclass };
 import * as acme from 'acme-client';
 export { acme };
+import * as handlers from './handlers/index.js';
+export { handlers };

package/dist_ts/smartacme.plugins.js

@@ -5,18 +5,21 @@ export { typedserver };
 import * as lik from '@push.rocks/lik';
 import * as smartdata from '@push.rocks/smartdata';
 import * as smartdelay from '@push.rocks/smartdelay';
-import * as smartdns from '@push.rocks/smartdns';
+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, smartlog, smartpromise, smartrequest, smartunique, smartstring, smarttime, };
+export { lik, smartdata, smartdelay, smartdnsClient, smartlog, smartpromise, smartrequest, smartunique, smartstring, smarttime, };
 // @tsclass scope
 import * as tsclass from '@tsclass/tsclass';
 export { tsclass };
 // third party scope
 import * as acme from 'acme-client';
 export { acme };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRhY21lLnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydGFjbWUucGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxtQkFBbUI7QUFDbkIsT0FBTyxLQUFLLFdBQVcsTUFBTSx5QkFBeUIsQ0FBQztBQUV2RCxPQUFPLEVBQUUsV0FBVyxFQUFFLENBQUM7QUFFdkIsbUJBQW1CO0FBQ25CLE9BQU8sS0FBSyxHQUFHLE1BQU0saUJBQWlCLENBQUM7QUFDdkMsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssVUFBVSxNQUFNLHdCQUF3QixDQUFDO0FBQ3JELE9BQU8sS0FBSyxRQUFRLE1BQU0sc0JBQXNCLENBQUM7QUFDakQsT0FBTyxLQUFLLFFBQVEsTUFBTSxzQkFBc0IsQ0FBQztBQUNqRCxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxLQUFLLFdBQVcsTUFBTSx5QkFBeUIsQ0FBQztBQUN2RCxPQUFPLEtBQUssV0FBVyxNQUFNLHlCQUF5QixDQUFDO0FBQ3ZELE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFFbkQsT0FBTyxFQUNMLEdBQUcsRUFDSCxTQUFTLEVBQ1QsVUFBVSxFQUNWLFFBQVEsRUFDUixRQUFRLEVBQ1IsWUFBWSxFQUNaLFlBQVksRUFDWixXQUFXLEVBQ1gsV0FBVyxFQUNYLFNBQVMsR0FDVixDQUFDO0FBRUYsaUJBQWlCO0FBQ2pCLE9BQU8sS0FBSyxPQUFPLE1BQU0sa0JBQWtCLENBQUM7QUFFNUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxDQUFDO0FBRW5CLG9CQUFvQjtBQUNwQixPQUFPLEtBQUssSUFBSSxNQUFNLGFBQWEsQ0FBQztBQUVwQyxPQUFPLEVBQUUsSUFBSSxFQUFFLENBQUMifQ==
+// local handlers for challenge types
+import * as handlers from './handlers/index.js';
+export { handlers };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRhY21lLnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydGFjbWUucGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxtQkFBbUI7QUFDbkIsT0FBTyxLQUFLLFdBQVcsTUFBTSx5QkFBeUIsQ0FBQztBQUV2RCxPQUFPLEVBQUUsV0FBVyxFQUFFLENBQUM7QUFFdkIsbUJBQW1CO0FBQ25CLE9BQU8sS0FBSyxHQUFHLE1BQU0saUJBQWlCLENBQUM7QUFDdkMsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssVUFBVSxNQUFNLHdCQUF3QixDQUFDO0FBQ3JELE9BQU8sS0FBSyxjQUFjLE1BQU0sNkJBQTZCLENBQUM7QUFDOUQsT0FBTyxLQUFLLFFBQVEsTUFBTSxzQkFBc0IsQ0FBQztBQUNqRCxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxLQUFLLFdBQVcsTUFBTSx5QkFBeUIsQ0FBQztBQUN2RCxPQUFPLEtBQUssV0FBVyxNQUFNLHlCQUF5QixDQUFDO0FBQ3ZELE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFFbkQsT0FBTyxFQUNMLEdBQUcsRUFDSCxTQUFTLEVBQ1QsVUFBVSxFQUNWLGNBQWMsRUFDZCxRQUFRLEVBQ1IsWUFBWSxFQUNaLFlBQVksRUFDWixXQUFXLEVBQ1gsV0FBVyxFQUNYLFNBQVMsR0FDVixDQUFDO0FBRUYsaUJBQWlCO0FBQ2pCLE9BQU8sS0FBSyxPQUFPLE1BQU0sa0JBQWtCLENBQUM7QUFFNUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxDQUFDO0FBRW5CLG9CQUFvQjtBQUNwQixPQUFPLEtBQUssSUFBSSxNQUFNLGFBQWEsQ0FBQztBQUVwQyxPQUFPLEVBQUUsSUFBSSxFQUFFLENBQUM7QUFDaEIscUNBQXFDO0FBQ3JDLE9BQU8sS0FBSyxRQUFRLE1BQU0scUJBQXFCLENBQUM7QUFDaEQsT0FBTyxFQUFFLFFBQVEsRUFBRSxDQUFDIn0=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartacme",
-  "version": "5.0.0",
+  "version": "6.0.1",
   "private": false,
   "description": "A TypeScript-based ACME client for LetsEncrypt certificate management with a focus on simplicity and power.",
   "main": "dist_ts/index.js",
@@ -27,35 +27,35 @@
     "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://code.foss.global/push.rocks/smartacme",
+  "homepage": "https://code.foss.global/push.rocks/smartacme#readme",
   "dependencies": {
-    "@api.global/typedserver": "^3.0.50",
-    "@push.rocks/lik": "^6.0.15",
-    "@push.rocks/smartdata": "^5.2.4",
+    "@api.global/typedserver": "^3.0.74",
+    "@push.rocks/lik": "^6.2.2",
+    "@push.rocks/smartdata": "^5.15.1",
     "@push.rocks/smartdelay": "^3.0.5",
-    "@push.rocks/smartdns": "^5.0.2",
+    "@push.rocks/smartdns": "^6.2.2",
     "@push.rocks/smartlog": "^3.0.7",
-    "@push.rocks/smartpromise": "^4.0.3",
-    "@push.rocks/smartrequest": "^2.0.22",
+    "@push.rocks/smartpromise": "^4.2.3",
+    "@push.rocks/smartrequest": "^2.1.0",
     "@push.rocks/smartstring": "^4.0.15",
-    "@push.rocks/smarttime": "^4.0.6",
+    "@push.rocks/smarttime": "^4.1.1",
     "@push.rocks/smartunique": "^3.0.9",
-    "@tsclass/tsclass": "^4.0.58",
-    "acme-client": "^4.2.5"
+    "@tsclass/tsclass": "^9.0.0",
+    "acme-client": "^5.4.0"
   },
   "devDependencies": {
-    "@apiclient.xyz/cloudflare": "^6.0.3",
-    "@git.zone/tsbuild": "^2.1.80",
-    "@git.zone/tsrun": "^1.2.44",
-    "@git.zone/tstest": "^1.0.90",
-    "@push.rocks/qenv": "^6.0.5",
-    "@push.rocks/tapbundle": "^5.0.23",
-    "@types/node": "^20.14.2"
+    "@apiclient.xyz/cloudflare": "^6.3.2",
+    "@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": "^5.6.3",
+    "@types/node": "^22.15.2"
   },
   "files": [
     "ts/**/*",

package/readme.md

@@ -1,4 +1,3 @@
-```markdown
 # @push.rocks/smartacme
 
 A TypeScript-based ACME client with an easy yet powerful interface for LetsEncrypt certificate management.
@@ -40,35 +39,40 @@ Ensure your project includes the necessary TypeScript configuration and dependen
 
 ### Creating a SmartAcme Instance
 
-Start by importing the `SmartAcme` class from the `@push.rocks/smartacme` package. You'll also need to import or define interfaces for your setup options:
+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', // Email used for Let's Encrypt registration and recovery
-  accountPrivateKey: null, // Private key for the account (optional, if not provided it will be generated)
+  accountEmail: 'youremail@example.com',
   mongoDescriptor: {
     mongoDbUrl: 'mongodb://yourmongoURL',
     mongoDbName: 'yourDbName',
     mongoDbPass: 'yourDbPassword',
   },
-  removeChallenge: async (dnsChallenge) => {
-    // Implement logic here to remove DNS challenge records
-  },
-  setChallenge: async (dnsChallenge) => {
-    // Implement logic here to create DNS challenge records
-  },
-  environment: 'integration', // Use 'production' for actual certificates
+  environment: 'integration', // 'production' to request real certificates
+  retryOptions: {},         // optional retry/backoff settings
+  challengeHandlers: [
+    new Dns01Handler(cfAccount),
+    // you can add more handlers, e.g. Http01Handler
+  ],
+  challengePriority: ['dns-01'], // optional ordering of challenge types
 });
 ```
 
 ### Initializing SmartAcme
 
-Before proceeding to request certificates, initialize your SmartAcme instance:
+Before proceeding to request certificates, start your SmartAcme instance:
 
 ```typescript
-await smartAcmeInstance.init();
+await smartAcmeInstance.start();
 ```
 
 ### Obtaining a Certificate for a Domain
@@ -83,34 +87,7 @@ console.log('Certificate:', myCert);
 
 ### Automating DNS Challenges
 
-Part of the ACME protocol involves responding to DNS challenges issued by the certificate authority to prove control over a domain. Implement the `setChallenge` and `removeChallenge` functions in your SmartAcme configuration to automate this process. These functions receive a `dnsChallenge` argument containing details needed to create or remove the necessary DNS records.
-
-```typescript
-import * as cloudflare from '@apiclient.xyz/cloudflare';
-import { Qenv } from '@push.rocks/qenv';
-
-const testQenv = new Qenv('./', './.nogit/');
-const testCloudflare = new cloudflare.CloudflareAccount(testQenv.getEnvVarOnDemand('CF_TOKEN'));
-
-const smartAcmeInstance = new SmartAcme({
-  accountEmail: 'domains@example.com',
-  accountPrivateKey: null,
-  mongoDescriptor: {
-    mongoDbName: testQenv.getEnvVarRequired('MONGODB_DATABASE'),
-    mongoDbPass: testQenv.getEnvVarRequired('MONGODB_PASSWORD'),
-    mongoDbUrl: testQenv.getEnvVarRequired('MONGODB_URL'),
-  },
-  removeChallenge: async (dnsChallenge) => {
-    testCloudflare.convenience.acmeRemoveDnsChallenge(dnsChallenge);
-  },
-  setChallenge: async (dnsChallenge) => {
-    testCloudflare.convenience.acmeSetDnsChallenge(dnsChallenge);
-  },
-  environment: 'integration',
-});
-
-await smartAcmeInstance.init();
-```
+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
 
@@ -130,7 +107,7 @@ When creating an instance of `SmartAcme`, you can specify an `environment` optio
 
 ### 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:
+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';
@@ -143,22 +120,16 @@ const cloudflareAccount = new cloudflare.CloudflareAccount(qenv.getEnvVarOnDeman
 async function main() {
   const smartAcmeInstance = new SmartAcme({
     accountEmail: 'youremail@example.com',
-    accountPrivateKey: null,
     mongoDescriptor: {
       mongoDbUrl: qenv.getEnvVarRequired('MONGODB_URL'),
       mongoDbName: qenv.getEnvVarRequired('MONGODB_DATABASE'),
       mongoDbPass: qenv.getEnvVarRequired('MONGODB_PASSWORD'),
     },
-    setChallenge: async (dnsChallenge) => {
-      await cloudflareAccount.convenience.acmeSetDnsChallenge(dnsChallenge);
-    },
-    removeChallenge: async (dnsChallenge) => {
-      await cloudflareAccount.convenience.acmeRemoveDnsChallenge(dnsChallenge);
-    },
     environment: 'integration',
+    challengeHandlers: [ new Dns01Handler(cloudflareAccount) ],
   });
 
-  await smartAcmeInstance.init();
+  await smartAcmeInstance.start();
 
   const myDomain = 'example.com';
   const myCert = await smartAcmeInstance.getCertificateForDomain(myDomain);
@@ -265,11 +236,10 @@ 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](license) file within this repository. 
+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](license) 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.
 
@@ -279,7 +249,7 @@ This project is owned and maintained by Task Venture Capital GmbH. The names and
 
 ### Company Information
 
-Task Venture Capital GmbH  
+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.

package/ts/00_commitinfo_data.ts

@@ -1,8 +1,8 @@
 /**
- * autocreated commitinfo by @pushrocks/commitinfo
+ * autocreated commitinfo by @push.rocks/commitinfo
  */
 export const commitinfo = {
   name: '@push.rocks/smartacme',
-  version: '5.0.0',
+  version: '6.0.1',
   description: 'A TypeScript-based ACME client for LetsEncrypt certificate management with a focus on simplicity and power.'
 }

package/ts/handlers/Dns01Handler.ts

@@ -0,0 +1,40 @@
+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: any;
+  private smartdns: plugins.smartdnsClient.Smartdns;
+
+  constructor(
+    cloudflareAccount: any,
+    smartdnsInstance?: plugins.smartdnsClient.Smartdns,
+  ) {
+    this.cf = cloudflareAccount;
+    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);
+  }
+}

package/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 Http01HandlerOptions {
+  /**
+   * Directory that serves HTTP requests for /.well-known/acme-challenge
+   */
+  webroot: string;
+}
+
+export class Http01Handler implements IChallengeHandler<{
+  type: string;
+  token: string;
+  keyAuthorization: string;
+  webPath: string;
+}> {
+  private webroot: string;
+
+  constructor(options: Http01HandlerOptions) {
+    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
+    }
+  }
+}

package/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>;
+}

package/ts/handlers/index.ts

@@ -0,0 +1,4 @@
+export type { IChallengeHandler } from './IChallengeHandler.js';
+// Removed legacy handler adapter
+export { Dns01Handler } from './Dns01Handler.js';
+export { Http01Handler } from './Http01Handler.js';

package/ts/index.ts

@@ -1,2 +1,2 @@
 export * from './smartacme.classes.smartacme.js';
-export { SmartacmeCert as Cert } from './smartacme.classes.cert.js';
+export { SmartacmeCert as Cert } from './smartacme.classes.cert.js';

package/ts/smartacme.classes.certmanager.ts

@@ -22,7 +22,7 @@ export class SmartacmeCertManager {
     smartAcmeArg: SmartAcme,
     optionsArg: {
       mongoDescriptor: plugins.smartdata.IMongoDescriptor;
-    }
+    },
   ) {
     this.mongoDescriptor = optionsArg.mongoDescriptor;
   }

package/ts/smartacme.classes.smartacme.ts

@@ -11,9 +11,30 @@ export interface ISmartAcmeOptions {
   accountPrivateKey?: string;
   accountEmail: string;
   mongoDescriptor: plugins.smartdata.IMongoDescriptor;
-  setChallenge: (dnsChallengeArg: plugins.tsclass.network.IDnsChallenge) => Promise<any>;
-  removeChallenge: (dnsChallengeArg: plugins.tsclass.network.IDnsChallenge) => Promise<any>;
+  // 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[];
 }
 
 /**
@@ -30,24 +51,50 @@ 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: (dnsChallengeArg: plugins.tsclass.network.IDnsChallenge) => Promise<any>;
-  private removeChallenge: (dnsChallengeArg: plugins.tsclass.network.IDnsChallenge) => Promise<any>;
 
   // certmanager
   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]);
   }
 
   /**
@@ -59,8 +106,6 @@ export class SmartAcme {
   public async start() {
     this.privateKey =
       this.options.accountPrivateKey || (await plugins.acme.forge.createPrivateKey()).toString();
-    this.setChallenge = this.options.setChallenge;
-    this.removeChallenge = this.options.removeChallenge;
 
     // CertMangaer
     this.certmanager = new SmartacmeCertManager(this, {
@@ -88,11 +133,65 @@ export class SmartAcme {
       termsOfServiceAgreed: true,
       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();
-  }
+    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));
+        });
+    }
 
   /**
    * gets a certificate
@@ -128,54 +227,71 @@ export class SmartAcme {
     // lets make sure others get the same interest
     const currentDomainInterst = await this.certmanager.interestMap.addInterest(certDomainName);
 
-    /* Place new order */
-    const order = await this.client.createOrder({
+    /* 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 fullHostName: 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({
-          hostName: fullHostName,
-          challenge: keyAuthorization,
-        });
-        await plugins.smartdelay.delayFor(30000);
-        await this.smartdns.checkUntilAvailable(fullHostName, 'TXT', keyAuthorization, 100, 5000);
-        console.log('Cool down an extra 60 second for region availability');
-        await plugins.smartdelay.delayFor(60000);
-
-        /* 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({
-            hostName: fullHostName,
-            challenge: keyAuthorization,
-          });
-        } 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);
         }
       }
     }
@@ -186,8 +302,8 @@ export class SmartAcme {
       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 */
 

package/ts/smartacme.plugins.ts

@@ -7,7 +7,7 @@ export { typedserver };
 import * as lik from '@push.rocks/lik';
 import * as smartdata from '@push.rocks/smartdata';
 import * as smartdelay from '@push.rocks/smartdelay';
-import * as smartdns from '@push.rocks/smartdns';
+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';
@@ -19,7 +19,7 @@ export {
   lik,
   smartdata,
   smartdelay,
-  smartdns,
+  smartdnsClient,
   smartlog,
   smartpromise,
   smartrequest,
@@ -37,3 +37,6 @@ export { tsclass };
 import * as acme from 'acme-client';
 
 export { acme };
+// local handlers for challenge types
+import * as handlers from './handlers/index.js';
+export { handlers };