@push.rocks/smartproxy 16.0.2 → 16.0.3

package/dist_ts/core/utils/route-manager.d.ts

@@ -0,0 +1,118 @@
+import * as plugins from '../../plugins.js';
+import type { IRouteConfig, TPortRange, IRouteContext } from '../../proxies/smart-proxy/models/route-types.js';
+/**
+ * Result of route matching
+ */
+export interface IRouteMatchResult {
+    route: IRouteConfig;
+    params?: Record<string, string>;
+}
+/**
+ * Logger interface for RouteManager
+ */
+export interface ILogger {
+    info: (message: string, ...args: any[]) => void;
+    warn: (message: string, ...args: any[]) => void;
+    error: (message: string, ...args: any[]) => void;
+    debug?: (message: string, ...args: any[]) => void;
+}
+/**
+ * Shared RouteManager used by both SmartProxy and NetworkProxy
+ *
+ * This provides a unified implementation for route management,
+ * route matching, and port handling.
+ */
+export declare class SharedRouteManager extends plugins.EventEmitter {
+    private routes;
+    private portMap;
+    private logger;
+    private enableDetailedLogging;
+    /**
+     * Memoization cache for expanded port ranges
+     */
+    private portRangeCache;
+    constructor(options: {
+        logger?: ILogger;
+        enableDetailedLogging?: boolean;
+        routes?: IRouteConfig[];
+    });
+    /**
+     * Update routes with new configuration
+     */
+    updateRoutes(routes?: IRouteConfig[]): void;
+    /**
+     * Get all routes
+     */
+    getRoutes(): IRouteConfig[];
+    /**
+     * Rebuild the port mapping for fast lookups
+     * Also logs information about the ports being listened on
+     */
+    private rebuildPortMap;
+    /**
+     * 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
+     */
+    expandPortRange(portRange: TPortRange): number[];
+    /**
+     * Get all ports that should be listened on
+     * This method automatically infers all required ports from route configurations
+     */
+    getListeningPorts(): number[];
+    /**
+     * Get all routes for a given port
+     */
+    getRoutesForPort(port: number): IRouteConfig[];
+    /**
+     * Find the matching route for a connection
+     */
+    findMatchingRoute(context: IRouteContext): IRouteMatchResult | null;
+    /**
+     * Check if a route matches the given context
+     */
+    private matchesRoute;
+    /**
+     * Match a domain pattern against a domain
+     * @deprecated Use the matchDomain function from route-utils.js instead
+     */
+    matchDomain(pattern: string, domain: string): boolean;
+    /**
+     * Match a path pattern against a path
+     * @deprecated Use the matchPath function from route-utils.js instead
+     */
+    matchPath(pattern: string, path: string): boolean;
+    /**
+     * Match an IP pattern against a pattern
+     * @deprecated Use the matchIpPattern function from route-utils.js instead
+     */
+    matchIpPattern(pattern: string, ip: string): boolean;
+    /**
+     * Match an IP against a CIDR pattern
+     * @deprecated Use the matchIpCidr function from route-utils.js instead
+     */
+    matchIpCidr(cidr: string, ip: string): boolean;
+    /**
+     * Convert an IP address to a numeric value
+     * @deprecated Use the ipToNumber function from route-utils.js instead
+     */
+    private ipToNumber;
+    /**
+     * Validate the route configuration and return any warnings
+     */
+    validateConfiguration(): string[];
+    /**
+     * Check if two route matches are similar (potential conflict)
+     */
+    private areMatchesSimilar;
+    /**
+     * Check if a route is completely shadowed by a higher priority route
+     */
+    private isRouteShadowed;
+    /**
+     * Check if route1 is more specific than route2
+     * @deprecated Use the calculateRouteSpecificity function from route-utils.js instead
+     */
+    private isRouteMoreSpecific;
+}

package/dist_ts/core/utils/route-manager.js

