@push.rocks/smartproxy 19.5.18 → 19.5.20

package/ts/proxies/http-proxy/request-handler.ts

@@ -4,11 +4,9 @@ import {
   type IHttpProxyOptions,
   type ILogger,
   createLogger,
-  type IReverseProxyConfig,
-  RouteManager
 } from './models/types.js';
+import { SharedRouteManager as RouteManager } from '../../core/routing/route-manager.js';
 import { ConnectionPool } from './connection-pool.js';
-import { ProxyRouter } from '../../routing/router/index.js';
 import { ContextCreator } from './context-creator.js';
 import { HttpRequestHandler } from './http-request-handler.js';
 import { Http2RequestHandler } from './http2-request-handler.js';
@@ -48,10 +46,9 @@ export class RequestHandler {
   constructor(
     private options: IHttpProxyOptions,
     private connectionPool: ConnectionPool,
-    private legacyRouter: ProxyRouter, // Legacy router for backward compatibility
     private routeManager?: RouteManager,
     private functionCache?: any, // FunctionCache - using any to avoid circular dependency
-    private router?: any // RouteRouter - using any to avoid circular dependency
+    private router?: any // HttpRouter - using any to avoid circular dependency
   ) {
     this.logger = createLogger(options.logLevel || 'info');
     this.securityManager = new SecurityManager(this.logger);
@@ -373,7 +370,8 @@ export class RequestHandler {
           tlsVersion: req.socket.getTLSVersion?.() || undefined
         });
 
-        matchingRoute = this.routeManager.findMatchingRoute(toBaseContext(routeContext));
+        const matchResult = this.routeManager.findMatchingRoute(toBaseContext(routeContext));
+        matchingRoute = matchResult?.route || null;
       } catch (err) {
         this.logger.error('Error finding matching route', err);
       }
@@ -581,86 +579,11 @@ export class RequestHandler {
       }
     }
 
