@serve.zone/dcrouter 8.1.0 → 9.1.1

package/dist_ts/opsserver/handlers/certificate.handler.js

@@ -0,0 +1,419 @@
+import * as plugins from '../../plugins.js';
+import * as interfaces from '../../../dist_ts_interfaces/index.js';
+export class CertificateHandler {
+    opsServerRef;
+    typedrouter = new plugins.typedrequest.TypedRouter();
+    constructor(opsServerRef) {
+        this.opsServerRef = opsServerRef;
+        this.opsServerRef.typedrouter.addTypedRouter(this.typedrouter);
+        this.registerHandlers();
+    }
+    registerHandlers() {
+        // Get Certificate Overview
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getCertificateOverview', async (dataArg) => {
+            const certificates = await this.buildCertificateOverview();
+            const summary = this.buildSummary(certificates);
+            return { certificates, summary };
+        }));
+        // Legacy route-based reprovision (backward compat)
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('reprovisionCertificate', async (dataArg) => {
+            return this.reprovisionCertificateByRoute(dataArg.routeName);
+        }));
+        // Domain-based reprovision (preferred)
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('reprovisionCertificateDomain', async (dataArg) => {
+            return this.reprovisionCertificateDomain(dataArg.domain);
+        }));
+        // Delete certificate
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('deleteCertificate', async (dataArg) => {
+            return this.deleteCertificate(dataArg.domain);
+        }));
+        // Export certificate
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('exportCertificate', async (dataArg) => {
+            return this.exportCertificate(dataArg.domain);
+        }));
+        // Import certificate
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('importCertificate', async (dataArg) => {
+            return this.importCertificate(dataArg.cert);
+        }));
+    }
+    /**
+     * Build domain-centric certificate overview.
+     * Instead of one row per route, we produce one row per unique domain.
+     */
+    async buildCertificateOverview() {
+        const dcRouter = this.opsServerRef.dcRouterRef;
+        const smartProxy = dcRouter.smartProxy;
+        if (!smartProxy)
+            return [];
+        const routes = smartProxy.routeManager.getRoutes();
+        // Phase 1: Collect unique domains with their associated route info
+        const domainMap = new Map();
+        for (const route of routes) {
+            if (!route.name)
+                continue;
+            const tls = route.action?.tls;
+            if (!tls)
+                continue;
+            // Skip passthrough routes - they don't manage certificates
+            if (tls.mode === 'passthrough')
+                continue;
+            const routeDomains = route.match.domains
+                ? (Array.isArray(route.match.domains) ? route.match.domains : [route.match.domains])
+                : [];
+            // Determine source
+            let source = 'none';
+            if (tls.certificate === 'auto') {
+                if (smartProxy.settings.certProvisionFunction) {
+                    source = 'provision-function';
+                }
+                else {
+                    source = 'acme';
+                }
+            }
+            else if (tls.certificate && typeof tls.certificate === 'object') {
+                source = 'static';
+            }
+            const canReprovision = source === 'acme' || source === 'provision-function';
+            const tlsMode = tls.mode;
+            for (const domain of routeDomains) {
+                const existing = domainMap.get(domain);
+                if (existing) {
+                    // Add this route name to the existing domain entry
+                    if (!existing.routeNames.includes(route.name)) {
+                        existing.routeNames.push(route.name);
+                    }
+                    // Upgrade source if more specific
+                    if (existing.source === 'none' && source !== 'none') {
+                        existing.source = source;
+                        existing.canReprovision = canReprovision;
+                    }
+                }
+                else {
+                    domainMap.set(domain, {
+                        routeNames: [route.name],
+                        source,
+                        tlsMode,
+                        canReprovision,
+                    });
+                }
+            }
+        }
+        // Phase 2: Resolve status for each unique domain
+        const certificates = [];
+        for (const [domain, info] of domainMap) {
+            let status = 'unknown';
+            let expiryDate;
+            let issuedAt;
+            let issuer;
+            let error;
+            // Check event-based status from certificateStatusMap (now keyed by domain)
+            const eventStatus = dcRouter.certificateStatusMap.get(domain);
+            if (eventStatus) {
+                status = eventStatus.status;
+                expiryDate = eventStatus.expiryDate;
+                issuedAt = eventStatus.issuedAt;
+                error = eventStatus.error;
+                if (eventStatus.source) {
+                    issuer = eventStatus.source;
+                }
+            }
+            // Try SmartProxy certificate status if no event data
+            if (status === 'unknown' && info.routeNames.length > 0) {
+                try {
+                    const rustStatus = await smartProxy.getCertificateStatus(info.routeNames[0]);
+                    if (rustStatus) {
+                        if (rustStatus.expiryDate)
+                            expiryDate = rustStatus.expiryDate;
+                        if (rustStatus.issuer)
+                            issuer = rustStatus.issuer;
+                        if (rustStatus.issuedAt)
+                            issuedAt = rustStatus.issuedAt;
+                        if (rustStatus.status === 'valid' || rustStatus.status === 'expired') {
+                            status = rustStatus.status;
+                        }
+                    }
+                }
+                catch {
+                    // Rust bridge may not support this command yet — ignore
+                }
+            }
+            // Check persisted cert data from StorageManager
+            if (status === 'unknown') {
+                const cleanDomain = domain.replace(/^\*\.?/, '');
+                let certData = await dcRouter.storageManager.getJSON(`/certs/${cleanDomain}`);
+                if (!certData) {
+                    // Also check certStore path (proxy-certs)
+                    certData = await dcRouter.storageManager.getJSON(`/proxy-certs/${domain}`);
+                }
+                if (certData?.validUntil) {
+                    expiryDate = new Date(certData.validUntil).toISOString();
+                    if (certData.created) {
+                        issuedAt = new Date(certData.created).toISOString();
+                    }
+                    issuer = 'smartacme-dns-01';
+                }
+                else if (certData?.publicKey) {
+                    // certStore has the cert — parse PEM for expiry
+                    try {
+                        const x509 = new plugins.crypto.X509Certificate(certData.publicKey);
+                        expiryDate = new Date(x509.validTo).toISOString();
+                        issuedAt = new Date(x509.validFrom).toISOString();
+                    }
+                    catch { /* PEM parsing failed */ }
+                    status = 'valid';
+                    issuer = 'cert-store';
+                }
+                else if (certData) {
+                    status = 'valid';
+                    issuer = 'cert-store';
+                }
+            }
+            // Compute status from expiry date
+            if (expiryDate && (status === 'valid' || status === 'unknown')) {
+                const expiry = new Date(expiryDate);
+                const now = new Date();
+                const daysUntilExpiry = (expiry.getTime() - now.getTime()) / (1000 * 60 * 60 * 24);
+                if (daysUntilExpiry < 0) {
+                    status = 'expired';
+                }
+                else if (daysUntilExpiry < 30) {
+                    status = 'expiring';
+                }
+                else {
+                    status = 'valid';
+                }
+            }
+            // Static certs with no other info default to 'valid'
+            if (info.source === 'static' && status === 'unknown') {
+                status = 'valid';
+            }
+            // ACME/provision-function routes with no cert data are still provisioning
+            if (status === 'unknown' && (info.source === 'acme' || info.source === 'provision-function')) {
+                status = 'provisioning';
+            }
+            // Phase 3: Attach backoff info
+            let backoffInfo;
+            if (dcRouter.certProvisionScheduler) {
+                const bi = await dcRouter.certProvisionScheduler.getBackoffInfo(domain);
+                if (bi) {
+                    backoffInfo = bi;
+                }
+            }
+            certificates.push({
+                domain,
+                routeNames: info.routeNames,
+                status,
+                source: info.source,
+                tlsMode: info.tlsMode,
+                expiryDate,
+                issuer,
+                issuedAt,
+                error,
+                canReprovision: info.canReprovision,
+                backoffInfo,
+            });
+        }
+        return certificates;
+    }
+    buildSummary(certificates) {
+        const summary = { total: 0, valid: 0, expiring: 0, expired: 0, failed: 0, unknown: 0 };
+        summary.total = certificates.length;
+        for (const cert of certificates) {
+            switch (cert.status) {
+                case 'valid':
+                    summary.valid++;
+                    break;
+                case 'expiring':
+                    summary.expiring++;
+                    break;
+                case 'expired':
+                    summary.expired++;
+                    break;
+                case 'failed':
+                    summary.failed++;
+                    break;
+                case 'provisioning': // count as unknown
+                case 'unknown':
+                    summary.unknown++;
+                    break;
+            }
+        }
+        return summary;
+    }
+    /**
+     * Legacy route-based reprovisioning
+     */
+    async reprovisionCertificateByRoute(routeName) {
+        const dcRouter = this.opsServerRef.dcRouterRef;
+        const smartProxy = dcRouter.smartProxy;
+        if (!smartProxy) {
+            return { success: false, message: 'SmartProxy is not running' };
+        }
+        try {
+            await smartProxy.provisionCertificate(routeName);
+            // Clear event-based status for domains in this route
+            for (const [domain, entry] of dcRouter.certificateStatusMap) {
+                if (entry.routeNames.includes(routeName)) {
+                    dcRouter.certificateStatusMap.delete(domain);
+                }
+            }
+            return { success: true, message: `Certificate reprovisioning triggered for route '${routeName}'` };
+        }
+        catch (err) {
+            return { success: false, message: err.message || 'Failed to reprovision certificate' };
+        }
+    }
+    /**
+     * Domain-based reprovisioning — clears backoff first, then triggers provision
+     */
+    async reprovisionCertificateDomain(domain) {
+        const dcRouter = this.opsServerRef.dcRouterRef;
+        const smartProxy = dcRouter.smartProxy;
+        if (!smartProxy) {
+            return { success: false, message: 'SmartProxy is not running' };
+        }
+        // Clear backoff for this domain (user override)
+        if (dcRouter.certProvisionScheduler) {
+            await dcRouter.certProvisionScheduler.clearBackoff(domain);
+        }
+        // Clear status map entry so it gets refreshed
+        dcRouter.certificateStatusMap.delete(domain);
+        // Try to provision via SmartAcme directly
+        if (dcRouter.smartAcme) {
+            try {
+                await dcRouter.smartAcme.getCertificateForDomain(domain);
+                return { success: true, message: `Certificate reprovisioning triggered for domain '${domain}'` };
+            }
+            catch (err) {
+                return { success: false, message: err.message || `Failed to reprovision certificate for ${domain}` };
+            }
+        }
+        // Fallback: try provisioning via the first matching route
+        const routeNames = dcRouter.findRouteNamesForDomain(domain);
+        if (routeNames.length > 0) {
+            try {
+                await smartProxy.provisionCertificate(routeNames[0]);
+                return { success: true, message: `Certificate reprovisioning triggered for domain '${domain}' via route '${routeNames[0]}'` };
+            }
+            catch (err) {
+                return { success: false, message: err.message || `Failed to reprovision certificate for ${domain}` };
+            }
+        }
+        return { success: false, message: `No routes found for domain '${domain}'` };
+    }
+    /**
+     * Delete certificate data for a domain from storage
+     */
+    async deleteCertificate(domain) {
+        const dcRouter = this.opsServerRef.dcRouterRef;
+        const cleanDomain = domain.replace(/^\*\.?/, '');
+        // Delete from all known storage paths
+        const paths = [
+            `/proxy-certs/${domain}`,
+            `/proxy-certs/${cleanDomain}`,
+            `/certs/${cleanDomain}`,
+        ];
+        for (const path of paths) {
+            try {
+                await dcRouter.storageManager.delete(path);
+            }
+            catch {
+                // Path may not exist — ignore
+            }
+        }
+        // Clear from in-memory status map
+        dcRouter.certificateStatusMap.delete(domain);
+        // Clear backoff info
+        if (dcRouter.certProvisionScheduler) {
+            await dcRouter.certProvisionScheduler.clearBackoff(domain);
+        }
+        return { success: true, message: `Certificate data deleted for '${domain}'` };
+    }
+    /**
+     * Export certificate data for a domain as ICert-shaped JSON
+     */
+    async exportCertificate(domain) {
+        const dcRouter = this.opsServerRef.dcRouterRef;
+        const cleanDomain = domain.replace(/^\*\.?/, '');
+        // Try SmartAcme /certs/ path first (has full ICert fields)
+        let certData = await dcRouter.storageManager.getJSON(`/certs/${cleanDomain}`);
+        if (certData && certData.publicKey && certData.privateKey) {
+            return {
+                success: true,
+                cert: {
+                    id: certData.id || plugins.crypto.randomUUID(),
+                    domainName: certData.domainName || domain,
+                    created: certData.created || Date.now(),
+                    validUntil: certData.validUntil || 0,
+                    privateKey: certData.privateKey,
+                    publicKey: certData.publicKey,
+                    csr: certData.csr || '',
+                },
+            };
+        }
+        // Fallback: try /proxy-certs/ with original domain
+        certData = await dcRouter.storageManager.getJSON(`/proxy-certs/${domain}`);
+        if (!certData || !certData.publicKey) {
+            // Try with clean domain
+            certData = await dcRouter.storageManager.getJSON(`/proxy-certs/${cleanDomain}`);
+        }
+        if (certData && certData.publicKey && certData.privateKey) {
+            return {
+                success: true,
+                cert: {
+                    id: plugins.crypto.randomUUID(),
+                    domainName: domain,
+                    created: certData.validFrom || Date.now(),
+                    validUntil: certData.validUntil || 0,
+                    privateKey: certData.privateKey,
+                    publicKey: certData.publicKey,
+                    csr: '',
+                },
+            };
+        }
+        return { success: false, message: `No certificate data found for '${domain}'` };
+    }
+    /**
+     * Import a certificate from ICert-shaped JSON
+     */
+    async importCertificate(cert) {
+        // Validate PEM content
+        if (!cert.publicKey || !cert.publicKey.includes('-----BEGIN CERTIFICATE-----')) {
+            return { success: false, message: 'Invalid publicKey: must contain a PEM-encoded certificate' };
+        }
+        if (!cert.privateKey || !cert.privateKey.includes('-----BEGIN')) {
+            return { success: false, message: 'Invalid privateKey: must contain a PEM-encoded key' };
+        }
+        const dcRouter = this.opsServerRef.dcRouterRef;
+        const cleanDomain = cert.domainName.replace(/^\*\.?/, '');
+        // Save to /certs/ (SmartAcme-compatible path)
+        await dcRouter.storageManager.setJSON(`/certs/${cleanDomain}`, {
+            id: cert.id,
+            domainName: cert.domainName,
+            created: cert.created,
+            validUntil: cert.validUntil,
+            privateKey: cert.privateKey,
+            publicKey: cert.publicKey,
+            csr: cert.csr || '',
+        });
+        // Also save to /proxy-certs/ (proxy-cert format)
+        await dcRouter.storageManager.setJSON(`/proxy-certs/${cert.domainName}`, {
+            domain: cert.domainName,
+            publicKey: cert.publicKey,
+            privateKey: cert.privateKey,
+            ca: undefined,
+            validUntil: cert.validUntil,
+            validFrom: cert.created,
+        });
+        // Update in-memory status map
+        dcRouter.certificateStatusMap.set(cert.domainName, {
+            status: 'valid',
+            source: 'static',
+            expiryDate: cert.validUntil ? new Date(cert.validUntil).toISOString() : undefined,
+            issuedAt: cert.created ? new Date(cert.created).toISOString() : undefined,
+            routeNames: [],
+        });
+        return { success: true, message: `Certificate imported for '${cert.domainName}'` };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"certificate.handler.js","sourceRoot":"","sources":["../../../../ts/opsserver/handlers/certificate.handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,kBAAkB,CAAC;AAE5C,OAAO,KAAK,UAAU,MAAM,iCAAiC,CAAC;AAE9D,MAAM,OAAO,kBAAkB;IAGT;IAFb,WAAW,GAAG,IAAI,OAAO,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC;IAE5D,YAAoB,YAAuB;QAAvB,iBAAY,GAAZ,YAAY,CAAW;QACzC,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,cAAc,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAC/D,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAC1B,CAAC;IAEO,gBAAgB;QACtB,2BAA2B;QAC3B,IAAI,CAAC,WAAW,CAAC,eAAe,CAC9B,IAAI,OAAO,CAAC,YAAY,CAAC,YAAY,CACnC,wBAAwB,EACxB,KAAK,EAAE,OAAO,EAAE,EAAE;YAChB,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,wBAAwB,EAAE,CAAC;YAC3D,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC;YAChD,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,CAAC;QACnC,CAAC,CACF,CACF,CAAC;QAEF,mDAAmD;QACnD,IAAI,CAAC,WAAW,CAAC,eAAe,CAC9B,IAAI,OAAO,CAAC,YAAY,CAAC,YAAY,CACnC,wBAAwB,EACxB,KAAK,EAAE,OAAO,EAAE,EAAE;YAChB,OAAO,IAAI,CAAC,6BAA6B,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QAC/D,CAAC,CACF,CACF,CAAC;QAEF,uCAAuC;QACvC,IAAI,CAAC,WAAW,CAAC,eAAe,CAC9B,IAAI,OAAO,CAAC,YAAY,CAAC,YAAY,CACnC,8BAA8B,EAC9B,KAAK,EAAE,OAAO,EAAE,EAAE;YAChB,OAAO,IAAI,CAAC,4BAA4B,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAC3D,CAAC,CACF,CACF,CAAC;QAEF,qBAAqB;QACrB,IAAI,CAAC,WAAW,CAAC,eAAe,CAC9B,IAAI,OAAO,CAAC,YAAY,CAAC,YAAY,CACnC,mBAAmB,EACnB,KAAK,EAAE,OAAO,EAAE,EAAE;YAChB,OAAO,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAChD,CAAC,CACF,CACF,CAAC;QAEF,qBAAqB;QACrB,IAAI,CAAC,WAAW,CAAC,eAAe,CAC9B,IAAI,OAAO,CAAC,YAAY,CAAC,YAAY,CACnC,mBAAmB,EACnB,KAAK,EAAE,OAAO,EAAE,EAAE;YAChB,OAAO,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAChD,CAAC,CACF,CACF,CAAC;QAEF,qBAAqB;QACrB,IAAI,CAAC,WAAW,CAAC,eAAe,CAC9B,IAAI,OAAO,CAAC,YAAY,CAAC,YAAY,CACnC,mBAAmB,EACnB,KAAK,EAAE,OAAO,EAAE,EAAE;YAChB,OAAO,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAC9C,CAAC,CACF,CACF,CAAC;IACJ,CAAC;IAED;;;OAGG;IACK,KAAK,CAAC,wBAAwB;QACpC,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC;QAC/C,MAAM,UAAU,GAAG,QAAQ,CAAC,UAAU,CAAC;QACvC,IAAI,CAAC,UAAU;YAAE,OAAO,EAAE,CAAC;QAE3B,MAAM,MAAM,GAAG,UAAU,CAAC,YAAY,CAAC,SAAS,EAAE,CAAC;QAEnD,mEAAmE;QACnE,MAAM,SAAS,GAAG,IAAI,GAAG,EAKrB,CAAC;QAEL,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;YAC3B,IAAI,CAAC,KAAK,CAAC,IAAI;gBAAE,SAAS;YAE1B,MAAM,GAAG,GAAG,KAAK,CAAC,MAAM,EAAE,GAAG,CAAC;YAC9B,IAAI,CAAC,GAAG;gBAAE,SAAS;YAEnB,2DAA2D;YAC3D,IAAI,GAAG,CAAC,IAAI,KAAK,aAAa;gBAAE,SAAS;YAEzC,MAAM,YAAY,GAAG,KAAK,CAAC,KAAK,CAAC,OAAO;gBACtC,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;gBACpF,CAAC,CAAC,EAAE,CAAC;YAEP,mBAAmB;YACnB,IAAI,MAAM,GAA2C,MAAM,CAAC;YAC5D,IAAI,GAAG,CAAC,WAAW,KAAK,MAAM,EAAE,CAAC;gBAC/B,IAAK,UAAU,CAAC,QAAgB,CAAC,qBAAqB,EAAE,CAAC;oBACvD,MAAM,GAAG,oBAAoB,CAAC;gBAChC,CAAC;qBAAM,CAAC;oBACN,MAAM,GAAG,MAAM,CAAC;gBAClB,CAAC;YACH,CAAC;iBAAM,IAAI,GAAG,CAAC,WAAW,IAAI,OAAO,GAAG,CAAC,WAAW,KAAK,QAAQ,EAAE,CAAC;gBAClE,MAAM,GAAG,QAAQ,CAAC;YACpB,CAAC;YAED,MAAM,cAAc,GAAG,MAAM,KAAK,MAAM,IAAI,MAAM,KAAK,oBAAoB,CAAC;YAC5E,MAAM,OAAO,GAAG,GAAG,CAAC,IAA+D,CAAC;YAEpF,KAAK,MAAM,MAAM,IAAI,YAAY,EAAE,CAAC;gBAClC,MAAM,QAAQ,GAAG,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;gBACvC,IAAI,QAAQ,EAAE,CAAC;oBACb,mDAAmD;oBACnD,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;wBAC9C,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;oBACvC,CAAC;oBACD,kCAAkC;oBAClC,IAAI,QAAQ,CAAC,MAAM,KAAK,MAAM,IAAI,MAAM,KAAK,MAAM,EAAE,CAAC;wBACpD,QAAQ,CAAC,MAAM,GAAG,MAAM,CAAC;wBACzB,QAAQ,CAAC,cAAc,GAAG,cAAc,CAAC;oBAC3C,CAAC;gBACH,CAAC;qBAAM,CAAC;oBACN,SAAS,CAAC,GAAG,CAAC,MAAM,EAAE;wBACpB,UAAU,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC;wBACxB,MAAM;wBACN,OAAO;wBACP,cAAc;qBACf,CAAC,CAAC;gBACL,CAAC;YACH,CAAC;QACH,CAAC;QAED,iDAAiD;QACjD,MAAM,YAAY,GAA2C,EAAE,CAAC;QAEhE,KAAK,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,SAAS,EAAE,CAAC;YACvC,IAAI,MAAM,GAA2C,SAAS,CAAC;YAC/D,IAAI,UAA8B,CAAC;YACnC,IAAI,QAA4B,CAAC;YACjC,IAAI,MAA0B,CAAC;YAC/B,IAAI,KAAyB,CAAC;YAE9B,2EAA2E;YAC3E,MAAM,WAAW,GAAG,QAAQ,CAAC,oBAAoB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YAC9D,IAAI,WAAW,EAAE,CAAC;gBAChB,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC;gBAC5B,UAAU,GAAG,WAAW,CAAC,UAAU,CAAC;gBACpC,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAC;gBAChC,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC;gBAC1B,IAAI,WAAW,CAAC,MAAM,EAAE,CAAC;oBACvB,MAAM,GAAG,WAAW,CAAC,MAAM,CAAC;gBAC9B,CAAC;YACH,CAAC;YAED,qDAAqD;YACrD,IAAI,MAAM,KAAK,SAAS,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACvD,IAAI,CAAC;oBACH,MAAM,UAAU,GAAG,MAAM,UAAU,CAAC,oBAAoB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;oBAC7E,IAAI,UAAU,EAAE,CAAC;wBACf,IAAI,UAAU,CAAC,UAAU;4BAAE,UAAU,GAAG,UAAU,CAAC,UAAU,CAAC;wBAC9D,IAAI,UAAU,CAAC,MAAM;4BAAE,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC;wBAClD,IAAI,UAAU,CAAC,QAAQ;4BAAE,QAAQ,GAAG,UAAU,CAAC,QAAQ,CAAC;wBACxD,IAAI,UAAU,CAAC,MAAM,KAAK,OAAO,IAAI,UAAU,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;4BACrE,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC;wBAC7B,CAAC;oBACH,CAAC;gBACH,CAAC;gBAAC,MAAM,CAAC;oBACP,wDAAwD;gBAC1D,CAAC;YACH,CAAC;YAED,gDAAgD;YAChD,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;gBACzB,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;gBACjD,IAAI,QAAQ,GAAG,MAAM,QAAQ,CAAC,cAAc,CAAC,OAAO,CAAC,UAAU,WAAW,EAAE,CAAC,CAAC;gBAC9E,IAAI,CAAC,QAAQ,EAAE,CAAC;oBACd,0CAA0C;oBAC1C,QAAQ,GAAG,MAAM,QAAQ,CAAC,cAAc,CAAC,OAAO,CAAC,gBAAgB,MAAM,EAAE,CAAC,CAAC;gBAC7E,CAAC;gBACD,IAAI,QAAQ,EAAE,UAAU,EAAE,CAAC;oBACzB,UAAU,GAAG,IAAI,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,WAAW,EAAE,CAAC;oBACzD,IAAI,QAAQ,CAAC,OAAO,EAAE,CAAC;wBACrB,QAAQ,GAAG,IAAI,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,WAAW,EAAE,CAAC;oBACtD,CAAC;oBACD,MAAM,GAAG,kBAAkB,CAAC;gBAC9B,CAAC;qBAAM,IAAI,QAAQ,EAAE,SAAS,EAAE,CAAC;oBAC/B,gDAAgD;oBAChD,IAAI,CAAC;wBACH,MAAM,IAAI,GAAG,IAAI,OAAO,CAAC,MAAM,CAAC,eAAe,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;wBACpE,UAAU,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,WAAW,EAAE,CAAC;wBAClD,QAAQ,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,CAAC;oBACpD,CAAC;oBAAC,MAAM,CAAC,CAAC,wBAAwB,CAAC,CAAC;oBACpC,MAAM,GAAG,OAAO,CAAC;oBACjB,MAAM,GAAG,YAAY,CAAC;gBACxB,CAAC;qBAAM,IAAI,QAAQ,EAAE,CAAC;oBACpB,MAAM,GAAG,OAAO,CAAC;oBACjB,MAAM,GAAG,YAAY,CAAC;gBACxB,CAAC;YACH,CAAC;YAED,kCAAkC;YAClC,IAAI,UAAU,IAAI,CAAC,MAAM,KAAK,OAAO,IAAI,MAAM,KAAK,SAAS,CAAC,EAAE,CAAC;gBAC/D,MAAM,MAAM,GAAG,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC;gBACpC,MAAM,GAAG,GAAG,IAAI,IAAI,EAAE,CAAC;gBACvB,MAAM,eAAe,GAAG,CAAC,MAAM,CAAC,OAAO,EAAE,GAAG,GAAG,CAAC,OAAO,EAAE,CAAC,GAAG,CAAC,IAAI,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC;gBAEnF,IAAI,eAAe,GAAG,CAAC,EAAE,CAAC;oBACxB,MAAM,GAAG,SAAS,CAAC;gBACrB,CAAC;qBAAM,IAAI,eAAe,GAAG,EAAE,EAAE,CAAC;oBAChC,MAAM,GAAG,UAAU,CAAC;gBACtB,CAAC;qBAAM,CAAC;oBACN,MAAM,GAAG,OAAO,CAAC;gBACnB,CAAC;YACH,CAAC;YAED,qDAAqD;YACrD,IAAI,IAAI,CAAC,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;gBACrD,MAAM,GAAG,OAAO,CAAC;YACnB,CAAC;YAED,0EAA0E;YAC1E,IAAI,MAAM,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,MAAM,KAAK,MAAM,IAAI,IAAI,CAAC,MAAM,KAAK,oBAAoB,CAAC,EAAE,CAAC;gBAC7F,MAAM,GAAG,cAAc,CAAC;YAC1B,CAAC;YAED,+BAA+B;YAC/B,IAAI,WAAgE,CAAC;YACrE,IAAI,QAAQ,CAAC,sBAAsB,EAAE,CAAC;gBACpC,MAAM,EAAE,GAAG,MAAM,QAAQ,CAAC,sBAAsB,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;gBACxE,IAAI,EAAE,EAAE,CAAC;oBACP,WAAW,GAAG,EAAE,CAAC;gBACnB,CAAC;YACH,CAAC;YAED,YAAY,CAAC,IAAI,CAAC;gBAChB,MAAM;gBACN,UAAU,EAAE,IAAI,CAAC,UAAU;gBAC3B,MAAM;gBACN,MAAM,EAAE,IAAI,CAAC,MAAM;gBACnB,OAAO,EAAE,IAAI,CAAC,OAAO;gBACrB,UAAU;gBACV,MAAM;gBACN,QAAQ;gBACR,KAAK;gBACL,cAAc,EAAE,IAAI,CAAC,cAAc;gBACnC,WAAW;aACZ,CAAC,CAAC;QACL,CAAC;QAED,OAAO,YAAY,CAAC;IACtB,CAAC;IAEO,YAAY,CAAC,YAAoD;QAQvE,MAAM,OAAO,GAAG,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;QACvF,OAAO,CAAC,KAAK,GAAG,YAAY,CAAC,MAAM,CAAC;QACpC,KAAK,MAAM,IAAI,IAAI,YAAY,EAAE,CAAC;YAChC,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;gBACpB,KAAK,OAAO;oBAAE,OAAO,CAAC,KAAK,EAAE,CAAC;oBAAC,MAAM;gBACrC,KAAK,UAAU;oBAAE,OAAO,CAAC,QAAQ,EAAE,CAAC;oBAAC,MAAM;gBAC3C,KAAK,SAAS;oBAAE,OAAO,CAAC,OAAO,EAAE,CAAC;oBAAC,MAAM;gBACzC,KAAK,QAAQ;oBAAE,OAAO,CAAC,MAAM,EAAE,CAAC;oBAAC,MAAM;gBACvC,KAAK,cAAc,CAAC,CAAC,mBAAmB;gBACxC,KAAK,SAAS;oBAAE,OAAO,CAAC,OAAO,EAAE,CAAC;oBAAC,MAAM;YAC3C,CAAC;QACH,CAAC;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,6BAA6B,CAAC,SAAiB;QAC3D,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC;QAC/C,MAAM,UAAU,GAAG,QAAQ,CAAC,UAAU,CAAC;QAEvC,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,2BAA2B,EAAE,CAAC;QAClE,CAAC;QAED,IAAI,CAAC;YACH,MAAM,UAAU,CAAC,oBAAoB,CAAC,SAAS,CAAC,CAAC;YACjD,qDAAqD;YACrD,KAAK,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,IAAI,QAAQ,CAAC,oBAAoB,EAAE,CAAC;gBAC5D,IAAI,KAAK,CAAC,UAAU,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;oBACzC,QAAQ,CAAC,oBAAoB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;gBAC/C,CAAC;YACH,CAAC;YACD,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,mDAAmD,SAAS,GAAG,EAAE,CAAC;QACrG,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,CAAC,OAAO,IAAI,mCAAmC,EAAE,CAAC;QACzF,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,4BAA4B,CAAC,MAAc;QACvD,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC;QAC/C,MAAM,UAAU,GAAG,QAAQ,CAAC,UAAU,CAAC;QAEvC,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,2BAA2B,EAAE,CAAC;QAClE,CAAC;QAED,gDAAgD;QAChD,IAAI,QAAQ,CAAC,sBAAsB,EAAE,CAAC;YACpC,MAAM,QAAQ,CAAC,sBAAsB,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;QAC7D,CAAC;QAED,8CAA8C;QAC9C,QAAQ,CAAC,oBAAoB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAE7C,0CAA0C;QAC1C,IAAI,QAAQ,CAAC,SAAS,EAAE,CAAC;YACvB,IAAI,CAAC;gBACH,MAAM,QAAQ,CAAC,SAAS,CAAC,uBAAuB,CAAC,MAAM,CAAC,CAAC;gBACzD,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,oDAAoD,MAAM,GAAG,EAAE,CAAC;YACnG,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,CAAC,OAAO,IAAI,yCAAyC,MAAM,EAAE,EAAE,CAAC;YACvG,CAAC;QACH,CAAC;QAED,0DAA0D;QAC1D,MAAM,UAAU,GAAG,QAAQ,CAAC,uBAAuB,CAAC,MAAM,CAAC,CAAC;QAC5D,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC1B,IAAI,CAAC;gBACH,MAAM,UAAU,CAAC,oBAAoB,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;gBACrD,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,oDAAoD,MAAM,gBAAgB,UAAU,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;YAChI,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,CAAC,OAAO,IAAI,yCAAyC,MAAM,EAAE,EAAE,CAAC;YACvG,CAAC;QACH,CAAC;QAED,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,+BAA+B,MAAM,GAAG,EAAE,CAAC;IAC/E,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,iBAAiB,CAAC,MAAc;QAC5C,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC;QAC/C,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;QAEjD,sCAAsC;QACtC,MAAM,KAAK,GAAG;YACZ,gBAAgB,MAAM,EAAE;YACxB,gBAAgB,WAAW,EAAE;YAC7B,UAAU,WAAW,EAAE;SACxB,CAAC;QAEF,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,IAAI,CAAC;gBACH,MAAM,QAAQ,CAAC,cAAc,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YAC7C,CAAC;YAAC,MAAM,CAAC;gBACP,8BAA8B;YAChC,CAAC;QACH,CAAC;QAED,kCAAkC;QAClC,QAAQ,CAAC,oBAAoB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAE7C,qBAAqB;QACrB,IAAI,QAAQ,CAAC,sBAAsB,EAAE,CAAC;YACpC,MAAM,QAAQ,CAAC,sBAAsB,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;QAC7D,CAAC;QAED,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,iCAAiC,MAAM,GAAG,EAAE,CAAC;IAChF,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,iBAAiB,CAAC,MAAc;QAa5C,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC;QAC/C,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;QAEjD,2DAA2D;QAC3D,IAAI,QAAQ,GAAG,MAAM,QAAQ,CAAC,cAAc,CAAC,OAAO,CAAC,UAAU,WAAW,EAAE,CAAC,CAAC;QAC9E,IAAI,QAAQ,IAAI,QAAQ,CAAC,SAAS,IAAI,QAAQ,CAAC,UAAU,EAAE,CAAC;YAC1D,OAAO;gBACL,OAAO,EAAE,IAAI;gBACb,IAAI,EAAE;oBACJ,EAAE,EAAE,QAAQ,CAAC,EAAE,IAAI,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE;oBAC9C,UAAU,EAAE,QAAQ,CAAC,UAAU,IAAI,MAAM;oBACzC,OAAO,EAAE,QAAQ,CAAC,OAAO,IAAI,IAAI,CAAC,GAAG,EAAE;oBACvC,UAAU,EAAE,QAAQ,CAAC,UAAU,IAAI,CAAC;oBACpC,UAAU,EAAE,QAAQ,CAAC,UAAU;oBAC/B,SAAS,EAAE,QAAQ,CAAC,SAAS;oBAC7B,GAAG,EAAE,QAAQ,CAAC,GAAG,IAAI,EAAE;iBACxB;aACF,CAAC;QACJ,CAAC;QAED,mDAAmD;QACnD,QAAQ,GAAG,MAAM,QAAQ,CAAC,cAAc,CAAC,OAAO,CAAC,gBAAgB,MAAM,EAAE,CAAC,CAAC;QAC3E,IAAI,CAAC,QAAQ,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC;YACrC,wBAAwB;YACxB,QAAQ,GAAG,MAAM,QAAQ,CAAC,cAAc,CAAC,OAAO,CAAC,gBAAgB,WAAW,EAAE,CAAC,CAAC;QAClF,CAAC;QAED,IAAI,QAAQ,IAAI,QAAQ,CAAC,SAAS,IAAI,QAAQ,CAAC,UAAU,EAAE,CAAC;YAC1D,OAAO;gBACL,OAAO,EAAE,IAAI;gBACb,IAAI,EAAE;oBACJ,EAAE,EAAE,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE;oBAC/B,UAAU,EAAE,MAAM;oBAClB,OAAO,EAAE,QAAQ,CAAC,SAAS,IAAI,IAAI,CAAC,GAAG,EAAE;oBACzC,UAAU,EAAE,QAAQ,CAAC,UAAU,IAAI,CAAC;oBACpC,UAAU,EAAE,QAAQ,CAAC,UAAU;oBAC/B,SAAS,EAAE,QAAQ,CAAC,SAAS;oBAC7B,GAAG,EAAE,EAAE;iBACR;aACF,CAAC;QACJ,CAAC;QAED,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,kCAAkC,MAAM,GAAG,EAAE,CAAC;IAClF,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,iBAAiB,CAAC,IAQ/B;QACC,uBAAuB;QACvB,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,6BAA6B,CAAC,EAAE,CAAC;YAC/E,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,2DAA2D,EAAE,CAAC;QAClG,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,UAAU,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC;YAChE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,oDAAoD,EAAE,CAAC;QAC3F,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC;QAC/C,MAAM,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;QAE1D,8CAA8C;QAC9C,MAAM,QAAQ,CAAC,cAAc,CAAC,OAAO,CAAC,UAAU,WAAW,EAAE,EAAE;YAC7D,EAAE,EAAE,IAAI,CAAC,EAAE;YACX,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,GAAG,EAAE,IAAI,CAAC,GAAG,IAAI,EAAE;SACpB,CAAC,CAAC;QAEH,iDAAiD;QACjD,MAAM,QAAQ,CAAC,cAAc,CAAC,OAAO,CAAC,gBAAgB,IAAI,CAAC,UAAU,EAAE,EAAE;YACvE,MAAM,EAAE,IAAI,CAAC,UAAU;YACvB,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,EAAE,EAAE,SAAS;YACb,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,SAAS,EAAE,IAAI,CAAC,OAAO;SACxB,CAAC,CAAC;QAEH,8BAA8B;QAC9B,QAAQ,CAAC,oBAAoB,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,EAAE;YACjD,MAAM,EAAE,OAAO;YACf,MAAM,EAAE,QAAQ;YAChB,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,SAAS;YACjF,QAAQ,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,SAAS;YACzE,UAAU,EAAE,EAAE;SACf,CAAC,CAAC;QAEH,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,6BAA6B,IAAI,CAAC,UAAU,GAAG,EAAE,CAAC;IACrF,CAAC;CACF"}

package/dist_ts/opsserver/handlers/config.handler.d.ts

@@ -0,0 +1,9 @@
+import * as plugins from '../../plugins.js';
+import type { OpsServer } from '../classes.opsserver.js';
+export declare class ConfigHandler {
+    private opsServerRef;
+    typedrouter: plugins.typedrequest.TypedRouter;
+    constructor(opsServerRef: OpsServer);
+    private registerHandlers;
+    private getConfiguration;
+}

package/dist_ts/opsserver/handlers/config.handler.js

@@ -0,0 +1,169 @@
+import * as plugins from '../../plugins.js';
+import * as paths from '../../paths.js';
+import * as interfaces from '../../../dist_ts_interfaces/index.js';
+export class ConfigHandler {
+    opsServerRef;
+    typedrouter = new plugins.typedrequest.TypedRouter();
+    constructor(opsServerRef) {
+        this.opsServerRef = opsServerRef;
+        // Add this handler's router to the parent
+        this.opsServerRef.typedrouter.addTypedRouter(this.typedrouter);
+        this.registerHandlers();
+    }
+    registerHandlers() {
+        // Get Configuration Handler (read-only)
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getConfiguration', async (dataArg, toolsArg) => {
+            const config = await this.getConfiguration();
+            return {
+                config,
+                section: dataArg.section,
+            };
+        }));
+    }
+    async getConfiguration() {
+        const dcRouter = this.opsServerRef.dcRouterRef;
+        const opts = dcRouter.options;
+        const resolvedPaths = dcRouter.resolvedPaths;
+        // --- System ---
+        const storageBackend = opts.storage?.readFunction
+            ? 'custom'
+            : opts.storage?.fsPath
+                ? 'filesystem'
+                : 'memory';
+        const system = {
+            baseDir: resolvedPaths.dcrouterHomeDir,
+            dataDir: resolvedPaths.dataDir,
+            publicIp: opts.publicIp || null,
+            proxyIps: opts.proxyIps || [],
+            uptime: Math.floor(process.uptime()),
+            storageBackend,
+            storagePath: opts.storage?.fsPath || null,
+        };
+        // --- SmartProxy ---
+        let acmeInfo = null;
+        if (opts.smartProxyConfig?.acme) {
+            const acme = opts.smartProxyConfig.acme;
+            acmeInfo = {
+                enabled: acme.enabled !== false,
+                accountEmail: acme.accountEmail || '',
+                useProduction: acme.useProduction !== false,
+                autoRenew: acme.autoRenew !== false,
+                renewThresholdDays: acme.renewThresholdDays || 30,
+            };
+        }
+        let routeCount = 0;
+        if (dcRouter.routeConfigManager) {
+            try {
+                const merged = await dcRouter.routeConfigManager.getMergedRoutes();
+                routeCount = merged.routes.length;
+            }
+            catch {
+                routeCount = opts.smartProxyConfig?.routes?.length || 0;
+            }
+        }
+        else if (opts.smartProxyConfig?.routes) {
+            routeCount = opts.smartProxyConfig.routes.length;
+        }
+        const smartProxy = {
+            enabled: !!dcRouter.smartProxy,
+            routeCount,
+            acme: acmeInfo,
+        };
+        // --- Email ---
+        let emailDomains = [];
+        if (dcRouter.emailServer && dcRouter.emailServer.domainRegistry) {
+            emailDomains = dcRouter.emailServer.domainRegistry.getAllDomains();
+        }
+        else if (opts.emailConfig?.domains) {
+            emailDomains = opts.emailConfig.domains.map((d) => typeof d === 'string' ? d : d.domain);
+        }
+        let portMapping = null;
+        if (opts.emailPortConfig?.portMapping) {
+            portMapping = {};
+            for (const [ext, int] of Object.entries(opts.emailPortConfig.portMapping)) {
+                portMapping[String(ext)] = int;
+            }
+        }
+        const email = {
+            enabled: !!dcRouter.emailServer,
+            ports: opts.emailConfig?.ports || [],
+            portMapping,
+            hostname: opts.emailConfig?.hostname || null,
+            domains: emailDomains,
+            emailRouteCount: opts.emailConfig?.routes?.length || 0,
+            receivedEmailsPath: opts.emailPortConfig?.receivedEmailsPath || null,
+        };
+        // --- DNS ---
+        const dnsRecords = (opts.dnsRecords || []).map(r => ({
+            name: r.name,
+            type: r.type,
+            value: r.value,
+            ttl: r.ttl,
+        }));
+        const dns = {
+            enabled: !!dcRouter.dnsServer,
+            port: 53,
+            nsDomains: opts.dnsNsDomains || [],
+            scopes: opts.dnsScopes || [],
+            recordCount: dnsRecords.length,
+            records: dnsRecords,
+            dnsChallenge: !!opts.dnsChallenge?.cloudflareApiKey,
+        };
+        // --- TLS ---
+        let tlsSource = 'none';
+        if (opts.tls?.certPath && opts.tls?.keyPath) {
+            tlsSource = 'static';
+        }
+        else if (opts.smartProxyConfig?.acme?.enabled !== false && opts.smartProxyConfig?.acme) {
+            tlsSource = 'acme';
+        }
+        const tls = {
+            contactEmail: opts.tls?.contactEmail || opts.smartProxyConfig?.acme?.accountEmail || null,
+            domain: opts.tls?.domain || null,
+            source: tlsSource,
+            certPath: opts.tls?.certPath || null,
+            keyPath: opts.tls?.keyPath || null,
+        };
+        // --- Cache ---
+        const cacheConfig = opts.cacheConfig;
+        const cache = {
+            enabled: cacheConfig?.enabled !== false,
+            storagePath: cacheConfig?.storagePath || resolvedPaths.defaultTsmDbPath,
+            dbName: cacheConfig?.dbName || 'dcrouter',
+            defaultTTLDays: cacheConfig?.defaultTTLDays || 30,
+            cleanupIntervalHours: cacheConfig?.cleanupIntervalHours || 1,
+            ttlConfig: cacheConfig?.ttlConfig ? { ...cacheConfig.ttlConfig } : {},
+        };
+        // --- RADIUS ---
+        const radiusCfg = opts.radiusConfig;
+        const radius = {
+            enabled: !!dcRouter.radiusServer,
+            authPort: radiusCfg?.authPort || null,
+            acctPort: radiusCfg?.acctPort || null,
+            bindAddress: radiusCfg?.bindAddress || null,
+            clientCount: radiusCfg?.clients?.length || 0,
+            vlanDefaultVlan: radiusCfg?.vlanAssignment?.defaultVlan ?? null,
+            vlanAllowUnknownMacs: radiusCfg?.vlanAssignment?.allowUnknownMacs ?? null,
+            vlanMappingCount: radiusCfg?.vlanAssignment?.mappings?.length || 0,
+        };
+        // --- Remote Ingress ---
+        const riCfg = opts.remoteIngressConfig;
+        const remoteIngress = {
+            enabled: !!dcRouter.remoteIngressManager,
+            tunnelPort: riCfg?.tunnelPort || null,
+            hubDomain: riCfg?.hubDomain || null,
+            tlsConfigured: !!(riCfg?.tls?.certPath && riCfg?.tls?.keyPath),
+        };
+        return {
+            system,
+            smartProxy,
+            email,
+            dns,
+            tls,
+            cache,
+            radius,
+            remoteIngress,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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