@push.rocks/smartproxy 3.26.0 → 3.28.1

package/dist_ts/classes.port80handler.js

@@ -1,19 +1,109 @@
-import * as http from 'http';
-import * as acme from 'acme-client';
-export class Port80Handler {
-    constructor() {
+import * as plugins from './plugins.js';
+/**
+ * Events emitted by the ACME Certificate Manager
+ */
+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 = {}));
+/**
+ * Improved ACME Certificate Manager with event emission and external certificate management
+ */
+export class AcmeCertManager extends plugins.EventEmitter {
+    /**
+     * Creates a new ACME Certificate Manager
+     * @param options Configuration options
+     */
+    constructor(options = {}) {
+        super();
+        this.server = null;
         this.acmeClient = null;
         this.accountKey = null;
+        this.renewalTimer = null;
+        this.isShuttingDown = false;
         this.domainCertificates = new Map();
-        // Create and start an HTTP server on port 80.
-        this.server = http.createServer((req, res) => this.handleRequest(req, res));
-        this.server.listen(80, () => {
-            console.log('Port80Handler is listening on port 80');
+        // Default options
+        this.options = {
+            port: options.port ?? 80,
+            contactEmail: options.contactEmail ?? 'admin@example.com',
+            useProduction: options.useProduction ?? false, // Safer default: staging
+            renewThresholdDays: options.renewThresholdDays ?? 30,
+            httpsRedirectPort: options.httpsRedirectPort ?? 443,
+            renewCheckIntervalHours: options.renewCheckIntervalHours ?? 24,
+        };
+    }
+    /**
+     * Starts the HTTP server for ACME challenges
+     */
+    async start() {
+        if (this.server) {
+            throw new Error('Server is already running');
+        }
+        if (this.isShuttingDown) {
+            throw new Error('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.`));
+                    }
+                    else if (error.code === 'EADDRINUSE') {
+                        reject(new Error(`Port ${this.options.port} is already in use.`));
+                    }
+                    else {
+                        reject(error);
+                    }
+                });
+                this.server.listen(this.options.port, () => {
+                    console.log(`AcmeCertManager is listening on port ${this.options.port}`);
+                    this.startRenewalTimer();
+                    this.emit(CertManagerEvents.MANAGER_STARTED, this.options.port);
+                    resolve();
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
         });
     }
     /**
-     * Adds a domain to be managed.
-     * @param domain The domain to add.
+     * Stops the HTTP server and renewal timer
+     */
+    async stop() {
+        if (!this.server) {
+            return;
+        }
+        this.isShuttingDown = true;
+        // Stop the renewal timer
+        if (this.renewalTimer) {
+            clearInterval(this.renewalTimer);
+            this.renewalTimer = null;
+        }
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(() => {
+                    this.server = null;
+                    this.isShuttingDown = false;
+                    this.emit(CertManagerEvents.MANAGER_STOPPED);
+                    resolve();
+                });
+            }
+            else {
+                this.isShuttingDown = false;
+                resolve();
+            }
+        });
+    }
+    /**
+     * Adds a domain to be managed for certificates
+     * @param domain The domain to add
      */
     addDomain(domain) {
         if (!this.domainCertificates.has(domain)) {
@@ -22,8 +112,8 @@ export class Port80Handler {
         }
     }
     /**
-     * Removes a domain from management.
-     * @param domain The domain to remove.
+     * Removes a domain from management
+     * @param domain The domain to remove
      */
     removeDomain(domain) {
         if (this.domainCertificates.delete(domain)) {
@@ -31,32 +121,91 @@ export class Port80Handler {
         }
     }
     /**
-     * Lazy initialization of the ACME client.
-     * Uses Let’s Encrypt’s production directory (for testing you might switch to staging).
+     * Sets a certificate for a domain directly (for externally obtained certificates)
+     * @param domain The domain for the certificate
+     * @param certificate The certificate (PEM format)
+     * @param privateKey The private key (PEM format)
+     * @param expiryDate Optional expiry date
+     */
+    setCertificate(domain, certificate, privateKey, expiryDate) {
+        let domainInfo = this.domainCertificates.get(domain);
+        if (!domainInfo) {
+            domainInfo = { certObtained: false, obtainingInProgress: false };
+            this.domainCertificates.set(domain, domainInfo);
+        }
+        domainInfo.certificate = certificate;
+        domainInfo.privateKey = privateKey;
+        domainInfo.certObtained = true;
+        domainInfo.obtainingInProgress = false;
+        if (expiryDate) {
+            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}`);
+            }
+        }
+        console.log(`Certificate set for ${domain}`);
+        // Emit certificate event
+        this.emitCertificateEvent(CertManagerEvents.CERTIFICATE_ISSUED, {
+            domain,
+            certificate,
+            privateKey,
+            expiryDate: domainInfo.expiryDate || new Date(Date.now() + 90 * 24 * 60 * 60 * 1000) // 90 days default
+        });
+    }
+    /**
+     * Gets the certificate for a domain if it exists
+     * @param domain The domain to get the certificate for
+     */
+    getCertificate(domain) {
+        const domainInfo = this.domainCertificates.get(domain);
+        if (!domainInfo || !domainInfo.certObtained || !domainInfo.certificate || !domainInfo.privateKey) {
+            return null;
+        }
+        return {
+            domain,
+            certificate: domainInfo.certificate,
+            privateKey: domainInfo.privateKey,
+            expiryDate: domainInfo.expiryDate || new Date(Date.now() + 90 * 24 * 60 * 60 * 1000) // 90 days default
+        };
+    }
+    /**
+     * Lazy initialization of the ACME client
+     * @returns An ACME client instance
      */
     async getAcmeClient() {
         if (this.acmeClient) {
             return this.acmeClient;
         }
-        // Generate a new account key and convert Buffer to string.
-        this.accountKey = (await acme.forge.createPrivateKey()).toString();
-        this.acmeClient = new acme.Client({
-            directoryUrl: acme.directory.letsencrypt.production, // Use production for a real certificate
-            // For testing, you could use:
-            // directoryUrl: acme.directory.letsencrypt.staging,
+        // 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. Make sure to update the contact email.
+        // Create a new account
         await this.acmeClient.createAccount({
             termsOfServiceAgreed: true,
-            contact: ['mailto:admin@example.com'],
+            contact: [`mailto:${this.options.contactEmail}`],
         });
         return this.acmeClient;
     }
     /**
-     * Handles incoming HTTP requests on port 80.
-     * If the request is for an ACME challenge, it responds with the key authorization.
-     * If the domain has a certificate, it redirects to HTTPS; otherwise, it initiates certificate issuance.
+     * Handles incoming HTTP requests
+     * @param req The HTTP request
+     * @param res The HTTP response
      */
     handleRequest(req, res) {
         const hostHeader = req.headers.host;
@@ -67,7 +216,7 @@ export class Port80Handler {
         }
         // 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 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;
@@ -78,18 +227,20 @@ export class Port80Handler {
             return;
         }
         const domainInfo = this.domainCertificates.get(domain);
-        // If certificate exists, redirect to HTTPS on port 443.
+        // If certificate exists, redirect to HTTPS
         if (domainInfo.certObtained) {
-            const redirectUrl = `https://${domain}:443${req.url}`;
+            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}`);
         }
         else {
-            // Trigger certificate issuance if not already running.
+            // Trigger certificate issuance if not already running
             if (!domainInfo.obtainingInProgress) {
-                domainInfo.obtainingInProgress = true;
                 this.obtainCertificate(domain).catch(err => {
+                    this.emit(CertManagerEvents.CERTIFICATE_FAILED, { domain, error: err.message });
                     console.error(`Error obtaining certificate for ${domain}:`, err);
                 });
             }
@@ -98,7 +249,10 @@ export class Port80Handler {
         }
     }
     /**
-     * Serves the ACME HTTP-01 challenge response.
+     * Serves the ACME HTTP-01 challenge response
+     * @param req The HTTP request
+     * @param res The HTTP response
+     * @param domain The domain for the challenge
      */
     handleAcmeChallenge(req, res, domain) {
         const domainInfo = this.domainCertificates.get(domain);
@@ -107,7 +261,7 @@ export class Port80Handler {
             res.end('Domain not configured');
             return;
         }
-        // The token is the last part of the URL.
+        // The token is the last part of the URL
         const urlParts = req.url?.split('/');
         const token = urlParts ? urlParts[urlParts.length - 1] : '';
         if (domainInfo.challengeToken === token && domainInfo.challengeKeyAuthorization) {
@@ -122,65 +276,180 @@ export class Port80Handler {
         }
     }
     /**
-     * Uses acme-client to perform a full ACME HTTP-01 challenge to obtain a certificate.
-     * On success, it stores the certificate and key in memory and clears challenge data.
+     * Obtains a certificate for a domain using ACME HTTP-01 challenge
+     * @param domain The domain to obtain a certificate for
+     * @param isRenewal Whether this is a renewal attempt
      */
-    async obtainCertificate(domain) {
+    async obtainCertificate(domain, isRenewal = false) {
+        // Get the domain info
+        const domainInfo = this.domainCertificates.get(domain);
+        if (!domainInfo) {
+            throw new Error(`Domain not found: ${domain}`);
+        }
+        // Prevent concurrent certificate issuance
+        if (domainInfo.obtainingInProgress) {
+            console.log(`Certificate issuance already in progress for ${domain}`);
+            return;
+        }
+        domainInfo.obtainingInProgress = true;
+        domainInfo.lastRenewalAttempt = new Date();
         try {
             const client = await this.getAcmeClient();
-            // Create a new order for the domain.
+            // Create a new order for the domain
             const order = await client.createOrder({
                 identifiers: [{ type: 'dns', value: domain }],
             });
-            // Get the authorizations for the order.
+            // 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.
+                // Get the key authorization for the challenge
                 const keyAuthorization = await client.getChallengeKeyAuthorization(challenge);
-                const domainInfo = this.domainCertificates.get(domain);
+                // Store the challenge data
                 domainInfo.challengeToken = challenge.token;
                 domainInfo.challengeKeyAuthorization = keyAuthorization;
-                // Notify the ACME server that the challenge is ready.
-                // The acme-client examples show that verifyChallenge takes three arguments:
-                // (authorization, challenge, keyAuthorization). However, the official TypeScript
-                // types appear to be out-of-sync. As a workaround, we cast client to 'any'.
-                await client.verifyChallenge(authz, challenge, keyAuthorization);
-                await client.completeChallenge(challenge);
-                // Wait until the challenge is validated.
-                await client.waitForValidStatus(challenge);
-                console.log(`HTTP-01 challenge completed for ${domain}`);
+                // 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;
+                }
             }
-            // Generate a CSR and a new private key for the domain.
-            // Convert the resulting Buffers to strings.
-            const [csrBuffer, privateKeyBuffer] = await acme.forge.createCsr({
+            // Generate a CSR and private key
+            const [csrBuffer, privateKeyBuffer] = await plugins.acme.forge.createCsr({
                 commonName: domain,
             });
             const csr = csrBuffer.toString();
             const privateKey = privateKeyBuffer.toString();
-            // Finalize the order and obtain the certificate.
+            // Finalize the order with our CSR
             await client.finalizeOrder(order, csr);
+            // Get the certificate with the full chain
             const certificate = await client.getCertificate(order);
-            const domainInfo = this.domainCertificates.get(domain);
+            // Store the certificate and key
             domainInfo.certificate = certificate;
             domainInfo.privateKey = privateKey;
             domainInfo.certObtained = true;
-            domainInfo.obtainingInProgress = false;
+            // Clear challenge data
             delete domainInfo.challengeToken;
             delete domainInfo.challengeKeyAuthorization;
-            console.log(`Certificate obtained for ${domain}`);
-            // In a production system, persist the certificate and key and reload your TLS server.
+            // 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}`);
+            }
+            console.log(`Certificate ${isRenewal ? 'renewed' : 'obtained'} for ${domain}`);
+            // Emit the appropriate event
+            const eventType = isRenewal
+                ? CertManagerEvents.CERTIFICATE_RENEWED
+                : CertManagerEvents.CERTIFICATE_ISSUED;
+            this.emitCertificateEvent(eventType, {
+                domain,
+                certificate,
+                privateKey,
+                expiryDate: domainInfo.expiryDate || new Date(Date.now() + 90 * 24 * 60 * 60 * 1000) // 90 days default
+            });
         }
         catch (error) {
-            console.error(`Error during certificate issuance for ${domain}:`, error);
-            const domainInfo = this.domainCertificates.get(domain);
-            if (domainInfo) {
-                domainInfo.obtainingInProgress = false;
+            // Check for rate limit errors
+            if (error.message && (error.message.includes('rateLimited') ||
+                error.message.includes('too many certificates') ||
+                error.message.includes('rate limit'))) {
+                console.error(`Rate limit reached for ${domain}. Waiting before retry.`);
+            }
+            else {
+                console.error(`Error during certificate issuance for ${domain}:`, error);
+            }
+            // Emit failure event
+            this.emit(CertManagerEvents.CERTIFICATE_FAILED, {
+                domain,
+                error: error.message || 'Unknown error',
+                isRenewal
+            });
+        }
+        finally {
+            // Reset flag whether successful or not
+            domainInfo.obtainingInProgress = false;
+        }
+    }
+    /**
+     * Starts the certificate renewal timer
+     */
+    startRenewalTimer() {
+        if (this.renewalTimer) {
+            clearInterval(this.renewalTimer);
+        }
+        // Convert hours to milliseconds
+        const checkInterval = this.options.renewCheckIntervalHours * 60 * 60 * 1000;
+        this.renewalTimer = setInterval(() => this.checkForRenewals(), checkInterval);
+        // Prevent the timer from keeping the process alive
+        if (this.renewalTimer.unref) {
+            this.renewalTimer.unref();
+        }
+        console.log(`Certificate renewal check scheduled every ${this.options.renewCheckIntervalHours} hours`);
+    }
+    /**
+     * Checks for certificates that need renewal
+     */
+    checkForRenewals() {
+        if (this.isShuttingDown) {
+            return;
+        }
+        console.log('Checking for certificates that need renewal...');
+        const now = new Date();
+        const renewThresholdMs = this.options.renewThresholdDays * 24 * 60 * 60 * 1000;
+        for (const [domain, domainInfo] of this.domainCertificates.entries()) {
+            // Skip domains without certificates or already in renewal
+            if (!domainInfo.certObtained || domainInfo.obtainingInProgress) {
+                continue;
+            }
+            // Skip domains without expiry dates
+            if (!domainInfo.expiryDate) {
+                continue;
+            }
+            const timeUntilExpiry = domainInfo.expiryDate.getTime() - now.getTime();
+            // Check if certificate is near expiry
+            if (timeUntilExpiry <= renewThresholdMs) {
+                console.log(`Certificate for ${domain} expires soon, renewing...`);
+                this.emit(CertManagerEvents.CERTIFICATE_EXPIRING, {
+                    domain,
+                    expiryDate: domainInfo.expiryDate,
+                    daysRemaining: Math.ceil(timeUntilExpiry / (24 * 60 * 60 * 1000))
+                });
+                // Start renewal process
+                this.obtainCertificate(domain, true).catch(err => {
+                    console.error(`Error renewing certificate for ${domain}:`, err);
+                });
             }
         }
     }
+    /**
+     * Emits a certificate event with the certificate data
+     * @param eventType The event type to emit
+     * @param data The certificate data
+     */
+    emitCertificateEvent(eventType, data) {
+        this.emit(eventType, data);
+    }
 }
-//# sourceMappingURL=data:application/json;base64,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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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"}