-    // Try modern router first, then fall back to legacy routing if needed
-    if (this.router) {
-      try {
-        // Try to find a matching route using the modern router
-        const route = this.router.routeReq(req);
-        if (route && route.action.type === 'forward' && route.action.target) {
-          // Handle this route similarly to RouteManager logic
-          this.logger.debug(`Found matching route via modern router: ${route.name || 'unnamed'}`);
-
-          // No need to do anything here, we'll continue with legacy routing
-          // The routeManager would have already found this route if applicable
-        }
-      } catch (err) {
-        this.logger.error('Error using modern router', err);
-        // Continue with legacy routing
-      }
-    }
-
-    // Fall back to legacy routing if no matching route found via RouteManager
-    let proxyConfig: IReverseProxyConfig | undefined;
-    try {
-      proxyConfig = this.legacyRouter.routeReq(req);
-    } catch (err) {
-      this.logger.error('Error routing request with legacy router', err);
-      res.statusCode = 500;
-      res.end('Internal Server Error');
-      if (this.metricsTracker) this.metricsTracker.incrementFailedRequests();
-      return;
-    }
-    if (!proxyConfig) {
-      this.logger.warn(`No proxy configuration for host: ${req.headers.host}`);
-      res.statusCode = 404;
-      res.end('Not Found: No proxy configuration for this host');
-      if (this.metricsTracker) this.metricsTracker.incrementFailedRequests();
-      return;
-    }
-    // Determine protocol to backend (per-domain override or global)
-    const backendProto = proxyConfig.backendProtocol || this.options.backendProtocol;
-    if (backendProto === 'http2') {
-      const destination = this.connectionPool.getNextTarget(
-        proxyConfig.destinationIps,
-        proxyConfig.destinationPorts[0]
-      );
-      const key = `${destination.host}:${destination.port}`;
-      let session = this.h2Sessions.get(key);
-      if (!session || session.closed || (session as any).destroyed) {
-        session = plugins.http2.connect(`http://${destination.host}:${destination.port}`);
-        this.h2Sessions.set(key, session);
-        session.on('error', () => this.h2Sessions.delete(key));
-        session.on('close', () => this.h2Sessions.delete(key));
-      }
-      // Build headers for HTTP/2 request
-      const hdrs: Record<string, any> = {
-        ':method': req.method,
-        ':path': req.url,
-        ':authority': `${destination.host}:${destination.port}`
-      };
-      for (const [hk, hv] of Object.entries(req.headers)) {
-        if (typeof hv === 'string') hdrs[hk] = hv;
-      }
-      const h2Stream = session.request(hdrs);
-      req.pipe(h2Stream);
-      h2Stream.on('response', (hdrs2: any) => {
-        const status = (hdrs2[':status'] as number) || 502;
-        res.statusCode = status;
-        // Copy headers from HTTP/2 response to HTTP/1 response
-        for (const [hk, hv] of Object.entries(hdrs2)) {
-          if (!hk.startsWith(':') && hv != null) {
-            res.setHeader(hk, hv as string | string[]);
-          }
-        }
-        h2Stream.pipe(res);
-      });
-      h2Stream.on('error', (err) => {
-        res.statusCode = 502;
-        res.end(`Bad Gateway: ${err.message}`);
-        if (this.metricsTracker) this.metricsTracker.incrementFailedRequests();
-      });
-      return;
-    }
+    // If no route was found, return 404
+    this.logger.warn(`No route configuration for host: ${req.headers.host}`);
+    res.statusCode = 404;
+    res.end('Not Found: No route configuration for this host');
+    if (this.metricsTracker) this.metricsTracker.incrementFailedRequests();
   }
 
   /**
@@ -688,7 +611,8 @@ export class RequestHandler {
     let matchingRoute: IRouteConfig | null = null;
     if (this.routeManager) {
       try {
-        matchingRoute = this.routeManager.findMatchingRoute(toBaseContext(routeContext));
+        const matchResult = this.routeManager.findMatchingRoute(toBaseContext(routeContext));
+        matchingRoute = matchResult?.route || null;
       } catch (err) {
         this.logger.error('Error finding matching route for HTTP/2 request', err);
       }
@@ -812,104 +736,9 @@ export class RequestHandler {
     const method = headers[':method'] || 'GET';
     const path = headers[':path'] || '/';
 
-    // If configured to proxy to backends over HTTP/2, use HTTP/2 client sessions
-    if (this.options.backendProtocol === 'http2') {
-      const authority = headers[':authority'] as string || '';
-      const host = authority.split(':')[0];
-      const fakeReq: any = {
-        headers: { host },
-        method: headers[':method'],
-        url: headers[':path'],
-        socket: (stream.session as any).socket
-      };
-      // Try modern router first if available
-      let route;
-      if (this.router) {
-        try {
-          route = this.router.routeReq(fakeReq);
-          if (route && route.action.type === 'forward' && route.action.target) {
-            this.logger.debug(`Found matching HTTP/2 route via modern router: ${route.name || 'unnamed'}`);
-            // The routeManager would have already found this route if applicable
-          }
-        } catch (err) {
-          this.logger.error('Error using modern router for HTTP/2', err);
-        }
-      }
-
-      // Fall back to legacy routing
-      const proxyConfig = this.legacyRouter.routeReq(fakeReq);
-      if (!proxyConfig) {
-        stream.respond({ ':status': 404 });
-        stream.end('Not Found');
-        if (this.metricsTracker) this.metricsTracker.incrementFailedRequests();
-        return;
-      }
-      const destination = this.connectionPool.getNextTarget(proxyConfig.destinationIps, proxyConfig.destinationPorts[0]);
-
-      // Use the helper for HTTP/2 to HTTP/2 routing
-      return Http2RequestHandler.handleHttp2WithHttp2Destination(
-        stream,
-        headers,
-        destination,
-        routeContext,
-        this.h2Sessions,
-        this.logger,
-        this.metricsTracker
-      );
-    }
-
-    try {
-      // Determine host for routing
-      const authority = headers[':authority'] as string || '';
-      const host = authority.split(':')[0];
-      // Fake request object for routing
-      const fakeReq: any = {
-        headers: { host },
-        method,
-        url: path,
-        socket: (stream.session as any).socket
-      };
-      // Try modern router first if available
-      if (this.router) {
-        try {
-          const route = this.router.routeReq(fakeReq);
-          if (route && route.action.type === 'forward' && route.action.target) {
-            this.logger.debug(`Found matching HTTP/2 route via modern router: ${route.name || 'unnamed'}`);
-            // The routeManager would have already found this route if applicable
-          }
-        } catch (err) {
-          this.logger.error('Error using modern router for HTTP/2', err);
-        }
-      }
-
-      // Fall back to legacy routing
-      const proxyConfig = this.legacyRouter.routeReq(fakeReq as any);
-      if (!proxyConfig) {
-        stream.respond({ ':status': 404 });
-        stream.end('Not Found');
-        if (this.metricsTracker) this.metricsTracker.incrementFailedRequests();
-        return;
-      }
-
-      // Select backend target
-      const destination = this.connectionPool.getNextTarget(
-        proxyConfig.destinationIps,
-        proxyConfig.destinationPorts[0]
-      );
-
-      // Use the helper for HTTP/2 to HTTP/1 routing
-      return Http2RequestHandler.handleHttp2WithHttp1Destination(
-        stream,
-        headers,
-        destination,
-        routeContext,
-        this.logger,
-        this.metricsTracker
-      );
-    } catch (err: any) {
-      stream.respond({ ':status': 500 });
-      stream.end('Internal Server Error');
-      if (this.metricsTracker) this.metricsTracker.incrementFailedRequests();
-    }
+    // No route was found
+    stream.respond({ ':status': 404 });
+    stream.end('Not Found: No route configuration for this request');
+    if (this.metricsTracker) this.metricsTracker.incrementFailedRequests();
   }
 }

package/ts/proxies/http-proxy/websocket-handler.ts

@@ -1,8 +1,8 @@
 import * as plugins from '../../plugins.js';
 import '../../core/models/socket-augmentation.js';
-import { type IHttpProxyOptions, type IWebSocketWithHeartbeat, type ILogger, createLogger, type IReverseProxyConfig } from './models/types.js';
+import { type IHttpProxyOptions, type IWebSocketWithHeartbeat, type ILogger, createLogger } from './models/types.js';
 import { ConnectionPool } from './connection-pool.js';
-import { ProxyRouter, RouteRouter } from '../../routing/router/index.js';
+import { HttpRouter } from '../../routing/router/index.js';
 import type { IRouteConfig } from '../smart-proxy/models/route-types.js';
 import type { IRouteContext } from '../../core/models/route-context.js';
 import { toBaseContext } from '../../core/models/route-context.js';
@@ -19,21 +19,20 @@ export class WebSocketHandler {
   private wsServer: plugins.ws.WebSocketServer | null = null;
   private logger: ILogger;
   private contextCreator: ContextCreator = new ContextCreator();
-  private routeRouter: RouteRouter | null = null;
+  private router: HttpRouter | null = null;
   private securityManager: SecurityManager;
 
   constructor(
     private options: IHttpProxyOptions,
     private connectionPool: ConnectionPool,
-    private legacyRouter: ProxyRouter, // Legacy router for backward compatibility
-    private routes: IRouteConfig[] = [] // Routes for modern router
+    private routes: IRouteConfig[] = []
   ) {
     this.logger = createLogger(options.logLevel || 'info');
     this.securityManager = new SecurityManager(this.logger, routes);
 
-    // Initialize modern router if we have routes
+    // Initialize router if we have routes
     if (routes.length > 0) {
-      this.routeRouter = new RouteRouter(routes, this.logger);
+      this.router = new HttpRouter(routes, this.logger);
     }
   }
 
@@ -44,10 +43,10 @@ export class WebSocketHandler {
     this.routes = routes;
 
     // Initialize or update the route router
-    if (!this.routeRouter) {
-      this.routeRouter = new RouteRouter(routes, this.logger);
+    if (!this.router) {
+      this.router = new HttpRouter(routes, this.logger);
     } else {
-      this.routeRouter.setRoutes(routes);
+      this.router.setRoutes(routes);
     }
 
     // Update the security manager
@@ -139,8 +138,8 @@ export class WebSocketHandler {
 
       // Try modern router first if available
       let route: IRouteConfig | undefined;
-      if (this.routeRouter) {
-        route = this.routeRouter.routeReq(req);
+      if (this.router) {
+        route = this.router.routeReq(req);
       }
 
       // Define destination variables
@@ -227,20 +226,10 @@ export class WebSocketHandler {
           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]
-        );
+        // No route found
+        this.logger.warn(`No route configuration for WebSocket host: ${req.headers.host}`);
+        wsIncoming.close(1008, 'No route configuration for this host');
+        return;
       }
       
       // Build target URL with potential path rewriting

package/ts/proxies/index.ts

@@ -7,11 +7,12 @@ export { HttpProxy, CertificateManager, ConnectionPool, RequestHandler, WebSocke
 export type { IMetricsTracker, MetricsTracker } from './http-proxy/index.js';
 // Export http-proxy models except IAcmeOptions
 export type { IHttpProxyOptions, ICertificateEntry, ILogger } from './http-proxy/models/types.js';
-export { RouteManager as HttpProxyRouteManager } from './http-proxy/models/types.js';
+// RouteManager has been unified - use SharedRouteManager from core/routing
+export { SharedRouteManager as HttpProxyRouteManager } from '../core/routing/route-manager.js';
 
 // Export SmartProxy with selective imports to avoid conflicts
 export { SmartProxy, ConnectionManager, SecurityManager, TimeoutManager, TlsManager, HttpProxyBridge, RouteConnectionHandler } from './smart-proxy/index.js';
-export { RouteManager as SmartProxyRouteManager } from './smart-proxy/route-manager.js';
+export { SharedRouteManager as SmartProxyRouteManager } from '../core/routing/route-manager.js';
 export * from './smart-proxy/utils/index.js';
 // Export smart-proxy models except IAcmeOptions
 export type { ISmartProxyOptions, IConnectionRecord, IRouteConfig, IRouteMatch, IRouteAction, IRouteTls, IRouteContext } from './smart-proxy/models/index.js';

package/ts/proxies/smart-proxy/connection-manager.ts

@@ -5,6 +5,7 @@ import { TimeoutManager } from './timeout-manager.js';
 import { logger } from '../../core/utils/logger.js';
 import { LifecycleComponent } from '../../core/utils/lifecycle-component.js';
 import { cleanupSocket } from '../../core/utils/socket-utils.js';
+import { WrappedSocket } from '../../core/models/wrapped-socket.js';
 
 /**
  * Manages connection lifecycle, tracking, and cleanup with performance optimizations
@@ -53,8 +54,9 @@ export class ConnectionManager extends LifecycleComponent {
   
   /**
    * Create and track a new connection
+   * Accepts either a regular net.Socket or a WrappedSocket for transparent PROXY protocol support
    */
