@push.rocks/smartproxy 16.0.2 → 16.0.4

package/dist_ts/proxies/network-proxy/websocket-handler.js

@@ -1,18 +1,49 @@
 import * as plugins from '../../plugins.js';
+import '../../core/models/socket-augmentation.js';
 import { createLogger } from './models/types.js';
 import { ConnectionPool } from './connection-pool.js';
-import { ProxyRouter } from '../../http/router/index.js';
+import { ProxyRouter, RouteRouter } from '../../http/router/index.js';
+import { toBaseContext } from '../../core/models/route-context.js';
+import { ContextCreator } from './context-creator.js';
+import { SecurityManager } from './security-manager.js';
+import { TemplateUtils } from '../../core/utils/template-utils.js';
+import { getMessageSize, toBuffer } from '../../core/utils/websocket-utils.js';
 /**
  * Handles WebSocket connections and proxying
  */
 export class WebSocketHandler {
-    constructor(options, connectionPool, router) {
+    constructor(options, connectionPool, legacyRouter, // Legacy router for backward compatibility
+    routes = [] // Routes for modern router
+    ) {
         this.options = options;
         this.connectionPool = connectionPool;
-        this.router = router;
+        this.legacyRouter = legacyRouter;
+        this.routes = routes;
         this.heartbeatInterval = null;
         this.wsServer = null;
+        this.contextCreator = new ContextCreator();
+        this.routeRouter = null;
         this.logger = createLogger(options.logLevel || 'info');
+        this.securityManager = new SecurityManager(this.logger, routes);
+        // Initialize modern router if we have routes
+        if (routes.length > 0) {
+            this.routeRouter = new RouteRouter(routes, this.logger);
+        }
+    }
+    /**
+     * Set the route configurations
+     */
+    setRoutes(routes) {
+        this.routes = routes;
+        // Initialize or update the route router
+        if (!this.routeRouter) {
+            this.routeRouter = new RouteRouter(routes, this.logger);
+        }
+        else {
+            this.routeRouter.setRoutes(routes);
+        }
+        // Update the security manager
+        this.securityManager.setRoutes(routes);
     }
     /**
      * Initialize WebSocket server on an existing HTTPS server
@@ -73,18 +104,115 @@ export class WebSocketHandler {
                 wsIncoming.isAlive = true;
                 wsIncoming.lastPong = Date.now();
             });
-            // Find target configuration based on request
-            const proxyConfig = this.router.routeReq(req);
-            if (!proxyConfig) {
-                this.logger.warn(`No proxy configuration for WebSocket host: ${req.headers.host}`);
-                wsIncoming.close(1008, 'No proxy configuration for this host');
-                return;
+            // Create a context for routing
+            const connectionId = `ws-${Date.now()}-${Math.floor(Math.random() * 10000)}`;
+            const routeContext = this.contextCreator.createHttpRouteContext(req, {
+                connectionId,
+                clientIp: req.socket.remoteAddress?.replace('::ffff:', '') || '0.0.0.0',
+                serverIp: req.socket.localAddress?.replace('::ffff:', '') || '0.0.0.0',
+                tlsVersion: req.socket.getTLSVersion?.() || undefined
+            });
+            // Try modern router first if available
+            let route;
+            if (this.routeRouter) {
+                route = this.routeRouter.routeReq(req);
             }
-            // Get destination target using round-robin if multiple targets
-            const destination = this.connectionPool.getNextTarget(proxyConfig.destinationIps, proxyConfig.destinationPorts[0]);
-            // Build target URL
+            // Define destination variables
+            let destination;
+            // If we found a route with the modern router, use it
+            if (route && route.action.type === 'forward' && route.action.target) {
+                this.logger.debug(`Found matching WebSocket route: ${route.name || 'unnamed'}`);
+                // Check if WebSockets are enabled for this route
+                if (route.action.websocket?.enabled === false) {
+                    this.logger.debug(`WebSockets are disabled for route: ${route.name || 'unnamed'}`);
+                    wsIncoming.close(1003, 'WebSockets not supported for this route');
+                    return;
+                }
+                // Check security restrictions if configured to authenticate WebSocket requests
+                if (route.action.websocket?.authenticateRequest !== false && route.security) {
+                    if (!this.securityManager.isAllowed(route, toBaseContext(routeContext))) {
+                        this.logger.warn(`WebSocket connection denied by security policy for ${routeContext.clientIp}`);
+                        wsIncoming.close(1008, 'Access denied by security policy');
+                        return;
+                    }
+                    // Check origin restrictions if configured
+                    const origin = req.headers.origin;
+                    if (origin && route.action.websocket?.allowedOrigins && route.action.websocket.allowedOrigins.length > 0) {
+                        const isAllowed = route.action.websocket.allowedOrigins.some(allowedOrigin => {
+                            // Handle wildcards and template variables
+                            if (allowedOrigin.includes('*') || allowedOrigin.includes('{')) {
+                                const pattern = allowedOrigin.replace(/\*/g, '.*');
+                                const resolvedPattern = TemplateUtils.resolveTemplateVariables(pattern, routeContext);
+                                const regex = new RegExp(`^${resolvedPattern}$`);
+                                return regex.test(origin);
+                            }
+                            return allowedOrigin === origin;
+                        });
+                        if (!isAllowed) {
+                            this.logger.warn(`WebSocket origin ${origin} not allowed for route: ${route.name || 'unnamed'}`);
+                            wsIncoming.close(1008, 'Origin not allowed');
+                            return;
+                        }
+                    }
+                }
+                // Extract target information, resolving functions if needed
+                let targetHost;
+                let targetPort;
+                try {
+                    // Resolve host if it's a function
+                    if (typeof route.action.target.host === 'function') {
+                        const resolvedHost = route.action.target.host(toBaseContext(routeContext));
+                        targetHost = resolvedHost;
+                        this.logger.debug(`Resolved function-based host for WebSocket: ${Array.isArray(resolvedHost) ? resolvedHost.join(', ') : resolvedHost}`);
+                    }
+                    else {
+                        targetHost = route.action.target.host;
+                    }
+                    // Resolve port if it's a function
+                    if (typeof route.action.target.port === 'function') {
+                        targetPort = route.action.target.port(toBaseContext(routeContext));
+                        this.logger.debug(`Resolved function-based port for WebSocket: ${targetPort}`);
+                    }
+                    else {
+                        targetPort = route.action.target.port === 'preserve' ? routeContext.port : route.action.target.port;
+                    }
+                    // Select a single host if an array was provided
+                    const selectedHost = Array.isArray(targetHost)
+                        ? targetHost[Math.floor(Math.random() * targetHost.length)]
+                        : targetHost;
+                    // Create a destination for the WebSocket connection
+                    destination = {
+                        host: selectedHost,
+                        port: targetPort
+                    };
+                }
+                catch (err) {
+                    this.logger.error(`Error evaluating function-based target for WebSocket: ${err}`);
+                    wsIncoming.close(1011, 'Internal server error');
+                    return;
+                }
+            }
+            else {
+                // Fall back to legacy routing if no matching route found via modern router
+                const proxyConfig = this.legacyRouter.routeReq(req);
+                if (!proxyConfig) {
+                    this.logger.warn(`No proxy configuration for WebSocket host: ${req.headers.host}`);
+                    wsIncoming.close(1008, 'No proxy configuration for this host');
+                    return;
+                }
+                // Get destination target using round-robin if multiple targets
+                destination = this.connectionPool.getNextTarget(proxyConfig.destinationIps, proxyConfig.destinationPorts[0]);
+            }
+            // Build target URL with potential path rewriting
             const protocol = req.socket.encrypted ? 'wss' : 'ws';
