@push.rocks/smartproxy 16.0.2 → 16.0.3

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

@@ -1,11 +1,14 @@
 import * as plugins from '../../plugins.js';
-import { createLogger } from './models/types.js';
+import { createLogger, RouteManager, convertLegacyConfigToRouteConfig } from './models/types.js';
+import { createBaseRouteContext } from '../../core/models/route-context.js';
 import { CertificateManager } from './certificate-manager.js';
 import { ConnectionPool } from './connection-pool.js';
 import { RequestHandler } from './request-handler.js';
 import { WebSocketHandler } from './websocket-handler.js';
 import { ProxyRouter } from '../../http/router/index.js';
+import { RouteRouter } from '../../http/router/route-router.js';
 import { Port80Handler } from '../../http/port80/port80-handler.js';
+import { FunctionCache } from './function-cache.js';
 /**
  * NetworkProxy provides a reverse proxy with TLS termination, WebSocket support,
  * automatic certificate management, and high-performance connection pooling.
@@ -19,8 +22,9 @@ export class NetworkProxy {
      * Creates a new NetworkProxy instance
      */
     constructor(optionsArg) {
-        this.proxyConfigs = [];
-        this.router = new ProxyRouter();
+        this.routes = [];
+        this.legacyRouter = new ProxyRouter(); // Legacy router for backward compatibility
+        this.router = new RouteRouter(); // New modern router
         // State tracking
         this.socketMap = new plugins.lik.ObjectMap();
         this.activeContexts = new Set();
@@ -64,13 +68,27 @@ export class NetworkProxy {
         };
         // Initialize logger
         this.logger = createLogger(this.options.logLevel);
-        // Initialize components
+        // Initialize route manager
+        this.routeManager = new RouteManager(this.logger);
+        // Initialize function cache
+        this.functionCache = new FunctionCache(this.logger, {
+            maxCacheSize: this.options.functionCacheSize || 1000,
+            defaultTtl: this.options.functionCacheTtl || 5000
+        });
+        // Initialize other components
         this.certificateManager = new CertificateManager(this.options);
         this.connectionPool = new ConnectionPool(this.options);
-        this.requestHandler = new RequestHandler(this.options, this.connectionPool, this.router);
-        this.webSocketHandler = new WebSocketHandler(this.options, this.connectionPool, this.router);
+        this.requestHandler = new RequestHandler(this.options, this.connectionPool, this.legacyRouter, // Still use legacy router for backward compatibility
+        this.routeManager, this.functionCache, this.router // Pass the new modern router as well
+        );
+        this.webSocketHandler = new WebSocketHandler(this.options, this.connectionPool, this.legacyRouter, this.routes // Pass current routes to WebSocketHandler
+        );
         // Connect request handler to this metrics tracker
         this.requestHandler.setMetricsTracker(this);
+        // Initialize with any provided routes
+        if (this.options.routes && this.options.routes.length > 0) {
+            this.updateRouteConfigs(this.options.routes);
+        }
     }
     /**
      * Implements IMetricsTracker interface to increment request counters
@@ -89,6 +107,14 @@ export class NetworkProxy {
      * Useful for SmartProxy to determine where to forward connections
      */
     getListeningPort() {
+        // If the server is running, get the actual listening port
+        if (this.httpsServer && this.httpsServer.address()) {
+            const address = this.httpsServer.address();
+            if (address && typeof address === 'object' && 'port' in address) {
+                return address.port;
+            }
+        }
+        // Fallback to configured port
         return this.options.port;
     }
     /**
@@ -130,7 +156,8 @@ export class NetworkProxy {
             connectionPoolSize: this.connectionPool.getPoolStatus(),
             uptime: Math.floor((Date.now() - this.startTime) / 1000),
             memoryUsage: process.memoryUsage(),
-            activeWebSockets: this.webSocketHandler.getConnectionInfo().activeConnections
+            activeWebSockets: this.webSocketHandler.getConnectionInfo().activeConnections,
+            functionCache: this.functionCache.getStats()
         };
     }
     /**
@@ -262,70 +289,115 @@ export class NetworkProxy {
         }
     }
     /**
-     * Updates proxy configurations
+     * Updates the route configurations - this is the primary method for configuring NetworkProxy
+     * @param routes The new route configurations to use
      */