-  public createConnection(socket: plugins.net.Socket): IConnectionRecord | null {
+  public createConnection(socket: plugins.net.Socket | WrappedSocket): IConnectionRecord | null {
     // Enforce connection limit
     if (this.connectionRecords.size >= this.maxConnections) {
       logger.log('warn', `Connection limit reached (${this.maxConnections}). Rejecting new connection.`, {
@@ -282,22 +284,26 @@ export class ConnectionManager extends LifecycleComponent {
       const cleanupPromises: Promise<void>[] = [];
       
       if (record.incoming) {
+        // Extract underlying socket if it's a WrappedSocket
+        const incomingSocket = record.incoming instanceof WrappedSocket ? record.incoming.socket : record.incoming;
         if (!record.incoming.writable || record.incoming.destroyed) {
           // Socket is not active, clean up immediately
-          cleanupPromises.push(cleanupSocket(record.incoming, `${record.id}-incoming`, { immediate: true }));
+          cleanupPromises.push(cleanupSocket(incomingSocket, `${record.id}-incoming`, { immediate: true }));
         } else {
           // Socket is still active, allow graceful cleanup
-          cleanupPromises.push(cleanupSocket(record.incoming, `${record.id}-incoming`, { allowDrain: true, gracePeriod: 5000 }));
+          cleanupPromises.push(cleanupSocket(incomingSocket, `${record.id}-incoming`, { allowDrain: true, gracePeriod: 5000 }));
         }
       }
       
       if (record.outgoing) {
+        // Extract underlying socket if it's a WrappedSocket
+        const outgoingSocket = record.outgoing instanceof WrappedSocket ? record.outgoing.socket : record.outgoing;
         if (!record.outgoing.writable || record.outgoing.destroyed) {
           // Socket is not active, clean up immediately
-          cleanupPromises.push(cleanupSocket(record.outgoing, `${record.id}-outgoing`, { immediate: true }));
+          cleanupPromises.push(cleanupSocket(outgoingSocket, `${record.id}-outgoing`, { immediate: true }));
         } else {
           // Socket is still active, allow graceful cleanup
-          cleanupPromises.push(cleanupSocket(record.outgoing, `${record.id}-outgoing`, { allowDrain: true, gracePeriod: 5000 }));
+          cleanupPromises.push(cleanupSocket(outgoingSocket, `${record.id}-outgoing`, { allowDrain: true, gracePeriod: 5000 }));
         }
       }
       
@@ -570,11 +576,13 @@ export class ConnectionManager extends LifecycleComponent {
           const shutdownPromises: Promise<void>[] = [];
           
           if (record.incoming) {
-            shutdownPromises.push(cleanupSocket(record.incoming, `${record.id}-incoming-shutdown`, { immediate: true }));
+            const incomingSocket = record.incoming instanceof WrappedSocket ? record.incoming.socket : record.incoming;
+            shutdownPromises.push(cleanupSocket(incomingSocket, `${record.id}-incoming-shutdown`, { immediate: true }));
           }
 
           if (record.outgoing) {
-            shutdownPromises.push(cleanupSocket(record.outgoing, `${record.id}-outgoing-shutdown`, { immediate: true }));
+            const outgoingSocket = record.outgoing instanceof WrappedSocket ? record.outgoing.socket : record.outgoing;
+            shutdownPromises.push(cleanupSocket(outgoingSocket, `${record.id}-outgoing-shutdown`, { immediate: true }));
           }
           
           // Don't wait for shutdown cleanup in this batch processing

package/ts/proxies/smart-proxy/http-proxy-bridge.ts

@@ -3,6 +3,7 @@ import { HttpProxy } from '../http-proxy/index.js';
 import { setupBidirectionalForwarding } from '../../core/utils/socket-utils.js';
 import type { IConnectionRecord, ISmartProxyOptions } from './models/interfaces.js';
 import type { IRouteConfig } from './models/route-types.js';
+import { WrappedSocket } from '../../core/models/wrapped-socket.js';
 
 export class HttpProxyBridge {
   private httpProxy: HttpProxy | null = null;
@@ -98,7 +99,7 @@ export class HttpProxyBridge {
    */
   public async forwardToHttpProxy(
     connectionId: string,
-    socket: plugins.net.Socket,
+    socket: plugins.net.Socket | WrappedSocket,
     record: IConnectionRecord,
     initialChunk: Buffer,
     httpProxyPort: number,
@@ -125,7 +126,10 @@ export class HttpProxyBridge {
     }
     
     // Use centralized bidirectional forwarding
-    setupBidirectionalForwarding(socket, proxySocket, {
+    // Extract underlying socket if it's a WrappedSocket
+    const underlyingSocket = socket instanceof WrappedSocket ? socket.socket : socket;
+    
+    setupBidirectionalForwarding(underlyingSocket, proxySocket, {
       onClientData: (chunk) => {
         // Update stats if needed
         if (record) {

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

@@ -17,7 +17,7 @@ export { TlsManager } from './tls-manager.js';
 export { HttpProxyBridge } from './http-proxy-bridge.js';
 
 // Export route-based components
-export { RouteManager } from './route-manager.js';
+export { SharedRouteManager as RouteManager } from '../../core/routing/route-manager.js';
 export { RouteConnectionHandler } from './route-connection-handler.js';
 export { NFTablesManager } from './nftables-manager.js';
 

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

@@ -1,4 +1,5 @@
 import * as plugins from '../../../plugins.js';
+import type { WrappedSocket } from '../../../core/models/wrapped-socket.js';
 // Certificate types removed - define IAcmeOptions locally
 export interface IAcmeOptions {
   enabled?: boolean;
@@ -34,6 +35,11 @@ export interface ISmartProxyOptions {
   // Port configuration
   preserveSourceIP?: boolean;  // Preserve client IP when forwarding
 
+  // PROXY protocol configuration
+  proxyIPs?: string[];  // List of trusted proxy IPs that can send PROXY protocol
+  acceptProxyProtocol?: boolean;  // Global option to accept PROXY protocol (defaults based on proxyIPs)
+  sendProxyProtocol?: boolean;  // Global option to send PROXY protocol to all targets
+
   // Global/default settings
   defaults?: {
     target?: {
@@ -128,8 +134,8 @@ export interface ISmartProxyOptions {
  */
 export interface IConnectionRecord {
   id: string; // Unique connection identifier
-  incoming: plugins.net.Socket;
-  outgoing: plugins.net.Socket | null;
+  incoming: plugins.net.Socket | WrappedSocket;
+  outgoing: plugins.net.Socket | WrappedSocket | null;
   incomingStartTime: number;
   outgoingStartTime?: number;
   outgoingClosedTime?: number;