@@ -0,0 +1,383 @@
+import * as plugins from '../../plugins.js';
+import { matchDomain, matchRouteDomain, matchPath, matchIpPattern, matchIpCidr, ipToNumber, isIpAuthorized, calculateRouteSpecificity } from './route-utils.js';
+/**
+ * Shared RouteManager used by both SmartProxy and NetworkProxy
+ *
+ * This provides a unified implementation for route management,
+ * route matching, and port handling.
+ */
+export class SharedRouteManager extends plugins.EventEmitter {
+    constructor(options) {
+        super();
+        this.routes = [];
+        this.portMap = new Map();
+        /**
+         * Memoization cache for expanded port ranges
+         */
+        this.portRangeCache = new Map();
+        // Set up logger (use console if not provided)
+        this.logger = options.logger || {
+            info: console.log,
+            warn: console.warn,
+            error: console.error,
+            debug: options.enableDetailedLogging ? console.log : undefined
+        };
+        this.enableDetailedLogging = options.enableDetailedLogging || false;
+        // Initialize routes if provided
+        if (options.routes) {
+            this.updateRoutes(options.routes);
+        }
+    }
+    /**
+     * Update routes with new configuration
+     */
+    updateRoutes(routes = []) {
+        // 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;
+        });
+        // Rebuild port mapping for fast lookups
+        this.rebuildPortMap();
+        this.logger.info(`Updated RouteManager with ${this.routes.length} routes`);
+    }
+    /**
+     * Get all routes
+     */
+    getRoutes() {
+        return [...this.routes];
+    }
+    /**
+     * Rebuild the port mapping for fast lookups
+     * Also logs information about the ports being listened on
+     */
+    rebuildPortMap() {
+        this.portMap.clear();
+        this.portRangeCache.clear(); // Clear cache when rebuilding
+        // Track ports for logging
+        const portToRoutesMap = new Map();
+        for (const route of this.routes) {
+            const ports = this.expandPortRange(route.match.ports);
+            // Skip if no ports were found
+            if (ports.length === 0) {
+                this.logger.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;
+        this.logger.info(`Route manager configured with ${totalRoutes} routes across ${totalPorts} ports`);
+        // Log port details if detailed logging is enabled
+        if (this.enableDetailedLogging) {
+            for (const [port, routes] of this.portMap.entries()) {
+                this.logger.info(`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
+     */
+    expandPortRange(portRange) {
+        // 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 = [];
+        if (Array.isArray(portRange)) {
+            // Handle array of port objects or numbers
+            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) {
+                        this.logger.warn(`Invalid port range: from (${item.from}) > to (${item.to})`);
+                        return [];
+                    }
+                    // Handle port range object
+                    const ports = [];
+                    for (let p = item.from; p <= item.to; p++) {
+                        ports.push(p);
+                    }
+                    return ports;
+                }
+                return [];
+            });
+        }
+        // Cache the result
+        this.portRangeCache.set(cacheKey, result);
+        return result;
+    }
+    /**
+     * Get all ports that should be listened on
+     * This method automatically infers all required ports from route configurations
+     */
+    getListeningPorts() {
+        // Return the unique set of ports from all routes
+        return Array.from(this.portMap.keys());
+    }
+    /**
+     * Get all routes for a given port
+     */
+    getRoutesForPort(port) {
+        return this.portMap.get(port) || [];
+    }
+    /**
+     * Find the matching route for a connection
+     */
+    findMatchingRoute(context) {
+        // Get routes for this port if using port-based filtering
+        const routesToCheck = context.port
+            ? (this.portMap.get(context.port) || [])
+            : this.routes;
+        // Find the first matching route based on priority order
+        for (const route of routesToCheck) {
+            if (this.matchesRoute(route, context)) {
+                return { route };
+            }
+        }
+        return null;
+    }
+    /**
+     * Check if a route matches the given context
+     */
+    matchesRoute(route, context) {
+        // Skip disabled routes
+        if (route.enabled === false) {
+            return false;
+        }
+        // Check port match if provided in context
+        if (context.port !== undefined) {
+            const ports = this.expandPortRange(route.match.ports);
+            if (!ports.includes(context.port)) {
+                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.matchIpPattern(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;
+            }
+        }
+        // Check header match if specified
+        if (route.match.headers && context.headers) {
+            for (const [headerName, expectedValue] of Object.entries(route.match.headers)) {
+                const actualValue = context.headers[headerName.toLowerCase()];
+                // If header doesn't exist, no match
+                if (actualValue === undefined) {
+                    return false;
+                }
+                // Match against string or regex
+                if (typeof expectedValue === 'string') {
+                    if (actualValue !== expectedValue) {
+                        return false;
+                    }
+                }
+                else if (expectedValue instanceof RegExp) {
+                    if (!expectedValue.test(actualValue)) {
+                        return false;
+                    }
+                }
+            }
+        }
+        // All criteria matched
+        return true;
+    }
+    /**
+     * Match a domain pattern against a domain
+     * @deprecated Use the matchDomain function from route-utils.js instead
+     */
+    matchDomain(pattern, domain) {
+        return matchDomain(pattern, domain);
+    }
+    /**
+     * Match a path pattern against a path
+     * @deprecated Use the matchPath function from route-utils.js instead
+     */
+    matchPath(pattern, path) {
+        return matchPath(pattern, path);
+    }
+    /**
+     * Match an IP pattern against a pattern
+     * @deprecated Use the matchIpPattern function from route-utils.js instead
+     */
+    matchIpPattern(pattern, ip) {
+        return matchIpPattern(pattern, ip);
+    }
+    /**
+     * Match an IP against a CIDR pattern
+     * @deprecated Use the matchIpCidr function from route-utils.js instead
+     */
+    matchIpCidr(cidr, ip) {
+        return matchIpCidr(cidr, ip);
+    }
+    /**
+     * Convert an IP address to a numeric value
+     * @deprecated Use the ipToNumber function from route-utils.js instead
+     */
+    ipToNumber(ip) {
+        return ipToNumber(ip);
+    }
+    /**
+     * Validate the route configuration and return any warnings
+     */
+    validateConfiguration() {
+        const warnings = [];
+        const duplicatePorts = new Map();
+        // Check for routes with the same exact match criteria
+        for (let i = 0; i < this.routes.length; i++) {
+            for (let j = i + 1; j < this.routes.length; j++) {
+                const route1 = this.routes[i];
+                const route2 = this.routes[j];
+                // Check if route match criteria are the same
+                if (this.areMatchesSimilar(route1.match, route2.match)) {
+                    warnings.push(`Routes "${route1.name || i}" and "${route2.name || j}" have similar match criteria. ` +
+                        `The route with higher priority (${Math.max(route1.priority || 0, route2.priority || 0)}) will be used.`);
+                }
+            }
+        }
+        // Check for routes that may never be matched due to priority
+        for (let i = 0; i < this.routes.length; i++) {
+            const route = this.routes[i];
+            const higherPriorityRoutes = this.routes.filter(r => (r.priority || 0) > (route.priority || 0));
+            for (const higherRoute of higherPriorityRoutes) {
+                if (this.isRouteShadowed(route, higherRoute)) {
+                    warnings.push(`Route "${route.name || i}" may never be matched because it is shadowed by ` +
+                        `higher priority route "${higherRoute.name || 'unnamed'}"`);
+                    break;
+                }
+            }
+        }
+        return warnings;
+    }
+    /**
+     * Check if two route matches are similar (potential conflict)
+     */
+    areMatchesSimilar(match1, match2) {
+        // Check port overlap
+        const ports1 = new Set(this.expandPortRange(match1.ports));
+        const ports2 = new Set(this.expandPortRange(match2.ports));
+        let havePortOverlap = false;
+        for (const port of ports1) {
+            if (ports2.has(port)) {
+                havePortOverlap = true;
+                break;
+            }
+        }
+        if (!havePortOverlap) {
+            return false;
+        }
+        // Check domain overlap
+        if (match1.domains && match2.domains) {
+            const domains1 = Array.isArray(match1.domains) ? match1.domains : [match1.domains];
+            const domains2 = Array.isArray(match2.domains) ? match2.domains : [match2.domains];
+            // Check if any domain pattern from match1 could match any from match2
+            let haveDomainOverlap = false;
+            for (const domain1 of domains1) {
+                for (const domain2 of domains2) {
+                    if (domain1 === domain2 ||
+                        (domain1.includes('*') || domain2.includes('*'))) {
+                        haveDomainOverlap = true;
+                        break;
+                    }
+                }
+                if (haveDomainOverlap)
+                    break;
+            }
+            if (!haveDomainOverlap) {
+                return false;
+            }
+        }
+        else if (match1.domains || match2.domains) {
+            // One has domains, the other doesn't - they could overlap
+            // The one with domains is more specific, so it's not exactly a conflict
+            return false;
+        }
+        // Check path overlap
+        if (match1.path && match2.path) {
+            // This is a simplified check - in a real implementation,
+            // you'd need to check if the path patterns could match the same paths
+            return match1.path === match2.path ||
+                match1.path.includes('*') ||
+                match2.path.includes('*');
+        }
+        else if (match1.path || match2.path) {
+            // One has a path, the other doesn't
+            return false;
+        }
+        // If we get here, the matches have significant overlap
+        return true;
+    }
+    /**
+     * Check if a route is completely shadowed by a higher priority route
+     */
+    isRouteShadowed(route, higherPriorityRoute) {
+        // If they don't have similar match criteria, no shadowing occurs
+        if (!this.areMatchesSimilar(route.match, higherPriorityRoute.match)) {
+            return false;
+        }
+        // If higher priority route has more specific criteria, no shadowing
+        const routeSpecificity = calculateRouteSpecificity(route.match);
+        const higherRouteSpecificity = calculateRouteSpecificity(higherPriorityRoute.match);
+        if (higherRouteSpecificity > routeSpecificity) {
+            return false;
+        }
+        // If higher priority route is equally or less specific but has higher priority,
+        // it shadows the lower priority route
+        return true;
+    }
+    /**
+     * Check if route1 is more specific than route2
+     * @deprecated Use the calculateRouteSpecificity function from route-utils.js instead
+     */
+    isRouteMoreSpecific(match1, match2) {
+        return calculateRouteSpecificity(match1) > calculateRouteSpecificity(match2);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route-manager.js","sourceRoot":"","sources":["../../../ts/core/utils/route-manager.ts"],"names":[],"mappings":"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"}

package/dist_ts/core/utils/route-utils.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Route matching utilities for SmartProxy components
+ *
+ * Contains shared logic for domain matching, path matching, and IP matching
+ * to be used by different proxy components throughout the system.
+ */
+/**
+ * Match a domain pattern against a domain
+ *
+ * @param pattern Domain pattern with optional wildcards (e.g., "*.example.com")
+ * @param domain Domain to match against the pattern
+ * @returns Whether the domain matches the pattern
+ */
+export declare function matchDomain(pattern: string, domain: string): boolean;
+/**
+ * Match domains from a route against a given domain
+ *
+ * @param domains Array or single domain pattern to match against
+ * @param domain Domain to match
+ * @returns Whether the domain matches any of the patterns
+ */
+export declare function matchRouteDomain(domains: string | string[] | undefined, domain: string | undefined): boolean;
+/**
+ * Match a path pattern against a path
+ *
+ * @param pattern Path pattern with optional wildcards
+ * @param path Path to match against the pattern
+ * @returns Whether the path matches the pattern
+ */
+export declare function matchPath(pattern: string, path: string): boolean;
+/**
+ * Parse CIDR notation into subnet and mask bits
+ *
+ * @param cidr CIDR string (e.g., "192.168.1.0/24")
+ * @returns Object with subnet and bits, or null if invalid
+ */
+export declare function parseCidr(cidr: string): {
+    subnet: string;
+    bits: number;
+} | null;
+/**
+ * Convert an IP address to a numeric value
+ *
+ * @param ip IPv4 address string (e.g., "192.168.1.1")
+ * @returns Numeric representation of the IP
+ */
+export declare function ipToNumber(ip: string): number;
+/**
+ * Match an IP against a CIDR pattern
+ *
+ * @param cidr CIDR pattern (e.g., "192.168.1.0/24")
+ * @param ip IP to match against the pattern
+ * @returns Whether the IP is in the CIDR range
+ */
+export declare function matchIpCidr(cidr: string, ip: string): boolean;
+/**
+ * Match an IP pattern against an IP
+ *
+ * @param pattern IP pattern (exact, CIDR, or with wildcards)
+ * @param ip IP to match against the pattern
+ * @returns Whether the IP matches the pattern
+ */
+export declare function matchIpPattern(pattern: string, ip: string): boolean;
+/**
+ * Match an IP against allowed and blocked IP patterns
+ *
+ * @param ip IP to check
+ * @param allowedIps Array of allowed IP patterns
+ * @param blockedIps Array of blocked IP patterns
+ * @returns Whether the IP is allowed
+ */
+export declare function isIpAuthorized(ip: string, allowedIps?: string[], blockedIps?: string[]): boolean;
+/**
+ * Match an HTTP header pattern against a header value
+ *
+ * @param pattern Expected header value (string or RegExp)
+ * @param value Actual header value
+ * @returns Whether the header matches the pattern
+ */
+export declare function matchHeader(pattern: string | RegExp, value: string): boolean;
+/**
+ * Calculate route specificity score
+ * Higher score means more specific matching criteria
+ *
+ * @param match Match criteria to evaluate
+ * @returns Numeric specificity score
+ */
+export declare function calculateRouteSpecificity(match: {
+    domains?: string | string[];
+    path?: string;
+    clientIp?: string[];
+    tlsVersion?: string[];
+    headers?: Record<string, string | RegExp>;
+}): number;