@push.rocks/smartproxy 19.5.18 → 19.5.20

package/ts/proxies/http-proxy/http-proxy.ts

@@ -1,13 +1,11 @@
 import * as plugins from '../../plugins.js';
 import {
   createLogger,
-  RouteManager,
-  convertLegacyConfigToRouteConfig
 } from './models/types.js';
+import { SharedRouteManager as RouteManager } from '../../core/routing/route-manager.js';
 import type {
   IHttpProxyOptions,
-  ILogger,
-  IReverseProxyConfig
+  ILogger
 } from './models/types.js';
 import type { IRouteConfig } from '../smart-proxy/models/route-types.js';
 import type { IRouteContext, IHttpRouteContext } from '../../core/models/route-context.js';
@@ -16,8 +14,7 @@ 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 '../../routing/router/index.js';
-import { RouteRouter } from '../../routing/router/route-router.js';
+import { HttpRouter } from '../../routing/router/index.js';
 import { cleanupSocket } from '../../core/utils/socket-utils.js';
 import { FunctionCache } from './function-cache.js';
 
@@ -43,8 +40,7 @@ export class HttpProxy implements IMetricsTracker {
   private connectionPool: ConnectionPool;
   private requestHandler: RequestHandler;
   private webSocketHandler: WebSocketHandler;
-  private legacyRouter = new ProxyRouter(); // Legacy router for backward compatibility
-  private router = new RouteRouter(); // New modern router
+  private router = new HttpRouter(); // Unified HTTP router
   private routeManager: RouteManager;
   private functionCache: FunctionCache;
   
@@ -87,7 +83,6 @@ export class HttpProxy implements IMetricsTracker {
       // Defaults for SmartProxy integration
       connectionPoolSize: optionsArg.connectionPoolSize || 50,
       portProxyIntegration: optionsArg.portProxyIntegration || false,
-      useExternalPort80Handler: optionsArg.useExternalPort80Handler || false,
       // Backend protocol (http1 or http2)
       backendProtocol: optionsArg.backendProtocol || 'http1',
       // Default ACME options
@@ -107,7 +102,11 @@ export class HttpProxy implements IMetricsTracker {
     this.logger = createLogger(this.options.logLevel);
 
     // Initialize route manager
-    this.routeManager = new RouteManager(this.logger);
+    this.routeManager = new RouteManager({
+      logger: this.logger,
+      enableDetailedLogging: this.options.logLevel === 'debug',
+      routes: []
+    });
 
     // Initialize function cache
     this.functionCache = new FunctionCache(this.logger, {
@@ -121,15 +120,13 @@ export class HttpProxy implements IMetricsTracker {
     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.router
     );
     this.webSocketHandler = new WebSocketHandler(
       this.options,
       this.connectionPool,
-      this.legacyRouter,
       this.routes // Pass current routes to WebSocketHandler
     );
 
@@ -429,65 +426,13 @@ export class HttpProxy implements IMetricsTracker {
       }
     }
 
-    // Create legacy proxy configs for the router
-    // This is only needed for backward compatibility with ProxyRouter
-    
-    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
-      });
-    }
-
-    // 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');
-    }
+    // Update the router with new routes
+    this.router.setRoutes(routes);
 
     // Update WebSocket handler with new routes
     this.webSocketHandler.setRoutes(routes);
 
-    this.logger.info(`Route configuration updated with ${routes.length} routes and ${legacyConfigs.length} proxy configs`);
+    this.logger.info(`Route configuration updated with ${routes.length} routes`);
   }
 
   // Legacy methods have been removed.

package/ts/proxies/http-proxy/models/types.ts

@@ -13,7 +13,6 @@ export interface IAcmeOptions {
   skipConfiguredCerts?: boolean;
 }
 import type { IRouteConfig } from '../../smart-proxy/models/route-types.js';
