@push.rocks/smartproxy 3.34.0 → 3.37.0

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@push.rocks/smartproxy",
-  "version": "3.34.0",
+  "version": "3.37.0",
   "private": false,
-  "description": "A powerful proxy package that effectively handles high traffic, with features such as SSL/TLS support, port proxying, WebSocket handling, and dynamic routing with authentication options.",
+  "description": "A powerful proxy package that effectively handles high traffic, with features such as SSL/TLS support, port proxying, WebSocket handling, dynamic routing with authentication options, and automatic ACME certificate management.",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
   "type": "module",
@@ -12,8 +12,8 @@
     "@git.zone/tsbuild": "^2.2.6",
     "@git.zone/tsrun": "^1.2.44",
     "@git.zone/tstest": "^1.0.77",
-    "@push.rocks/tapbundle": "^5.5.6",
-    "@types/node": "^22.13.9",
+    "@push.rocks/tapbundle": "^5.5.10",
+    "@types/node": "^22.13.10",
     "typescript": "^5.8.2"
   },
   "dependencies": {
@@ -22,7 +22,7 @@
     "@push.rocks/smartpromise": "^4.2.3",
     "@push.rocks/smartrequest": "^2.0.23",
     "@push.rocks/smartstring": "^4.0.15",
-    "@tsclass/tsclass": "^4.4.3",
+    "@tsclass/tsclass": "^5.0.0",
     "@types/minimatch": "^5.1.2",
     "@types/ws": "^8.18.0",
     "acme-client": "^5.4.0",

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartproxy',
-  version: '3.34.0',
-  description: 'A powerful proxy package that effectively handles high traffic, with features such as SSL/TLS support, port proxying, WebSocket handling, and dynamic routing with authentication options.'
+  version: '3.37.0',
+  description: 'A powerful proxy package that effectively handles high traffic, with features such as SSL/TLS support, port proxying, WebSocket handling, dynamic routing with authentication options, and automatic ACME certificate management.'
 }

package/ts/classes.networkproxy.ts

@@ -1,5 +1,6 @@
 import * as plugins from './plugins.js';
 import { ProxyRouter } from './classes.router.js';
