@push.rocks/smartproxy 16.0.2 → 16.0.4

package/ts/proxies/network-proxy/network-proxy.ts

@@ -1,18 +1,25 @@
 import * as plugins from '../../plugins.js';
 import {
-  createLogger
+  createLogger,
+  RouteManager,
+  convertLegacyConfigToRouteConfig
 } from './models/types.js';
 import type {
   INetworkProxyOptions,
   ILogger,
   IReverseProxyConfig
 } from './models/types.js';
+import type { IRouteConfig } from '../smart-proxy/models/route-types.js';
+import type { IRouteContext, IHttpRouteContext } from '../../core/models/route-context.js';
+import { createBaseRouteContext } from '../../core/models/route-context.js';
 import { CertificateManager } from './certificate-manager.js';
 import { ConnectionPool } from './connection-pool.js';
 import { RequestHandler, type IMetricsTracker } from './request-handler.js';
 import { WebSocketHandler } from './websocket-handler.js';
 import { ProxyRouter } from '../../http/router/index.js';
+import { RouteRouter } from '../../http/router/route-router.js';
 import { Port80Handler } from '../../http/port80/port80-handler.js';
+import { FunctionCache } from './function-cache.js';
 
 /**
  * NetworkProxy provides a reverse proxy with TLS termination, WebSocket support,
@@ -25,17 +32,20 @@ export class NetworkProxy implements IMetricsTracker {
   }
   // Configuration
   public options: INetworkProxyOptions;
-  public proxyConfigs: IReverseProxyConfig[] = [];
-  
+  public routes: IRouteConfig[] = [];
+
   // Server instances (HTTP/2 with HTTP/1 fallback)
   public httpsServer: any;
-  
+
   // Core components
   private certificateManager: CertificateManager;
   private connectionPool: ConnectionPool;
   private requestHandler: RequestHandler;
   private webSocketHandler: WebSocketHandler;
-  private router = new ProxyRouter();
+  private legacyRouter = new ProxyRouter(); // Legacy router for backward compatibility
+  private router = new RouteRouter(); // New modern router
+  private routeManager: RouteManager;
+  private functionCache: FunctionCache;
   
   // State tracking
   public socketMap = new plugins.lik.ObjectMap<plugins.net.Socket>();
@@ -94,15 +104,41 @@ export class NetworkProxy implements IMetricsTracker {
     
     // Initialize logger
     this.logger = createLogger(this.options.logLevel);
-    
-    // Initialize components
+
+    // Initialize route manager
+    this.routeManager = new RouteManager(this.logger);
+
+    // Initialize function cache
+    this.functionCache = new FunctionCache(this.logger, {
+      maxCacheSize: this.options.functionCacheSize || 1000,
+      defaultTtl: this.options.functionCacheTtl || 5000
+    });
+
+    // Initialize other components
     this.certificateManager = new CertificateManager(this.options);
     this.connectionPool = new ConnectionPool(this.options);
-    this.requestHandler = new RequestHandler(this.options, this.connectionPool, this.router);
-    this.webSocketHandler = new WebSocketHandler(this.options, this.connectionPool, this.router);
-    
+    this.requestHandler = new RequestHandler(
+      this.options,
+      this.connectionPool,
+      this.legacyRouter, // Still use legacy router for backward compatibility
+      this.routeManager,
+      this.functionCache,
+      this.router // Pass the new modern router as well
+    );
+    this.webSocketHandler = new WebSocketHandler(
+      this.options,
+      this.connectionPool,
+      this.legacyRouter,
+      this.routes // Pass current routes to WebSocketHandler
+    );
+
     // Connect request handler to this metrics tracker
     this.requestHandler.setMetricsTracker(this);
+
+    // Initialize with any provided routes
+    if (this.options.routes && this.options.routes.length > 0) {
+      this.updateRouteConfigs(this.options.routes);
+    }
   }
 
   /**
@@ -124,6 +160,14 @@ export class NetworkProxy implements IMetricsTracker {
    * Useful for SmartProxy to determine where to forward connections
    */
   public getListeningPort(): number {
+    // If the server is running, get the actual listening port
+    if (this.httpsServer && this.httpsServer.address()) {
+      const address = this.httpsServer.address();
+      if (address && typeof address === 'object' && 'port' in address) {
+        return address.port;
+      }
+    }
+    // Fallback to configured port
     return this.options.port;
   }
 