-import type { IRouteContext } from '../../../core/models/route-context.js';
 
 /**
  * Configuration options for HttpProxy
@@ -34,7 +33,6 @@ export interface IHttpProxyOptions {
   // Settings for SmartProxy integration
   connectionPoolSize?: number; // Maximum connections to maintain in the pool to each backend
   portProxyIntegration?: boolean; // Flag to indicate this proxy is used by SmartProxy
-  useExternalPort80Handler?: boolean; // @deprecated - use SmartCertManager instead
   // Protocol to use when proxying to backends: HTTP/1.x or HTTP/2
   backendProtocol?: 'http1' | 'http2';
 
@@ -58,329 +56,7 @@ export interface ICertificateEntry {
   expires?: Date;
 }
 
-/**
- * @deprecated Use IRouteConfig instead. This interface will be removed in a future release.
- *
- * IMPORTANT: This is a legacy interface maintained only for backward compatibility.
- * New code should use IRouteConfig for all configuration purposes.
- *
- * @see IRouteConfig for the modern, recommended configuration format
- */
-export interface IReverseProxyConfig {
-  /** Target hostnames/IPs to proxy requests to */
-  destinationIps: string[];
-
-  /** Target ports to proxy requests to */
-  destinationPorts: number[];
-
-  /** Hostname to match for routing */
-  hostName: string;
-
-  /** SSL private key for this host (PEM format) */
-  privateKey: string;
-
-  /** SSL public key/certificate for this host (PEM format) */
-  publicKey: string;
-
-  /** Basic authentication configuration */
-  authentication?: {
-    type: 'Basic';
-    user: string;
-    pass: string;
-  };
-
-  /** Whether to rewrite the Host header to match the target */
-  rewriteHostHeader?: boolean;
-
-  /**
-   * Protocol to use when proxying to this backend: 'http1' or 'http2'.
-   * Overrides the global backendProtocol option if set.
-   */
-  backendProtocol?: 'http1' | 'http2';
-}
-
-/**
- * Convert a legacy IReverseProxyConfig to the modern IRouteConfig format
- *
- * @deprecated This function is maintained for backward compatibility.
- * New code should create IRouteConfig objects directly.
- *
- * @param legacyConfig The legacy configuration to convert
- * @param proxyPort The port the proxy listens on
- * @returns A modern route configuration equivalent to the legacy config
- */
-export function convertLegacyConfigToRouteConfig(
-  legacyConfig: IReverseProxyConfig,
-  proxyPort: number
-): IRouteConfig {
-  // Create basic route configuration
-  const routeConfig: IRouteConfig = {
-    // Match properties
-    match: {
-      ports: proxyPort,
-      domains: legacyConfig.hostName
-    },
-
-    // Action properties
-    action: {
-      type: 'forward',
-      target: {
-        host: legacyConfig.destinationIps,
-        port: legacyConfig.destinationPorts[0]
-      },
-
-      // TLS mode is always 'terminate' for legacy configs
-      tls: {
-        mode: 'terminate',
-        certificate: {
-          key: legacyConfig.privateKey,
-          cert: legacyConfig.publicKey
-        }
-      },
-
-      // Advanced options
-      advanced: {
-        // Rewrite host header if specified
-        headers: legacyConfig.rewriteHostHeader ? { 'host': '{domain}' } : {}
-      }
-    },
-
-    // Metadata
-    name: `Legacy Config - ${legacyConfig.hostName}`,
-    priority: 0, // Default priority
-    enabled: true
-  };
-
-  // Add authentication if present
-  if (legacyConfig.authentication) {
-    routeConfig.security = {
-      authentication: {
-        type: 'basic',
-        credentials: [{
-          username: legacyConfig.authentication.user,
-          password: legacyConfig.authentication.pass
-        }]
-      }
-    };
-  }
-
-  // Add backend protocol if specified
-  if (legacyConfig.backendProtocol) {
-    if (!routeConfig.action.options) {
-      routeConfig.action.options = {};
-    }
-    routeConfig.action.options.backendProtocol = legacyConfig.backendProtocol;
-  }
-
-  return routeConfig;
-}
-
-/**
- * Route manager for NetworkProxy
- * Handles route matching and configuration
- */
-export class RouteManager {
-  private routes: IRouteConfig[] = [];
-  private logger: ILogger;
-
-  constructor(logger: ILogger) {
-    this.logger = logger;
-  }
-
-  /**
-   * Update the routes configuration
-   */
-  public updateRoutes(routes: IRouteConfig[]): void {
-    // Sort routes by priority (higher first)
-    this.routes = [...routes].sort((a, b) => {
-      const priorityA = a.priority ?? 0;
-      const priorityB = b.priority ?? 0;
-      return priorityB - priorityA;
-    });
-
-    this.logger.info(`Updated RouteManager with ${this.routes.length} routes`);
-  }
-
-  /**
-   * Get all routes
-   */
-  public getRoutes(): IRouteConfig[] {
-    return [...this.routes];
-  }
-
-  /**
-   * Find the first matching route for a context
-   */
-  public findMatchingRoute(context: IRouteContext): IRouteConfig | null {
-    for (const route of this.routes) {
-      if (this.matchesRoute(route, context)) {
-        return route;
-      }
-    }
-    return null;
-  }
 
-  /**
-   * Check if a route matches the given context
-   */
-  private matchesRoute(route: IRouteConfig, context: IRouteContext): boolean {
-    // Skip disabled routes
-    if (route.enabled === false) {
-      return false;
-    }
-
-    // Check domain match if specified
-    if (route.match.domains && context.domain) {
-      const domains = Array.isArray(route.match.domains)
-        ? route.match.domains
-        : [route.match.domains];
-
-      if (!domains.some(domainPattern => this.matchDomain(domainPattern, context.domain!))) {
-        return false;
-      }
-    }
-
-    // Check path match if specified
-    if (route.match.path && context.path) {
-      if (!this.matchPath(route.match.path, context.path)) {
-        return false;
-      }
-    }
-
-    // Check client IP match if specified
-    if (route.match.clientIp && context.clientIp) {
-      if (!route.match.clientIp.some(ip => this.matchIp(ip, context.clientIp))) {
-        return false;
-      }
-    }
-
-    // Check TLS version match if specified
-    if (route.match.tlsVersion && context.tlsVersion) {
-      if (!route.match.tlsVersion.includes(context.tlsVersion)) {
-        return false;
-      }
-    }
-
-    // All criteria matched
-    return true;
-  }
-
-  /**
-   * Match a domain pattern against a domain
-   */
-  private matchDomain(pattern: string, domain: string): boolean {
-    if (pattern === domain) {
-      return true;
-    }
-
-    if (pattern.includes('*')) {
-      const regexPattern = pattern
-        .replace(/\./g, '\\.')
-        .replace(/\*/g, '.*');
-
-      const regex = new RegExp(`^${regexPattern}$`, 'i');
-      return regex.test(domain);
-    }
-
-    return false;
-  }
-
-  /**
-   * Match a path pattern against a path
-   */
-  private matchPath(pattern: string, path: string): boolean {
-    if (pattern === path) {
-      return true;
-    }
-
-    if (pattern.endsWith('*')) {
-      const prefix = pattern.slice(0, -1);
-      return path.startsWith(prefix);
-    }
-
-    return false;
-  }
-
-  /**
-   * Match an IP pattern against an IP
-   * Supports exact matches, wildcard patterns, and CIDR notation
-   */
-  private matchIp(pattern: string, ip: string): boolean {
-    // Exact match
-    if (pattern === ip) {
-      return true;
-    }
-
-    // Wildcard matching (e.g., 192.168.0.*)
-    if (pattern.includes('*')) {
-      const regexPattern = pattern
-        .replace(/\./g, '\\.')
-        .replace(/\*/g, '.*');
-
-      const regex = new RegExp(`^${regexPattern}$`);
-      return regex.test(ip);
-    }
-
-    // CIDR matching (e.g., 192.168.0.0/24)
-    if (pattern.includes('/')) {
-      try {
-        const [subnet, bits] = pattern.split('/');
-        
-        // Convert IP addresses to numeric format for comparison
-        const ipBinary = this.ipToBinary(ip);
-        const subnetBinary = this.ipToBinary(subnet);
-        
-        if (!ipBinary || !subnetBinary) {
-          return false;
-        }
-        
-        // Get the subnet mask from CIDR notation
-        const mask = parseInt(bits, 10);
-        if (isNaN(mask) || mask < 0 || mask > 32) {
-          return false;
-        }
-        
-        // Check if the first 'mask' bits match between IP and subnet
-        return ipBinary.slice(0, mask) === subnetBinary.slice(0, mask);
-      } catch (error) {
-        // If we encounter any error during CIDR matching, return false
-        return false;
-      }
-    }
-
-    return false;
-  }
-  
-  /**
-   * Convert an IP address to its binary representation
-   * @param ip The IP address to convert
-   * @returns Binary string representation or null if invalid
-   */
-  private ipToBinary(ip: string): string | null {
-    // Handle IPv4 addresses only for now
-    const parts = ip.split('.');
-    
-    // Validate IP format
-    if (parts.length !== 4) {
-      return null;
-    }
-    
-    // Convert each octet to 8-bit binary and concatenate
-    try {
-      return parts
-        .map(part => {
-          const num = parseInt(part, 10);
-          if (isNaN(num) || num < 0 || num > 255) {
-            throw new Error('Invalid IP octet');
-          }
-          return num.toString(2).padStart(8, '0');
-        })
-        .join('');
-    } catch (error) {
-      return null;
-    }
-  }
-}
 
 /**
  * Interface for connection tracking in the pool