+import { AcmeCertManager, CertManagerEvents } from './classes.port80handler.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
@@ -20,6 +21,18 @@ export interface INetworkProxyOptions {
   // New settings for PortProxy integration
   connectionPoolSize?: number; // Maximum connections to maintain in the pool to each backend
   portProxyIntegration?: boolean; // Flag to indicate this proxy is used by PortProxy
+  
+  // ACME certificate management options
+  acme?: {
+    enabled?: boolean;              // Whether to enable automatic certificate management
+    port?: number;                  // Port to listen on for ACME challenges (default: 80)
+    contactEmail?: string;          // Email for Let's Encrypt account 
+    useProduction?: boolean;        // Whether to use Let's Encrypt production (default: false for staging)
+    renewThresholdDays?: number;    // Days before expiry to renew certificates (default: 30)
+    autoRenew?: boolean;            // Whether to automatically renew certificates (default: true)
+    certificateStore?: string;      // Directory to store certificates (default: ./certs)
+    skipConfiguredCerts?: boolean;  // Skip domains that already have certificates configured
+  };
 }
 
 interface IWebSocketWithHeartbeat extends plugins.wsDefault {
@@ -59,12 +72,19 @@ export class NetworkProxy {
   private defaultCertificates: { key: string; cert: string };
   private certificateCache: Map<string, { key: string; cert: string; expires?: Date }> = new Map();
   
+  // ACME certificate manager
+  private certManager: AcmeCertManager | null = null;
+  private certificateStoreDir: string;
+  
   // New connection pool for backend connections
   private connectionPool: Map<string, Array<{
     socket: plugins.net.Socket;
     lastUsed: number;
     isIdle: boolean;
   }>> = new Map();
+  
+  // Track round-robin positions for load balancing
+  private roundRobinPositions: Map<string, number> = new Map();
 
   /**
    * Creates a new NetworkProxy instance
@@ -85,9 +105,33 @@ export class NetworkProxy {
       },
       // New defaults for PortProxy integration
       connectionPoolSize: optionsArg.connectionPoolSize || 50,
-      portProxyIntegration: optionsArg.portProxyIntegration || false
+      portProxyIntegration: optionsArg.portProxyIntegration || false,
+      // Default ACME options
+      acme: {
+        enabled: optionsArg.acme?.enabled || false,
+        port: optionsArg.acme?.port || 80,
+        contactEmail: optionsArg.acme?.contactEmail || 'admin@example.com',
+        useProduction: optionsArg.acme?.useProduction || false, // Default to staging for safety
+        renewThresholdDays: optionsArg.acme?.renewThresholdDays || 30,
+        autoRenew: optionsArg.acme?.autoRenew !== false, // Default to true
+        certificateStore: optionsArg.acme?.certificateStore || './certs',
+        skipConfiguredCerts: optionsArg.acme?.skipConfiguredCerts || false
+      }
     };
     
+    // Set up certificate store directory
+    this.certificateStoreDir = path.resolve(this.options.acme.certificateStore);
+    
+    // Ensure certificate store directory exists
+    try {
+      if (!fs.existsSync(this.certificateStoreDir)) {
+        fs.mkdirSync(this.certificateStoreDir, { recursive: true });
+        this.log('info', `Created certificate store directory: ${this.certificateStoreDir}`);
+      }
+    } catch (error) {
+      this.log('warn', `Failed to create certificate store directory: ${error}`);
+    }
+    
     this.loadDefaultCertificates();
   }
 
@@ -330,17 +374,230 @@ export class NetworkProxy {
     }
   }
 
+  /**
+   * Initializes the ACME certificate manager for automatic certificate issuance
+   * @private
+   */
+  private async initializeAcmeManager(): Promise<void> {
+    if (!this.options.acme.enabled) {
+      return;
+    }
+    
+    // Create certificate manager
+    this.certManager = new AcmeCertManager({
+      port: this.options.acme.port,
+      contactEmail: this.options.acme.contactEmail,
+      useProduction: this.options.acme.useProduction,
+      renewThresholdDays: this.options.acme.renewThresholdDays,
+      httpsRedirectPort: this.options.port, // Redirect to our HTTPS port
+      renewCheckIntervalHours: 24 // Check daily for renewals
+    });
+    
+    // Register event handlers
+    this.certManager.on(CertManagerEvents.CERTIFICATE_ISSUED, this.handleCertificateIssued.bind(this));
+    this.certManager.on(CertManagerEvents.CERTIFICATE_RENEWED, this.handleCertificateIssued.bind(this));
+    this.certManager.on(CertManagerEvents.CERTIFICATE_FAILED, this.handleCertificateFailed.bind(this));
+    this.certManager.on(CertManagerEvents.CERTIFICATE_EXPIRING, (data) => {
+      this.log('info', `Certificate for ${data.domain} expires in ${data.daysRemaining} days`);
+    });
+    
+    // Start the manager
+    try {
+      await this.certManager.start();
+      this.log('info', `ACME Certificate Manager started on port ${this.options.acme.port}`);
+      
+      // Add domains from proxy configs
+      this.registerDomainsWithAcmeManager();
+    } catch (error) {
+      this.log('error', `Failed to start ACME Certificate Manager: ${error}`);
+      this.certManager = null;
+    }
+  }
+  
+  /**
+   * Registers domains from proxy configs with the ACME manager
+   * @private
+   */
+  private registerDomainsWithAcmeManager(): void {
+    if (!this.certManager) return;
+    
+    // Get all hostnames from proxy configs
+    this.proxyConfigs.forEach(config => {
+      const hostname = config.hostName;
+      
+      // Skip wildcard domains - can't get certs for these with HTTP-01 validation
+      if (hostname.includes('*')) {
+        this.log('info', `Skipping wildcard domain for ACME: ${hostname}`);
+        return;
+      }
+      
+      // Skip domains already with certificates if configured to do so
+      if (this.options.acme.skipConfiguredCerts) {
+        const cachedCert = this.certificateCache.get(hostname);
+        if (cachedCert) {
+          this.log('info', `Skipping domain with existing certificate: ${hostname}`);
+          return;
+        }
+      }
+      
+      // Check for existing certificate in the store
+      const certPath = path.join(this.certificateStoreDir, `${hostname}.cert.pem`);
+      const keyPath = path.join(this.certificateStoreDir, `${hostname}.key.pem`);
+      
+      try {
+        if (fs.existsSync(certPath) && fs.existsSync(keyPath)) {
+          // Load existing certificate and key
+          const cert = fs.readFileSync(certPath, 'utf8');
+          const key = fs.readFileSync(keyPath, 'utf8');
+          
+          // Extract expiry date from certificate if possible
+          let expiryDate: Date | undefined;
+          try {
+            const matches = cert.match(/Not After\s*:\s*(.*?)(?:\n|$)/i);
+            if (matches && matches[1]) {
+              expiryDate = new Date(matches[1]);
+            }
+          } catch (error) {
+            this.log('warn', `Failed to extract expiry date from certificate for ${hostname}`);
+          }
+          
+          // Update the certificate in the manager
+          this.certManager.setCertificate(hostname, cert, key, expiryDate);
+          
+          // Also update our own certificate cache
+          this.updateCertificateCache(hostname, cert, key, expiryDate);
+          
+          this.log('info', `Loaded existing certificate for ${hostname}`);
+        } else {
+          // Register the domain for certificate issuance
+          this.certManager.addDomain(hostname);
+          this.log('info', `Registered domain for ACME certificate issuance: ${hostname}`);
+        }
+      } catch (error) {
+        this.log('error', `Error registering domain ${hostname} with ACME manager: ${error}`);
+      }
+    });
+  }
+  
+  /**
+   * Handles newly issued or renewed certificates from ACME manager
+   * @private
+   */
+  private handleCertificateIssued(data: { domain: string; certificate: string; privateKey: string; expiryDate: Date }): void {
+    const { domain, certificate, privateKey, expiryDate } = data;
+    
+    this.log('info', `Certificate ${this.certificateCache.has(domain) ? 'renewed' : 'issued'} for ${domain}, valid until ${expiryDate.toISOString()}`);
+    
+    // Update certificate in HTTPS server
+    this.updateCertificateCache(domain, certificate, privateKey, expiryDate);
+    
+    // Save the certificate to the filesystem
+    this.saveCertificateToStore(domain, certificate, privateKey);
+  }
+  
+  /**
+   * Handles certificate issuance failures
+   * @private
+   */
+  private handleCertificateFailed(data: { domain: string; error: string }): void {
+    this.log('error', `Certificate issuance failed for ${data.domain}: ${data.error}`);
+  }
+  
+  /**
+   * Saves certificate and private key to the filesystem
+   * @private
+   */
+  private saveCertificateToStore(domain: string, certificate: string, privateKey: string): void {
+    try {
+      const certPath = path.join(this.certificateStoreDir, `${domain}.cert.pem`);
+      const keyPath = path.join(this.certificateStoreDir, `${domain}.key.pem`);
+      
+      fs.writeFileSync(certPath, certificate);
+      fs.writeFileSync(keyPath, privateKey);
+      
+      // Ensure private key has restricted permissions
+      try {
+        fs.chmodSync(keyPath, 0o600);
+      } catch (error) {
+        this.log('warn', `Failed to set permissions on private key for ${domain}: ${error}`);
+      }
+      
+      this.log('info', `Saved certificate for ${domain} to ${certPath}`);
+    } catch (error) {
+      this.log('error', `Failed to save certificate for ${domain}: ${error}`);
+    }
+  }
+  
+  /**
+   * Handles SNI (Server Name Indication) for TLS connections
+   * Used by the HTTPS server to select the correct certificate for each domain
+   * @private
+   */
+  private handleSNI(domain: string, cb: (err: Error | null, ctx: plugins.tls.SecureContext) => void): void {
+    this.log('debug', `SNI request for domain: ${domain}`);
+    
+    // Check if we have a certificate for this domain
+    const certs = this.certificateCache.get(domain);
+    
+    if (certs) {
+      try {
+        // Create TLS context with the cached certificate
+        const context = plugins.tls.createSecureContext({
+          key: certs.key,
+          cert: certs.cert
+        });
+        
+        this.log('debug', `Using cached certificate for ${domain}`);
+        cb(null, context);
+        return;
+      } catch (err) {
+        this.log('error', `Error creating secure context for ${domain}:`, err);
+      }
+    }
+    
+    // Check if we should trigger certificate issuance
+    if (this.options.acme?.enabled && this.certManager && !domain.includes('*')) {
+      // Check if this domain is already registered
+      const certData = this.certManager.getCertificate(domain);
+      
+      if (!certData) {
+        this.log('info', `No certificate found for ${domain}, registering for issuance`);
+        this.certManager.addDomain(domain);
+      }
+    }
+    
+    // Fall back to default certificate
+    try {
+      const context = plugins.tls.createSecureContext({
+        key: this.defaultCertificates.key,
+        cert: this.defaultCertificates.cert
+      });
+      
+      this.log('debug', `Using default certificate for ${domain}`);
+      cb(null, context);
+    } catch (err) {
+      this.log('error', `Error creating default secure context:`, err);
+      cb(new Error('Cannot create secure context'), null);
+    }
+  }
+  
   /**
    * Starts the proxy server
    */
   public async start(): Promise<void> {
     this.startTime = Date.now();
     
+    // Initialize ACME certificate manager if enabled
+    if (this.options.acme.enabled) {
+      await this.initializeAcmeManager();
+    }
+    
     // Create the HTTPS server
     this.httpsServer = plugins.https.createServer(
       {
         key: this.defaultCertificates.key,
-        cert: this.defaultCertificates.cert
+        cert: this.defaultCertificates.cert,
+        SNICallback: (domain, cb) => this.handleSNI(domain, cb)
       },
       (req, res) => this.handleRequest(req, res)
     );
@@ -556,7 +813,10 @@ export class NetworkProxy {
     const outGoingDeferred = plugins.smartpromise.defer();
 
     try {
-      const wsTarget = `ws://${wsDestinationConfig.destinationIp}:${wsDestinationConfig.destinationPort}${reqArg.url}`;
+      // Select destination IP and port for WebSocket
+      const wsDestinationIp = this.selectDestinationIp(wsDestinationConfig);
+      const wsDestinationPort = this.selectDestinationPort(wsDestinationConfig);
+      const wsTarget = `ws://${wsDestinationIp}:${wsDestinationPort}${reqArg.url}`;
       this.log('debug', `Proxying WebSocket to ${wsTarget}`);
       
       wsOutgoing = new plugins.wsDefault(wsTarget);
@@ -688,8 +948,12 @@ export class NetworkProxy {
       const useConnectionPool = this.options.portProxyIntegration && 
                                 originRequest.socket.remoteAddress?.includes('127.0.0.1');
       
+      // Select destination IP and port from the arrays
+      const destinationIp = this.selectDestinationIp(destinationConfig);
+      const destinationPort = this.selectDestinationPort(destinationConfig);
+      
       // Construct destination URL
-      const destinationUrl = `http://${destinationConfig.destinationIp}:${destinationConfig.destinationPort}${originRequest.url}`;
+      const destinationUrl = `http://${destinationIp}:${destinationPort}${originRequest.url}`;
       
       if (useConnectionPool) {
         this.log('debug', `[${reqId}] Proxying to ${destinationUrl} (using connection pool)`);
@@ -697,8 +961,8 @@ export class NetworkProxy {
           reqId, 
           originRequest, 
           originResponse, 
-          destinationConfig.destinationIp, 
-          destinationConfig.destinationPort,
+          destinationIp, 
+          destinationPort,
           originRequest.url
         );
       } else {
@@ -1084,6 +1348,80 @@ export class NetworkProxy {
     }
   }
 
+  /**
+   * Selects a destination IP from the array using round-robin
+   * @param config The proxy configuration
+   * @returns A destination IP address
+   */
+  private selectDestinationIp(config: plugins.tsclass.network.IReverseProxyConfig): string {
+    // For array-based configs
+    if (Array.isArray(config.destinationIps) && config.destinationIps.length > 0) {
+      // Get the current position or initialize it
+      const key = `ip_${config.hostName}`;
+      let position = this.roundRobinPositions.get(key) || 0;
+      
+      // Select the IP using round-robin
+      const selectedIp = config.destinationIps[position];
+      
+      // Update the position for next time
+      position = (position + 1) % config.destinationIps.length;
+      this.roundRobinPositions.set(key, position);
+      
+      return selectedIp;
+    }
+    
+    // For backward compatibility with test suites that rely on specific behavior
+    // Check if there's a proxyConfigs entry that matches this hostname
+    const matchingConfig = this.proxyConfigs.find(cfg => 
+      cfg.hostName === config.hostName && 
+      (cfg as any).destinationIp
+    );
+    
+    if (matchingConfig) {
+      return (matchingConfig as any).destinationIp;
+    }
+    
+    // Fallback to localhost
+    return 'localhost';
+  }
+  
+  /**
+   * Selects a destination port from the array using round-robin
+   * @param config The proxy configuration
+   * @returns A destination port number
+   */
+  private selectDestinationPort(config: plugins.tsclass.network.IReverseProxyConfig): number {
+    // For array-based configs
+    if (Array.isArray(config.destinationPorts) && config.destinationPorts.length > 0) {
+      // Get the current position or initialize it
+      const key = `port_${config.hostName}`;
+      let position = this.roundRobinPositions.get(key) || 0;
+      
+      // Select the port using round-robin
+      const selectedPort = config.destinationPorts[position];
+      
+      // Update the position for next time
+      position = (position + 1) % config.destinationPorts.length;
+      this.roundRobinPositions.set(key, position);
+      
+      return selectedPort;
+    }
+    
+    // For backward compatibility with test suites that rely on specific behavior
+    // Check if there's a proxyConfigs entry that matches this hostname
+    const matchingConfig = this.proxyConfigs.find(cfg => 
+      cfg.hostName === config.hostName && 
+      (cfg as any).destinationPort
+    );
+    
+    if (matchingConfig) {
+      return parseInt((matchingConfig as any).destinationPort, 10);
+    }
+    
+    // Fallback to port 80
+    return 80;
+  }
+
   /**
    * Updates proxy configurations
    */
@@ -1144,6 +1482,48 @@ export class NetworkProxy {
     }
   }
 
+  /**
+   * Converts PortProxy domain configurations to NetworkProxy configs
+   * @param domainConfigs PortProxy domain configs
+   * @param sslKeyPair Default SSL key pair to use if not specified
+   * @returns Array of NetworkProxy configs
+   */
+  public convertPortProxyConfigs(
+    domainConfigs: Array<{
+      domains: string[];
+      targetIPs?: string[];
+      allowedIPs?: string[];
+    }>,
+    sslKeyPair?: { key: string; cert: string }
+  ): plugins.tsclass.network.IReverseProxyConfig[] {
+    const proxyConfigs: plugins.tsclass.network.IReverseProxyConfig[] = [];
+    
+    // Use default certificates if not provided
+    const sslKey = sslKeyPair?.key || this.defaultCertificates.key;
+    const sslCert = sslKeyPair?.cert || this.defaultCertificates.cert;
+    
+    for (const domainConfig of domainConfigs) {
+      // Each domain in the domains array gets its own config
+      for (const domain of domainConfig.domains) {
+        // Skip non-hostname patterns (like IP addresses)
+        if (domain.match(/^\d+\.\d+\.\d+\.\d+$/) || domain === '*' || domain === 'localhost') {
+          continue;
+        }
+        
+        proxyConfigs.push({
+          hostName: domain,
+          destinationIps: domainConfig.targetIPs || ['localhost'],
+          destinationPorts: [this.options.port], // Use the NetworkProxy port
+          privateKey: sslKey,
+          publicKey: sslCert
+        });
+      }
+    }
+    
+    this.log('info', `Converted ${domainConfigs.length} PortProxy configs to ${proxyConfigs.length} NetworkProxy configs`);
+    return proxyConfigs;
+  }
+
   /**
    * Adds default headers to be included in all responses
    */
@@ -1208,6 +1588,16 @@ export class NetworkProxy {
     }
     this.connectionPool.clear();
     
+    // Stop ACME certificate manager if it's running
+    if (this.certManager) {
+      try {
+        await this.certManager.stop();
+        this.log('info', 'ACME Certificate Manager stopped');
+      } catch (error) {
+        this.log('error', 'Error stopping ACME Certificate Manager', error);
+      }
+    }
+    
     // Close the HTTPS server
     return new Promise((resolve) => {
       this.httpsServer.close(() => {
@@ -1217,6 +1607,71 @@ export class NetworkProxy {
     });
   }
 
+  /**
+   * Requests a new certificate for a domain
+   * This can be used to manually trigger certificate issuance
+   * @param domain The domain to request a certificate for
+   * @returns A promise that resolves when the request is submitted (not when the certificate is issued)
+   */
+  public async requestCertificate(domain: string): Promise<boolean> {
+    if (!this.options.acme.enabled) {
+      this.log('warn', 'ACME certificate management is not enabled');
+      return false;
+    }
+    
+    if (!this.certManager) {
+      this.log('error', 'ACME certificate manager is not initialized');
+      return false;
+    }
+    
+    // Skip wildcard domains - can't get certs for these with HTTP-01 validation
+    if (domain.includes('*')) {
+      this.log('error', `Cannot request certificate for wildcard domain: ${domain}`);
+      return false;
+    }
+    
+    try {
+      this.certManager.addDomain(domain);
+      this.log('info', `Certificate request submitted for domain: ${domain}`);
+      return true;
+    } catch (error) {
+      this.log('error', `Error requesting certificate for domain ${domain}:`, error);
+      return false;
+    }
+  }
+  
+  /**
+   * Updates the certificate cache for a domain
+   * @param domain The domain name
+   * @param certificate The certificate (PEM format)
+   * @param privateKey The private key (PEM format)
+   * @param expiryDate Optional expiry date
+   */
+  private updateCertificateCache(domain: string, certificate: string, privateKey: string, expiryDate?: Date): void {
+    // Update certificate context in HTTPS server if it's running
+    if (this.httpsServer) {
+      try {
+        this.httpsServer.addContext(domain, {
+          key: privateKey,
+          cert: certificate
+        });
+        this.log('debug', `Updated SSL context for domain: ${domain}`);
+      } catch (error) {
+        this.log('error', `Error updating SSL context for domain ${domain}:`, error);
+      }
+    }
+    
+    // Update certificate in cache
+    this.certificateCache.set(domain, {
+      key: privateKey,
+      cert: certificate,
+      expires: expiryDate
+    });
+    
+    // Add to active contexts set
+    this.activeContexts.add(domain);
+  }
+
   /**
    * Logs a message according to the configured log level
    */