@@ -171,7 +215,8 @@ export class NetworkProxy implements IMetricsTracker {
       connectionPoolSize: this.connectionPool.getPoolStatus(),
       uptime: Math.floor((Date.now() - this.startTime) / 1000),
       memoryUsage: process.memoryUsage(),
-      activeWebSockets: this.webSocketHandler.getConnectionInfo().activeConnections
+      activeWebSockets: this.webSocketHandler.getConnectionInfo().activeConnections,
+      functionCache: this.functionCache.getStats()
     };
   }
 
@@ -325,96 +370,142 @@ export class NetworkProxy implements IMetricsTracker {
   }
 
   /**
-   * Updates proxy configurations
+   * Updates the route configurations - this is the primary method for configuring NetworkProxy
+   * @param routes The new route configurations to use
    */
-  public async updateProxyConfigs(
-    proxyConfigsArg: IReverseProxyConfig[]
-  ): Promise<void> {
-    this.logger.info(`Updating proxy configurations (${proxyConfigsArg.length} configs)`);
-    
-    // Update internal configs
-    this.proxyConfigs = proxyConfigsArg;
-    this.router.setNewProxyConfigs(proxyConfigsArg);
-    
-    // Collect all hostnames for cleanup later
-    const currentHostNames = new Set<string>();
-    
-    // Add/update SSL contexts for each host
-    for (const config of proxyConfigsArg) {
-      currentHostNames.add(config.hostName);
-      
+  public async updateRouteConfigs(routes: IRouteConfig[]): Promise<void> {
+    this.logger.info(`Updating route configurations (${routes.length} routes)`);
+
+    // Update routes in RouteManager, modern router, WebSocketHandler, and SecurityManager
+    this.routeManager.updateRoutes(routes);
+    this.router.setRoutes(routes);
+    this.webSocketHandler.setRoutes(routes);
+    this.requestHandler.securityManager.setRoutes(routes);
+    this.routes = routes;
+
+    // Directly update the certificate manager with the new routes
+    // This will extract domains and handle certificate provisioning
+    this.certificateManager.updateRouteConfigs(routes);
+
+    // Collect all domains and certificates for configuration
+    const currentHostnames = new Set<string>();
+    const certificateUpdates = new Map<string, { cert: string, key: string }>();
+
+    // Process each route to extract domain and certificate information
+    for (const route of routes) {
+      // Skip non-forward routes or routes without domains
+      if (route.action.type !== 'forward' || !route.match.domains) {
+        continue;
+      }
+
+      // Get domains from route
+      const domains = Array.isArray(route.match.domains)
+        ? route.match.domains
+        : [route.match.domains];
+
+      // Process each domain
+      for (const domain of domains) {
+        // Skip wildcard domains for direct host configuration
+        if (domain.includes('*')) {
+          continue;
+        }
+
+        currentHostnames.add(domain);
+
+        // Check if we have a static certificate for this domain
+        if (route.action.tls?.certificate && route.action.tls.certificate !== 'auto') {
+          certificateUpdates.set(domain, {
+            cert: route.action.tls.certificate.cert,
+            key: route.action.tls.certificate.key
+          });
+        }
+      }
+    }
+
+    // Update certificate cache with any static certificates
+    for (const [domain, certData] of certificateUpdates.entries()) {
       try {
-        // Update certificate in cache
         this.certificateManager.updateCertificateCache(
-          config.hostName,
-          config.publicKey,
-          config.privateKey
+          domain,
+          certData.cert,
+          certData.key
         );
-        
-        this.activeContexts.add(config.hostName);
+
+        this.activeContexts.add(domain);
       } catch (error) {
-        this.logger.error(`Failed to add SSL context for ${config.hostName}`, error);
+        this.logger.error(`Failed to add SSL context for ${domain}`, error);
       }
     }
-    
+
     // Clean up removed contexts
     for (const hostname of this.activeContexts) {
-      if (!currentHostNames.has(hostname)) {
+      if (!currentHostnames.has(hostname)) {
         this.logger.info(`Hostname ${hostname} removed from configuration`);
         this.activeContexts.delete(hostname);
       }
     }
-    
-    // Register domains with Port80Handler if available
-    const domainsForACME = Array.from(currentHostNames)
-      .filter(domain => !domain.includes('*')); // Skip wildcard domains
-    
-    this.certificateManager.registerDomainsWithPort80Handler(domainsForACME);
-  }
 
-  /**
-   * Converts SmartProxy domain configurations to NetworkProxy configs
-   * @param domainConfigs SmartProxy domain configs
-   * @param sslKeyPair Default SSL key pair to use if not specified
-   * @returns Array of NetworkProxy configs
-   */
-  public convertSmartProxyConfigs(
-    domainConfigs: Array<{
-      domains: string[];
-      targetIPs?: string[];
-      allowedIPs?: string[];
-    }>,
-    sslKeyPair?: { key: string; cert: string }
-  ): IReverseProxyConfig[] {
-    const proxyConfigs: IReverseProxyConfig[] = [];
-    
-    // Use default certificates if not provided
-    const defaultCerts = this.certificateManager.getDefaultCertificates();
-    const sslKey = sslKeyPair?.key || defaultCerts.key;
-    const sslCert = sslKeyPair?.cert || defaultCerts.cert;
+    // Create legacy proxy configs for the router
+    // This is only needed for backward compatibility with ProxyRouter
     
-    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
-        });
+    const defaultPort = 443; // Default port for HTTPS when using 'preserve'
+    // and will be removed in the future
+    const legacyConfigs: IReverseProxyConfig[] = [];
+
+    for (const domain of currentHostnames) {
+      // Find route for this domain
+      const route = routes.find(r => {
+        const domains = Array.isArray(r.match.domains) ? r.match.domains : [r.match.domains];
+        return domains.includes(domain);
+      });
+
+      if (!route || route.action.type !== 'forward' || !route.action.target) {
+        continue;
+      }
+
+      // Skip routes with function-based targets - we'll handle them during request processing
+      if (typeof route.action.target.host === 'function' || typeof route.action.target.port === 'function') {
+        this.logger.info(`Domain ${domain} uses function-based targets - will be handled at request time`);
+        continue;
       }
+
+      // Extract static target information
+      const targetHosts = Array.isArray(route.action.target.host)
+        ? route.action.target.host
+        : [route.action.target.host];
+
+      // Handle 'preserve' port value
+      const targetPort = route.action.target.port === 'preserve' ? defaultPort : route.action.target.port;
+
+      // Get certificate information
+      const certData = certificateUpdates.get(domain);
+      const defaultCerts = this.certificateManager.getDefaultCertificates();
+
+      legacyConfigs.push({
+        hostName: domain,
+        destinationIps: targetHosts,
+        destinationPorts: [targetPort],
+        privateKey: certData?.key || defaultCerts.key,
+        publicKey: certData?.cert || defaultCerts.cert
+      });
     }
-    
-    this.logger.info(`Converted ${domainConfigs.length} SmartProxy configs to ${proxyConfigs.length} NetworkProxy configs`);
-    return proxyConfigs;
+
+    // Update the router with legacy configs
+    // Handle both old and new router interfaces
+    if (typeof this.router.setRoutes === 'function') {
+      this.router.setRoutes(routes);
+    } else if (typeof this.router.setNewProxyConfigs === 'function') {
+      this.router.setNewProxyConfigs(legacyConfigs);
+    } else {
+      this.logger.warn('Router has no recognized configuration method');
+    }
+
+    this.logger.info(`Route configuration updated with ${routes.length} routes and ${legacyConfigs.length} proxy configs`);
   }
 
+  // Legacy methods have been removed.
+  // Please use updateRouteConfigs() directly with modern route-based configuration.
+
   /**
    * Adds default headers to be included in all responses
    */
@@ -474,11 +565,32 @@ export class NetworkProxy implements IMetricsTracker {
   public async requestCertificate(domain: string): Promise<boolean> {
     return this.certificateManager.requestCertificate(domain);
   }
+  
+  /**
+   * Update certificate for a domain
+   * 
+   * This method allows direct updates of certificates from external sources
+   * like Port80Handler or custom certificate providers.
+   * 
+   * @param domain The domain to update certificate for
+   * @param certificate The new certificate (public key)
+   * @param privateKey The new private key
+   * @param expiryDate Optional expiry date
+   */
+  public updateCertificate(
+    domain: string,
+    certificate: string,
+    privateKey: string,
+    expiryDate?: Date
+  ): void {
+    this.logger.info(`Updating certificate for ${domain}`);
+    this.certificateManager.updateCertificateCache(domain, certificate, privateKey, expiryDate);
+  }
 
   /**
-   * Gets all proxy configurations currently in use
+   * Gets all route configurations currently in use
    */
-  public getProxyConfigs(): IReverseProxyConfig[] {
-    return [...this.proxyConfigs];
+  public getRouteConfigs(): IRouteConfig[] {
+    return this.routeManager.getRoutes();
   }
 }