@push.rocks/smartproxy 16.0.2 → 16.0.3

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

@@ -1,14 +1,13 @@
 import * as plugins from '../../plugins.js';
 import { NetworkProxy } from '../network-proxy/index.js';
 import { Port80Handler } from '../../http/port80/port80-handler.js';
-import { Port80HandlerEvents } from '../../core/models/common-types.js';
 import { subscribeToPort80Handler } from '../../core/utils/event-utils.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'
@@ -41,7 +40,7 @@ export class NetworkProxyBridge {
      */
     async initialize() {
         if (!this.networkProxy && this.settings.useNetworkProxy && this.settings.useNetworkProxy.length > 0) {
-            // Configure NetworkProxy options based on PortProxy settings
+            // Configure NetworkProxy options based on SmartProxy settings
             const networkProxyOptions = {
                 port: this.settings.networkProxyPort,
                 portProxyIntegration: true,
@@ -65,29 +64,8 @@ export class NetworkProxyBridge {
         if (!this.networkProxy)
             return;
         console.log(`Received certificate for ${data.domain} from Port80Handler, updating NetworkProxy`);
-        try {
-            // Find existing config for this domain
-            const existingConfigs = this.networkProxy.getProxyConfigs()
-                .filter(config => config.hostName === data.domain);
-            if (existingConfigs.length > 0) {
-                // Update existing configs with new certificate
-                for (const config of existingConfigs) {
-                    config.privateKey = data.privateKey;
-                    config.publicKey = data.certificate;
-                }
-                // Apply updated configs
-                this.networkProxy.updateProxyConfigs(existingConfigs)
-                    .then(() => console.log(`Updated certificate for ${data.domain} in NetworkProxy`))
-                    .catch(err => console.log(`Error updating certificate in NetworkProxy: ${err}`));
-            }
-            else {
-                // Create a new config for this domain
-                console.log(`No existing config found for ${data.domain}, creating new config in NetworkProxy`);
-            }
-        }
-        catch (err) {
-            console.log(`Error handling certificate event: ${err}`);
-        }
+        // Apply certificate directly to NetworkProxy
+        this.networkProxy.updateCertificate(data.domain, data.certificate, data.privateKey);
     }
     /**
      * Apply an external (static) certificate into NetworkProxy
@@ -97,7 +75,8 @@ export class NetworkProxyBridge {
             console.log(`NetworkProxy not initialized: cannot apply external certificate for ${data.domain}`);
             return;
         }
-        this.handleCertificateEvent(data);
+        // Apply certificate directly to NetworkProxy
+        this.networkProxy.updateCertificate(data.domain, data.certificate, data.privateKey);
     }
     /**
      * Get the NetworkProxy instance
@@ -135,83 +114,6 @@ export class NetworkProxyBridge {
             }
         }
     }
-    /**
-     * 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) {
-        if (!this.port80Handler) {
-            console.log('Cannot register domains - Port80Handler not initialized');
-            return;
-        }
-        // Extract domains from routes that require TLS termination
-        const domainsToRegister = new Set();
-        for (const route of routes) {
-            // Skip routes without domains or TLS configuration
-            if (!route.match.domains || !route.action.tls)
-                continue;
-            // Only register domains for routes that terminate TLS
-            if (route.action.tls.mode !== 'terminate' && route.action.tls.mode !== 'terminate-and-reencrypt')
-                continue;
-            // Extract domains from route
-            const domains = Array.isArray(route.match.domains)
-                ? route.match.domains
-                : [route.match.domains];
-            // Add each domain to the set (avoiding duplicates)
-            for (const domain of domains) {
-                // Skip wildcards
-                if (domain.includes('*')) {
-                    console.log(`Skipping wildcard domain for ACME: ${domain}`);
-                    continue;
-                }
-                domainsToRegister.add(domain);
-            }
-        }
-        // Register each unique domain with Port80Handler
-        for (const domain of domainsToRegister) {
-            try {
-                this.port80Handler.addDomain({
-                    domainName: domain,
-                    sslRedirect: true,
-                    acmeMaintenance: true,
-                    // Include route reference if we can find it
-                    routeReference: this.findRouteReferenceForDomain(domain, routes)
-                });
-                console.log(`Registered domain with Port80Handler: ${domain}`);
-            }
-            catch (err) {
-                console.log(`Error registering domain ${domain} with Port80Handler: ${err}`);
-            }
-        }
-    }
-    /**
-     * 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
-     */
-    findRouteReferenceForDomain(domain, routes) {
-        // Find the first route that matches this domain
-        for (const route of routes) {
-            if (!route.match.domains)
-                continue;
-            const domains = Array.isArray(route.match.domains)
-                ? route.match.domains
-                : [route.match.domains];
-            if (domains.includes(domain)) {
-                return {
-                    routeId: undefined, // No explicit IDs in our current routes
-                    routeName: route.name
-                };
-            }
-        }
-        return undefined;
-    }
     /**
      * Forwards a TLS connection to a NetworkProxy for handling
      */
@@ -256,7 +158,6 @@ export class NetworkProxyBridge {
             // Now set up bidirectional piping between client and NetworkProxy
             socket.pipe(proxySocket);
             proxySocket.pipe(socket);
-            // Update activity on data transfer (caller should handle this)
             if (this.settings.enableDetailedLogging) {
                 console.log(`[${connectionId}] TLS connection successfully forwarded to NetworkProxy`);
             }
@@ -265,13 +166,8 @@ export 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
      */
@@ -281,118 +177,20 @@ export class NetworkProxyBridge {
             return;
         }
         try {
-            // Get SSL certificates from assets
-            // Import fs directly since it's not in plugins
-            const fs = await import('fs');
-            let defaultCertPair;
-            try {
-                defaultCertPair = {
-                    key: fs.readFileSync('assets/certs/key.pem', 'utf8'),
-                    cert: fs.readFileSync('assets/certs/cert.pem', 'utf8'),
-                };
-            }
-            catch (certError) {
-                console.log(`Warning: Could not read default certificates: ${certError}`);
-                console.log('Using empty certificate placeholders - ACME will generate proper certificates if enabled');
-                // Use empty placeholders - NetworkProxy will use its internal defaults
-                // or ACME will generate proper ones if enabled
-                defaultCertPair = {
-                    key: '',
-                    cert: '',
-                };
-            }
-            // Map routes directly to NetworkProxy configs
-            const proxyConfigs = this.mapRoutesToNetworkProxyConfigs(routes, defaultCertPair);
-            // Update the proxy configs
-            await this.networkProxy.updateProxyConfigs(proxyConfigs);
-            console.log(`Synced ${proxyConfigs.length} configurations to NetworkProxy`);
-            // Register domains with Port80Handler for certificate issuance
-            if (this.port80Handler) {
-                this.registerDomainsWithPort80Handler(routes);
-            }
+            // Filter only routes that are applicable to NetworkProxy (TLS termination)
+            const networkProxyRoutes = routes.filter(route => {
+                return (route.action.type === 'forward' &&
+                    route.action.tls &&
+                    (route.action.tls.mode === 'terminate' || route.action.tls.mode === 'terminate-and-reencrypt'));
+            });
+            // Pass routes directly to NetworkProxy
+            await this.networkProxy.updateRouteConfigs(networkProxyRoutes);
+            console.log(`Synced ${networkProxyRoutes.length} routes directly to NetworkProxy`);
         }
         catch (err) {
             console.log(`Error syncing routes to NetworkProxy: ${err}`);
         }
     }
-    /**
-     * 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, defaultCertPair) {
-        const configs = [];
-        for (const route of routes) {
-            // Skip routes without domains
-            if (!route.match.domains)
-                continue;
-            // Skip non-forward routes
-            if (route.action.type !== 'forward')
-                continue;
-            // Skip routes without TLS configuration
-            if (!route.action.tls || !route.action.target)
-                continue;
-            // Skip routes that don't require TLS termination
-            if (route.action.tls.mode !== 'terminate' && route.action.tls.mode !== 'terminate-and-reencrypt')
-                continue;
-            // Get domains from route
-            const domains = Array.isArray(route.match.domains)
-                ? route.match.domains
-                : [route.match.domains];
-            // Create a config for each domain
-            for (const domain of domains) {
-                // Get certificate
-                let certKey = defaultCertPair.key;
-                let certCert = defaultCertPair.cert;
-                // Use custom certificate if specified
-                if (route.action.tls.certificate !== 'auto' && typeof route.action.tls.certificate === 'object') {
-                    certKey = route.action.tls.certificate.key;
-                    certCert = route.action.tls.certificate.cert;
-                }
-                // Determine target hosts and ports
-                const targetHosts = Array.isArray(route.action.target.host)
-                    ? route.action.target.host
-                    : [route.action.target.host];
-                const targetPort = route.action.target.port;
-                // Create the NetworkProxy config
-                const config = {
-                    hostName: domain,
-                    privateKey: certKey,
-                    publicKey: certCert,
-                    destinationIps: targetHosts,
-                    destinationPorts: [targetPort]
-                    // Note: We can't include additional metadata as it's not supported in the interface
-                };
-                configs.push(config);
-            }
-        }
-        return configs;
-    }
-    /**
-     * @deprecated This method is kept for backward compatibility.
-     * Use mapRoutesToNetworkProxyConfigs() instead.
-     */
-    convertRoutesToNetworkProxyConfigs(routes, defaultCertPair) {
-        return this.mapRoutesToNetworkProxyConfigs(routes, defaultCertPair);
-    }
-    /**
-     * @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().
-     */
-    async syncDomainConfigsToNetworkProxy() {
-        console.log('DEPRECATED: Method syncDomainConfigsToNetworkProxy will be removed in a future version.');
-        console.log('Please use syncRoutesToNetworkProxy() instead for direct route-based configuration.');
-        await this.syncRoutesToNetworkProxy(this.settings.routes || []);
-    }
     /**
      * Request a certificate for a specific domain
      *
@@ -421,13 +219,6 @@ export class NetworkProxyBridge {
                         routeName
                     };
                 }
-                else {
-                    // Try to find a route reference from the current routes
-                    const routeReference = this.findRouteReferenceForDomain(domain, this.settings.routes || []);
-                    if (routeReference) {
-                        domainOptions.routeReference = routeReference;
-                    }
-                }
                 // Register the domain for certificate issuance
                 this.port80Handler.addDomain(domainOptions);
                 console.log(`Domain ${domain} registered for certificate issuance`);
@@ -463,4 +254,4 @@ export class NetworkProxyBridge {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"network-proxy-bridge.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/network-proxy-bridge.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"network-proxy-bridge.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/network-proxy-bridge.ts"],"names":[],"mappings":"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"}

package/dist_ts/proxies/smart-proxy/port-manager.d.ts

@@ -0,0 +1,81 @@
+import * as plugins from '../../plugins.js';
+import type { ISmartProxyOptions } from './models/interfaces.js';
+import { RouteConnectionHandler } from './route-connection-handler.js';
+/**
+ * PortManager handles the dynamic creation and removal of port listeners
+ *
+ * This class provides methods to add and remove listening ports at runtime,
+ * allowing SmartProxy to adapt to configuration changes without requiring
+ * a full restart.
+ */
+export declare class PortManager {
+    private servers;
+    private settings;
+    private routeConnectionHandler;
+    private isShuttingDown;
+    /**
+     * Create a new PortManager
+     *
+     * @param settings The SmartProxy settings
+     * @param routeConnectionHandler The handler for new connections
+     */
+    constructor(settings: ISmartProxyOptions, routeConnectionHandler: RouteConnectionHandler);
+    /**
+     * Start listening on a specific port
+     *
+     * @param port The port number to listen on
+     * @returns Promise that resolves when the server is listening or rejects on error
+     */
+    addPort(port: number): Promise<void>;
+    /**
+     * Stop listening on a specific port
+     *
+     * @param port The port to stop listening on
+     * @returns Promise that resolves when the server is closed
+     */
+    removePort(port: number): Promise<void>;
+    /**
+     * Add multiple ports at once
+     *
+     * @param ports Array of ports to add
+     * @returns Promise that resolves when all servers are listening
+     */
+    addPorts(ports: number[]): Promise<void>;
+    /**
+     * Remove multiple ports at once
+     *
+     * @param ports Array of ports to remove
+     * @returns Promise that resolves when all servers are closed
+     */
+    removePorts(ports: number[]): Promise<void>;
+    /**
+     * Update listening ports to match the provided list
+     *
+     * This will add any ports that aren't currently listening,
+     * and remove any ports that are no longer needed.
+     *
+     * @param ports Array of ports that should be listening
+     * @returns Promise that resolves when all operations are complete
+     */
+    updatePorts(ports: number[]): Promise<void>;
+    /**
+     * Get all ports that are currently listening
+     *
+     * @returns Array of port numbers
+     */
+    getListeningPorts(): number[];
+    /**
+     * Mark the port manager as shutting down
+     */
+    setShuttingDown(isShuttingDown: boolean): void;
+    /**
+     * Close all listening servers
+     *
+     * @returns Promise that resolves when all servers are closed
+     */
+    closeAll(): Promise<void>;
+    /**
+     * Get all server instances (for testing or debugging)
+     */
+    getServers(): Map<number, plugins.net.Server>;
+}

package/dist_ts/proxies/smart-proxy/port-manager.js

@@ -0,0 +1,166 @@
+import * as plugins from '../../plugins.js';
+import { RouteConnectionHandler } from './route-connection-handler.js';
+/**
+ * PortManager handles the dynamic creation and removal of port listeners
+ *
+ * This class provides methods to add and remove listening ports at runtime,
+ * allowing SmartProxy to adapt to configuration changes without requiring
+ * a full restart.
+ */
+export class PortManager {
+    /**
+     * Create a new PortManager
+     *
+     * @param settings The SmartProxy settings
+     * @param routeConnectionHandler The handler for new connections
+     */
+    constructor(settings, routeConnectionHandler) {
+        this.servers = new Map();
+        this.isShuttingDown = false;
+        this.settings = settings;
+        this.routeConnectionHandler = routeConnectionHandler;
+    }
+    /**
+     * Start listening on a specific port
+     *
+     * @param port The port number to listen on
+     * @returns Promise that resolves when the server is listening or rejects on error
+     */
+    async addPort(port) {
+        // Check if we're already listening on this port
+        if (this.servers.has(port)) {
+            console.log(`PortManager: Already listening on port ${port}`);
+            return;
+        }
+        // Create a server for this port
+        const server = plugins.net.createServer((socket) => {
+            // Check if shutting down
+            if (this.isShuttingDown) {
+                socket.end();
+                socket.destroy();
+                return;
+            }
+            // Delegate to route connection handler
+            this.routeConnectionHandler.handleConnection(socket);
+        }).on('error', (err) => {
+            console.log(`Server Error on port ${port}: ${err.message}`);
+        });
+        // Start listening on the port
+        return new Promise((resolve, reject) => {
+            server.listen(port, () => {
+                const isNetworkProxyPort = this.settings.useNetworkProxy?.includes(port);
+                console.log(`SmartProxy -> OK: Now listening on port ${port}${isNetworkProxyPort ? ' (NetworkProxy forwarding enabled)' : ''}`);
+                // Store the server reference
+                this.servers.set(port, server);
+                resolve();
+            }).on('error', (err) => {
+                console.log(`Failed to listen on port ${port}: ${err.message}`);
+                reject(err);
+            });
+        });
+    }
+    /**
+     * Stop listening on a specific port
+     *
+     * @param port The port to stop listening on
+     * @returns Promise that resolves when the server is closed
+     */
+    async removePort(port) {
+        // Get the server for this port
+        const server = this.servers.get(port);
+        if (!server) {
+            console.log(`PortManager: Not listening on port ${port}`);
+            return;
+        }
+        // Close the server
+        return new Promise((resolve) => {
+            server.close((err) => {
+                if (err) {
+                    console.log(`Error closing server on port ${port}: ${err.message}`);
+                }
+                else {
+                    console.log(`SmartProxy -> Stopped listening on port ${port}`);
+                }
+                // Remove the server reference
+                this.servers.delete(port);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Add multiple ports at once
+     *
+     * @param ports Array of ports to add
+     * @returns Promise that resolves when all servers are listening
+     */
+    async addPorts(ports) {
+        const uniquePorts = [...new Set(ports)];
+        await Promise.all(uniquePorts.map(port => this.addPort(port)));
+    }
+    /**
+     * Remove multiple ports at once
+     *
+     * @param ports Array of ports to remove
+     * @returns Promise that resolves when all servers are closed
+     */
+    async removePorts(ports) {
+        const uniquePorts = [...new Set(ports)];
+        await Promise.all(uniquePorts.map(port => this.removePort(port)));
+    }
+    /**
+     * Update listening ports to match the provided list
+     *
+     * This will add any ports that aren't currently listening,
+     * and remove any ports that are no longer needed.
+     *
+     * @param ports Array of ports that should be listening
+     * @returns Promise that resolves when all operations are complete
+     */
+    async updatePorts(ports) {
+        const targetPorts = new Set(ports);
+        const currentPorts = new Set(this.servers.keys());
+        // Find ports to add and remove
+        const portsToAdd = ports.filter(port => !currentPorts.has(port));
+        const portsToRemove = Array.from(currentPorts).filter(port => !targetPorts.has(port));
+        // Log the changes
+        if (portsToAdd.length > 0) {
+            console.log(`PortManager: Adding new listeners for ports: ${portsToAdd.join(', ')}`);
+        }
+        if (portsToRemove.length > 0) {
+            console.log(`PortManager: Removing listeners for ports: ${portsToRemove.join(', ')}`);
+        }
+        // Add and remove ports
+        await this.removePorts(portsToRemove);
+        await this.addPorts(portsToAdd);
+    }
+    /**
+     * Get all ports that are currently listening
+     *
+     * @returns Array of port numbers
+     */
+    getListeningPorts() {
+        return Array.from(this.servers.keys());
+    }
+    /**
+     * Mark the port manager as shutting down
+     */
+    setShuttingDown(isShuttingDown) {
+        this.isShuttingDown = isShuttingDown;
+    }
+    /**
+     * Close all listening servers
+     *
+     * @returns Promise that resolves when all servers are closed
+     */
+    async closeAll() {
+        const allPorts = Array.from(this.servers.keys());
+        await this.removePorts(allPorts);
+    }
+    /**
+     * Get all server instances (for testing or debugging)
+     */
+    getServers() {
+        return new Map(this.servers);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/proxies/smart-proxy/route-connection-handler.d.ts

@@ -17,7 +17,12 @@ export declare class RouteConnectionHandler {
     private timeoutManager;
     private routeManager;
     private settings;
+    private routeContextCache;
     constructor(settings: ISmartProxyOptions, connectionManager: ConnectionManager, securityManager: SecurityManager, tlsManager: TlsManager, networkProxyBridge: NetworkProxyBridge, timeoutManager: TimeoutManager, routeManager: RouteManager);
+    /**
+     * Create a route context object for port and host mapping functions
+     */
+    private createRouteContext;
     /**
      * Handle a new incoming connection
      */