@push.rocks/smartproxy 15.0.2 → 16.0.3

package/ts/proxies/smart-proxy/domain-config-manager.ts

@@ -1,441 +0,0 @@
-import * as plugins from '../../plugins.js';
-import type { IDomainConfig, ISmartProxyOptions } from './models/interfaces.js';
-import type { TForwardingType, IForwardConfig } from '../../forwarding/config/forwarding-types.js';
-import type { ForwardingHandler } from '../../forwarding/handlers/base-handler.js';
-import { ForwardingHandlerFactory } from '../../forwarding/factory/forwarding-factory.js';
-import type { IRouteConfig } from './models/route-types.js';
-import { RouteManager } from './route-manager.js';
-
-/**
- * Manages domain configurations and target selection
- */
-export class DomainConfigManager {
-  // Track round-robin indices for domain configs
-  private domainTargetIndices: Map<IDomainConfig, number> = new Map();
-
-  // Cache forwarding handlers for each domain config
-  private forwardingHandlers: Map<IDomainConfig, ForwardingHandler> = new Map();
-
-  // Store derived domain configs from routes
-  private derivedDomainConfigs: IDomainConfig[] = [];
-
-  // Reference to RouteManager for route-based configuration
-  private routeManager?: RouteManager;
-
-  constructor(private settings: ISmartProxyOptions) {
-    // Initialize with derived domain configs if using route-based configuration
-    if (settings.routes && !settings.domainConfigs) {
-      this.generateDomainConfigsFromRoutes();
-    }
-  }
-
-  /**
-   * Set the route manager reference for route-based queries
-   */
-  public setRouteManager(routeManager: RouteManager): void {
-    this.routeManager = routeManager;
-
-    // Regenerate domain configs from routes if needed
-    if (this.settings.routes && (!this.settings.domainConfigs || this.settings.domainConfigs.length === 0)) {
-      this.generateDomainConfigsFromRoutes();
-    }
-  }
-
-  /**
-   * Generate domain configs from routes
-   */
-  public generateDomainConfigsFromRoutes(): void {
-    this.derivedDomainConfigs = [];
-
-    if (!this.settings.routes) return;
-
-    for (const route of this.settings.routes) {
-      if (route.action.type !== 'forward' || !route.match.domains) continue;
-
-      // Convert route to domain config
-      const domainConfig = this.routeToDomainConfig(route);
-      if (domainConfig) {
-        this.derivedDomainConfigs.push(domainConfig);
-      }
-    }
-  }
-
-  /**
-   * Convert a route to a domain config
-   */
-  private routeToDomainConfig(route: IRouteConfig): IDomainConfig | null {
-    if (route.action.type !== 'forward' || !route.action.target) return null;
-
-    // Get domains from route
-    const domains = Array.isArray(route.match.domains) ?
-      route.match.domains :
-      (route.match.domains ? [route.match.domains] : []);
-
-    if (domains.length === 0) return null;
-
-    // Determine forwarding type based on TLS mode
-    let forwardingType: TForwardingType = 'http-only';
-    if (route.action.tls) {
-      switch (route.action.tls.mode) {
-        case 'passthrough':
-          forwardingType = 'https-passthrough';
-          break;
-        case 'terminate':
-          forwardingType = 'https-terminate-to-http';
-          break;
-        case 'terminate-and-reencrypt':
-          forwardingType = 'https-terminate-to-https';
-          break;
-      }
-    }
-
-    // Create domain config
-    return {
-      domains,
-      forwarding: {
-        type: forwardingType,
-        target: {
-          host: route.action.target.host,
-          port: route.action.target.port
-        },
-        security: route.action.security ? {
-          allowedIps: route.action.security.allowedIps,
-          blockedIps: route.action.security.blockedIps,
-          maxConnections: route.action.security.maxConnections
-        } : undefined,
-        https: route.action.tls && route.action.tls.certificate !== 'auto' ? {
-          customCert: route.action.tls.certificate
-        } : undefined,
-        advanced: route.action.advanced
-      }
-    };
-  }
-
-  /**
-   * Updates the domain configurations
-   */
-  public updateDomainConfigs(newDomainConfigs: IDomainConfig[]): void {
-    // If we're using domainConfigs property, update it
-    if (this.settings.domainConfigs) {
-      this.settings.domainConfigs = newDomainConfigs;
-    } else {
-      // Otherwise update our derived configs
-      this.derivedDomainConfigs = newDomainConfigs;
-    }
-
-    // Reset target indices for removed configs
-    const currentConfigSet = new Set(newDomainConfigs);
-    for (const [config] of this.domainTargetIndices) {
-      if (!currentConfigSet.has(config)) {
-        this.domainTargetIndices.delete(config);
-      }
-    }
-
-    // Clear handlers for removed configs and create handlers for new configs
-    const handlersToRemove: IDomainConfig[] = [];
-    for (const [config] of this.forwardingHandlers) {
-      if (!currentConfigSet.has(config)) {
-        handlersToRemove.push(config);
-      }
-    }
-
-    // Remove handlers that are no longer needed
-    for (const config of handlersToRemove) {
-      this.forwardingHandlers.delete(config);
-    }
-
-    // Create handlers for new configs
-    for (const config of newDomainConfigs) {
-      if (!this.forwardingHandlers.has(config)) {
-        try {
-          const handler = this.createForwardingHandler(config);
-          this.forwardingHandlers.set(config, handler);
-        } catch (err) {
-          console.log(`Error creating forwarding handler for domain ${config.domains.join(', ')}: ${err}`);
-        }
-      }
-    }
-  }
-
-  /**
-   * Get all domain configurations
-   */
-  public getDomainConfigs(): IDomainConfig[] {
-    // Use domainConfigs from settings if available, otherwise use derived configs
-    return this.settings.domainConfigs || this.derivedDomainConfigs;
-  }
-
-  /**
-   * Find domain config matching a server name
-   */
-  public findDomainConfig(serverName: string): IDomainConfig | undefined {
-    if (!serverName) return undefined;
-
-    // Get domain configs from the appropriate source
-    const domainConfigs = this.getDomainConfigs();
-
-    // Check for direct match
-    for (const config of domainConfigs) {
-      if (config.domains.some(d => plugins.minimatch(serverName, d))) {
-        return config;
-      }
-    }
-
-    // No match found
-    return undefined;
-  }
-
-  /**
-   * Find domain config for a specific port
-   */
-  public findDomainConfigForPort(port: number): IDomainConfig | undefined {
-    // Get domain configs from the appropriate source
-    const domainConfigs = this.getDomainConfigs();
-
-    // Check if any domain config has a matching port range
-    for (const domain of domainConfigs) {
-      const portRanges = domain.forwarding?.advanced?.portRanges;
-      if (portRanges && portRanges.length > 0 && this.isPortInRanges(port, portRanges)) {
-        return domain;
-      }
-    }
-
-    // If we're in route-based mode, also check routes for this port
-    if (this.settings.routes && (!this.settings.domainConfigs || this.settings.domainConfigs.length === 0)) {
-      const routesForPort = this.settings.routes.filter(route => {
-        // Check if this port is in the route's ports
-        if (typeof route.match.ports === 'number') {
-          return route.match.ports === port;
-        } else if (Array.isArray(route.match.ports)) {
-          return route.match.ports.some(p => {
-            if (typeof p === 'number') {
-              return p === port;
-            } else if (p.from && p.to) {
-              return port >= p.from && port <= p.to;
-            }
-            return false;
-          });
-        }
-        return false;
-      });
-
-      // If we found any routes for this port, convert the first one to a domain config
-      if (routesForPort.length > 0 && routesForPort[0].action.type === 'forward') {
-        const domainConfig = this.routeToDomainConfig(routesForPort[0]);
-        if (domainConfig) {
-          return domainConfig;
-        }
-      }
-    }
-
-    return undefined;
-  }
-  
-  /**
-   * Check if a port is within any of the given ranges
-   */
-  public isPortInRanges(port: number, ranges: Array<{ from: number; to: number }>): boolean {
-    return ranges.some((range) => port >= range.from && port <= range.to);
-  }
-  
-  /**
-   * Get target IP with round-robin support
-   */
-  public getTargetIP(domainConfig: IDomainConfig): string {
-    const targetHosts = Array.isArray(domainConfig.forwarding.target.host)
-      ? domainConfig.forwarding.target.host
-      : [domainConfig.forwarding.target.host];
-
-    if (targetHosts.length > 0) {
-      const currentIndex = this.domainTargetIndices.get(domainConfig) || 0;
-      const ip = targetHosts[currentIndex % targetHosts.length];
-      this.domainTargetIndices.set(domainConfig, currentIndex + 1);
-      return ip;
-    }
-
-    return this.settings.targetIP || 'localhost';
-  }
-
-  /**
-   * Get target host with round-robin support (for tests)
-   * This is just an alias for getTargetIP for easier test compatibility
-   */
-  public getTargetHost(domainConfig: IDomainConfig): string {
-    return this.getTargetIP(domainConfig);
-  }
-
-  /**
-   * Get target port from domain config
-   */
-  public getTargetPort(domainConfig: IDomainConfig, defaultPort: number): number {
-    return domainConfig.forwarding.target.port || defaultPort;
-  }
-
-  /**
-   * Checks if a domain should use NetworkProxy
-   */
-  public shouldUseNetworkProxy(domainConfig: IDomainConfig): boolean {
-    const forwardingType = this.getForwardingType(domainConfig);
-    return forwardingType === 'https-terminate-to-http' ||
-           forwardingType === 'https-terminate-to-https';
-  }
-
-  /**
-   * Gets the NetworkProxy port for a domain
-   */
-  public getNetworkProxyPort(domainConfig: IDomainConfig): number | undefined {
-    // First check if we should use NetworkProxy at all
-    if (!this.shouldUseNetworkProxy(domainConfig)) {
-      return undefined;
-    }
-
-    return domainConfig.forwarding.advanced?.networkProxyPort || this.settings.networkProxyPort;
-  }
-
-  /**
-   * Get effective allowed and blocked IPs for a domain
-   *
-   * This method combines domain-specific security rules from the forwarding configuration
-   * with global security defaults when necessary.
-   */
-  public getEffectiveIPRules(domainConfig: IDomainConfig): {
-    allowedIPs: string[],
-    blockedIPs: string[]
-  } {
-    // Start with empty arrays
-    const allowedIPs: string[] = [];
-    const blockedIPs: string[] = [];
-
-    // Add IPs from forwarding security settings if available
-    if (domainConfig.forwarding?.security?.allowedIps) {
-      allowedIPs.push(...domainConfig.forwarding.security.allowedIps);
-    } else {
-      // If no allowed IPs are specified in forwarding config and global defaults exist, use them
-      if (this.settings.defaultAllowedIPs && this.settings.defaultAllowedIPs.length > 0) {
-        allowedIPs.push(...this.settings.defaultAllowedIPs);
-      } else {
-        // Default to allow all if no specific rules
-        allowedIPs.push('*');
-      }
-    }
-
-    // Add blocked IPs from forwarding security settings if available
-    if (domainConfig.forwarding?.security?.blockedIps) {
-      blockedIPs.push(...domainConfig.forwarding.security.blockedIps);
-    }
-
-    // Always add global blocked IPs, even if domain has its own rules
-    // This ensures that global blocks take precedence
-    if (this.settings.defaultBlockedIPs && this.settings.defaultBlockedIPs.length > 0) {
-      // Add only unique IPs that aren't already in the list
-      for (const ip of this.settings.defaultBlockedIPs) {
-        if (!blockedIPs.includes(ip)) {
-          blockedIPs.push(ip);
-        }
-      }
-    }
-
-    return {
-      allowedIPs,
-      blockedIPs
-    };
-  }
-  
-  /**
-   * Get connection timeout for a domain
-   */
-  public getConnectionTimeout(domainConfig?: IDomainConfig): number {
-    if (domainConfig?.forwarding.advanced?.timeout) {
-      return domainConfig.forwarding.advanced.timeout;
-    }
-
-    return this.settings.maxConnectionLifetime || 86400000; // 24 hours default
-  }
-
-  /**
-   * Creates a forwarding handler for a domain configuration
-   */
-  private createForwardingHandler(domainConfig: IDomainConfig): ForwardingHandler {
-    // Create a new handler using the factory
-    const handler = ForwardingHandlerFactory.createHandler(domainConfig.forwarding);
-
-    // Initialize the handler
-    handler.initialize().catch(err => {
-      console.log(`Error initializing forwarding handler for ${domainConfig.domains.join(', ')}: ${err}`);
-    });
-
-    return handler;
-  }
-
-  /**
-   * Gets a forwarding handler for a domain config
-   * If no handler exists, creates one
-   */
-  public getForwardingHandler(domainConfig: IDomainConfig): ForwardingHandler {
-    // If we already have a handler, return it
-    if (this.forwardingHandlers.has(domainConfig)) {
-      return this.forwardingHandlers.get(domainConfig)!;
-    }
-
-    // Otherwise create a new handler
-    const handler = this.createForwardingHandler(domainConfig);
-    this.forwardingHandlers.set(domainConfig, handler);
-
-    return handler;
-  }
-
-  /**
-   * Gets the forwarding type for a domain config
-   */
-  public getForwardingType(domainConfig?: IDomainConfig): TForwardingType | undefined {
-    if (!domainConfig?.forwarding) return undefined;
-    return domainConfig.forwarding.type;
-  }
-
-  /**
-   * Checks if the forwarding type requires TLS termination
-   */
-  public requiresTlsTermination(domainConfig?: IDomainConfig): boolean {
-    if (!domainConfig) return false;
-
-    const forwardingType = this.getForwardingType(domainConfig);
-    return forwardingType === 'https-terminate-to-http' ||
-           forwardingType === 'https-terminate-to-https';
-  }
-
-  /**
-   * Checks if the forwarding type supports HTTP
-   */
-  public supportsHttp(domainConfig?: IDomainConfig): boolean {
-    if (!domainConfig) return false;
-
-    const forwardingType = this.getForwardingType(domainConfig);
-
-    // HTTP-only always supports HTTP
-    if (forwardingType === 'http-only') return true;
-
-    // For termination types, check the HTTP settings
-    if (forwardingType === 'https-terminate-to-http' ||
-        forwardingType === 'https-terminate-to-https') {
-      // HTTP is supported by default for termination types
-      return domainConfig.forwarding?.http?.enabled !== false;
-    }
-
-    // HTTPS-passthrough doesn't support HTTP
-    return false;
-  }
-
-  /**
-   * Checks if HTTP requests should be redirected to HTTPS
-   */
-  public shouldRedirectToHttps(domainConfig?: IDomainConfig): boolean {
-    if (!domainConfig?.forwarding) return false;
-
-    // Only check for redirect if HTTP is enabled
-    if (this.supportsHttp(domainConfig)) {
-      return !!domainConfig.forwarding.http?.redirectToHttps;
-    }
-
-    return false;
-  }
-}

