roster-server 2.0.6 → 2.1.1

package/vendor/acme-dns-01-cli-wrapper.js

@@ -0,0 +1,161 @@
+'use strict';
+
+const legacyCli = require('acme-dns-01-cli');
+
+function toPromise(fn, context) {
+    if (typeof fn !== 'function') {
+        return async function () {
+            return null;
+        };
+    }
+
+    return async function (opts) {
+        return new Promise((resolve, reject) => {
+            let done = false;
+            const finish = (err, result) => {
+                if (done) return;
+                done = true;
+                if (err) reject(err);
+                else resolve(result);
+            };
+
+            try {
+                // Legacy callback style
+                if (fn.length >= 2) {
+                    fn.call(context, opts, finish);
+                    return;
+                }
+
+                // Promise or sync style
+                Promise.resolve(fn.call(context, opts)).then(
+                    (result) => finish(null, result),
+                    finish
+                );
+            } catch (err) {
+                finish(err);
+            }
+        });
+    };
+}
+
+module.exports.create = function create(config = {}) {
+    const challenger = legacyCli.create(config);
+    const propagationDelay = Number.isFinite(config.propagationDelay)
+        ? config.propagationDelay
+        : 120000;
+    const envAutoContinue = process.env.ROSTER_DNS_AUTO_CONTINUE;
+    const parseAutoContinue = (value, fallback) => {
+        if (value === undefined || value === null || value === '') return fallback;
+        const normalized = String(value).trim().toLowerCase();
+        if (['1', 'true', 'yes', 'on'].includes(normalized)) return true;
+        if (['0', 'false', 'no', 'off'].includes(normalized)) return false;
+        return fallback;
+    };
+    const autoContinue = config.autoContinue !== undefined
+        ? parseAutoContinue(config.autoContinue, false)
+        : parseAutoContinue(envAutoContinue, false);
+    const dryRunDelay = Number.isFinite(config.dryRunDelay)
+        ? config.dryRunDelay
+        : Number.isFinite(Number(process.env.ROSTER_DNS_DRYRUN_DELAY_MS))
+            ? Number(process.env.ROSTER_DNS_DRYRUN_DELAY_MS)
+            : propagationDelay;
+
+    function sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+
+    const presentedByHost = new Map();
+
+    async function setChallenge(opts) {
+        const isInteractive = Boolean(process.stdin && process.stdin.isTTY);
+        if (isInteractive && !autoContinue) {
+            return toPromise(challenger.set, challenger)(opts);
+        }
+
+        const ch = opts?.challenge || {};
+        console.info('');
+        console.info("[ACME dns-01 '" + (ch.altname || opts?.altname || 'unknown') + "' CHALLENGE]");
+        console.info("You're about to receive the following DNS query:");
+        console.info('');
+        const dnsHost = String(ch.dnsHost || '');
+        const dnsAuth = ch.dnsAuthorization || opts?.dnsAuthorization || null;
+        if (dnsHost && dnsAuth) {
+            presentedByHost.set(dnsHost, dnsAuth);
+        }
+        const isDryRunChallenge = dnsHost.includes('_greenlock-dryrun-');
+        const effectiveDelay = isDryRunChallenge
+            ? Math.max(0, dryRunDelay)
+            : propagationDelay;
+
+        console.info(
+            '\tTXT\t' +
+                (ch.dnsHost || '_acme-challenge.<domain>') +
+                '\t' +
+                (ch.dnsAuthorization || '<dns-authorization-token>') +
+                '\tTTL 60'
+        );
+        console.info('');
+        console.info(
+            'Non-interactive mode (or autoContinue) detected. ' +
+            'Set the TXT record now. Continuing automatically in ' +
+            effectiveDelay +
+            'ms...'
+        );
+        await sleep(effectiveDelay);
+        return null;
+    }
+
+    async function getChallenge(opts) {
+        const ch = opts?.challenge || {};
+        const dnsHost = String(ch.dnsHost || opts?.dnsHost || '');
+        const dnsAuthorization =
+            ch.dnsAuthorization ||
+            opts?.dnsAuthorization ||
+            (dnsHost ? presentedByHost.get(dnsHost) : null);
+
+        if (!dnsAuthorization) {
+            return null;
+        }
+
+        return {
+            ...(typeof ch === 'object' ? ch : {}),
+            dnsAuthorization
+        };
+    }
+
+    const wrapped = {
+        propagationDelay,
+        set: setChallenge,
+        remove: toPromise(challenger.remove, challenger),
+        get: getChallenge,
+        zones: async (opts) => {
+            const dnsHost =
+                opts?.dnsHost ||
+                opts?.challenge?.dnsHost ||
+                opts?.challenge?.altname ||
+                opts?.altname;
+
+            if (!dnsHost || typeof dnsHost !== 'string') {
+                return [];
+            }
+
+            // Best-effort root zone extraction for legacy/manual flow.
+            const zone = dnsHost
+                .replace(/^_acme-challenge\./, '')
+                .replace(/^_greenlock-[^.]+\./, '')
+                .replace(/\.$/, '');
+
+            return zone ? [zone] : [];
+        }
+    };
+
+    if (typeof challenger.init === 'function') {
+        wrapped.init = toPromise(challenger.init, challenger);
+    }
+
+    if (challenger.options && typeof challenger.options === 'object') {
+        wrapped.options = { ...challenger.options };
+    }
+
+    return wrapped;
+};