-            const targetUrl = `${protocol}://${destination.host}:${destination.port}${req.url}`;
+            let targetPath = req.url || '/';
+            // Apply path rewriting if configured
+            if (route?.action.websocket?.rewritePath) {
+                const originalPath = targetPath;
+                targetPath = TemplateUtils.resolveTemplateVariables(route.action.websocket.rewritePath, { ...routeContext, path: targetPath });
+                this.logger.debug(`WebSocket path rewritten: ${originalPath} -> ${targetPath}`);
+            }
+            const targetUrl = `${protocol}://${destination.host}:${destination.port}${targetPath}`;
             this.logger.debug(`WebSocket connection from ${req.socket.remoteAddress} to ${targetUrl}`);
             // Create headers for outgoing WebSocket connection
             const headers = {};
@@ -98,15 +226,50 @@ export class WebSocketHandler {
                     headers[key] = value;
                 }
             }
-            // Override host header if needed
-            if (proxyConfig.rewriteHostHeader) {
-                headers['host'] = `${destination.host}:${destination.port}`;
+            // Always rewrite host header for WebSockets for consistency
+            headers['host'] = `${destination.host}:${destination.port}`;
+            // Add custom headers from route configuration
+            if (route?.action.websocket?.customHeaders) {
+                for (const [key, value] of Object.entries(route.action.websocket.customHeaders)) {
+                    // Skip if header already exists and we're not overriding
+                    if (headers[key.toLowerCase()] && !value.startsWith('!')) {
+                        continue;
+                    }
+                    // Handle special delete directive (!delete)
+                    if (value === '!delete') {
+                        delete headers[key.toLowerCase()];
+                        continue;
+                    }
+                    // Handle forced override (!value)
+                    let finalValue;
+                    if (value.startsWith('!') && value !== '!delete') {
+                        // Keep the ! but resolve any templates in the rest
+                        const templateValue = value.substring(1);
+                        finalValue = '!' + TemplateUtils.resolveTemplateVariables(templateValue, routeContext);
+                    }
+                    else {
+                        // Resolve templates in the entire value
+                        finalValue = TemplateUtils.resolveTemplateVariables(value, routeContext);
+                    }
+                    // Set the header
+                    headers[key.toLowerCase()] = finalValue;
+                }
             }
-            // Create outgoing WebSocket connection
-            const wsOutgoing = new plugins.wsDefault(targetUrl, {
+            // Create WebSocket connection options
+            const wsOptions = {
                 headers: headers,
                 followRedirects: true
-            });
+            };
+            // Add subprotocols if configured
+            if (route?.action.websocket?.subprotocols && route.action.websocket.subprotocols.length > 0) {
+                wsOptions.protocols = route.action.websocket.subprotocols;
+            }
+            else if (req.headers['sec-websocket-protocol']) {
+                // Pass through client requested protocols
+                wsOptions.protocols = req.headers['sec-websocket-protocol'].split(',').map(p => p.trim());
+            }
+            // Create outgoing WebSocket connection
+            const wsOutgoing = new plugins.wsDefault(targetUrl, wsOptions);
             // Handle connection errors
             wsOutgoing.on('error', (err) => {
                 this.logger.error(`WebSocket target connection error: ${err.message}`);
@@ -116,9 +279,54 @@ export class WebSocketHandler {
             });
             // Handle outgoing connection open
             wsOutgoing.on('open', () => {
+                // Set up custom ping interval if configured
+                let pingInterval = null;
+                if (route?.action.websocket?.pingInterval && route.action.websocket.pingInterval > 0) {
+                    pingInterval = setInterval(() => {
+                        if (wsIncoming.readyState === wsIncoming.OPEN) {
+                            wsIncoming.ping();
+                            this.logger.debug(`Sent WebSocket ping to client for route: ${route.name || 'unnamed'}`);
+                        }
+                    }, route.action.websocket.pingInterval);
+                    // Don't keep process alive just for pings
+                    if (pingInterval.unref)
+                        pingInterval.unref();
+                }
+                // Set up custom ping timeout if configured
+                let pingTimeout = null;
+                const pingTimeoutMs = route?.action.websocket?.pingTimeout || 60000; // Default 60s
+                // Define timeout function for cleaner code
+                const resetPingTimeout = () => {
+                    if (pingTimeout)
+                        clearTimeout(pingTimeout);
+                    pingTimeout = setTimeout(() => {
+                        this.logger.debug(`WebSocket ping timeout for client connection on route: ${route?.name || 'unnamed'}`);
+                        wsIncoming.terminate();
+                    }, pingTimeoutMs);
+                    // Don't keep process alive just for timeouts
+                    if (pingTimeout.unref)
+                        pingTimeout.unref();
+                };
+                // Reset timeout on pong
+                wsIncoming.on('pong', () => {
+                    wsIncoming.isAlive = true;
+                    wsIncoming.lastPong = Date.now();
+                    resetPingTimeout();
+                });
+                // Initial ping timeout
+                resetPingTimeout();
+                // Handle potential message size limits
+                const maxSize = route?.action.websocket?.maxPayloadSize || 0;
                 // Forward incoming messages to outgoing connection
                 wsIncoming.on('message', (data, isBinary) => {
                     if (wsOutgoing.readyState === wsOutgoing.OPEN) {
+                        // Check message size if limit is set
+                        const messageSize = getMessageSize(data);
+                        if (maxSize > 0 && messageSize > maxSize) {
+                            this.logger.warn(`WebSocket message exceeds max size (${messageSize} > ${maxSize})`);
+                            wsIncoming.close(1009, 'Message too big');
+                            return;
+                        }
                         wsOutgoing.send(data, { binary: isBinary });
                     }
                 });
@@ -134,12 +342,22 @@ export class WebSocketHandler {
                     if (wsOutgoing.readyState === wsOutgoing.OPEN) {
                         wsOutgoing.close(code, reason);
                     }
+                    // Clean up timers
+                    if (pingInterval)
+                        clearInterval(pingInterval);
+                    if (pingTimeout)
+                        clearTimeout(pingTimeout);
                 });
                 wsOutgoing.on('close', (code, reason) => {
                     this.logger.debug(`WebSocket target connection closed: ${code} ${reason}`);
                     if (wsIncoming.readyState === wsIncoming.OPEN) {
                         wsIncoming.close(code, reason);
                     }
+                    // Clean up timers
+                    if (pingInterval)
+                        clearInterval(pingInterval);
+                    if (pingTimeout)
+                        clearTimeout(pingTimeout);
                 });
                 this.logger.debug(`WebSocket connection established: ${req.headers.host} -> ${destination.host}:${destination.port}`);
             });
@@ -185,4 +403,4 @@ export class WebSocketHandler {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"websocket-handler.js","sourceRoot":"","sources":["../../../ts/proxies/network-proxy/websocket-handler.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"websocket-handler.js","sourceRoot":"","sources":["../../../ts/proxies/network-proxy/websocket-handler.ts"],"names":[],"mappings":"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"}

package/dist_ts/proxies/smart-proxy/index.d.ts

@@ -12,4 +12,4 @@ export { TlsManager } from './tls-manager.js';
 export { NetworkProxyBridge } from './network-proxy-bridge.js';
 export { RouteManager } from './route-manager.js';
 export { RouteConnectionHandler } from './route-connection-handler.js';
-export { createRoute, createHttpRoute, createHttpsRoute, createPassthroughRoute, createRedirectRoute, createHttpToHttpsRedirect, createBlockRoute, createLoadBalancerRoute, createHttpsServer } from './route-helpers.js';
+export * from './utils/index.js';

package/dist_ts/proxies/smart-proxy/index.js

@@ -16,6 +16,6 @@ export { NetworkProxyBridge } from './network-proxy-bridge.js';
 // Export route-based components
 export { RouteManager } from './route-manager.js';
 export { RouteConnectionHandler } from './route-connection-handler.js';
-// Export route helpers for configuration
-export { createRoute, createHttpRoute, createHttpsRoute, createPassthroughRoute, createRedirectRoute, createHttpToHttpsRedirect, createBlockRoute, createLoadBalancerRoute, createHttpsServer } from './route-helpers.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFDSCxtQkFBbUI7QUFDbkIsY0FBYyxtQkFBbUIsQ0FBQztBQUVsQyxtQ0FBbUM7QUFDbkMsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRTlDLGlDQUFpQztBQUNqQyxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUM1RCxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDeEQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ3RELE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUM5QyxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUUvRCxnQ0FBZ0M7QUFDaEMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ2xELE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBRXZFLHlDQUF5QztBQUN6QyxPQUFPLEVBQ0wsV0FBVyxFQUNYLGVBQWUsRUFDZixnQkFBZ0IsRUFDaEIsc0JBQXNCLEVBQ3RCLG1CQUFtQixFQUNuQix5QkFBeUIsRUFDekIsZ0JBQWdCLEVBQ2hCLHVCQUF1QixFQUN2QixpQkFBaUIsRUFDbEIsTUFBTSxvQkFBb0IsQ0FBQyJ9
+// Export all helper functions from the utils directory
+export * from './utils/index.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9wcm94aWVzL3NtYXJ0LXByb3h5L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFDSCxtQkFBbUI7QUFDbkIsY0FBYyxtQkFBbUIsQ0FBQztBQUVsQyxtQ0FBbUM7QUFDbkMsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRTlDLGlDQUFpQztBQUNqQyxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUM1RCxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDeEQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ3RELE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUM5QyxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUUvRCxnQ0FBZ0M7QUFDaEMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ2xELE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBRXZFLHVEQUF1RDtBQUN2RCxjQUFjLGtCQUFrQixDQUFDIn0=

package/dist_ts/proxies/smart-proxy/models/interfaces.d.ts

@@ -19,11 +19,6 @@ export declare function isRoutedOptions(options: any): boolean;
  */
 export interface ISmartProxyOptions {
     routes: IRouteConfig[];
-    globalPortRanges?: Array<{
-        from: number;
-        to: number;
-    }>;
-    forwardAllGlobalRanges?: boolean;
     preserveSourceIP?: boolean;
     defaults?: {
         target?: {
@@ -104,6 +99,9 @@ export interface IConnectionRecord {
     tlsHandshakeComplete: boolean;
     hasReceivedInitialData: boolean;
     routeConfig?: IRouteConfig;
+    targetHost?: string;
+    targetPort?: number;
+    tlsVersion?: string;
     hasKeepAlive: boolean;
     inactivityWarningIssued?: boolean;
     incomingTerminationReason?: string | null;

package/dist_ts/proxies/smart-proxy/models/route-types.d.ts

@@ -25,13 +25,32 @@ export interface IRouteMatch {
     tlsVersion?: string[];
     headers?: Record<string, string | RegExp>;
 }
+/**
+ * Context provided to port and host mapping functions
+ */
+export interface IRouteContext {
+    port: number;
+    domain?: string;
+    clientIp: string;
+    serverIp: string;
+    path?: string;
+    query?: string;
+    headers?: Record<string, string>;
+    isTls: boolean;
+    tlsVersion?: string;
+    routeName?: string;
+    routeId?: string;
+    targetHost?: string | string[];
+    targetPort?: number;
+    timestamp: number;
+    connectionId: string;
+}
 /**
  * Target configuration for forwarding
  */
 export interface IRouteTarget {
-    host: string | string[];
-    port: number;
-    preservePort?: boolean;
+    host: string | string[] | ((context: IRouteContext) => string | string[]);
+    port: number | 'preserve' | ((context: IRouteContext) => number);
 }
 /**
  * TLS configuration for route actions
@@ -66,7 +85,7 @@ export interface IRouteAuthentication {
     oauthClientId?: string;
     oauthClientSecret?: string;
     oauthRedirectUri?: string;
-    [key: string]: any;
+    options?: Record<string, unknown>;
 }
 /**
  * Security options for route actions
@@ -99,6 +118,15 @@ export interface IRouteTestResponse {
     headers: Record<string, string>;
     body: string;
 }
+/**
+ * URL rewriting configuration
+ */
+export interface IRouteUrlRewrite {
+    pattern: string;
+    target: string;
+    flags?: string;
+    onlyRewritePath?: boolean;
+}
 /**
  * Advanced options for route actions
  */
@@ -108,6 +136,7 @@ export interface IRouteAdvanced {
     keepAlive?: boolean;
     staticFiles?: IRouteStaticFiles;
     testResponse?: IRouteTestResponse;
+    urlRewrite?: IRouteUrlRewrite;
 }
 /**
  * WebSocket configuration
@@ -117,6 +146,11 @@ export interface IRouteWebSocket {
     pingInterval?: number;
     pingTimeout?: number;
     maxPayloadSize?: number;
+    customHeaders?: Record<string, string>;
+    subprotocols?: string[];
+    rewritePath?: string;
+    allowedOrigins?: string[];
+    authenticateRequest?: boolean;
 }
 /**
  * Load balancing configuration
@@ -144,6 +178,10 @@ export interface IRouteAction {
     loadBalancing?: IRouteLoadBalancing;
     security?: IRouteSecurity;
     advanced?: IRouteAdvanced;
+    options?: {
+        backendProtocol?: 'http1' | 'http2';
+        [key: string]: any;
+    };
 }
 /**
  * Rate limiting configuration
@@ -182,12 +220,26 @@ export interface IRouteSecurity {
     ipAllowList?: string[];
     ipBlockList?: string[];
 }
+/**
+ * CORS configuration for a route
+ */
+export interface IRouteCors {
+    enabled: boolean;
+    allowOrigin?: string | string[];
+    allowMethods?: string;
+    allowHeaders?: string;
+    allowCredentials?: boolean;
+    exposeHeaders?: string;
+    maxAge?: number;
+    preflight?: boolean;
+}
 /**
  * Headers configuration
  */
 export interface IRouteHeaders {
     request?: Record<string, string>;
     response?: Record<string, string>;
+    cors?: IRouteCors;
 }
 /**
  * The core unified configuration interface

package/dist_ts/proxies/smart-proxy/network-proxy-bridge.d.ts

@@ -8,8 +8,8 @@ import type { IRouteConfig } from './models/route-types.js';
  * Manages NetworkProxy integration for TLS termination
  *
  * NetworkProxyBridge connects SmartProxy with NetworkProxy to handle TLS termination.
- * It directly maps route configurations to NetworkProxy configuration format and manages
- * certificate provisioning through Port80Handler when ACME is enabled.
+ * It directly passes route configurations to NetworkProxy and manages the physical
+ * connection piping between SmartProxy and NetworkProxy for TLS termination.
  *
  * It is used by SmartProxy for routes that have:
  * - TLS mode of 'terminate' or 'terminate-and-reencrypt'
@@ -52,23 +52,6 @@ export declare class NetworkProxyBridge {
      * Stop NetworkProxy
      */
     stop(): Promise<void>;
-    /**
-     * Register domains from routes with Port80Handler for certificate management
-     *
-     * Extracts domains from routes that require TLS termination and registers them
-     * with the Port80Handler for certificate issuance and renewal.
-     *
-     * @param routes The route configurations to extract domains from
-     */
-    registerDomainsWithPort80Handler(routes: IRouteConfig[]): void;
-    /**
-     * Finds the route reference for a given domain
-     *
-     * @param domain The domain to find a route reference for
-     * @param routes The routes to search
-     * @returns The route reference if found, undefined otherwise
-     */
-    private findRouteReferenceForDomain;
     /**
      * Forwards a TLS connection to a NetworkProxy for handling
      */
@@ -76,48 +59,12 @@ export declare class NetworkProxyBridge {
     /**
      * Synchronizes routes to NetworkProxy
      *
-     * This method directly maps route configurations to NetworkProxy format and updates
-     * the NetworkProxy with these configurations. It handles:
-     *
-     * - Extracting domain, target, and certificate information from routes
-     * - Converting TLS mode settings to NetworkProxy configuration
-     * - Applying security and advanced settings
-     * - Registering domains for ACME certificate provisioning when needed
+     * This method directly passes route configurations to NetworkProxy without any
+     * intermediate conversion. NetworkProxy natively understands route configurations.
      *
      * @param routes The route configurations to sync to NetworkProxy
      */
     syncRoutesToNetworkProxy(routes: IRouteConfig[]): Promise<void>;
-    /**
-     * Map routes directly to NetworkProxy configuration format
-     *
-     * This method directly maps route configurations to NetworkProxy's format
-     * without any intermediate domain-based representation. It processes each route
-     * and creates appropriate NetworkProxy configs for domains that require TLS termination.
-     *
-     * @param routes Array of route configurations to map
-     * @param defaultCertPair Default certificate to use if no custom certificate is specified
-     * @returns Array of NetworkProxy configurations
-     */
-    mapRoutesToNetworkProxyConfigs(routes: IRouteConfig[], defaultCertPair: {
-        key: string;
-        cert: string;
-    }): plugins.tsclass.network.IReverseProxyConfig[];
-    /**
-     * @deprecated This method is kept for backward compatibility.
-     * Use mapRoutesToNetworkProxyConfigs() instead.
-     */
-    convertRoutesToNetworkProxyConfigs(routes: IRouteConfig[], defaultCertPair: {
-        key: string;
-        cert: string;
-    }): plugins.tsclass.network.IReverseProxyConfig[];
-    /**
-     * @deprecated This method is deprecated and will be removed in a future version.
-     * Use syncRoutesToNetworkProxy() instead.
-     *
-     * This legacy method exists only for backward compatibility and
-     * simply forwards to syncRoutesToNetworkProxy().
-     */
-    syncDomainConfigsToNetworkProxy(): Promise<void>;
     /**
      * Request a certificate for a specific domain
      *