-    async updateProxyConfigs(proxyConfigsArg) {
-        this.logger.info(`Updating proxy configurations (${proxyConfigsArg.length} configs)`);
-        // Update internal configs
-        this.proxyConfigs = proxyConfigsArg;
-        this.router.setNewProxyConfigs(proxyConfigsArg);
-        // Collect all hostnames for cleanup later
-        const currentHostNames = new Set();
-        // Add/update SSL contexts for each host
-        for (const config of proxyConfigsArg) {
-            currentHostNames.add(config.hostName);
+    async updateRouteConfigs(routes) {
+        this.logger.info(`Updating route configurations (${routes.length} routes)`);
+        // Update routes in RouteManager, modern router, WebSocketHandler, and SecurityManager
+        this.routeManager.updateRoutes(routes);
+        this.router.setRoutes(routes);
+        this.webSocketHandler.setRoutes(routes);
+        this.requestHandler.securityManager.setRoutes(routes);
+        this.routes = routes;
+        // Directly update the certificate manager with the new routes
+        // This will extract domains and handle certificate provisioning
+        this.certificateManager.updateRouteConfigs(routes);
+        // Collect all domains and certificates for configuration
+        const currentHostnames = new Set();
+        const certificateUpdates = new Map();
+        // Process each route to extract domain and certificate information
+        for (const route of routes) {
+            // Skip non-forward routes or routes without domains
+            if (route.action.type !== 'forward' || !route.match.domains) {
+                continue;
+            }
+            // Get domains from route
+            const domains = Array.isArray(route.match.domains)
+                ? route.match.domains
+                : [route.match.domains];
+            // Process each domain
+            for (const domain of domains) {
+                // Skip wildcard domains for direct host configuration
+                if (domain.includes('*')) {
+                    continue;
+                }
+                currentHostnames.add(domain);
+                // Check if we have a static certificate for this domain
+                if (route.action.tls?.certificate && route.action.tls.certificate !== 'auto') {
+                    certificateUpdates.set(domain, {
+                        cert: route.action.tls.certificate.cert,
+                        key: route.action.tls.certificate.key
+                    });
+                }
+            }
+        }
+        // Update certificate cache with any static certificates
+        for (const [domain, certData] of certificateUpdates.entries()) {
             try {
-                // Update certificate in cache
-                this.certificateManager.updateCertificateCache(config.hostName, config.publicKey, config.privateKey);
-                this.activeContexts.add(config.hostName);
+                this.certificateManager.updateCertificateCache(domain, certData.cert, certData.key);
+                this.activeContexts.add(domain);
             }
             catch (error) {
-                this.logger.error(`Failed to add SSL context for ${config.hostName}`, error);
+                this.logger.error(`Failed to add SSL context for ${domain}`, error);
             }
         }
         // Clean up removed contexts
         for (const hostname of this.activeContexts) {
-            if (!currentHostNames.has(hostname)) {
+            if (!currentHostnames.has(hostname)) {
                 this.logger.info(`Hostname ${hostname} removed from configuration`);
                 this.activeContexts.delete(hostname);
             }
         }
-        // Register domains with Port80Handler if available
-        const domainsForACME = Array.from(currentHostNames)
-            .filter(domain => !domain.includes('*')); // Skip wildcard domains
-        this.certificateManager.registerDomainsWithPort80Handler(domainsForACME);
-    }
-    /**
-     * Converts SmartProxy domain configurations to NetworkProxy configs
-     * @param domainConfigs SmartProxy domain configs
-     * @param sslKeyPair Default SSL key pair to use if not specified
-     * @returns Array of NetworkProxy configs
-     */
-    convertSmartProxyConfigs(domainConfigs, sslKeyPair) {
-        const proxyConfigs = [];
-        // Use default certificates if not provided
-        const defaultCerts = this.certificateManager.getDefaultCertificates();
-        const sslKey = sslKeyPair?.key || defaultCerts.key;
-        const sslCert = sslKeyPair?.cert || defaultCerts.cert;
-        for (const domainConfig of domainConfigs) {
-            // Each domain in the domains array gets its own config
-            for (const domain of domainConfig.domains) {
-                // Skip non-hostname patterns (like IP addresses)
-                if (domain.match(/^\d+\.\d+\.\d+\.\d+$/) || domain === '*' || domain === 'localhost') {
-                    continue;
-                }
-                proxyConfigs.push({
-                    hostName: domain,
-                    destinationIps: domainConfig.targetIPs || ['localhost'],
-                    destinationPorts: [this.options.port], // Use the NetworkProxy port
-                    privateKey: sslKey,
-                    publicKey: sslCert
-                });
+        // Create legacy proxy configs for the router
+        // This is only needed for backward compatibility with ProxyRouter
+        // and will be removed in the future
+        const legacyConfigs = [];
+        for (const domain of currentHostnames) {
+            // Find route for this domain
+            const route = routes.find(r => {
+                const domains = Array.isArray(r.match.domains) ? r.match.domains : [r.match.domains];
+                return domains.includes(domain);
+            });
+            if (!route || route.action.type !== 'forward' || !route.action.target) {
+                continue;
+            }
+            // Skip routes with function-based targets - we'll handle them during request processing
+            if (typeof route.action.target.host === 'function' || typeof route.action.target.port === 'function') {
+                this.logger.info(`Domain ${domain} uses function-based targets - will be handled at request time`);
+                continue;
             }
+            // Extract static target information
+            const targetHosts = Array.isArray(route.action.target.host)
+                ? route.action.target.host
+                : [route.action.target.host];
+            const targetPort = route.action.target.port;
+            // Get certificate information
+            const certData = certificateUpdates.get(domain);
+            const defaultCerts = this.certificateManager.getDefaultCertificates();
+            legacyConfigs.push({
+                hostName: domain,
+                destinationIps: targetHosts,
+                destinationPorts: [targetPort],
+                privateKey: certData?.key || defaultCerts.key,
+                publicKey: certData?.cert || defaultCerts.cert
+            });
+        }
+        // Update the router with legacy configs
+        // Handle both old and new router interfaces
+        if (typeof this.router.setRoutes === 'function') {
+            this.router.setRoutes(routes);
+        }
+        else if (typeof this.router.setNewProxyConfigs === 'function') {
+            this.router.setNewProxyConfigs(legacyConfigs);
         }
-        this.logger.info(`Converted ${domainConfigs.length} SmartProxy configs to ${proxyConfigs.length} NetworkProxy configs`);
-        return proxyConfigs;
+        else {
+            this.logger.warn('Router has no recognized configuration method');
+        }
+        this.logger.info(`Route configuration updated with ${routes.length} routes and ${legacyConfigs.length} proxy configs`);
     }
+    // Legacy methods have been removed.
+    // Please use updateRouteConfigs() directly with modern route-based configuration.
     /**
      * Adds default headers to be included in all responses
      */
@@ -378,10 +450,25 @@ export class NetworkProxy {
         return this.certificateManager.requestCertificate(domain);
     }
     /**
-     * Gets all proxy configurations currently in use
+     * Update certificate for a domain
+     *
+     * This method allows direct updates of certificates from external sources
+     * like Port80Handler or custom certificate providers.
+     *
+     * @param domain The domain to update certificate for
+     * @param certificate The new certificate (public key)
+     * @param privateKey The new private key
+     * @param expiryDate Optional expiry date
+     */
+    updateCertificate(domain, certificate, privateKey, expiryDate) {
+        this.logger.info(`Updating certificate for ${domain}`);
+        this.certificateManager.updateCertificateCache(domain, certificate, privateKey, expiryDate);
+    }
+    /**
+     * Gets all route configurations currently in use
      */
-    getProxyConfigs() {
-        return [...this.proxyConfigs];
+    getRouteConfigs() {
+        return this.routeManager.getRoutes();
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"network-proxy.js","sourceRoot":"","sources":["../../../ts/proxies/network-proxy/network-proxy.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"network-proxy.js","sourceRoot":"","sources":["../../../ts/proxies/network-proxy/network-proxy.ts"],"names":[],"mappings":"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"}

package/dist_ts/proxies/network-proxy/request-handler.d.ts

@@ -1,7 +1,9 @@
 import * as plugins from '../../plugins.js';
-import { type INetworkProxyOptions } from './models/types.js';
+import '../../core/models/socket-augmentation.js';
+import { type INetworkProxyOptions, RouteManager } from './models/types.js';
 import { ConnectionPool } from './connection-pool.js';
 import { ProxyRouter } from '../../http/router/index.js';
+import { SecurityManager } from './security-manager.js';
 /**
  * Interface for tracking metrics
  */
@@ -16,12 +18,23 @@ export type MetricsTracker = IMetricsTracker;
 export declare class RequestHandler {
     private options;
     private connectionPool;
-    private router;
+    private legacyRouter;
+    private routeManager?;
+    private functionCache?;
+    private router?;
     private defaultHeaders;
     private logger;
     private metricsTracker;
     private h2Sessions;
-    constructor(options: INetworkProxyOptions, connectionPool: ConnectionPool, router: ProxyRouter);
+    private contextCreator;
+    securityManager: SecurityManager;
+    constructor(options: INetworkProxyOptions, connectionPool: ConnectionPool, legacyRouter: ProxyRouter, // Legacy router for backward compatibility
+    routeManager?: RouteManager, functionCache?: any, // FunctionCache - using any to avoid circular dependency
+    router?: any);
+    /**
+     * Set the route manager instance
+     */
+    setRouteManager(routeManager: RouteManager): void;
     /**
      * Set the metrics tracker instance
      */
@@ -40,18 +53,38 @@ export declare class RequestHandler {
     };
     /**
      * Apply CORS headers to response if configured
+     * Implements Phase 5.5: Context-aware CORS handling
+     *
+     * @param res The server response to apply headers to
+     * @param req The incoming request
+     * @param route Optional route config with CORS settings
      */
     private applyCorsHeaders;
     /**
      * Apply default headers to response
      */
     private applyDefaultHeaders;
+    /**
+     * Apply URL rewriting based on route configuration
+     * Implements Phase 5.2: URL rewriting using route context
+     *
+     * @param req The request with the URL to rewrite
+     * @param route The route configuration containing rewrite rules
+     * @param routeContext Context for template variable resolution
+     * @returns True if URL was rewritten, false otherwise
+     */
+    private applyUrlRewriting;
+    /**
+     * Apply header modifications from route configuration
+     * Implements Phase 5.1: Route-based header manipulation
+     */
+    private applyRouteHeaderModifications;
     /**
      * Handle an HTTP request
      */
     handleRequest(req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse): Promise<void>;
     /**
-     * Handle HTTP/2 stream requests by proxying to HTTP/1 backends
+     * Handle HTTP/2 stream requests with function-based target support
      */
-    handleHttp2(stream: any, headers: any): Promise<void>;
+    handleHttp2(stream: plugins.http2.ServerHttp2Stream, headers: plugins.http2.IncomingHttpHeaders): Promise<void>;
 }