@push.rocks/smartproxy 4.2.4 → 4.2.6

package/dist_ts/classes.port80handler.js

@@ -1,22 +1,48 @@
 import * as plugins from './plugins.js';
+import { IncomingMessage, ServerResponse } from 'http';
 /**
- * Events emitted by the ACME Certificate Manager
+ * Custom error classes for better error handling
  */
-export var CertManagerEvents;
-(function (CertManagerEvents) {
-    CertManagerEvents["CERTIFICATE_ISSUED"] = "certificate-issued";
-    CertManagerEvents["CERTIFICATE_RENEWED"] = "certificate-renewed";
-    CertManagerEvents["CERTIFICATE_FAILED"] = "certificate-failed";
-    CertManagerEvents["CERTIFICATE_EXPIRING"] = "certificate-expiring";
-    CertManagerEvents["MANAGER_STARTED"] = "manager-started";
-    CertManagerEvents["MANAGER_STOPPED"] = "manager-stopped";
-})(CertManagerEvents || (CertManagerEvents = {}));
+export class Port80HandlerError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'Port80HandlerError';
+    }
+}
+export class CertificateError extends Port80HandlerError {
+    constructor(message, domain, isRenewal = false) {
+        super(`${message} for domain ${domain}${isRenewal ? ' (renewal)' : ''}`);
+        this.domain = domain;
+        this.isRenewal = isRenewal;
+        this.name = 'CertificateError';
+    }
+}
+export class ServerError extends Port80HandlerError {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'ServerError';
+    }
+}
 /**
- * Improved ACME Certificate Manager with event emission and external certificate management
+ * Events emitted by the Port80Handler
  */
