@push.rocks/smartproxy 19.5.19 → 19.5.20

package/dist_ts/core/routing/matchers/ip.js

@@ -0,0 +1,169 @@
+/**
+ * IpMatcher provides comprehensive IP address matching functionality
+ * Supporting exact matches, CIDR notation, ranges, and wildcards
+ */
+export class IpMatcher {
+    /**
+     * Check if a value is a valid IPv4 address
+     */
+    static isValidIpv4(ip) {
+        const parts = ip.split('.');
+        if (parts.length !== 4)
+            return false;
+        return parts.every(part => {
+            const num = parseInt(part, 10);
+            return !isNaN(num) && num >= 0 && num <= 255 && part === num.toString();
+        });
+    }
+    /**
+     * Check if a value is a valid IPv6 address (simplified check)
+     */
+    static isValidIpv6(ip) {
+        // Basic IPv6 validation - can be enhanced
+        const ipv6Regex = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|(([0-9a-fA-F]{1,4}:){1,7}|:):|(([0-9a-fA-F]{1,4}:){1,6}|::):[0-9a-fA-F]{1,4})$/;
+        return ipv6Regex.test(ip);
+    }
+    /**
+     * Convert IP address to numeric value for comparison
+     */
+    static ipToNumber(ip) {
+        const parts = ip.split('.');
+        return parts.reduce((acc, part, index) => {
+            return acc + (parseInt(part, 10) << (8 * (3 - index)));
+        }, 0);
+    }
+    /**
+     * Match an IP against a CIDR notation pattern
+     */
+    static matchCidr(cidr, ip) {
+        const [range, bits] = cidr.split('/');
+        if (!bits || !this.isValidIpv4(range) || !this.isValidIpv4(ip)) {
+            return false;
+        }
+        const rangeMask = parseInt(bits, 10);
+        if (isNaN(rangeMask) || rangeMask < 0 || rangeMask > 32) {
+            return false;
+        }
+        const rangeNum = this.ipToNumber(range);
+        const ipNum = this.ipToNumber(ip);
+        const mask = (-1 << (32 - rangeMask)) >>> 0;
+        return (rangeNum & mask) === (ipNum & mask);
+    }
+    /**
+     * Match an IP against a wildcard pattern
+     */
+    static matchWildcard(pattern, ip) {
+        if (!this.isValidIpv4(ip))
+            return false;
+        const patternParts = pattern.split('.');
+        const ipParts = ip.split('.');
+        if (patternParts.length !== 4)
+            return false;
+        return patternParts.every((part, index) => {
+            if (part === '*')
+                return true;
+            return part === ipParts[index];
+        });
+    }
+    /**
+     * Match an IP against a range (e.g., "192.168.1.1-192.168.1.100")
+     */
+    static matchRange(range, ip) {
+        const [start, end] = range.split('-').map(s => s.trim());
+        if (!start || !end || !this.isValidIpv4(start) || !this.isValidIpv4(end) || !this.isValidIpv4(ip)) {
+            return false;
+        }
+        const startNum = this.ipToNumber(start);
+        const endNum = this.ipToNumber(end);
+        const ipNum = this.ipToNumber(ip);
+        return ipNum >= startNum && ipNum <= endNum;
+    }
+    /**
+     * Match an IP pattern against an IP address
+     * Supports multiple formats:
+     * - Exact match: "192.168.1.1"
+     * - CIDR: "192.168.1.0/24"
+     * - Wildcard: "192.168.1.*"
+     * - Range: "192.168.1.1-192.168.1.100"
+     */
+    static match(pattern, ip, options = {}) {
+        // Handle null/undefined cases
+        if (!pattern || !ip) {
+            return false;
+        }
+        // Normalize inputs
+        const normalizedPattern = pattern.trim();
+        const normalizedIp = ip.trim();
+        // Extract IPv4 from IPv6-mapped addresses (::ffff:192.168.1.1)
+        const ipv4Match = normalizedIp.match(/::ffff:(\d+\.\d+\.\d+\.\d+)/i);
+        const testIp = ipv4Match ? ipv4Match[1] : normalizedIp;
+        // Exact match
+        if (normalizedPattern === testIp) {
+            return true;
+        }
+        // CIDR notation
+        if (options.allowCidr !== false && normalizedPattern.includes('/')) {
+            return this.matchCidr(normalizedPattern, testIp);
+        }
+        // Wildcard matching
+        if (normalizedPattern.includes('*')) {
+            return this.matchWildcard(normalizedPattern, testIp);
+        }
+        // Range matching
+        if (options.allowRanges !== false && normalizedPattern.includes('-')) {
+            return this.matchRange(normalizedPattern, testIp);
+        }
+        return false;
+    }
+    /**
+     * Check if an IP is authorized based on allow and block lists
+     */
+    static isAuthorized(ip, allowList = [], blockList = []) {
+        // If IP is in block list, deny
+        if (blockList.some(pattern => this.match(pattern, ip))) {
+            return false;
+        }
+        // If allow list is empty, allow all (except blocked)
+        if (allowList.length === 0) {
+            return true;
+        }
+        // If allow list exists, IP must match
+        return allowList.some(pattern => this.match(pattern, ip));
+    }
+    /**
+     * Calculate the specificity of an IP pattern
+     * Higher values mean more specific patterns
+     */
+    static calculateSpecificity(pattern) {
+        if (!pattern)
+            return 0;
+        let score = 0;
+        // Exact IPs are most specific
+        if (this.isValidIpv4(pattern) || this.isValidIpv6(pattern)) {
+            score += 100;
+        }
+        // CIDR notation
+        if (pattern.includes('/')) {
+            const [, bits] = pattern.split('/');
+            const maskBits = parseInt(bits, 10);
+            if (!isNaN(maskBits)) {
+                score += maskBits; // Higher mask = more specific
+            }
+        }
+        // Wildcard patterns
+        const wildcards = (pattern.match(/\*/g) || []).length;
+        score -= wildcards * 20; // More wildcards = less specific
+        // Range patterns are somewhat specific
+        if (pattern.includes('-')) {
+            score += 30;
+        }
+        return score;
+    }
+    /**
+     * Instance method for interface compliance
+     */
+    match(pattern, ip, options) {
+        return IpMatcher.match(pattern, ip, options);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/core/routing/matchers/path.d.ts

@@ -0,0 +1,44 @@
+import type { IMatcher, IPathMatchResult } from '../types.js';
+/**
+ * PathMatcher provides comprehensive path matching functionality
+ * Supporting exact matches, wildcards, and parameter extraction
+ */
+export declare class PathMatcher implements IMatcher<IPathMatchResult> {
+    /**
+     * Convert a path pattern to a regex and extract parameter names
+     * Supports:
+     * - Exact paths: /api/users
+     * - Wildcards: /api/*
+     * - Parameters: /api/users/:id
+     * - Mixed: /api/users/:id/*
+     */
+    private static patternToRegex;
+    /**
+     * Match a path pattern against a request path
+     * @param pattern The pattern to match
+     * @param path The request path to test
+     * @returns Match result with params and remainder
+     */
+    static match(pattern: string, path: string): IPathMatchResult;
+    /**
+     * Check if a pattern contains parameters or wildcards
+     */
+    static isDynamicPattern(pattern: string): boolean;
+    /**
+     * Calculate the specificity of a path pattern
+     * Higher values mean more specific patterns
+     */
+    static calculateSpecificity(pattern: string): number;
+    /**
+     * Find all matching patterns from a list
+     * Returns patterns sorted by specificity (most specific first)
+     */
+    static findAllMatches(patterns: string[], path: string): Array<{
+        pattern: string;
+        result: IPathMatchResult;
+    }>;
+    /**
+     * Instance method for interface compliance
+     */
+    match(pattern: string, path: string): IPathMatchResult;
+}

package/dist_ts/core/routing/matchers/path.js

@@ -0,0 +1,148 @@
+/**
+ * PathMatcher provides comprehensive path matching functionality
+ * Supporting exact matches, wildcards, and parameter extraction
+ */
+export class PathMatcher {
+    /**
+     * Convert a path pattern to a regex and extract parameter names
+     * Supports:
+     * - Exact paths: /api/users
+     * - Wildcards: /api/*
+     * - Parameters: /api/users/:id
+     * - Mixed: /api/users/:id/*
+     */
+    static patternToRegex(pattern) {
+        const paramNames = [];
+        let regexPattern = pattern;
+        // Escape special regex characters except : and *
+        regexPattern = regexPattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+        // Handle path parameters (:param)
+        regexPattern = regexPattern.replace(/:(\w+)/g, (match, paramName) => {
+            paramNames.push(paramName);
+            return '([^/]+)'; // Match any non-slash characters
+        });
+        // Handle wildcards
+        regexPattern = regexPattern.replace(/\*/g, '(.*)');
+        // Ensure the pattern matches from start
+        regexPattern = `^${regexPattern}`;
+        // If pattern doesn't end with wildcard, ensure it matches to end
+        // But only for patterns that don't have parameters or wildcards
+        if (!pattern.includes('*') && !pattern.includes(':') && !pattern.endsWith('/')) {
+            regexPattern = `${regexPattern}$`;
+        }
+        return {
+            regex: new RegExp(regexPattern),
+            paramNames
+        };
+    }
+    /**
+     * Match a path pattern against a request path
+     * @param pattern The pattern to match
+     * @param path The request path to test
+     * @returns Match result with params and remainder
+     */
+    static match(pattern, path) {
+        // Handle null/undefined cases
+        if (!pattern || !path) {
+            return { matches: false };
+        }
+        // Normalize paths (remove trailing slashes unless it's just "/")
+        const normalizedPattern = pattern === '/' ? '/' : pattern.replace(/\/$/, '');
+        const normalizedPath = path === '/' ? '/' : path.replace(/\/$/, '');
+        // Exact match (most common case)
+        if (normalizedPattern === normalizedPath) {
+            return {
+                matches: true,
+                pathMatch: normalizedPath,
+                pathRemainder: '',
+                params: {}
+            };
+        }
+        // Pattern matching (wildcards and parameters)
+        const { regex, paramNames } = this.patternToRegex(normalizedPattern);
+        const match = normalizedPath.match(regex);
+        if (!match) {
+            return { matches: false };
+        }
+        // Extract parameters
+        const params = {};
+        paramNames.forEach((name, index) => {
+            params[name] = match[index + 1];
+        });
+        // Calculate path match and remainder
+        let pathMatch = match[0];
+        let pathRemainder = normalizedPath.substring(pathMatch.length);
+        // Handle wildcard captures
+        if (normalizedPattern.includes('*') && match.length > paramNames.length + 1) {
+            const wildcardCapture = match[match.length - 1];
+            if (wildcardCapture) {
+                pathRemainder = wildcardCapture;
+                pathMatch = normalizedPath.substring(0, normalizedPath.length - wildcardCapture.length);
+            }
+        }
+        // Clean up path match (remove trailing slash if present)
+        if (pathMatch !== '/' && pathMatch.endsWith('/')) {
+            pathMatch = pathMatch.slice(0, -1);
+        }
+        return {
+            matches: true,
+            pathMatch,
+            pathRemainder,
+            params
+        };
+    }
+    /**
+     * Check if a pattern contains parameters or wildcards
+     */
+    static isDynamicPattern(pattern) {
+        return pattern.includes(':') || pattern.includes('*');
+    }
+    /**
+     * Calculate the specificity of a path pattern
+     * Higher values mean more specific patterns
+     */
+    static calculateSpecificity(pattern) {
+        if (!pattern)
+            return 0;
+        let score = 0;
+        // Exact paths are most specific
+        if (!this.isDynamicPattern(pattern)) {
+            score += 100;
+        }
+        // Count path segments
+        const segments = pattern.split('/').filter(s => s.length > 0);
+        score += segments.length * 10;
+        // Count static segments (more static = more specific)
+        const staticSegments = segments.filter(s => !s.startsWith(':') && s !== '*');
+        score += staticSegments.length * 20;
+        // Penalize wildcards and parameters
+        const wildcards = (pattern.match(/\*/g) || []).length;
+        const params = (pattern.match(/:/g) || []).length;
+        score -= wildcards * 30; // Wildcards are very generic
+        score -= params * 10; // Parameters are somewhat generic
+        // Bonus for longer patterns
+        score += pattern.length;
+        return score;
+    }
+    /**
+     * Find all matching patterns from a list
+     * Returns patterns sorted by specificity (most specific first)
+     */
+    static findAllMatches(patterns, path) {
+        const matches = patterns
+            .map(pattern => ({
+            pattern,
+            result: this.match(pattern, path)
+        }))
+            .filter(({ result }) => result.matches);
+        // Sort by specificity (highest first)
+        return matches.sort((a, b) => this.calculateSpecificity(b.pattern) - this.calculateSpecificity(a.pattern));
+    }
+    /**
+     * Instance method for interface compliance
+     */
+    match(pattern, path) {
+        return PathMatcher.match(pattern, path);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,88 @@
+import * as plugins from '../../plugins.js';
+import type { IRouteConfig, TPortRange, IRouteContext } from '../../proxies/smart-proxy/models/route-types.js';
+/**
+ * Result of route lookup
+ */
+export interface IRouteLookupResult {
+    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): IRouteLookupResult | null;
+    /**
+     * Check if a route matches the given context
+     */
+    private matchesRoute;
+    /**
+     * 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;
+}