@push.rocks/smartproxy 12.0.0 → 13.1.2

package/dist_ts/http/port80/challenge-responder.js

@@ -0,0 +1,203 @@
+import * as plugins from '../../plugins.js';
+import { IncomingMessage, ServerResponse } from 'http';
+import { CertificateEvents } from '../../certificate/events/certificate-events.js';
+/**
+ * ChallengeResponder handles ACME HTTP-01 challenges by leveraging SmartAcme
+ * It acts as a bridge between the HTTP server and the ACME challenge verification process
+ */
+export class ChallengeResponder extends plugins.EventEmitter {
+    /**
+     * Creates a new challenge responder
+     * @param useProduction Whether to use production ACME servers
+     * @param email Account email for ACME
+     * @param certificateStore Directory to store certificates
+     */
+    constructor(useProduction = false, email = 'admin@example.com', certificateStore = './certs') {
+        super();
+        this.useProduction = useProduction;
+        this.email = email;
+        this.certificateStore = certificateStore;
+        this.smartAcme = null;
+        this.http01Handler = null;
+    }
+    /**
+     * Initialize the ACME client
+     */
+    async initialize() {
+        try {
+            // Create the HTTP-01 memory handler from SmartACME
+            this.http01Handler = new plugins.smartacme.handlers.Http01MemoryHandler();
+            // Ensure certificate store directory exists
+            await this.ensureCertificateStore();
+            // Create a MemoryCertManager for certificate storage
+            const certManager = new plugins.smartacme.certmanagers.MemoryCertManager();
+            // Initialize the SmartACME client with appropriate options
+            this.smartAcme = new plugins.smartacme.SmartAcme({
+                accountEmail: this.email,
+                certManager: certManager,
+                environment: this.useProduction ? 'production' : 'integration',
+                challengeHandlers: [this.http01Handler],
+                challengePriority: ['http-01']
+            });
+            // Set up event forwarding from SmartAcme
+            this.setupEventListeners();
+            // Start the SmartACME client
+            await this.smartAcme.start();
+            console.log('ACME client initialized successfully');
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to initialize ACME client: ${errorMessage}`);
+        }
+    }
+    /**
+     * Ensure the certificate store directory exists
+     */
+    async ensureCertificateStore() {
+        try {
+            await plugins.fs.promises.mkdir(this.certificateStore, { recursive: true });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to create certificate store: ${errorMessage}`);
+        }
+    }
+    /**
+     * Setup event listeners to forward SmartACME events to our own event emitter
+     */
+    setupEventListeners() {
+        if (!this.smartAcme)
+            return;
+        const setupEvents = (emitter) => {
+            // Forward certificate events
+            emitter.on('certificate', (data) => {
+                const isRenewal = !!data.isRenewal;
+                const certData = {
+                    domain: data.domainName || data.domain,
+                    certificate: data.publicKey || data.cert,
+                    privateKey: data.privateKey || data.key,
+                    expiryDate: new Date(data.validUntil || data.expiryDate || Date.now()),
+                    source: 'http01',
+                    isRenewal
+                };
+                const eventType = isRenewal
+                    ? CertificateEvents.CERTIFICATE_RENEWED
+                    : CertificateEvents.CERTIFICATE_ISSUED;
+                this.emit(eventType, certData);
+            });
+            // Forward error events
+            emitter.on('error', (error) => {
+                const domain = error.domainName || error.domain || 'unknown';
+                const failureData = {
+                    domain,
+                    error: error.message || String(error),
+                    isRenewal: !!error.isRenewal
+                };
+                this.emit(CertificateEvents.CERTIFICATE_FAILED, failureData);
+            });
+        };
+        // Check for direct event methods on SmartAcme
+        if (typeof this.smartAcme.on === 'function') {
+            setupEvents(this.smartAcme);
+        }
+        // Check for eventEmitter property
+        else if (this.smartAcme.eventEmitter) {
+            setupEvents(this.smartAcme.eventEmitter);
+        }
+        // If no proper event handling, log a warning
+        else {
+            console.warn('SmartAcme instance does not support expected event interface - events may not be forwarded');
+        }
+    }
+    /**
+     * Handle HTTP request by checking if it's an ACME challenge
+     * @param req HTTP request object
+     * @param res HTTP response object
+     * @returns true if the request was handled, false otherwise
+     */
+    handleRequest(req, res) {
+        if (!this.http01Handler)
+            return false;
+        // Check if this is an ACME challenge request (/.well-known/acme-challenge/*)
+        const url = req.url || '';
+        if (url.startsWith('/.well-known/acme-challenge/')) {
+            try {
+                // Delegate to the HTTP-01 memory handler, which knows how to serve challenges
+                this.http01Handler.handleRequest(req, res);
+                return true;
+            }
+            catch (error) {
+                console.error('Error handling ACME challenge:', error);
+                // If there was an error, send a 404 response
+                res.writeHead(404);
+                res.end('Not found');
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Request a certificate for a domain
+     * @param domain Domain name to request a certificate for
+     * @param isRenewal Whether this is a renewal request
+     */
+    async requestCertificate(domain, isRenewal = false) {
+        if (!this.smartAcme) {
+            throw new Error('ACME client not initialized');
+        }
+        try {
+            // Request certificate using SmartACME
+            const certObj = await this.smartAcme.getCertificateForDomain(domain);
+            // Convert the certificate object to our CertificateData format
+            const certData = {
+                domain,
+                certificate: certObj.publicKey,
+                privateKey: certObj.privateKey,
+                expiryDate: new Date(certObj.validUntil),
+                source: 'http01',
+                isRenewal
+            };
+            return certData;
+        }
+        catch (error) {
+            // Create failure object
+            const failure = {
+                domain,
+                error: error instanceof Error ? error.message : String(error),
+                isRenewal
+            };
+            // Emit failure event
+            this.emit(CertificateEvents.CERTIFICATE_FAILED, failure);
+            // Rethrow with more context
+            throw new Error(`Failed to ${isRenewal ? 'renew' : 'obtain'} certificate for ${domain}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Check if a certificate is expiring soon and trigger renewal if needed
+     * @param domain Domain name
+     * @param certificate Certificate data
+     * @param thresholdDays Days before expiry to trigger renewal
+     */
+    checkCertificateExpiry(domain, certificate, thresholdDays = 30) {
+        if (!certificate.expiryDate)
+            return;
+        const now = new Date();
+        const expiryDate = certificate.expiryDate;
+        const daysDifference = Math.floor((expiryDate.getTime() - now.getTime()) / (1000 * 60 * 60 * 24));
+        if (daysDifference <= thresholdDays) {
+            const expiryInfo = {
+                domain,
+                expiryDate,
+                daysRemaining: daysDifference
+            };
+            this.emit(CertificateEvents.CERTIFICATE_EXPIRING, expiryInfo);
+            // Automatically attempt renewal if expiring
+            if (this.smartAcme) {
+                this.requestCertificate(domain, true).catch(error => {
+                    console.error(`Failed to auto-renew certificate for ${domain}:`, error);
+                });
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/http/port80/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Port 80 handling
+ */
+export { Port80Handler } from './port80-handler.js';
+export { ChallengeResponder } from './challenge-responder.js';
+export { HttpError as Port80HandlerError, CertificateError as CertError } from '../models/http-types.js';

package/dist_ts/http/port80/index.js

@@ -0,0 +1,9 @@
+/**
+ * Port 80 handling
+ */
+// Export the main components
+export { Port80Handler } from './port80-handler.js';
+export { ChallengeResponder } from './challenge-responder.js';
+// Export backward compatibility interfaces and types
+export { HttpError as Port80HandlerError, CertificateError as CertError } from '../models/http-types.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9odHRwL3BvcnQ4MC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILDZCQUE2QjtBQUM3QixPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDcEQsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFFOUQscURBQXFEO0FBQ3JELE9BQU8sRUFDTCxTQUFTLElBQUksa0JBQWtCLEVBQy9CLGdCQUFnQixJQUFJLFNBQVMsRUFDOUIsTUFBTSx5QkFBeUIsQ0FBQyJ9

package/dist_ts/http/port80/port80-handler.d.ts

@@ -0,0 +1,121 @@
+import * as plugins from '../../plugins.js';
+import { CertificateEvents } from '../../certificate/events/certificate-events.js';
+import type { IDomainOptions, ICertificateData, IAcmeOptions } from '../../certificate/models/certificate-types.js';
+import { HttpError, CertificateError, ServerError } from '../models/http-types.js';
+export { HttpError as Port80HandlerError, CertificateError, ServerError };
+export declare const Port80HandlerEvents: typeof CertificateEvents;
+/**
+ * Configuration options for the Port80Handler
+ */
+/**
+ * Port80Handler with ACME certificate management and request forwarding capabilities
+ * Now with glob pattern support for domain matching
+ */
+export declare class Port80Handler extends plugins.EventEmitter {
+    private domainCertificates;
+    private challengeResponder;
+    private server;
+    private isShuttingDown;
+    private options;
+    /**
+     * Creates a new Port80Handler
+     * @param options Configuration options
+     */
+    constructor(options?: IAcmeOptions);
+    /**
+     * Starts the HTTP server for ACME challenges
+     */
+    start(): Promise<void>;
+    /**
+     * Stops the HTTP server and cleanup resources
+     */
+    stop(): Promise<void>;
+    /**
+     * Adds a domain with configuration options
+     * @param options Domain configuration options
+     */
+    addDomain(options: IDomainOptions): void;
+    /**
+     * Removes a domain from management
+     * @param domain The domain to remove
+     */
+    removeDomain(domain: string): void;
+    /**
+     * Gets the certificate for a domain if it exists
+     * @param domain The domain to get the certificate for
+     */
+    getCertificate(domain: string): ICertificateData | null;
+    /**
+     * Check if a domain is a glob pattern
+     * @param domain Domain to check
+     * @returns True if the domain is a glob pattern
+     */
+    private isGlobPattern;
+    /**
+     * Get domain info for a specific domain, using glob pattern matching if needed
+     * @param requestDomain The actual domain from the request
+     * @returns The domain info or null if not found
+     */
+    private getDomainInfoForRequest;
+    /**
+     * Check if a domain matches a glob pattern
+     * @param domain The domain to check
+     * @param pattern The pattern to match against
+     * @returns True if the domain matches the pattern
+     */
+    private domainMatchesPattern;
+    /**
+     * Handles incoming HTTP requests
+     * @param req The HTTP request
+     * @param res The HTTP response
+     */
+    private handleRequest;
+    /**
+     * 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
+     */
+    private forwardRequest;
+    /**
+     * 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
+     */
+    private obtainCertificate;
+    /**
+     * 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
+     */
+    private extractExpiryDateFromCertificate;
+    /**
+     * Get a default expiry date (90 days from now)
+     * @returns Default expiry date
+     */
+    private getDefaultExpiryDate;
+    /**
+     * Emits a certificate event with the certificate data
+     * @param eventType The event type to emit
+     * @param data The certificate data
+     */
+    private emitCertificateEvent;
+    /**
+     * Gets all domains and their certificate status
+     * @returns Map of domains to certificate status
+     */
+    getDomainCertificateStatus(): Map<string, {
+        certObtained: boolean;
+        expiryDate?: Date;
+        daysRemaining?: number;
+        obtainingInProgress: boolean;
+        lastRenewalAttempt?: Date;
+    }>;
+    /**
+     * Request a certificate renewal for a specific domain.
+     * @param domain The domain to renew.
+     */
+    renewCertificate(domain: string): Promise<void>;
+}