-export class AcmeCertManager extends plugins.EventEmitter {
+export var Port80HandlerEvents;
+(function (Port80HandlerEvents) {
+    Port80HandlerEvents["CERTIFICATE_ISSUED"] = "certificate-issued";
+    Port80HandlerEvents["CERTIFICATE_RENEWED"] = "certificate-renewed";
+    Port80HandlerEvents["CERTIFICATE_FAILED"] = "certificate-failed";
+    Port80HandlerEvents["CERTIFICATE_EXPIRING"] = "certificate-expiring";
+    Port80HandlerEvents["MANAGER_STARTED"] = "manager-started";
+    Port80HandlerEvents["MANAGER_STOPPED"] = "manager-stopped";
+    Port80HandlerEvents["REQUEST_FORWARDED"] = "request-forwarded";
+})(Port80HandlerEvents || (Port80HandlerEvents = {}));
+/**
+ * Port80Handler with ACME certificate management and request forwarding capabilities
+ */
+export class Port80Handler extends plugins.EventEmitter {
     /**
-     * Creates a new ACME Certificate Manager
+     * Creates a new Port80Handler
      * @param options Configuration options
      */
     constructor(options = {}) {
@@ -32,7 +58,7 @@ export class AcmeCertManager extends plugins.EventEmitter {
             port: options.port ?? 80,
             contactEmail: options.contactEmail ?? 'admin@example.com',
             useProduction: options.useProduction ?? false, // Safer default: staging
-            renewThresholdDays: options.renewThresholdDays ?? 30,
+            renewThresholdDays: options.renewThresholdDays ?? 10, // Changed to 10 days as per requirements
             httpsRedirectPort: options.httpsRedirectPort ?? 443,
             renewCheckIntervalHours: options.renewCheckIntervalHours ?? 24,
         };
@@ -42,34 +68,43 @@ export class AcmeCertManager extends plugins.EventEmitter {
      */
     async start() {
         if (this.server) {
-            throw new Error('Server is already running');
+            throw new ServerError('Server is already running');
         }
         if (this.isShuttingDown) {
-            throw new Error('Server is shutting down');
+            throw new ServerError('Server is shutting down');
         }
         return new Promise((resolve, reject) => {
             try {
                 this.server = plugins.http.createServer((req, res) => this.handleRequest(req, res));
                 this.server.on('error', (error) => {
                     if (error.code === 'EACCES') {
-                        reject(new Error(`Permission denied to bind to port ${this.options.port}. Try running with elevated privileges or use a port > 1024.`));
+                        reject(new ServerError(`Permission denied to bind to port ${this.options.port}. Try running with elevated privileges or use a port > 1024.`, error.code));
                     }
                     else if (error.code === 'EADDRINUSE') {
-                        reject(new Error(`Port ${this.options.port} is already in use.`));
+                        reject(new ServerError(`Port ${this.options.port} is already in use.`, error.code));
                     }
                     else {
-                        reject(error);
+                        reject(new ServerError(error.message, error.code));
                     }
                 });
                 this.server.listen(this.options.port, () => {
-                    console.log(`AcmeCertManager is listening on port ${this.options.port}`);
+                    console.log(`Port80Handler is listening on port ${this.options.port}`);
                     this.startRenewalTimer();
-                    this.emit(CertManagerEvents.MANAGER_STARTED, this.options.port);
+                    this.emit(Port80HandlerEvents.MANAGER_STARTED, this.options.port);
+                    // Start certificate process for domains with acmeMaintenance enabled
+                    for (const [domain, domainInfo] of this.domainCertificates.entries()) {
+                        if (domainInfo.options.acmeMaintenance && !domainInfo.certObtained && !domainInfo.obtainingInProgress) {
+                            this.obtainCertificate(domain).catch(err => {
+                                console.error(`Error obtaining initial certificate for ${domain}:`, err);
+                            });
+                        }
+                    }
                     resolve();
                 });
             }
             catch (error) {
-                reject(error);
+                const message = error instanceof Error ? error.message : 'Unknown error starting server';
+                reject(new ServerError(message));
             }
         });
     }
@@ -91,7 +126,7 @@ export class AcmeCertManager extends plugins.EventEmitter {
                 this.server.close(() => {
                     this.server = null;
                     this.isShuttingDown = false;
-                    this.emit(CertManagerEvents.MANAGER_STOPPED);
+                    this.emit(Port80HandlerEvents.MANAGER_STOPPED);
                     resolve();
                 });
             }
@@ -102,13 +137,38 @@ export class AcmeCertManager extends plugins.EventEmitter {
         });
     }
     /**
-     * Adds a domain to be managed for certificates
-     * @param domain The domain to add
+     * Adds a domain with configuration options
+     * @param options Domain configuration options
      */
-    addDomain(domain) {
-        if (!this.domainCertificates.has(domain)) {
-            this.domainCertificates.set(domain, { certObtained: false, obtainingInProgress: false });
-            console.log(`Domain added: ${domain}`);
+    addDomain(options) {
+        if (!options.domainName || typeof options.domainName !== 'string') {
+            throw new Port80HandlerError('Invalid domain name');
+        }
+        const domainName = options.domainName;
+        if (!this.domainCertificates.has(domainName)) {
+            this.domainCertificates.set(domainName, {
+                options,
+                certObtained: false,
+                obtainingInProgress: false
+            });
+            console.log(`Domain added: ${domainName} with configuration:`, {
+                sslRedirect: options.sslRedirect,
+                acmeMaintenance: options.acmeMaintenance,
+                hasForward: !!options.forward,
+                hasAcmeForward: !!options.acmeForward
+            });
+            // If acmeMaintenance is enabled, start certificate process immediately
+            if (options.acmeMaintenance && this.server) {
+                this.obtainCertificate(domainName).catch(err => {
+                    console.error(`Error obtaining initial certificate for ${domainName}:`, err);
+                });
+            }
+        }
+        else {
+            // Update existing domain with new options
+            const existing = this.domainCertificates.get(domainName);
+            existing.options = options;
+            console.log(`Domain ${domainName} configuration updated`);
         }
     }
     /**
@@ -128,9 +188,22 @@ export class AcmeCertManager extends plugins.EventEmitter {
      * @param expiryDate Optional expiry date
      */
     setCertificate(domain, certificate, privateKey, expiryDate) {
+        if (!domain || !certificate || !privateKey) {
+            throw new Port80HandlerError('Domain, certificate and privateKey are required');
+        }
         let domainInfo = this.domainCertificates.get(domain);
         if (!domainInfo) {
-            domainInfo = { certObtained: false, obtainingInProgress: false };
+            // Create default domain options if not already configured
+            const defaultOptions = {
+                domainName: domain,
+                sslRedirect: true,
+                acmeMaintenance: true
+            };
+            domainInfo = {
+                options: defaultOptions,
+                certObtained: false,
+                obtainingInProgress: false
+            };
             this.domainCertificates.set(domain, domainInfo);
         }
         domainInfo.certificate = certificate;
@@ -141,26 +214,16 @@ export class AcmeCertManager extends plugins.EventEmitter {
             domainInfo.expiryDate = expiryDate;
         }
         else {
-            // Try to extract expiry date from certificate
-            try {
-                // This is a simplistic approach - in a real implementation, use a proper
-                // certificate parsing library like node-forge or x509
-                const matches = certificate.match(/Not After\s*:\s*(.*?)(?:\n|$)/i);
-                if (matches && matches[1]) {
-                    domainInfo.expiryDate = new Date(matches[1]);
-                }
-            }
-            catch (error) {
-                console.warn(`Failed to extract expiry date from certificate for ${domain}`);
-            }
+            // Extract expiry date from certificate
+            domainInfo.expiryDate = this.extractExpiryDateFromCertificate(certificate, domain);
         }
         console.log(`Certificate set for ${domain}`);
         // Emit certificate event
-        this.emitCertificateEvent(CertManagerEvents.CERTIFICATE_ISSUED, {
+        this.emitCertificateEvent(Port80HandlerEvents.CERTIFICATE_ISSUED, {
             domain,
             certificate,
             privateKey,
-            expiryDate: domainInfo.expiryDate || new Date(Date.now() + 90 * 24 * 60 * 60 * 1000) // 90 days default
+            expiryDate: domainInfo.expiryDate || this.getDefaultExpiryDate()
         });
     }
     /**
@@ -176,7 +239,7 @@ export class AcmeCertManager extends plugins.EventEmitter {
             domain,
             certificate: domainInfo.certificate,
             privateKey: domainInfo.privateKey,
-            expiryDate: domainInfo.expiryDate || new Date(Date.now() + 90 * 24 * 60 * 60 * 1000) // 90 days default
+            expiryDate: domainInfo.expiryDate || this.getDefaultExpiryDate()
         };
     }
     /**
@@ -187,20 +250,26 @@ export class AcmeCertManager extends plugins.EventEmitter {
         if (this.acmeClient) {
             return this.acmeClient;
         }
-        // Generate a new account key
-        this.accountKey = (await plugins.acme.forge.createPrivateKey()).toString();
-        this.acmeClient = new plugins.acme.Client({
-            directoryUrl: this.options.useProduction
-                ? plugins.acme.directory.letsencrypt.production
-                : plugins.acme.directory.letsencrypt.staging,
-            accountKey: this.accountKey,
-        });
-        // Create a new account
-        await this.acmeClient.createAccount({
-            termsOfServiceAgreed: true,
-            contact: [`mailto:${this.options.contactEmail}`],
-        });
-        return this.acmeClient;
+        try {
+            // Generate a new account key
+            this.accountKey = (await plugins.acme.forge.createPrivateKey()).toString();
+            this.acmeClient = new plugins.acme.Client({
+                directoryUrl: this.options.useProduction
+                    ? plugins.acme.directory.letsencrypt.production
+                    : plugins.acme.directory.letsencrypt.staging,
+                accountKey: this.accountKey,
+            });
+            // Create a new account
+            await this.acmeClient.createAccount({
+                termsOfServiceAgreed: true,
+                contact: [`mailto:${this.options.contactEmail}`],
+            });
+            return this.acmeClient;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error initializing ACME client';
+            throw new Port80HandlerError(`Failed to initialize ACME client: ${message}`);
+        }
     }
     /**
      * Handles incoming HTTP requests
@@ -216,36 +285,111 @@ export class AcmeCertManager extends plugins.EventEmitter {
         }
         // Extract domain (ignoring any port in the Host header)
         const domain = hostHeader.split(':')[0];
-        // If the request is for an ACME HTTP-01 challenge, handle it
-        if (req.url && req.url.startsWith('/.well-known/acme-challenge/')) {
-            this.handleAcmeChallenge(req, res, domain);
-            return;
-        }
+        // Check if domain is configured
         if (!this.domainCertificates.has(domain)) {
             res.statusCode = 404;
             res.end('Domain not configured');
             return;
         }
         const domainInfo = this.domainCertificates.get(domain);
-        // If certificate exists, redirect to HTTPS
-        if (domainInfo.certObtained) {
+        const options = domainInfo.options;
+        // If the request is for an ACME HTTP-01 challenge, handle it
+        if (req.url && req.url.startsWith('/.well-known/acme-challenge/') && (options.acmeMaintenance || options.acmeForward)) {
+            // Check if we should forward ACME requests
+            if (options.acmeForward) {
+                this.forwardRequest(req, res, options.acmeForward, 'ACME challenge');
+                return;
+            }
+            this.handleAcmeChallenge(req, res, domain);
+            return;
+        }
+        // Check if we should forward non-ACME requests
+        if (options.forward) {
+            this.forwardRequest(req, res, options.forward, 'HTTP');
+            return;
+        }
+        // If certificate exists and sslRedirect is enabled, redirect to HTTPS
+        if (domainInfo.certObtained && options.sslRedirect) {
             const httpsPort = this.options.httpsRedirectPort;
             const portSuffix = httpsPort === 443 ? '' : `:${httpsPort}`;
             const redirectUrl = `https://${domain}${portSuffix}${req.url || '/'}`;
             res.statusCode = 301;
             res.setHeader('Location', redirectUrl);
             res.end(`Redirecting to ${redirectUrl}`);
+            return;
         }
-        else {
+        // Handle case where certificate maintenance is enabled but not yet obtained
+        if (options.acmeMaintenance && !domainInfo.certObtained) {
             // Trigger certificate issuance if not already running
             if (!domainInfo.obtainingInProgress) {
                 this.obtainCertificate(domain).catch(err => {
-                    this.emit(CertManagerEvents.CERTIFICATE_FAILED, { domain, error: err.message });
+                    const errorMessage = err instanceof Error ? err.message : 'Unknown error';
+                    this.emit(Port80HandlerEvents.CERTIFICATE_FAILED, {
+                        domain,
+                        error: errorMessage,
+                        isRenewal: false
+                    });
                     console.error(`Error obtaining certificate for ${domain}:`, err);
                 });
             }
             res.statusCode = 503;
             res.end('Certificate issuance in progress, please try again later.');
+            return;
+        }
+        // Default response for unhandled request
+        res.statusCode = 404;
+        res.end('No handlers configured for this request');
+    }
+    /**
+     * Forwards an HTTP request to the specified target
+     * @param req The original request
+     * @param res The response object
+     * @param target The forwarding target (IP and port)
+     * @param requestType Type of request for logging
+     */
+    forwardRequest(req, res, target, requestType) {
+        const options = {
+            hostname: target.ip,
+            port: target.port,
+            path: req.url,
+            method: req.method,
+            headers: { ...req.headers }
+        };
+        const domain = req.headers.host?.split(':')[0] || 'unknown';
+        console.log(`Forwarding ${requestType} request for ${domain} to ${target.ip}:${target.port}`);
+        const proxyReq = plugins.http.request(options, (proxyRes) => {
+            // Copy status code
+            res.statusCode = proxyRes.statusCode || 500;
+            // Copy headers
+            for (const [key, value] of Object.entries(proxyRes.headers)) {
+                if (value)
+                    res.setHeader(key, value);
+            }
+            // Pipe response data
+            proxyRes.pipe(res);
+            this.emit(Port80HandlerEvents.REQUEST_FORWARDED, {
+                domain,
+                requestType,
+                target: `${target.ip}:${target.port}`,
+                statusCode: proxyRes.statusCode
+            });
+        });
+        proxyReq.on('error', (error) => {
+            console.error(`Error forwarding request to ${target.ip}:${target.port}:`, error);
+            if (!res.headersSent) {
+                res.statusCode = 502;
+                res.end(`Proxy error: ${error.message}`);
+            }
+            else {
+                res.end();
+            }
+        });
+        // Pipe original request to proxy request
+        if (req.readable) {
+            req.pipe(proxyReq);
+        }
+        else {
+            proxyReq.end();
         }
     }
     /**
@@ -284,7 +428,12 @@ export class AcmeCertManager extends plugins.EventEmitter {
         // Get the domain info
         const domainInfo = this.domainCertificates.get(domain);
         if (!domainInfo) {
-            throw new Error(`Domain not found: ${domain}`);
+            throw new CertificateError('Domain not found', domain, isRenewal);
+        }
+        // Verify that acmeMaintenance is enabled
+        if (!domainInfo.options.acmeMaintenance) {
+            console.log(`Skipping certificate issuance for ${domain} - acmeMaintenance is disabled`);
+            return;
         }
         // Prevent concurrent certificate issuance
         if (domainInfo.obtainingInProgress) {
@@ -301,35 +450,8 @@ export class AcmeCertManager extends plugins.EventEmitter {
             });
             // Get the authorizations for the order
             const authorizations = await client.getAuthorizations(order);
-            for (const authz of authorizations) {
-                const challenge = authz.challenges.find(ch => ch.type === 'http-01');
-                if (!challenge) {
-                    throw new Error('HTTP-01 challenge not found');
-                }
-                // Get the key authorization for the challenge
-                const keyAuthorization = await client.getChallengeKeyAuthorization(challenge);
-                // Store the challenge data
-                domainInfo.challengeToken = challenge.token;
-                domainInfo.challengeKeyAuthorization = keyAuthorization;
-                // ACME client type definition workaround - use compatible approach
-                // First check if challenge verification is needed
-                const authzUrl = authz.url;
-                try {
-                    // Check if authzUrl exists and perform verification
-                    if (authzUrl) {
-                        await client.verifyChallenge(authz, challenge);
-                    }
-                    // Complete the challenge
-                    await client.completeChallenge(challenge);
-                    // Wait for validation
-                    await client.waitForValidStatus(challenge);
-                    console.log(`HTTP-01 challenge completed for ${domain}`);
-                }
-                catch (error) {
-                    console.error(`Challenge error for ${domain}:`, error);
-                    throw error;
-                }
-            }
+            // Process each authorization
+            await this.processAuthorizations(client, domain, authorizations);
             // Generate a CSR and private key
             const [csrBuffer, privateKeyBuffer] = await plugins.acme.forge.createCsr({
                 commonName: domain,
@@ -348,26 +470,17 @@ export class AcmeCertManager extends plugins.EventEmitter {
             delete domainInfo.challengeToken;
             delete domainInfo.challengeKeyAuthorization;
             // Extract expiry date from certificate
-            try {
-                const matches = certificate.match(/Not After\s*:\s*(.*?)(?:\n|$)/i);
-                if (matches && matches[1]) {
-                    domainInfo.expiryDate = new Date(matches[1]);
-                    console.log(`Certificate for ${domain} will expire on ${domainInfo.expiryDate.toISOString()}`);
-                }
-            }
-            catch (error) {
-                console.warn(`Failed to extract expiry date from certificate for ${domain}`);
-            }
+            domainInfo.expiryDate = this.extractExpiryDateFromCertificate(certificate, domain);
             console.log(`Certificate ${isRenewal ? 'renewed' : 'obtained'} for ${domain}`);
             // Emit the appropriate event
             const eventType = isRenewal
-                ? CertManagerEvents.CERTIFICATE_RENEWED
-                : CertManagerEvents.CERTIFICATE_ISSUED;
+                ? Port80HandlerEvents.CERTIFICATE_RENEWED
+                : Port80HandlerEvents.CERTIFICATE_ISSUED;
             this.emitCertificateEvent(eventType, {
                 domain,
                 certificate,
                 privateKey,
-                expiryDate: domainInfo.expiryDate || new Date(Date.now() + 90 * 24 * 60 * 60 * 1000) // 90 days default
+                expiryDate: domainInfo.expiryDate || this.getDefaultExpiryDate()
             });
         }
         catch (error) {
@@ -381,17 +494,60 @@ export class AcmeCertManager extends plugins.EventEmitter {
                 console.error(`Error during certificate issuance for ${domain}:`, error);
             }
             // Emit failure event
-            this.emit(CertManagerEvents.CERTIFICATE_FAILED, {
+            this.emit(Port80HandlerEvents.CERTIFICATE_FAILED, {
                 domain,
                 error: error.message || 'Unknown error',
                 isRenewal
             });
+            throw new CertificateError(error.message || 'Certificate issuance failed', domain, isRenewal);
         }
         finally {
             // Reset flag whether successful or not
             domainInfo.obtainingInProgress = false;
         }
     }
+    /**
+     * Process ACME authorizations by verifying and completing challenges
+     * @param client ACME client
+     * @param domain Domain name
+     * @param authorizations Authorizations to process
+     */
+    async processAuthorizations(client, domain, authorizations) {
+        const domainInfo = this.domainCertificates.get(domain);
+        if (!domainInfo) {
+            throw new CertificateError('Domain not found during authorization', domain);
+        }
+        for (const authz of authorizations) {
+            const challenge = authz.challenges.find(ch => ch.type === 'http-01');
+            if (!challenge) {
+                throw new CertificateError('HTTP-01 challenge not found', domain);
+            }
+            // Get the key authorization for the challenge
+            const keyAuthorization = await client.getChallengeKeyAuthorization(challenge);
+            // Store the challenge data
+            domainInfo.challengeToken = challenge.token;
+            domainInfo.challengeKeyAuthorization = keyAuthorization;
+            // ACME client type definition workaround - use compatible approach
+            // First check if challenge verification is needed
+            const authzUrl = authz.url;
+            try {
+                // Check if authzUrl exists and perform verification
+                if (authzUrl) {
+                    await client.verifyChallenge(authz, challenge);
+                }
+                // Complete the challenge
+                await client.completeChallenge(challenge);
+                // Wait for validation
+                await client.waitForValidStatus(challenge);
+                console.log(`HTTP-01 challenge completed for ${domain}`);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Unknown challenge error';
+                console.error(`Challenge error for ${domain}:`, error);
+                throw new CertificateError(`Challenge verification failed: ${errorMessage}`, domain);
+            }
+        }
+    }
     /**
      * Starts the certificate renewal timer
      */
@@ -419,6 +575,10 @@ export class AcmeCertManager extends plugins.EventEmitter {
         const now = new Date();
         const renewThresholdMs = this.options.renewThresholdDays * 24 * 60 * 60 * 1000;
         for (const [domain, domainInfo] of this.domainCertificates.entries()) {
+            // Skip domains with acmeMaintenance disabled
+            if (!domainInfo.options.acmeMaintenance) {
+                continue;
+            }
             // Skip domains without certificates or already in renewal
             if (!domainInfo.certObtained || domainInfo.obtainingInProgress) {
                 continue;
@@ -431,18 +591,54 @@ export class AcmeCertManager extends plugins.EventEmitter {
             // Check if certificate is near expiry
             if (timeUntilExpiry <= renewThresholdMs) {
                 console.log(`Certificate for ${domain} expires soon, renewing...`);
-                this.emit(CertManagerEvents.CERTIFICATE_EXPIRING, {
+                const daysRemaining = Math.ceil(timeUntilExpiry / (24 * 60 * 60 * 1000));
+                this.emit(Port80HandlerEvents.CERTIFICATE_EXPIRING, {
                     domain,
                     expiryDate: domainInfo.expiryDate,
-                    daysRemaining: Math.ceil(timeUntilExpiry / (24 * 60 * 60 * 1000))
+                    daysRemaining
                 });
                 // Start renewal process
                 this.obtainCertificate(domain, true).catch(err => {
-                    console.error(`Error renewing certificate for ${domain}:`, err);
+                    const errorMessage = err instanceof Error ? err.message : 'Unknown error';
+                    console.error(`Error renewing certificate for ${domain}:`, errorMessage);
                 });
             }
         }
     }
+    /**
+     * Extract expiry date from certificate using a more robust approach
+     * @param certificate Certificate PEM string
+     * @param domain Domain for logging
+     * @returns Extracted expiry date or default
+     */
+    extractExpiryDateFromCertificate(certificate, domain) {
+        try {
+            // This is still using regex, but in a real implementation you would use
+            // a library like node-forge or x509 to properly parse the certificate
+            const matches = certificate.match(/Not After\s*:\s*(.*?)(?:\n|$)/i);
+            if (matches && matches[1]) {
+                const expiryDate = new Date(matches[1]);
+                // Validate that we got a valid date
+                if (!isNaN(expiryDate.getTime())) {
+                    console.log(`Certificate for ${domain} will expire on ${expiryDate.toISOString()}`);
+                    return expiryDate;
+                }
+            }
+            console.warn(`Could not extract valid expiry date from certificate for ${domain}, using default`);
+            return this.getDefaultExpiryDate();
+        }
+        catch (error) {
+            console.warn(`Failed to extract expiry date from certificate for ${domain}, using default`);
+            return this.getDefaultExpiryDate();
+        }
+    }
+    /**
+     * Get a default expiry date (90 days from now)
+     * @returns Default expiry date
+     */
+    getDefaultExpiryDate() {
+        return new Date(Date.now() + 90 * 24 * 60 * 60 * 1000); // 90 days default
+    }
     /**
      * Emits a certificate event with the certificate data
      * @param eventType The event type to emit
@@ -452,4 +648,4 @@ export class AcmeCertManager extends plugins.EventEmitter {
         this.emit(eventType, data);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.port80handler.js","sourceRoot":"","sources":["../ts/classes.port80handler.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.port80handler.js","sourceRoot":"","sources":["../ts/classes.port80handler.ts"],"names":[],"mappings":"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"}