@push.rocks/smartproxy 19.5.19 → 19.5.20

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

@@ -0,0 +1,342 @@
+import * as plugins from '../../plugins.js';
+import { matchRouteDomain, calculateRouteSpecificity } from './route-utils.js';
+import { DomainMatcher, PathMatcher, IpMatcher } from './matchers/index.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 => DomainMatcher.match(domainPattern, context.domain))) {
+                return false;
+            }
+        }
+        // Check path match if specified
+        if (route.match.path && context.path) {
+            if (!PathMatcher.match(route.match.path, context.path).matches) {
+                return false;
+            }
+        }
+        // Check client IP match if specified
+        if (route.match.clientIp && context.clientIp) {
+            if (!route.match.clientIp.some(ip => IpMatcher.match(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;
+    }
+    /**
+     * 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;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route-manager.js","sourceRoot":"","sources":["../../../ts/core/routing/route-manager.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,28 @@
+/**
+ * Route matching utilities for SmartProxy components
+ *
+ * This file provides utility functions that use the unified matchers
+ * and additional route-specific utilities.
+ */
+/**
+ * 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;
+/**
+ * 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;

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

@@ -0,0 +1,67 @@
+/**
+ * Route matching utilities for SmartProxy components
+ *
+ * This file provides utility functions that use the unified matchers
+ * and additional route-specific utilities.
+ */
+import { DomainMatcher, PathMatcher, IpMatcher, HeaderMatcher } from './matchers/index.js';
+import { RouteSpecificity } from './specificity.js';
+/**
+ * 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 function matchRouteDomain(domains, domain) {
+    // If no domains specified in the route, match all domains
+    if (!domains) {
+        return true;
+    }
+    // If no domain in the request, can't match domain-specific routes
+    if (!domain) {
+        return false;
+    }
+    const patterns = Array.isArray(domains) ? domains : [domains];
+    return patterns.some(pattern => DomainMatcher.match(pattern, domain));
+}
+/**
+ * Calculate route specificity score
+ * Higher score means more specific matching criteria
+ *
+ * @param match Match criteria to evaluate
+ * @returns Numeric specificity score
+ */
+export function calculateRouteSpecificity(match) {
+    let score = 0;
+    // Path specificity using PathMatcher
+    if (match.path) {
+        score += PathMatcher.calculateSpecificity(match.path);
+    }
+    // Domain specificity using DomainMatcher
+    if (match.domains) {
+        const domains = Array.isArray(match.domains) ? match.domains : [match.domains];
+        // Use the highest specificity among all domains
+        const domainScore = Math.max(...domains.map(d => DomainMatcher.calculateSpecificity(d)));
+        score += domainScore;
+    }
+    // Headers specificity using HeaderMatcher
+    if (match.headers) {
+        const stringHeaders = {};
+        for (const [key, value] of Object.entries(match.headers)) {
+            stringHeaders[key] = value instanceof RegExp ? value.source : value;
+        }
+        score += HeaderMatcher.calculateSpecificity(stringHeaders);
+    }
+    // Client IP adds some specificity
+    if (match.clientIp && match.clientIp.length > 0) {
+        // Use the first IP pattern for specificity
+        score += IpMatcher.calculateSpecificity(match.clientIp[0]);
+    }
+    // TLS version adds minimal specificity
+    if (match.tlsVersion && match.tlsVersion.length > 0) {
+        score += match.tlsVersion.length * 10;
+    }
+    return score;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/core/routing/specificity.d.ts

@@ -0,0 +1,30 @@
+import type { IRouteConfig } from '../../proxies/smart-proxy/models/route-types.js';
+import type { IRouteSpecificity } from './types.js';
+/**
+ * Unified route specificity calculator
+ * Provides consistent specificity scoring across all routing components
+ */
+export declare class RouteSpecificity {
+    /**
+     * Calculate the total specificity score for a route
+     * Higher scores indicate more specific routes that should match first
+     */
+    static calculate(route: IRouteConfig): IRouteSpecificity;
+    /**
+     * Compare two routes and determine which is more specific
+     * @returns positive if route1 is more specific, negative if route2 is more specific, 0 if equal
+     */
+    static compare(route1: IRouteConfig, route2: IRouteConfig): number;
+    /**
+     * Sort routes by specificity (most specific first)
+     */
+    static sort(routes: IRouteConfig[]): IRouteConfig[];
+    /**
+     * Find the most specific route from a list
+     */
+    static findMostSpecific(routes: IRouteConfig[]): IRouteConfig | null;
+    /**
+     * Check if a route has any matching criteria
+     */
+    static hasMatchCriteria(route: IRouteConfig): boolean;
+}

package/dist_ts/core/routing/specificity.js

@@ -0,0 +1,115 @@
+import { DomainMatcher, PathMatcher, IpMatcher, HeaderMatcher } from './matchers/index.js';
+/**
+ * Unified route specificity calculator
+ * Provides consistent specificity scoring across all routing components
+ */
+export class RouteSpecificity {
+    /**
+     * Calculate the total specificity score for a route
+     * Higher scores indicate more specific routes that should match first
+     */
+    static calculate(route) {
+        const specificity = {
+            pathSpecificity: 0,
+            domainSpecificity: 0,
+            ipSpecificity: 0,
+            headerSpecificity: 0,
+            tlsSpecificity: 0,
+            totalScore: 0
+        };
+        // Path specificity
+        if (route.match.path) {
+            specificity.pathSpecificity = PathMatcher.calculateSpecificity(route.match.path);
+        }
+        // Domain specificity
+        if (route.match.domains) {
+            const domains = Array.isArray(route.match.domains)
+                ? route.match.domains
+                : [route.match.domains];
+            // Use the highest specificity among all domains
+            specificity.domainSpecificity = Math.max(...domains.map(d => DomainMatcher.calculateSpecificity(d)));
+        }
+        // IP specificity (clientIp is an array of IPs)
+        if (route.match.clientIp && route.match.clientIp.length > 0) {
+            // Use the first IP pattern for specificity calculation
+            specificity.ipSpecificity = IpMatcher.calculateSpecificity(route.match.clientIp[0]);
+        }
+        // Header specificity (convert RegExp values to strings)
+        if (route.match.headers) {
+            const stringHeaders = {};
+            for (const [key, value] of Object.entries(route.match.headers)) {
+                stringHeaders[key] = value instanceof RegExp ? value.source : value;
+            }
+            specificity.headerSpecificity = HeaderMatcher.calculateSpecificity(stringHeaders);
+        }
+        // TLS version specificity
+        if (route.match.tlsVersion && route.match.tlsVersion.length > 0) {
+            specificity.tlsSpecificity = route.match.tlsVersion.length * 10;
+        }
+        // Calculate total score with weights
+        specificity.totalScore =
+            specificity.pathSpecificity * 3 + // Path is most important
+                specificity.domainSpecificity * 2 + // Domain is second
+                specificity.ipSpecificity * 1.5 + // IP is moderately important
+                specificity.headerSpecificity * 1 + // Headers are less important
+                specificity.tlsSpecificity * 0.5; // TLS is least important
+        return specificity;
+    }
+    /**
+     * Compare two routes and determine which is more specific
+     * @returns positive if route1 is more specific, negative if route2 is more specific, 0 if equal
+     */
+    static compare(route1, route2) {
+        const spec1 = this.calculate(route1);
+        const spec2 = this.calculate(route2);
+        // First compare by total score
+        if (spec1.totalScore !== spec2.totalScore) {
+            return spec1.totalScore - spec2.totalScore;
+        }
+        // If total scores are equal, compare by individual components
+        // Path is most important tiebreaker
+        if (spec1.pathSpecificity !== spec2.pathSpecificity) {
+            return spec1.pathSpecificity - spec2.pathSpecificity;
+        }
+        // Then domain
+        if (spec1.domainSpecificity !== spec2.domainSpecificity) {
+            return spec1.domainSpecificity - spec2.domainSpecificity;
+        }
+        // Then IP
+        if (spec1.ipSpecificity !== spec2.ipSpecificity) {
+            return spec1.ipSpecificity - spec2.ipSpecificity;
+        }
+        // Then headers
+        if (spec1.headerSpecificity !== spec2.headerSpecificity) {
+            return spec1.headerSpecificity - spec2.headerSpecificity;
+        }
+        // Finally TLS
+        return spec1.tlsSpecificity - spec2.tlsSpecificity;
+    }
+    /**
+     * Sort routes by specificity (most specific first)
+     */
+    static sort(routes) {
+        return [...routes].sort((a, b) => this.compare(b, a));
+    }
+    /**
+     * Find the most specific route from a list
+     */
+    static findMostSpecific(routes) {
+        if (routes.length === 0)
+            return null;
+        return routes.reduce((most, current) => this.compare(current, most) > 0 ? current : most);
+    }
+    /**
+     * Check if a route has any matching criteria
+     */
+    static hasMatchCriteria(route) {
+        const match = route.match;
+        return !!(match.domains ||
+            match.path ||
+            match.clientIp?.length ||
+            match.headers ||
+            match.tlsVersion?.length);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/core/routing/types.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Core routing types used throughout the routing system
+ */
+export interface IPathMatchResult {
+    matches: boolean;
+    params?: Record<string, string>;
+    pathMatch?: string;
+    pathRemainder?: string;
+}
+export interface IRouteMatchResult {
+    matches: boolean;
+    score: number;
+    specificity: number;
+    matchedCriteria: string[];
+}
+export interface IDomainMatchOptions {
+    allowWildcards?: boolean;
+    caseInsensitive?: boolean;
+}
+export interface IIpMatchOptions {
+    allowCidr?: boolean;
+    allowRanges?: boolean;
+}
+export interface IHeaderMatchOptions {
+    caseInsensitive?: boolean;
+    exactMatch?: boolean;
+}
+export interface IRouteSpecificity {
+    pathSpecificity: number;
+    domainSpecificity: number;
+    ipSpecificity: number;
+    headerSpecificity: number;
+    tlsSpecificity: number;
+    totalScore: number;
+}
+export interface IMatcher<T = any, O = any> {
+    match(pattern: string, value: string, options?: O): T | boolean;
+}
+export interface IAsyncMatcher<T = any, O = any> {
+    match(pattern: string, value: string, options?: O): Promise<T | boolean>;
+}

package/dist_ts/core/routing/types.js

@@ -0,0 +1,5 @@
+/**
+ * Core routing types used throughout the routing system
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9jb3JlL3JvdXRpbmcvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUcifQ==