@push.rocks/smartproxy 16.0.2 → 16.0.3

package/dist_ts/http/router/route-router.d.ts

@@ -0,0 +1,108 @@
+import * as plugins from '../../plugins.js';
+import type { IRouteConfig } from '../../proxies/smart-proxy/models/route-types.js';
+import type { ILogger } from '../../proxies/network-proxy/models/types.js';
+/**
+ * Optional path pattern configuration that can be added to proxy configs
+ */
+export interface PathPatternConfig {
+    pathPattern?: string;
+}
+/**
+ * Interface for router result with additional metadata
+ */
+export interface RouterResult {
+    route: IRouteConfig;
+    pathMatch?: string;
+    pathParams?: Record<string, string>;
+    pathRemainder?: string;
+}
+/**
+ * Router for HTTP reverse proxy requests based on route configurations
+ *
+ * Supports the following domain matching patterns:
+ * - Exact matches: "example.com"
+ * - Wildcard subdomains: "*.example.com" (matches any subdomain of example.com)
+ * - TLD wildcards: "example.*" (matches example.com, example.org, etc.)
+ * - Complex wildcards: "*.lossless*" (matches any subdomain of any lossless domain)
+ * - Default fallback: "*" (matches any unmatched domain)
+ *
+ * Also supports path pattern matching for each domain:
+ * - Exact path: "/api/users"
+ * - Wildcard paths: "/api/*"
+ * - Path parameters: "/users/:id/profile"
+ */
+export declare class RouteRouter {
+    private routes;
+    private defaultRoute?;
+    private pathPatterns;
+    private logger;
+    constructor(routes?: IRouteConfig[], logger?: ILogger);
+    /**
+     * Sets a new set of routes to be routed to
+     * @param routes Array of route configurations
+     */
+    setRoutes(routes: IRouteConfig[]): void;
+    /**
+     * Routes a request based on hostname and path
+     * @param req The incoming HTTP request
+     * @returns The matching route or undefined if no match found
+     */
+    routeReq(req: plugins.http.IncomingMessage): IRouteConfig | undefined;
+    /**
+     * Routes a request with detailed matching information
+     * @param req The incoming HTTP request
+     * @returns Detailed routing result including matched route and path information
+     */
+    routeReqWithDetails(req: plugins.http.IncomingMessage): RouterResult | undefined;
+    /**
+     * Find potential wildcard patterns that could match a given hostname
+     * Handles complex patterns like "*.lossless*" or other partial matches
+     * @param hostname The hostname to find wildcard matches for
+     * @returns Array of potential wildcard patterns that could match
+     */
+    private findWildcardMatches;
+    /**
+     * Find a route for a specific host and path
+     */
+    private findRouteForHost;
+    /**
+     * Matches a URL path against a pattern
+     * Supports:
+     * - Exact matches: /users/profile
+     * - Wildcards: /api/* (matches any path starting with /api/)
+     * - Path parameters: /users/:id (captures id as a parameter)
+     *
+     * @param path The URL path to match
+     * @param pattern The pattern to match against
+     * @returns Match result with params and remainder, or null if no match
+     */
+    private matchPath;
+    /**
+     * Gets all currently active route configurations
+     * @returns Array of all active routes
+     */
+    getRoutes(): IRouteConfig[];
+    /**
+     * Gets all hostnames that this router is configured to handle
+     * @returns Array of hostnames
+     */
+    getHostnames(): string[];
+    /**
+     * Adds a single new route configuration
+     * @param route The route configuration to add
+     */
+    addRoute(route: IRouteConfig): void;
+    /**
+     * Removes routes by domain pattern
+     * @param domain The domain pattern to remove routes for
+     * @returns Boolean indicating whether any routes were removed
+     */
+    removeRoutesByDomain(domain: string): boolean;
+    /**
+     * Legacy method for compatibility with ProxyRouter
+     * Converts IReverseProxyConfig to IRouteConfig and calls setRoutes
+     *
+     * @param configs Array of legacy proxy configurations
+     */
+    setNewProxyConfigs(configs: any[]): void;
+}

package/dist_ts/http/router/route-router.js

@@ -0,0 +1,393 @@
+import * as plugins from '../../plugins.js';
+/**
+ * Router for HTTP reverse proxy requests based on route configurations
+ *
+ * Supports the following domain matching patterns:
+ * - Exact matches: "example.com"
+ * - Wildcard subdomains: "*.example.com" (matches any subdomain of example.com)
+ * - TLD wildcards: "example.*" (matches example.com, example.org, etc.)
+ * - Complex wildcards: "*.lossless*" (matches any subdomain of any lossless domain)
+ * - Default fallback: "*" (matches any unmatched domain)
+ *
+ * Also supports path pattern matching for each domain:
+ * - Exact path: "/api/users"
+ * - Wildcard paths: "/api/*"
+ * - Path parameters: "/users/:id/profile"
+ */
+export class RouteRouter {
+    constructor(routes, logger) {
+        // Store original routes for reference
+        this.routes = [];
+        // Store path patterns separately since they're not in the original interface
+        this.pathPatterns = new Map();
+        this.logger = logger || {
+            error: console.error,
+            warn: console.warn,
+            info: console.info,
+            debug: console.debug
+        };
+        if (routes) {
+            this.setRoutes(routes);
+        }
+    }
+    /**
+     * Sets a new set of routes to be routed to
+     * @param routes Array of route configurations
+     */
+    setRoutes(routes) {
+        this.routes = [...routes];
+        // Sort routes by priority
+        this.routes.sort((a, b) => {
+            const priorityA = a.priority ?? 0;
+            const priorityB = b.priority ?? 0;
+            return priorityB - priorityA;
+        });
+        // Find default route if any (route with "*" as domain)
+        this.defaultRoute = this.routes.find(route => {
+            const domains = Array.isArray(route.match.domains)
+                ? route.match.domains
+                : [route.match.domains];
+            return domains.includes('*');
+        });
+        // Extract path patterns from route match.path
+        for (const route of this.routes) {
+            if (route.match.path) {
+                this.pathPatterns.set(route, route.match.path);
+            }
+        }
+        const uniqueDomains = this.getHostnames();
+        this.logger.info(`Router initialized with ${this.routes.length} routes (${uniqueDomains.length} unique hosts)`);
+    }
+    /**
+     * Routes a request based on hostname and path
+     * @param req The incoming HTTP request
+     * @returns The matching route or undefined if no match found
+     */
+    routeReq(req) {
+        const result = this.routeReqWithDetails(req);
+        return result ? result.route : undefined;
+    }
+    /**
+     * Routes a request with detailed matching information
+     * @param req The incoming HTTP request
+     * @returns Detailed routing result including matched route and path information
+     */
+    routeReqWithDetails(req) {
+        // Extract and validate host header
+        const originalHost = req.headers.host;
+        if (!originalHost) {
+            this.logger.error('No host header found in request');
+            return this.defaultRoute ? { route: this.defaultRoute } : undefined;
+        }
+        // Parse URL for path matching
+        const parsedUrl = plugins.url.parse(req.url || '/');
+        const urlPath = parsedUrl.pathname || '/';
+        // Extract hostname without port
+        const hostWithoutPort = originalHost.split(':')[0].toLowerCase();
+        // First try exact hostname match
+        const exactRoute = this.findRouteForHost(hostWithoutPort, urlPath);
+        if (exactRoute) {
+            return exactRoute;
+        }
+        // Try various wildcard patterns
+        if (hostWithoutPort.includes('.')) {
+            const domainParts = hostWithoutPort.split('.');
+            // Try wildcard subdomain (*.example.com)
+            if (domainParts.length > 2) {
+                const wildcardDomain = `*.${domainParts.slice(1).join('.')}`;
+                const wildcardRoute = this.findRouteForHost(wildcardDomain, urlPath);
+                if (wildcardRoute) {
+                    return wildcardRoute;
+                }
+            }
+            // Try TLD wildcard (example.*)
+            const baseDomain = domainParts.slice(0, -1).join('.');
+            const tldWildcardDomain = `${baseDomain}.*`;
+            const tldWildcardRoute = this.findRouteForHost(tldWildcardDomain, urlPath);
+            if (tldWildcardRoute) {
+                return tldWildcardRoute;
+            }
+            // Try complex wildcard patterns
+            const wildcardPatterns = this.findWildcardMatches(hostWithoutPort);
+            for (const pattern of wildcardPatterns) {
+                const wildcardRoute = this.findRouteForHost(pattern, urlPath);
+                if (wildcardRoute) {
+                    return wildcardRoute;
+                }
+            }
+        }
+        // Fall back to default route if available
+        if (this.defaultRoute) {
+            this.logger.warn(`No specific route found for host: ${hostWithoutPort}, using default`);
+            return { route: this.defaultRoute };
+        }
+        this.logger.error(`No route found for host: ${hostWithoutPort}`);
+        return undefined;
+    }
+    /**
+     * Find potential wildcard patterns that could match a given hostname
+     * Handles complex patterns like "*.lossless*" or other partial matches
+     * @param hostname The hostname to find wildcard matches for
+     * @returns Array of potential wildcard patterns that could match
+     */
+    findWildcardMatches(hostname) {
+        const patterns = [];
+        // Find all routes with wildcard domains
+        for (const route of this.routes) {
+            if (!route.match.domains)
+                continue;
+            const domains = Array.isArray(route.match.domains)
+                ? route.match.domains
+                : [route.match.domains];
+            // Filter to only wildcard domains
+            const wildcardDomains = domains.filter(domain => domain.includes('*'));
+            // Convert each wildcard domain to a regex pattern and check if it matches
+            for (const domain of wildcardDomains) {
+                // Skip the default wildcard '*'
+                if (domain === '*')
+                    continue;
+                // Skip already checked patterns (*.domain.com and domain.*)
+                if (domain.startsWith('*.') && domain.indexOf('*', 2) === -1)
+                    continue;
+                if (domain.endsWith('.*') && domain.indexOf('*') === domain.length - 1)
+                    continue;
+                // Convert wildcard pattern to regex
+                const regexPattern = domain
+                    .replace(/\./g, '\\.') // Escape dots
+                    .replace(/\*/g, '.*'); // Convert * to .* for regex
+                // Create regex object with case insensitive flag
+                const regex = new RegExp(`^${regexPattern}$`, 'i');
+                // If hostname matches this complex pattern, add it to the list
+                if (regex.test(hostname)) {
+                    patterns.push(domain);
+                }
+            }
+        }
+        return patterns;
+    }
+    /**
+     * Find a route for a specific host and path
+     */
+    findRouteForHost(hostname, path) {
+        // Find all routes for this hostname
+        const matchingRoutes = this.routes.filter(route => {
+            if (!route.match.domains)
+                return false;
+            const domains = Array.isArray(route.match.domains)
+                ? route.match.domains
+                : [route.match.domains];
+            return domains.some(domain => domain.toLowerCase() === hostname.toLowerCase());
+        });
+        if (matchingRoutes.length === 0) {
+            return undefined;
+        }
+        // First try routes with path patterns
+        const routesWithPaths = matchingRoutes.filter(route => this.pathPatterns.has(route));
+        // Already sorted by priority during setRoutes
+        // Check each route with path pattern
+        for (const route of routesWithPaths) {
+            const pathPattern = this.pathPatterns.get(route);
+            if (pathPattern) {
+                const pathMatch = this.matchPath(path, pathPattern);
+                if (pathMatch) {
+                    return {
+                        route,
+                        pathMatch: pathMatch.matched,
+                        pathParams: pathMatch.params,
+                        pathRemainder: pathMatch.remainder
+                    };
+                }
+            }
+        }
+        // If no path pattern matched, use the first route without a path pattern
+        const routeWithoutPath = matchingRoutes.find(route => !this.pathPatterns.has(route));
+        if (routeWithoutPath) {
+            return { route: routeWithoutPath };
+        }
+        return undefined;
+    }
+    /**
+     * Matches a URL path against a pattern
+     * Supports:
+     * - Exact matches: /users/profile
+     * - Wildcards: /api/* (matches any path starting with /api/)
+     * - Path parameters: /users/:id (captures id as a parameter)
+     *
+     * @param path The URL path to match
+     * @param pattern The pattern to match against
+     * @returns Match result with params and remainder, or null if no match
+     */
+    matchPath(path, pattern) {
+        // Handle exact match
+        if (path === pattern) {
+            return {
+                matched: pattern,
+                params: {},
+                remainder: ''
+            };
+        }
+        // Handle wildcard match
+        if (pattern.endsWith('/*')) {
+            const prefix = pattern.slice(0, -2);
+            if (path === prefix || path.startsWith(`${prefix}/`)) {
+                return {
+                    matched: prefix,
+                    params: {},
+                    remainder: path.slice(prefix.length)
+                };
+            }
+            return null;
+        }
+        // Handle path parameters
+        const patternParts = pattern.split('/').filter(p => p);
+        const pathParts = path.split('/').filter(p => p);
+        // Too few path parts to match
+        if (pathParts.length < patternParts.length) {
+            return null;
+        }
+        const params = {};
+        // Compare each part
+        for (let i = 0; i < patternParts.length; i++) {
+            const patternPart = patternParts[i];
+            const pathPart = pathParts[i];
+            // Handle parameter
+            if (patternPart.startsWith(':')) {
+                const paramName = patternPart.slice(1);
+                params[paramName] = pathPart;
+                continue;
+            }
+            // Handle wildcard at the end
+            if (patternPart === '*' && i === patternParts.length - 1) {
+                break;
+            }
+            // Handle exact match for this part
+            if (patternPart !== pathPart) {
+                return null;
+            }
+        }
+        // Calculate the remainder - the unmatched path parts
+        const remainderParts = pathParts.slice(patternParts.length);
+        const remainder = remainderParts.length ? '/' + remainderParts.join('/') : '';
+        // Calculate the matched path
+        const matchedParts = patternParts.map((part, i) => {
+            return part.startsWith(':') ? pathParts[i] : part;
+        });
+        const matched = '/' + matchedParts.join('/');
+        return {
+            matched,
+            params,
+            remainder
+        };
+    }
+    /**
+     * Gets all currently active route configurations
+     * @returns Array of all active routes
+     */
+    getRoutes() {
+        return [...this.routes];
+    }
+    /**
+     * Gets all hostnames that this router is configured to handle
+     * @returns Array of hostnames
+     */
+    getHostnames() {
+        const hostnames = new Set();
+        for (const route of this.routes) {
+            if (!route.match.domains)
+                continue;
+            const domains = Array.isArray(route.match.domains)
+                ? route.match.domains
+                : [route.match.domains];
+            for (const domain of domains) {
+                if (domain !== '*') {
+                    hostnames.add(domain.toLowerCase());
+                }
+            }
+        }
+        return Array.from(hostnames);
+    }
+    /**
+     * Adds a single new route configuration
+     * @param route The route configuration to add
+     */
+    addRoute(route) {
+        this.routes.push(route);
+        // Store path pattern if present
+        if (route.match.path) {
+            this.pathPatterns.set(route, route.match.path);
+        }
+        // Re-sort routes by priority
+        this.routes.sort((a, b) => {
+            const priorityA = a.priority ?? 0;
+            const priorityB = b.priority ?? 0;
+            return priorityB - priorityA;
+        });
+    }
+    /**
+     * Removes routes by domain pattern
+     * @param domain The domain pattern to remove routes for
+     * @returns Boolean indicating whether any routes were removed
+     */
+    removeRoutesByDomain(domain) {
+        const initialCount = this.routes.length;
+        // Find routes to remove
+        const routesToRemove = this.routes.filter(route => {
+            if (!route.match.domains)
+                return false;
+            const domains = Array.isArray(route.match.domains)
+                ? route.match.domains
+                : [route.match.domains];
+            return domains.includes(domain);
+        });
+        // Remove them from the patterns map
+        for (const route of routesToRemove) {
+            this.pathPatterns.delete(route);
+        }
+        // Filter them out of the routes array
+        this.routes = this.routes.filter(route => {
+            if (!route.match.domains)
+                return true;
+            const domains = Array.isArray(route.match.domains)
+                ? route.match.domains
+                : [route.match.domains];
+            return !domains.includes(domain);
+        });
+        return this.routes.length !== initialCount;
+    }
+    /**
+     * Legacy method for compatibility with ProxyRouter
+     * Converts IReverseProxyConfig to IRouteConfig and calls setRoutes
+     *
+     * @param configs Array of legacy proxy configurations
+     */
+    setNewProxyConfigs(configs) {
+        // Convert legacy configs to routes and add them
+        const routes = configs.map(config => {
+            // Create a basic route configuration from the legacy config
+            return {
+                match: {
+                    ports: config.destinationPorts[0], // Just use the first port
+                    domains: config.hostName
+                },
+                action: {
+                    type: 'forward',
+                    target: {
+                        host: config.destinationIps,
+                        port: config.destinationPorts[0]
+                    },
+                    tls: {
+                        mode: 'terminate',
+                        certificate: {
+                            key: config.privateKey,
+                            cert: config.publicKey
+                        }
+                    }
+                },
+                name: `Legacy Config - ${config.hostName}`,
+                enabled: true
+            };
+        });
+        this.setRoutes(routes);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route-router.js","sourceRoot":"","sources":["../../../ts/http/router/route-router.ts"],"names":[],"mappings":"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"}

package/dist_ts/index.d.ts

@@ -2,11 +2,17 @@
  * SmartProxy main module exports
  */
 export * from './proxies/nftables-proxy/index.js';
-export * from './proxies/network-proxy/index.js';
+export { NetworkProxy, CertificateManager, ConnectionPool, RequestHandler, WebSocketHandler } from './proxies/network-proxy/index.js';
+export type { IMetricsTracker, MetricsTracker } from './proxies/network-proxy/index.js';
+export * from './proxies/network-proxy/models/index.js';
+export { RouteManager as NetworkProxyRouteManager } from './proxies/network-proxy/models/types.js';
 export { Port80Handler, Port80HandlerError as HttpError, ServerError, CertificateError } from './http/port80/port80-handler.js';
 export { Port80HandlerEvents } from './certificate/events/certificate-events.js';
 export * from './redirect/classes.redirect.js';
-export * from './proxies/smart-proxy/index.js';
+export { SmartProxy, ConnectionManager, SecurityManager, TimeoutManager, TlsManager, NetworkProxyBridge, RouteConnectionHandler } from './proxies/smart-proxy/index.js';
+export { RouteManager } from './proxies/smart-proxy/route-manager.js';
+export * from './proxies/smart-proxy/models/index.js';
+export * from './proxies/smart-proxy/utils/index.js';
 export { SniHandler } from './tls/sni/sni-handler.js';
 export * from './proxies/smart-proxy/models/interfaces.js';
 export * from './core/models/common-types.js';

package/dist_ts/index.js

@@ -4,13 +4,20 @@
 // Legacy exports (to maintain backward compatibility)
 // Migrated to the new proxies structure
 export * from './proxies/nftables-proxy/index.js';
-export * from './proxies/network-proxy/index.js';
+// Export NetworkProxy elements selectively to avoid RouteManager ambiguity
+export { NetworkProxy, CertificateManager, ConnectionPool, RequestHandler, WebSocketHandler } from './proxies/network-proxy/index.js';
+export * from './proxies/network-proxy/models/index.js';
+export { RouteManager as NetworkProxyRouteManager } from './proxies/network-proxy/models/types.js';
 // Export port80handler elements selectively to avoid conflicts
 export { Port80Handler, Port80HandlerError as HttpError, ServerError, CertificateError } from './http/port80/port80-handler.js';
 // Use re-export to control the names
 export { Port80HandlerEvents } from './certificate/events/certificate-events.js';
 export * from './redirect/classes.redirect.js';
-export * from './proxies/smart-proxy/index.js';
+// Export SmartProxy elements selectively to avoid RouteManager ambiguity
+export { SmartProxy, ConnectionManager, SecurityManager, TimeoutManager, TlsManager, NetworkProxyBridge, RouteConnectionHandler } from './proxies/smart-proxy/index.js';
+export { RouteManager } from './proxies/smart-proxy/route-manager.js';
+export * from './proxies/smart-proxy/models/index.js';
+export * from './proxies/smart-proxy/utils/index.js';
 // Original: export * from './smartproxy/classes.pp.snihandler.js'
 // Now we export from the new module
 export { SniHandler } from './tls/sni/sni-handler.js';
@@ -24,4 +31,4 @@ export * as forwarding from './forwarding/index.js';
 export * as certificate from './certificate/index.js';
 export * as tls from './tls/index.js';
 export * as http from './http/index.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILHNEQUFzRDtBQUN0RCx3Q0FBd0M7QUFDeEMsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELCtEQUErRDtBQUMvRCxPQUFPLEVBQ0wsYUFBYSxFQUNiLGtCQUFrQixJQUFJLFNBQVMsRUFDL0IsV0FBVyxFQUNYLGdCQUFnQixFQUNqQixNQUFNLGlDQUFpQyxDQUFDO0FBQ3pDLHFDQUFxQztBQUNyQyxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSw0Q0FBNEMsQ0FBQztBQUVqRixjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsZ0NBQWdDLENBQUM7QUFDL0Msa0VBQWtFO0FBQ2xFLG9DQUFvQztBQUNwQyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDdEQsa0VBQWtFO0FBQ2xFLG9DQUFvQztBQUNwQyxjQUFjLDRDQUE0QyxDQUFDO0FBRTNELDJCQUEyQjtBQUMzQixjQUFjLCtCQUErQixDQUFDO0FBRTlDLHVDQUF1QztBQUN2QyxPQUFPLEtBQUssVUFBVSxNQUFNLHVCQUF1QixDQUFDO0FBQ3BELE9BQU8sS0FBSyxXQUFXLE1BQU0sd0JBQXdCLENBQUM7QUFDdEQsT0FBTyxLQUFLLEdBQUcsTUFBTSxnQkFBZ0IsQ0FBQztBQUN0QyxPQUFPLEtBQUssSUFBSSxNQUFNLGlCQUFpQixDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILHNEQUFzRDtBQUN0RCx3Q0FBd0M7QUFDeEMsY0FBYyxtQ0FBbUMsQ0FBQztBQUVsRCwyRUFBMkU7QUFDM0UsT0FBTyxFQUFFLFlBQVksRUFBRSxrQkFBa0IsRUFBRSxjQUFjLEVBQUUsY0FBYyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFFdEksY0FBYyx5Q0FBeUMsQ0FBQztBQUN4RCxPQUFPLEVBQUUsWUFBWSxJQUFJLHdCQUF3QixFQUFFLE1BQU0seUNBQXlDLENBQUM7QUFFbkcsK0RBQStEO0FBQy9ELE9BQU8sRUFDTCxhQUFhLEVBQ2Isa0JBQWtCLElBQUksU0FBUyxFQUMvQixXQUFXLEVBQ1gsZ0JBQWdCLEVBQ2pCLE1BQU0saUNBQWlDLENBQUM7QUFDekMscUNBQXFDO0FBQ3JDLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLDRDQUE0QyxDQUFDO0FBRWpGLGNBQWMsZ0NBQWdDLENBQUM7QUFFL0MseUVBQXlFO0FBQ3pFLE9BQU8sRUFBRSxVQUFVLEVBQUUsaUJBQWlCLEVBQUUsZUFBZSxFQUFFLGNBQWMsRUFBRSxVQUFVLEVBQUUsa0JBQWtCLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUN4SyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sd0NBQXdDLENBQUM7QUFDdEUsY0FBYyx1Q0FBdUMsQ0FBQztBQUN0RCxjQUFjLHNDQUFzQyxDQUFDO0FBRXJELGtFQUFrRTtBQUNsRSxvQ0FBb0M7QUFDcEMsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ3RELGtFQUFrRTtBQUNsRSxvQ0FBb0M7QUFDcEMsY0FBYyw0Q0FBNEMsQ0FBQztBQUUzRCwyQkFBMkI7QUFDM0IsY0FBYywrQkFBK0IsQ0FBQztBQUU5Qyx1Q0FBdUM7QUFDdkMsT0FBTyxLQUFLLFVBQVUsTUFBTSx1QkFBdUIsQ0FBQztBQUNwRCxPQUFPLEtBQUssV0FBVyxNQUFNLHdCQUF3QixDQUFDO0FBQ3RELE9BQU8sS0FBSyxHQUFHLE1BQU0sZ0JBQWdCLENBQUM7QUFDdEMsT0FBTyxLQUFLLElBQUksTUFBTSxpQkFBaUIsQ0FBQyJ9

package/dist_ts/proxies/index.d.ts

@@ -1,6 +1,11 @@
 /**
  * Proxy implementations module
  */
-export * from './smart-proxy/index.js';
-export * from './network-proxy/index.js';
+export { NetworkProxy, CertificateManager, ConnectionPool, RequestHandler, WebSocketHandler } from './network-proxy/index.js';
+export type { IMetricsTracker, MetricsTracker } from './network-proxy/index.js';
+export * from './network-proxy/models/index.js';
+export { SmartProxy, ConnectionManager, SecurityManager, TimeoutManager, TlsManager, NetworkProxyBridge, RouteConnectionHandler } from './smart-proxy/index.js';
+export { RouteManager as SmartProxyRouteManager } from './smart-proxy/route-manager.js';
+export * from './smart-proxy/utils/index.js';
+export * from './smart-proxy/models/index.js';
 export * from './nftables-proxy/index.js';

package/dist_ts/proxies/index.js

@@ -1,8 +1,14 @@
 /**
  * Proxy implementations module
  */
-// Export submodules
-export * from './smart-proxy/index.js';
-export * from './network-proxy/index.js';
+// Export NetworkProxy with selective imports to avoid RouteManager ambiguity
+export { NetworkProxy, CertificateManager, ConnectionPool, RequestHandler, WebSocketHandler } from './network-proxy/index.js';
+export * from './network-proxy/models/index.js';
+// Export SmartProxy with selective imports to avoid RouteManager ambiguity
+export { SmartProxy, ConnectionManager, SecurityManager, TimeoutManager, TlsManager, NetworkProxyBridge, RouteConnectionHandler } from './smart-proxy/index.js';
+export { RouteManager as SmartProxyRouteManager } from './smart-proxy/route-manager.js';
+export * from './smart-proxy/utils/index.js';
+export * from './smart-proxy/models/index.js';
+// Export NFTables proxy (no conflicts)
 export * from './nftables-proxy/index.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9wcm94aWVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsb0JBQW9CO0FBQ3BCLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLDJCQUEyQixDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9wcm94aWVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsNkVBQTZFO0FBQzdFLE9BQU8sRUFBRSxZQUFZLEVBQUUsa0JBQWtCLEVBQUUsY0FBYyxFQUFFLGNBQWMsRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBRTlILGNBQWMsaUNBQWlDLENBQUM7QUFFaEQsMkVBQTJFO0FBQzNFLE9BQU8sRUFBRSxVQUFVLEVBQUUsaUJBQWlCLEVBQUUsZUFBZSxFQUFFLGNBQWMsRUFBRSxVQUFVLEVBQUUsa0JBQWtCLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUNoSyxPQUFPLEVBQUUsWUFBWSxJQUFJLHNCQUFzQixFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFDeEYsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLCtCQUErQixDQUFDO0FBRTlDLHVDQUF1QztBQUN2QyxjQUFjLDJCQUEyQixDQUFDIn0=

package/dist_ts/proxies/network-proxy/certificate-manager.d.ts

@@ -1,6 +1,7 @@
 import * as plugins from '../../plugins.js';
 import { type INetworkProxyOptions, type ICertificateEntry } from './models/types.js';
 import { Port80Handler } from '../../http/port80/port80-handler.js';
+import type { IRouteConfig } from '../smart-proxy/models/route-types.js';
 /**
  * Manages SSL certificates for NetworkProxy including ACME integration
  */
@@ -33,6 +34,13 @@ export declare class CertificateManager {
      * Sets an external Port80Handler for certificate management
      */
     setExternalPort80Handler(handler: Port80Handler): void;
+    /**
+     * Update route configurations managed by this certificate manager
+     * This method is called when route configurations change
+     *
+     * @param routes Array of route configurations
+     */
+    updateRouteConfigs(routes: IRouteConfig[]): void;
     /**
      * Handle newly issued or renewed certificates from Port80Handler
      */
@@ -64,8 +72,21 @@ export declare class CertificateManager {
     requestCertificate(domain: string): Promise<boolean>;
     /**
      * Registers domains with Port80Handler for ACME certificate management
+     * @param domains String array of domains to register
      */
     registerDomainsWithPort80Handler(domains: string[]): void;
+    /**
+     * Extract domains from route configurations and register with Port80Handler
+     * This method enables direct integration with route-based configuration
+     *
+     * @param routes Array of route configurations
+     */
+    registerRoutesWithPort80Handler(routes: IRouteConfig[]): void;
+    /**
+     * Process a route config to determine if it requires automatic certificate provisioning
+     * @param route Route configuration to process
+     */
+    processRouteForCertificates(route: IRouteConfig): void;
     /**
      * Initialize internal Port80Handler
      */