@push.rocks/smartproxy 15.0.2 → 16.0.3

package/ts/proxies/smart-proxy/route-manager.ts

@@ -7,8 +7,7 @@ import type {
 } from './models/route-types.js';
 import type {
   ISmartProxyOptions,
-  IRoutedSmartProxyOptions,
-  IDomainConfig
+  IRoutedSmartProxyOptions
 } from './models/interfaces.js';
 import {
   isRoutedOptions,
@@ -59,36 +58,88 @@ export class RouteManager extends plugins.EventEmitter {
   
   /**
    * Rebuild the port mapping for fast lookups
+   * Also logs information about the ports being listened on
    */
   private rebuildPortMap(): void {
     this.portMap.clear();
-    
+    this.portRangeCache.clear(); // Clear cache when rebuilding
+
+    // Track ports for logging
+    const portToRoutesMap = new Map<number, string[]>();
+
     for (const route of this.routes) {
       const ports = this.expandPortRange(route.match.ports);
-      
+
+      // Skip if no ports were found
+      if (ports.length === 0) {
+        console.warn(`Route ${route.name || 'unnamed'} has no valid ports to listen on`);
+        continue;
+      }
+
       for (const port of ports) {
+        // Add to portMap for routing
         if (!this.portMap.has(port)) {
           this.portMap.set(port, []);
         }
         this.portMap.get(port)!.push(route);
+
+        // Add to tracking for logging
+        if (!portToRoutesMap.has(port)) {
+          portToRoutesMap.set(port, []);
+        }
+        portToRoutesMap.get(port)!.push(route.name || 'unnamed');
+      }
+    }
+
+    // Log summary of ports and routes
+    const totalPorts = this.portMap.size;
+    const totalRoutes = this.routes.length;
+    console.log(`Route manager configured with ${totalRoutes} routes across ${totalPorts} ports`);
+
+    // Log port details if detailed logging is enabled
+    const enableDetailedLogging = this.options.enableDetailedLogging;
+    if (enableDetailedLogging) {
+      for (const [port, routes] of this.portMap.entries()) {
+        console.log(`Port ${port}: ${routes.length} routes (${portToRoutesMap.get(port)!.join(', ')})`);
       }
     }
   }
   
   /**
    * Expand a port range specification into an array of individual ports
+   * Uses caching to improve performance for frequently used port ranges
+   *
+   * @public - Made public to allow external code to interpret port ranges
    */
-  private expandPortRange(portRange: TPortRange): number[] {
+  public expandPortRange(portRange: TPortRange): number[] {
+    // For simple number, return immediately
     if (typeof portRange === 'number') {
       return [portRange];
     }
-    
+
+    // Create a cache key for this port range
+    const cacheKey = JSON.stringify(portRange);
+
+    // Check if we have a cached result
+    if (this.portRangeCache.has(cacheKey)) {
+      return this.portRangeCache.get(cacheKey)!;
+    }
+
+    // Process the port range
+    let result: number[] = [];
+
     if (Array.isArray(portRange)) {
       // Handle array of port objects or numbers
-      return portRange.flatMap(item => {
+      result = portRange.flatMap(item => {
         if (typeof item === 'number') {
           return [item];
         } else if (typeof item === 'object' && 'from' in item && 'to' in item) {
+          // Handle port range object - check valid range
+          if (item.from > item.to) {
+            console.warn(`Invalid port range: from (${item.from}) > to (${item.to})`);
+            return [];
+          }
+
           // Handle port range object
           const ports: number[] = [];
           for (let p = item.from; p <= item.to; p++) {
@@ -99,14 +150,24 @@ export class RouteManager extends plugins.EventEmitter {
         return [];
       });
     }
-    
-    return [];
+
+    // Cache the result
+    this.portRangeCache.set(cacheKey, result);
+
+    return result;
   }
   
+  /**
+   * Memoization cache for expanded port ranges
+   */
+  private portRangeCache: Map<string, number[]> = new Map();
+
   /**
    * Get all ports that should be listened on
+   * This method automatically infers all required ports from route configurations
    */
   public getListeningPorts(): number[] {
+    // Return the unique set of ports from all routes
     return Array.from(this.portMap.keys());
   }
   
@@ -183,21 +244,36 @@ export class RouteManager extends plugins.EventEmitter {
    * Match an IP against a pattern
    */
   private matchIpPattern(pattern: string, ip: string): boolean {
-    // Handle exact match
-    if (pattern === ip) {
+    // Normalize IPv6-mapped IPv4 addresses
+    const normalizedIp = ip.startsWith('::ffff:') ? ip.substring(7) : ip;
+    const normalizedPattern = pattern.startsWith('::ffff:') ? pattern.substring(7) : pattern;
+    
+    // Handle exact match with normalized addresses
+    if (pattern === ip || normalizedPattern === normalizedIp || 
+        pattern === normalizedIp || normalizedPattern === ip) {
       return true;
     }
     
     // Handle CIDR notation (e.g., 192.168.1.0/24)
     if (pattern.includes('/')) {
-      return this.matchIpCidr(pattern, ip);
+      return this.matchIpCidr(pattern, normalizedIp) || 
+             (normalizedPattern !== pattern && this.matchIpCidr(normalizedPattern, normalizedIp));
     }
     
     // Handle glob pattern (e.g., 192.168.1.*)
     if (pattern.includes('*')) {
       const regexPattern = pattern.replace(/\./g, '\\.').replace(/\*/g, '.*');
       const regex = new RegExp(`^${regexPattern}$`);
-      return regex.test(ip);
+      if (regex.test(ip) || regex.test(normalizedIp)) {
+        return true;
+      }
+      
+      // If pattern was normalized, also test with normalized pattern
+      if (normalizedPattern !== pattern) {
+        const normalizedRegexPattern = normalizedPattern.replace(/\./g, '\\.').replace(/\*/g, '.*');
+        const normalizedRegex = new RegExp(`^${normalizedRegexPattern}$`);
+        return normalizedRegex.test(ip) || normalizedRegex.test(normalizedIp);
+      }
     }
     
     return false;
@@ -213,9 +289,13 @@ export class RouteManager extends plugins.EventEmitter {
       const [subnet, bits] = cidr.split('/');
       const mask = parseInt(bits, 10);
       
+      // Normalize IPv6-mapped IPv4 addresses
+      const normalizedIp = ip.startsWith('::ffff:') ? ip.substring(7) : ip;
+      const normalizedSubnet = subnet.startsWith('::ffff:') ? subnet.substring(7) : subnet;
+      
       // Convert IP addresses to numeric values
-      const ipNum = this.ipToNumber(ip);
-      const subnetNum = this.ipToNumber(subnet);
+      const ipNum = this.ipToNumber(normalizedIp);
+      const subnetNum = this.ipToNumber(normalizedSubnet);
       
       // Calculate subnet mask
       const maskNum = ~(2 ** (32 - mask) - 1);
@@ -232,7 +312,10 @@ export class RouteManager extends plugins.EventEmitter {
    * Convert an IP address to a numeric value
    */
   private ipToNumber(ip: string): number {
-    const parts = ip.split('.').map(part => parseInt(part, 10));
+    // Normalize IPv6-mapped IPv4 addresses
+    const normalizedIp = ip.startsWith('::ffff:') ? ip.substring(7) : ip;
+    
+    const parts = normalizedIp.split('.').map(part => parseInt(part, 10));
     return (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8) | parts[3];
   }
   
@@ -304,135 +387,9 @@ export class RouteManager extends plugins.EventEmitter {
   }
   
   /**
-   * Convert a domain config to routes
-   * (For backward compatibility with code that still uses domainConfigs)
-   */
-  public domainConfigToRoutes(domainConfig: IDomainConfig): IRouteConfig[] {
-    const routes: IRouteConfig[] = [];
-    const { domains, forwarding } = domainConfig;
-    
-    // Determine the action based on forwarding type
-    let action: IRouteAction = {
-      type: 'forward',
-      target: {
-        host: forwarding.target.host,
-        port: forwarding.target.port
-      }
-    };
-    
-    // Set TLS mode based on forwarding type
-    switch (forwarding.type) {
-      case 'http-only':
-        // No TLS settings needed
-        break;
-      case 'https-passthrough':
-        action.tls = { mode: 'passthrough' };
-        break;
-      case 'https-terminate-to-http':
-        action.tls = { 
-          mode: 'terminate',
-          certificate: forwarding.https?.customCert ? {
-            key: forwarding.https.customCert.key,
-            cert: forwarding.https.customCert.cert
-          } : 'auto'
-        };
-        break;
-      case 'https-terminate-to-https':
-        action.tls = { 
-          mode: 'terminate-and-reencrypt',
-          certificate: forwarding.https?.customCert ? {
-            key: forwarding.https.customCert.key,
-            cert: forwarding.https.customCert.cert
-          } : 'auto'
-        };
-        break;
-    }
-    
-    // Add security settings if present
-    if (forwarding.security) {
-      action.security = {
-        allowedIps: forwarding.security.allowedIps,
-        blockedIps: forwarding.security.blockedIps,
-        maxConnections: forwarding.security.maxConnections
-      };
-    }
-    
-    // Add advanced settings if present
-    if (forwarding.advanced) {
-      action.advanced = {
-        timeout: forwarding.advanced.timeout,
-        headers: forwarding.advanced.headers,
-        keepAlive: forwarding.advanced.keepAlive
-      };
-    }
-    
-    // Determine which port to use based on forwarding type
-    const defaultPort = forwarding.type.startsWith('https') ? 443 : 80;
-    
-    // Add the main route
-    routes.push({
-      match: {
-        ports: defaultPort,
-        domains
-      },
-      action,
-      name: `Route for ${domains.join(', ')}`
-    });
-    
-    // Add HTTP redirect if needed
-    if (forwarding.http?.redirectToHttps) {
-      routes.push({
-        match: {
-          ports: 80,
-          domains
-        },
-        action: {
-          type: 'redirect',
-          redirect: {
-            to: 'https://{domain}{path}',
-            status: 301
-          }
-        },
-        name: `HTTP Redirect for ${domains.join(', ')}`,
-        priority: 100 // Higher priority for redirects
-      });
-    }
-    
-    // Add port ranges if specified
-    if (forwarding.advanced?.portRanges) {
-      for (const range of forwarding.advanced.portRanges) {
-        routes.push({
-          match: {
-            ports: [{ from: range.from, to: range.to }],
-            domains
-          },
-          action,
-          name: `Port Range ${range.from}-${range.to} for ${domains.join(', ')}`
-        });
-      }
-    }
-    
-    return routes;
-  }
-  
-  /**
-   * Update routes based on domain configs
-   * (For backward compatibility with code that still uses domainConfigs)
+   * Domain-based configuration methods have been removed
+   * as part of the migration to pure route-based configuration
    */
-  public updateFromDomainConfigs(domainConfigs: IDomainConfig[]): void {
-    const routes: IRouteConfig[] = [];
-    
-    // Convert each domain config to routes
-    for (const config of domainConfigs) {
-      routes.push(...this.domainConfigToRoutes(config));
-    }
-    
-    // Merge with existing routes that aren't derived from domain configs
-    const nonDomainRoutes = this.routes.filter(r => 
-      !r.name || !r.name.includes('for '));
-    
-    this.updateRoutes([...nonDomainRoutes, ...routes]);
-  }
   
   /**
    * Validate the route configuration and return any warnings