package/ts/proxies/smart-proxy/port-range-manager.ts

@@ -1,211 +0,0 @@
-import type { ISmartProxyOptions } from './models/interfaces.js';
-
-/**
- * Manages port ranges and port-based configuration
- */
-export class PortRangeManager {
-  constructor(private settings: ISmartProxyOptions) {}
-  
-  /**
-   * Get all ports that should be listened on
-   */
-  public getListeningPorts(): Set<number> {
-    const listeningPorts = new Set<number>();
-    
-    // Always include the main fromPort
-    listeningPorts.add(this.settings.fromPort);
-    
-    // Add ports from global port ranges if defined
-    if (this.settings.globalPortRanges && this.settings.globalPortRanges.length > 0) {
-      for (const range of this.settings.globalPortRanges) {
-        for (let port = range.from; port <= range.to; port++) {
-          listeningPorts.add(port);
-        }
-      }
-    }
-    
-    return listeningPorts;
-  }
-  
-  /**
-   * Check if a port should use NetworkProxy for forwarding
-   */
-  public shouldUseNetworkProxy(port: number): boolean {
-    return !!this.settings.useNetworkProxy && this.settings.useNetworkProxy.includes(port);
-  }
-  
-  /**
-   * Check if port should use global forwarding
-   */
-  public shouldUseGlobalForwarding(port: number): boolean {
-    return (
-      !!this.settings.forwardAllGlobalRanges &&
-      this.isPortInGlobalRanges(port)
-    );
-  }
-  
-  /**
-   * Check if a port is in global ranges
-   */
-  public isPortInGlobalRanges(port: number): boolean {
-    return (
-      this.settings.globalPortRanges &&
-      this.isPortInRanges(port, this.settings.globalPortRanges)
-    );
-  }
-  
-  /**
-   * Check if a port falls within the specified ranges
-   */
-  public isPortInRanges(port: number, ranges: Array<{ from: number; to: number }>): boolean {
-    return ranges.some((range) => port >= range.from && port <= range.to);
-  }
-  
-  /**
-   * Get forwarding port for a specific listening port
-   * This determines what port to connect to on the target
-   */
-  public getForwardingPort(listeningPort: number): number {
-    // If using global forwarding, forward to the original port
-    if (this.settings.forwardAllGlobalRanges && this.isPortInGlobalRanges(listeningPort)) {
-      return listeningPort;
-    }
-    
-    // Otherwise use the configured toPort
-    return this.settings.toPort;
-  }
-  
-  /**
-   * Find domain-specific port ranges that include a given port
-   */
-  public findDomainPortRange(port: number): { 
-    domainIndex: number, 
-    range: { from: number, to: number } 
-  } | undefined {
-    for (let i = 0; i < this.settings.domainConfigs.length; i++) {
-      const domain = this.settings.domainConfigs[i];
-      // Get port ranges from forwarding.advanced if available
-      const portRanges = domain.forwarding?.advanced?.portRanges;
-      if (portRanges && portRanges.length > 0) {
-        for (const range of portRanges) {
-          if (port >= range.from && port <= range.to) {
-            return { domainIndex: i, range };
-          }
-        }
-      }
-    }
-    return undefined;
-  }
-  
-  /**
-   * Get a list of all configured ports
-   * This includes the fromPort, NetworkProxy ports, and ports from all ranges
-   */
-  public getAllConfiguredPorts(): number[] {
-    const ports = new Set<number>();
-    
-    // Add main listening port
-    ports.add(this.settings.fromPort);
-    
-    // Add NetworkProxy port if configured
-    if (this.settings.networkProxyPort) {
-      ports.add(this.settings.networkProxyPort);
-    }
-    
-    // Add NetworkProxy ports
-    if (this.settings.useNetworkProxy) {
-      for (const port of this.settings.useNetworkProxy) {
-        ports.add(port);
-      }
-    }
-    
-    
-    // Add global port ranges
-    if (this.settings.globalPortRanges) {
-      for (const range of this.settings.globalPortRanges) {
-        for (let port = range.from; port <= range.to; port++) {
-          ports.add(port);
-        }
-      }
-    }
-    
-    // Add domain-specific port ranges
-    for (const domain of this.settings.domainConfigs) {
-      // Get port ranges from forwarding.advanced
-      const portRanges = domain.forwarding?.advanced?.portRanges;
-      if (portRanges && portRanges.length > 0) {
-        for (const range of portRanges) {
-          for (let port = range.from; port <= range.to; port++) {
-            ports.add(port);
-          }
-        }
-      }
-
-      // Add domain-specific NetworkProxy port if configured in forwarding.advanced
-      const networkProxyPort = domain.forwarding?.advanced?.networkProxyPort;
-      if (networkProxyPort) {
-        ports.add(networkProxyPort);
-      }
-    }
-    
-    return Array.from(ports);
-  }
-  
-  /**
-   * Validate port configuration
-   * Returns array of warning messages
-   */
-  public validateConfiguration(): string[] {
-    const warnings: string[] = [];
-    
-    // Check for overlapping port ranges
-    const portMappings = new Map<number, string[]>();
-    
-    // Track global port ranges
-    if (this.settings.globalPortRanges) {
-      for (const range of this.settings.globalPortRanges) {
-        for (let port = range.from; port <= range.to; port++) {
-          if (!portMappings.has(port)) {
-            portMappings.set(port, []);
-          }
-          portMappings.get(port)!.push('Global Port Range');
-        }
-      }
-    }
-    
-    // Track domain-specific port ranges
-    for (const domain of this.settings.domainConfigs) {
-      // Get port ranges from forwarding.advanced
-      const portRanges = domain.forwarding?.advanced?.portRanges;
-      if (portRanges && portRanges.length > 0) {
-        for (const range of portRanges) {
-          for (let port = range.from; port <= range.to; port++) {
-            if (!portMappings.has(port)) {
-              portMappings.set(port, []);
-            }
-            portMappings.get(port)!.push(`Domain: ${domain.domains.join(', ')}`);
-          }
-        }
-      }
-    }
-    
-    // Check for ports with multiple mappings
-    for (const [port, mappings] of portMappings.entries()) {
-      if (mappings.length > 1) {
-        warnings.push(`Port ${port} has multiple mappings: ${mappings.join(', ')}`);
-      }
-    }
-    
-    // Check if main ports are used elsewhere
-    if (portMappings.has(this.settings.fromPort) && portMappings.get(this.settings.fromPort)!.length > 0) {
-      warnings.push(`Main listening port ${this.settings.fromPort} is also used in port ranges`);
-    }
-    
-    if (this.settings.networkProxyPort && portMappings.has(this.settings.networkProxyPort)) {
-      warnings.push(`NetworkProxy port ${this.settings.networkProxyPort} is also used in port ranges`);
-    }
-    
-    
-    return warnings;
-  }
-}