@push.rocks/smartproxy 15.0.2 → 16.0.3

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

@@ -2,7 +2,6 @@ import * as plugins from '../../plugins.js';
 import type { ISmartProxyOptions } from './models/interfaces.js';
 import { ConnectionManager } from './connection-manager.js';
 import { SecurityManager } from './security-manager.js';
-import { DomainConfigManager } from './domain-config-manager.js';
 import { TlsManager } from './tls-manager.js';
 import { NetworkProxyBridge } from './network-proxy-bridge.js';
 import { TimeoutManager } from './timeout-manager.js';
@@ -13,13 +12,17 @@ import { RouteManager } from './route-manager.js';
 export declare class RouteConnectionHandler {
     private connectionManager;
     private securityManager;
-    private domainConfigManager;
     private tlsManager;
     private networkProxyBridge;
     private timeoutManager;
     private routeManager;
     private settings;
-    constructor(settings: ISmartProxyOptions, connectionManager: ConnectionManager, securityManager: SecurityManager, domainConfigManager: DomainConfigManager, tlsManager: TlsManager, networkProxyBridge: NetworkProxyBridge, timeoutManager: TimeoutManager, routeManager: RouteManager);
+    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
      */
@@ -45,9 +48,8 @@ export declare class RouteConnectionHandler {
      */
     private handleBlockAction;
     /**
-     * Handle a connection using legacy domain configuration
+     * Legacy connection handling has been removed in favor of pure route-based approach
      */
-    private handleLegacyConnection;
     /**
      * Sets up a direct connection to the target
      */