@push.rocks/smartproxy 5.1.0 → 6.0.0

package/dist_ts/classes.pp.portproxy.js

@@ -5,9 +5,11 @@ import { DomainConfigManager } from './classes.pp.domainconfigmanager.js';
 import { TlsManager } from './classes.pp.tlsmanager.js';
 import { NetworkProxyBridge } from './classes.pp.networkproxybridge.js';
 import { TimeoutManager } from './classes.pp.timeoutmanager.js';
-import { AcmeManager } from './classes.pp.acmemanager.js';
 import { PortRangeManager } from './classes.pp.portrangemanager.js';
 import { ConnectionHandler } from './classes.pp.connectionhandler.js';
+import { Port80Handler, Port80HandlerEvents } from './port80handler/classes.port80handler.js';
+import * as path from 'path';
+import * as fs from 'fs';
 /**
  * PortProxy - Main class that coordinates all components
  */
@@ -16,6 +18,8 @@ export class PortProxy {
         this.netServers = [];
         this.connectionLogger = null;
         this.isShuttingDown = false;
+        // Port80Handler for ACME certificate management
+        this.port80Handler = null;
         // Set reasonable defaults for all settings
         this.settings = {
             ...settingsArg,
@@ -42,17 +46,42 @@ export class PortProxy {
             keepAliveInactivityMultiplier: settingsArg.keepAliveInactivityMultiplier || 6,
             extendedKeepAliveLifetime: settingsArg.extendedKeepAliveLifetime || 7 * 24 * 60 * 60 * 1000,
             networkProxyPort: settingsArg.networkProxyPort || 8443,
-            acme: settingsArg.acme || {
-                enabled: false,
-                port: 80,
-                contactEmail: 'admin@example.com',
-                useProduction: false,
-                renewThresholdDays: 30,
-                autoRenew: true,
-                certificateStore: './certs',
-                skipConfiguredCerts: false,
-            },
+            port80HandlerConfig: settingsArg.port80HandlerConfig || {},
+            globalPortRanges: settingsArg.globalPortRanges || [],
         };
+        // Set port80HandlerConfig defaults, using legacy acme config if available
+        if (!this.settings.port80HandlerConfig || Object.keys(this.settings.port80HandlerConfig).length === 0) {
+            if (this.settings.acme) {
+                // Migrate from legacy acme config
+                this.settings.port80HandlerConfig = {
+                    enabled: this.settings.acme.enabled,
+                    port: this.settings.acme.port || 80,
+                    contactEmail: this.settings.acme.contactEmail || 'admin@example.com',
+                    useProduction: this.settings.acme.useProduction || false,
+                    renewThresholdDays: this.settings.acme.renewThresholdDays || 30,
+                    autoRenew: this.settings.acme.autoRenew !== false, // Default to true
+                    certificateStore: this.settings.acme.certificateStore || './certs',
+                    skipConfiguredCerts: this.settings.acme.skipConfiguredCerts || false,
+                    httpsRedirectPort: this.settings.fromPort,
+                    renewCheckIntervalHours: 24
+                };
+            }
+            else {
+                // Set defaults if no config provided
+                this.settings.port80HandlerConfig = {
+                    enabled: false,
+                    port: 80,
+                    contactEmail: 'admin@example.com',
+                    useProduction: false,
+                    renewThresholdDays: 30,
+                    autoRenew: true,
+                    certificateStore: './certs',
+                    skipConfiguredCerts: false,
+                    httpsRedirectPort: this.settings.fromPort,
+                    renewCheckIntervalHours: 24
+                };
+            }
+        }
         // Initialize component managers
         this.timeoutManager = new TimeoutManager(this.settings);
         this.securityManager = new SecurityManager(this.settings);
@@ -61,10 +90,90 @@ export class PortProxy {
         this.tlsManager = new TlsManager(this.settings);
         this.networkProxyBridge = new NetworkProxyBridge(this.settings);
         this.portRangeManager = new PortRangeManager(this.settings);
-        this.acmeManager = new AcmeManager(this.settings, this.networkProxyBridge);
         // Initialize connection handler
         this.connectionHandler = new ConnectionHandler(this.settings, this.connectionManager, this.securityManager, this.domainConfigManager, this.tlsManager, this.networkProxyBridge, this.timeoutManager, this.portRangeManager);
     }
+    /**
+     * Initialize the Port80Handler for ACME certificate management
+     */
+    async initializePort80Handler() {
+        const config = this.settings.port80HandlerConfig;
+        if (!config || !config.enabled) {
+            console.log('Port80Handler is disabled in configuration');
+            return;
+        }
+        try {
+            // Ensure the certificate store directory exists
+            if (config.certificateStore) {
+                const certStorePath = path.resolve(config.certificateStore);
+                if (!fs.existsSync(certStorePath)) {
+                    fs.mkdirSync(certStorePath, { recursive: true });
+                    console.log(`Created certificate store directory: ${certStorePath}`);
+                }
+            }
+            // Create Port80Handler with options from config
+            this.port80Handler = new Port80Handler({
+                port: config.port,
+                contactEmail: config.contactEmail,
+                useProduction: config.useProduction,
+                renewThresholdDays: config.renewThresholdDays,
+                httpsRedirectPort: config.httpsRedirectPort || this.settings.fromPort,
+                renewCheckIntervalHours: config.renewCheckIntervalHours,
+                enabled: config.enabled,
+                autoRenew: config.autoRenew,
+                certificateStore: config.certificateStore,
+                skipConfiguredCerts: config.skipConfiguredCerts
+            });
+            // Register domain forwarding configurations
+            if (config.domainForwards) {
+                for (const forward of config.domainForwards) {
+                    this.port80Handler.addDomain({
+                        domainName: forward.domain,
+                        sslRedirect: true,
+                        acmeMaintenance: true,
+                        forward: forward.forwardConfig,
+                        acmeForward: forward.acmeForwardConfig
+                    });
+                    console.log(`Registered domain forwarding for ${forward.domain}`);
+                }
+            }
+            // Register all non-wildcard domains from domain configs
+            for (const domainConfig of this.settings.domainConfigs) {
+                for (const domain of domainConfig.domains) {
+                    // Skip wildcards
+                    if (domain.includes('*'))
+                        continue;
+                    this.port80Handler.addDomain({
+                        domainName: domain,
+                        sslRedirect: true,
+                        acmeMaintenance: true
+                    });
+                    console.log(`Registered domain ${domain} with Port80Handler`);
+                }
+            }
+            // Set up event listeners
+            this.port80Handler.on(Port80HandlerEvents.CERTIFICATE_ISSUED, (certData) => {
+                console.log(`Certificate issued for ${certData.domain}, valid until ${certData.expiryDate.toISOString()}`);
+            });
+            this.port80Handler.on(Port80HandlerEvents.CERTIFICATE_RENEWED, (certData) => {
+                console.log(`Certificate renewed for ${certData.domain}, valid until ${certData.expiryDate.toISOString()}`);
+            });
+            this.port80Handler.on(Port80HandlerEvents.CERTIFICATE_FAILED, (failureData) => {
+                console.log(`Certificate ${failureData.isRenewal ? 'renewal' : 'issuance'} failed for ${failureData.domain}: ${failureData.error}`);
+            });
+            this.port80Handler.on(Port80HandlerEvents.CERTIFICATE_EXPIRING, (expiryData) => {
+                console.log(`Certificate for ${expiryData.domain} is expiring in ${expiryData.daysRemaining} days`);
+            });
+            // Share Port80Handler with NetworkProxyBridge
+            this.networkProxyBridge.setPort80Handler(this.port80Handler);
+            // Start Port80Handler
+            await this.port80Handler.start();
+            console.log(`Port80Handler started on port ${config.port}`);
+        }
+        catch (err) {
+            console.log(`Error initializing Port80Handler: ${err}`);
+        }
+    }
     /**
      * Start the proxy server
      */
@@ -74,6 +183,8 @@ export class PortProxy {
             console.log("Cannot start PortProxy while it's shutting down");
             return;
         }
+        // Initialize Port80Handler if enabled
+        await this.initializePort80Handler();
         // Initialize and start NetworkProxy if needed
         if (this.settings.useNetworkProxy &&
             this.settings.useNetworkProxy.length > 0) {
@@ -178,6 +289,17 @@ export class PortProxy {
     async stop() {
         console.log('PortProxy shutting down...');
         this.isShuttingDown = true;
+        // Stop the Port80Handler if running
+        if (this.port80Handler) {
+            try {
+                await this.port80Handler.stop();
+                console.log('Port80Handler stopped');
+                this.port80Handler = null;
+            }
+            catch (err) {
+                console.log(`Error stopping Port80Handler: ${err}`);
+            }
+        }
         // Stop accepting new connections
         const closeServerPromises = this.netServers.map((server) => new Promise((resolve) => {
             if (!server.listening) {
@@ -218,21 +340,141 @@ export class PortProxy {
         if (this.networkProxyBridge.getNetworkProxy()) {
             await this.networkProxyBridge.syncDomainConfigsToNetworkProxy();
         }
+        // If Port80Handler is running, register non-wildcard domains
+        if (this.port80Handler && this.settings.port80HandlerConfig?.enabled) {
+            for (const domainConfig of newDomainConfigs) {
+                for (const domain of domainConfig.domains) {
+                    // Skip wildcards
+                    if (domain.includes('*'))
+                        continue;
+                    this.port80Handler.addDomain({
+                        domainName: domain,
+                        sslRedirect: true,
+                        acmeMaintenance: true
+                    });
+                }
+            }
+            console.log('Registered non-wildcard domains with Port80Handler');
+        }
     }
     /**
-     * Updates the ACME certificate settings
+     * Updates the Port80Handler configuration
      */
-    async updateAcmeSettings(acmeSettings) {
-        console.log('Updating ACME certificate settings');
-        // Delegate to AcmeManager
-        await this.acmeManager.updateAcmeSettings(acmeSettings);
+    async updatePort80HandlerConfig(config) {
+        if (!config)
+            return;
+        console.log('Updating Port80Handler configuration');
+        // Update the settings
+        this.settings.port80HandlerConfig = {
+            ...this.settings.port80HandlerConfig,
+            ...config
+        };
+        // Check if we need to restart Port80Handler
+        let needsRestart = false;
+        // Restart if enabled state changed
+        if (this.port80Handler && config.enabled === false) {
+            needsRestart = true;
+        }
+        else if (!this.port80Handler && config.enabled === true) {
+            needsRestart = true;
+        }
+        else if (this.port80Handler && (config.port !== undefined ||
+            config.contactEmail !== undefined ||
+            config.useProduction !== undefined ||
+            config.renewThresholdDays !== undefined ||
+            config.renewCheckIntervalHours !== undefined)) {
+            // Restart if critical settings changed
+            needsRestart = true;
+        }
+        if (needsRestart) {
+            // Stop if running
+            if (this.port80Handler) {
+                try {
+                    await this.port80Handler.stop();
+                    this.port80Handler = null;
+                    console.log('Stopped Port80Handler for configuration update');
+                }
+                catch (err) {
+                    console.log(`Error stopping Port80Handler: ${err}`);
+                }
+            }
+            // Start with new config if enabled
+            if (this.settings.port80HandlerConfig.enabled) {
+                await this.initializePort80Handler();
+                console.log('Restarted Port80Handler with new configuration');
+            }
+        }
+        else if (this.port80Handler) {
+            // Just update domain forwards if they changed
+            if (config.domainForwards) {
+                for (const forward of config.domainForwards) {
+                    this.port80Handler.addDomain({
+                        domainName: forward.domain,
+                        sslRedirect: true,
+                        acmeMaintenance: true,
+                        forward: forward.forwardConfig,
+                        acmeForward: forward.acmeForwardConfig
+                    });
+                }
+                console.log('Updated domain forwards in Port80Handler');
+            }
+        }
     }
     /**
-     * Requests a certificate for a specific domain
+     * Request a certificate for a specific domain
      */
     async requestCertificate(domain) {
-        // Delegate to AcmeManager
-        return this.acmeManager.requestCertificate(domain);
+        // Validate domain format
+        if (!this.isValidDomain(domain)) {
+            console.log(`Invalid domain format: ${domain}`);
+            return false;
+        }
+        // Use Port80Handler if available
+        if (this.port80Handler) {
+            try {
+                // Check if we already have a certificate
+                const cert = this.port80Handler.getCertificate(domain);
+                if (cert) {
+                    console.log(`Certificate already exists for ${domain}, valid until ${cert.expiryDate.toISOString()}`);
+                    return true;
+                }
+                // Register domain for certificate issuance
+                this.port80Handler.addDomain({
+                    domainName: domain,
+                    sslRedirect: true,
+                    acmeMaintenance: true
+                });
+                console.log(`Domain ${domain} registered for certificate issuance`);
+                return true;
+            }
+            catch (err) {
+                console.log(`Error registering domain with Port80Handler: ${err}`);
+                return false;
+            }
+        }
+        // Fall back to NetworkProxyBridge
+        return this.networkProxyBridge.requestCertificate(domain);
+    }
+    /**
+     * Validates if a domain name is valid for certificate issuance
+     */
+    isValidDomain(domain) {
+        // Very basic domain validation
+        if (!domain || domain.length === 0) {
+            return false;
+        }
+        // Check for wildcard domains (they can't get ACME certs)
+        if (domain.includes('*')) {
+            console.log(`Wildcard domains like "${domain}" are not supported for ACME certificates`);
+            return false;
+        }
+        // Check if domain has at least one dot and no invalid characters
+        const validDomainRegex = /^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+        if (!validDomainRegex.test(domain)) {
+            console.log(`Domain "${domain}" has invalid format`);
+            return false;
+        }
+        return true;
     }
     /**
      * Get statistics about current connections
@@ -261,8 +503,65 @@ export class PortProxy {
             nonTlsConnections,
             keepAliveConnections,
             networkProxyConnections,
-            terminationStats
+            terminationStats,
+            acmeEnabled: !!this.port80Handler,
+            port80HandlerPort: this.port80Handler ? this.settings.port80HandlerConfig?.port : null
+        };
+    }
+    /**
+     * Get a list of eligible domains for ACME certificates
+     */
+    getEligibleDomainsForCertificates() {
+        // Collect all non-wildcard domains from domain configs
+        const domains = [];
+        for (const config of this.settings.domainConfigs) {
+            // Skip domains that can't be used with ACME
+            const eligibleDomains = config.domains.filter(domain => !domain.includes('*') && this.isValidDomain(domain));
+            domains.push(...eligibleDomains);
+        }
+        return domains;
+    }
+    /**
+     * Get status of certificates managed by Port80Handler
+     */
+    getCertificateStatus() {
+        if (!this.port80Handler) {
+            return {
+                enabled: false,
+                message: 'Port80Handler is not enabled'
+            };
+        }
+        // Get eligible domains
+        const eligibleDomains = this.getEligibleDomainsForCertificates();
+        const certificateStatus = {};
+        // Check each domain
+        for (const domain of eligibleDomains) {
+            const cert = this.port80Handler.getCertificate(domain);
+            if (cert) {
+                const now = new Date();
+                const expiryDate = cert.expiryDate;
+                const daysRemaining = Math.floor((expiryDate.getTime() - now.getTime()) / (24 * 60 * 60 * 1000));
+                certificateStatus[domain] = {
+                    status: 'valid',
+                    expiryDate: expiryDate.toISOString(),
+                    daysRemaining,
+                    renewalNeeded: daysRemaining <= this.settings.port80HandlerConfig.renewThresholdDays
+                };
+            }
+            else {
+                certificateStatus[domain] = {
+                    status: 'missing',
+                    message: 'No certificate found'
+                };
+            }
+        }
+        return {
+            enabled: true,
+            port: this.settings.port80HandlerConfig.port,
+            useProduction: this.settings.port80HandlerConfig.useProduction,
+            autoRenew: this.settings.port80HandlerConfig.autoRenew,
+            certificates: certificateStatus
         };
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.pp.portproxy.js","sourceRoot":"","sources":["../ts/classes.pp.portproxy.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.pp.portproxy.js","sourceRoot":"","sources":["../ts/classes.pp.portproxy.ts"],"names":[],"mappings":"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"}

package/dist_ts/index.d.ts

@@ -1,7 +1,7 @@
-export * from './classes.nftablesproxy.js';
-export * from './classes.networkproxy.js';
-export * from './classes.port80handler.js';
+export * from './nfttablesproxy/classes.nftablesproxy.js';
+export * from './networkproxy/classes.np.networkproxy.js';
+export * from './port80handler/classes.port80handler.js';
 export * from './classes.sslredirect.js';
-export * from './classes.pp.portproxy.js';
-export * from './classes.pp.snihandler.js';
-export * from './classes.pp.interfaces.js';
+export * from './smartproxy/classes.smartproxy.js';
+export * from './smartproxy/classes.pp.snihandler.js';
+export * from './smartproxy/classes.pp.interfaces.js';

package/dist_ts/index.js

@@ -1,8 +1,8 @@
-export * from './classes.nftablesproxy.js';
-export * from './classes.networkproxy.js';
-export * from './classes.port80handler.js';
+export * from './nfttablesproxy/classes.nftablesproxy.js';
+export * from './networkproxy/classes.np.networkproxy.js';
+export * from './port80handler/classes.port80handler.js';
 export * from './classes.sslredirect.js';
-export * from './classes.pp.portproxy.js';
-export * from './classes.pp.snihandler.js';
-export * from './classes.pp.interfaces.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLDRCQUE0QixDQUFDIn0=
+export * from './smartproxy/classes.smartproxy.js';
+export * from './smartproxy/classes.pp.snihandler.js';
+export * from './smartproxy/classes.pp.interfaces.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDJDQUEyQyxDQUFDO0FBQzFELGNBQWMsMkNBQTJDLENBQUM7QUFDMUQsY0FBYywwQ0FBMEMsQ0FBQztBQUN6RCxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsb0NBQW9DLENBQUM7QUFDbkQsY0FBYyx1Q0FBdUMsQ0FBQztBQUN0RCxjQUFjLHVDQUF1QyxDQUFDIn0=

package/dist_ts/networkproxy/classes.np.certificatemanager.d.ts

@@ -0,0 +1,77 @@
+import * as plugins from '../plugins.js';
+import { type INetworkProxyOptions, type ICertificateEntry } from './classes.np.types.js';
+import { Port80Handler } from '../port80handler/classes.port80handler.js';
+/**
+ * Manages SSL certificates for NetworkProxy including ACME integration
+ */
+export declare class CertificateManager {
+    private options;
+    private defaultCertificates;
+    private certificateCache;
+    private port80Handler;
+    private externalPort80Handler;
+    private certificateStoreDir;
+    private logger;
+    private httpsServer;
+    constructor(options: INetworkProxyOptions);
+    /**
+     * Loads default certificates from the filesystem
+     */
+    loadDefaultCertificates(): void;
+    /**
+     * Set the HTTPS server reference for context updates
+     */
+    setHttpsServer(server: plugins.https.Server): void;
+    /**
+     * Get default certificates
+     */
+    getDefaultCertificates(): {
+        key: string;
+        cert: string;
+    };
+    /**
+     * Sets an external Port80Handler for certificate management
+     */
+    setExternalPort80Handler(handler: Port80Handler): void;
+    /**
+     * Handle newly issued or renewed certificates from Port80Handler
+     */
+    private handleCertificateIssued;
+    /**
+     * Handle certificate issuance failures
+     */
+    private handleCertificateFailed;
+    /**
+     * Saves certificate and private key to the filesystem
+     */
+    private saveCertificateToStore;
+    /**
+     * Handles SNI (Server Name Indication) for TLS connections
+     * Used by the HTTPS server to select the correct certificate for each domain
+     */
+    handleSNI(domain: string, cb: (err: Error | null, ctx: plugins.tls.SecureContext) => void): void;
+    /**
+     * Updates certificate in cache
+     */
+    updateCertificateCache(domain: string, certificate: string, privateKey: string, expiryDate?: Date): void;
+    /**
+     * Gets a certificate for a domain
+     */
+    getCertificate(domain: string): ICertificateEntry | undefined;
+    /**
+     * Requests a new certificate for a domain
+     */
+    requestCertificate(domain: string): Promise<boolean>;
+    /**
+     * Registers domains with Port80Handler for ACME certificate management
+     */
+    registerDomainsWithPort80Handler(domains: string[]): void;
+    /**
+     * Initialize internal Port80Handler
+     */
+    initializePort80Handler(): Promise<Port80Handler | null>;
+    /**
+     * Stop the Port80Handler if it was internally created
+     */
+    stopPort80Handler(): Promise<void>;
+}