@push.rocks/smartproxy 21.1.3 → 21.1.6

package/dist_ts/proxies/smart-proxy/metrics-collector.js

@@ -14,6 +14,10 @@ export class MetricsCollector {
         this.totalRequests = 0;
         // Connection byte tracking for per-route/IP metrics
         this.connectionByteTrackers = new Map();
+        // Track connection durations for percentile calculations
+        this.connectionDurations = [];
+        this.bytesInArray = [];
+        this.bytesOutArray = [];
         // Connection metrics implementation
         this.connections = {
             active: () => {
@@ -142,17 +146,27 @@ export class MetricsCollector {
                 return this.connections.total();
             }
         };
-        // Percentiles implementation (placeholder for now)
+        // Percentiles implementation
         this.percentiles = {
             connectionDuration: () => {
-                // TODO: Implement percentile calculations
-                return { p50: 0, p95: 0, p99: 0 };
+                return {
+                    p50: this.calculatePercentile(this.connectionDurations, 0.5),
+                    p95: this.calculatePercentile(this.connectionDurations, 0.95),
+                    p99: this.calculatePercentile(this.connectionDurations, 0.99)
+                };
             },
             bytesTransferred: () => {
-                // TODO: Implement percentile calculations
                 return {
-                    in: { p50: 0, p95: 0, p99: 0 },
-                    out: { p50: 0, p95: 0, p99: 0 }
+                    in: {
+                        p50: this.calculatePercentile(this.bytesInArray, 0.5),
+                        p95: this.calculatePercentile(this.bytesInArray, 0.95),
+                        p99: this.calculatePercentile(this.bytesInArray, 0.99)
+                    },
+                    out: {
+                        p50: this.calculatePercentile(this.bytesOutArray, 0.5),
+                        p95: this.calculatePercentile(this.bytesOutArray, 0.95),
+                        p99: this.calculatePercentile(this.bytesOutArray, 0.99)
+                    }
                 };
             }
         };
@@ -160,6 +174,14 @@ export class MetricsCollector {
         this.retentionSeconds = config?.retentionSeconds || 3600;
         this.throughputTracker = new ThroughputTracker(this.retentionSeconds);
     }
+    // Helper to calculate percentiles from an array
+    calculatePercentile(arr, percentile) {
+        if (arr.length === 0)
+            return 0;
+        const sorted = [...arr].sort((a, b) => a - b);
+        const index = Math.floor((sorted.length - 1) * percentile);
+        return sorted[index];
+    }
     /**
      * Record a new request
      */
@@ -220,6 +242,25 @@ export class MetricsCollector {
      * Clean up tracking for a closed connection
      */
     removeConnection(connectionId) {
+        const tracker = this.connectionByteTrackers.get(connectionId);
+        if (tracker) {
+            // Calculate connection duration
+            const duration = Date.now() - tracker.startTime;
+            // Add to arrays for percentile calculations (bounded to prevent memory growth)
+            const MAX_SAMPLES = 5000;
+            this.connectionDurations.push(duration);
+            if (this.connectionDurations.length > MAX_SAMPLES) {
+                this.connectionDurations.shift();
+            }
+            this.bytesInArray.push(tracker.bytesIn);
+            if (this.bytesInArray.length > MAX_SAMPLES) {
+                this.bytesInArray.shift();
+            }
+            this.bytesOutArray.push(tracker.bytesOut);
+            if (this.bytesOutArray.length > MAX_SAMPLES) {
+                this.bytesOutArray.shift();
+            }
+        }
         this.connectionByteTrackers.delete(connectionId);
     }
     /**
@@ -263,6 +304,10 @@ export class MetricsCollector {
                 }
             }
         }, this.sampleIntervalMs);
+        // Unref the interval so it doesn't keep the process alive
+        if (this.samplingInterval.unref) {
+            this.samplingInterval.unref();
+        }
         // Subscribe to new connections
         this.connectionSubscription = this.smartProxy.routeConnectionHandler.newConnectionSubject.subscribe({
             next: (record) => {
@@ -307,4 +352,4 @@ export class MetricsCollector {
         this.stop();
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"metrics-collector.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/metrics-collector.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"metrics-collector.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/metrics-collector.ts"],"names":[],"mappings":"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"}

package/dist_ts/proxies/smart-proxy/route-orchestrator.d.ts

@@ -0,0 +1,56 @@
+import type { IRouteConfig } from './models/route-types.js';
+import type { ILogger } from '../http-proxy/models/types.js';
+import type { PortManager } from './port-manager.js';
+import type { SharedRouteManager as RouteManager } from '../../core/routing/route-manager.js';
+import type { HttpProxyBridge } from './http-proxy-bridge.js';
+import type { NFTablesManager } from './nftables-manager.js';
+import type { SmartCertManager } from './certificate-manager.js';
+/**
+ * Orchestrates route updates and coordination between components
+ * Extracted from SmartProxy to reduce class complexity
+ */
+export declare class RouteOrchestrator {
+    private routeUpdateLock;
+    private portManager;
+    private routeManager;
+    private httpProxyBridge;
+    private nftablesManager;
+    private certManager;
+    private logger;
+    constructor(portManager: PortManager, routeManager: RouteManager, httpProxyBridge: HttpProxyBridge, nftablesManager: NFTablesManager, certManager: SmartCertManager | null, logger: ILogger);
+    /**
+     * Set or update certificate manager reference
+     */
+    setCertManager(certManager: SmartCertManager | null): void;
+    /**
+     * Get certificate manager reference
+     */
+    getCertManager(): SmartCertManager | null;
+    /**
+     * Update routes with validation and coordination
+     */
+    updateRoutes(oldRoutes: IRouteConfig[], newRoutes: IRouteConfig[], options?: {
+        acmePort?: number;
+        acmeOptions?: any;
+        acmeState?: any;
+        globalChallengeRouteActive?: boolean;
+        createCertificateManager?: (routes: IRouteConfig[], certStore: string, acmeOptions?: any, initialState?: any) => Promise<SmartCertManager>;
+        verifyChallengeRouteRemoved?: () => Promise<void>;
+    }): Promise<{
+        portUsageMap: Map<number, Set<string>>;
+        newChallengeRouteActive: boolean;
+        newCertManager?: SmartCertManager;
+    }>;
+    /**
+     * Update port usage map based on the provided routes
+     */
+    updatePortUsageMap(routes: IRouteConfig[]): Map<number, Set<string>>;
+    /**
+     * Find ports that have no routes in the new configuration
+     */
+    private findOrphanedPorts;
+    /**
+     * Update NFTables routes
+     */
+    private updateNfTablesRoutes;
+}

package/dist_ts/proxies/smart-proxy/route-orchestrator.js

@@ -0,0 +1,204 @@
+import { logger } from '../../core/utils/logger.js';
+import { RouteValidator } from './utils/route-validator.js';
+import { Mutex } from './utils/mutex.js';
+/**
+ * Orchestrates route updates and coordination between components
+ * Extracted from SmartProxy to reduce class complexity
+ */
+export class RouteOrchestrator {
+    constructor(portManager, routeManager, httpProxyBridge, nftablesManager, certManager, logger) {
+        this.certManager = null;
+        this.portManager = portManager;
+        this.routeManager = routeManager;
+        this.httpProxyBridge = httpProxyBridge;
+        this.nftablesManager = nftablesManager;
+        this.certManager = certManager;
+        this.logger = logger;
+        this.routeUpdateLock = new Mutex();
+    }
+    /**
+     * Set or update certificate manager reference
+     */
+    setCertManager(certManager) {
+        this.certManager = certManager;
+    }
+    /**
+     * Get certificate manager reference
+     */
+    getCertManager() {
+        return this.certManager;
+    }
+    /**
+     * Update routes with validation and coordination
+     */
+    async updateRoutes(oldRoutes, newRoutes, options = {}) {
+        return this.routeUpdateLock.runExclusive(async () => {
+            // Validate route configurations
+            const validation = RouteValidator.validateRoutes(newRoutes);
+            if (!validation.valid) {
+                RouteValidator.logValidationErrors(validation.errors);
+                throw new Error(`Route validation failed: ${validation.errors.size} route(s) have errors`);
+            }
+            // Track port usage before and after updates
+            const oldPortUsage = this.updatePortUsageMap(oldRoutes);
+            const newPortUsage = this.updatePortUsageMap(newRoutes);
+            // Get the lists of currently listening ports and new ports needed
+            const currentPorts = new Set(this.portManager.getListeningPorts());
+            const newPortsSet = new Set(newPortUsage.keys());
+            // Log the port usage for debugging
+            this.logger.debug(`Current listening ports: ${Array.from(currentPorts).join(', ')}`);
+            this.logger.debug(`Ports needed for new routes: ${Array.from(newPortsSet).join(', ')}`);
+            // Find orphaned ports - ports that no longer have any routes
+            const orphanedPorts = this.findOrphanedPorts(oldPortUsage, newPortUsage);
+            // Find new ports that need binding (only ports that we aren't already listening on)
+            const newBindingPorts = Array.from(newPortsSet).filter(p => !currentPorts.has(p));
+            // Check for ACME challenge port to give it special handling
+            const acmePort = options.acmePort || 80;
+            const acmePortNeeded = newPortsSet.has(acmePort);
+            const acmePortListed = newBindingPorts.includes(acmePort);
+            if (acmePortNeeded && acmePortListed) {
+                this.logger.info(`Adding ACME challenge port ${acmePort} to routes`);
+            }
+            // Update NFTables routes
+            await this.updateNfTablesRoutes(oldRoutes, newRoutes);
+            // Update routes in RouteManager
+            this.routeManager.updateRoutes(newRoutes);
+            // Release orphaned ports first to free resources
+            if (orphanedPorts.length > 0) {
+                this.logger.info(`Releasing ${orphanedPorts.length} orphaned ports: ${orphanedPorts.join(', ')}`);
+                await this.portManager.removePorts(orphanedPorts);
+            }
+            // Add new ports if needed
+            if (newBindingPorts.length > 0) {
+                this.logger.info(`Binding to ${newBindingPorts.length} new ports: ${newBindingPorts.join(', ')}`);
+                // Handle port binding with improved error recovery
+                try {
+                    await this.portManager.addPorts(newBindingPorts);
+                }
+                catch (error) {
+                    // Special handling for port binding errors
+                    if (error.code === 'EADDRINUSE') {
+                        const port = error.port || newBindingPorts[0];
+                        const isAcmePort = port === acmePort;
+                        if (isAcmePort) {
+                            this.logger.warn(`Could not bind to ACME challenge port ${port}. It may be in use by another application.`);
+                            // Re-throw with more helpful message
+                            throw new Error(`ACME challenge port ${port} is already in use by another application. ` +
+                                `Configure a different port in settings.acme.port (e.g., 8080) or free up port ${port}.`);
+                        }
+                    }
+                    // Re-throw the original error for other cases
+                    throw error;
+                }
+            }
+            // If HttpProxy is initialized, resync the configurations
+            if (this.httpProxyBridge.getHttpProxy()) {
+                await this.httpProxyBridge.syncRoutesToHttpProxy(newRoutes);
+            }
+            // Update certificate manager if needed
+            let newCertManager;
+            let newChallengeRouteActive = options.globalChallengeRouteActive || false;
+            if (this.certManager && options.createCertificateManager) {
+                const existingAcmeOptions = this.certManager.getAcmeOptions();
+                const existingState = this.certManager.getState();
+                // Store global state before stopping
+                newChallengeRouteActive = existingState.challengeRouteActive;
+                // Keep certificate manager routes in sync before stopping
+                this.certManager.setRoutes(newRoutes);
+                await this.certManager.stop();
+                // Verify the challenge route has been properly removed
+                if (options.verifyChallengeRouteRemoved) {
+                    await options.verifyChallengeRouteRemoved();
+                }
+                // Create new certificate manager with preserved state
+                newCertManager = await options.createCertificateManager(newRoutes, './certs', existingAcmeOptions, { challengeRouteActive: newChallengeRouteActive });
+                this.certManager = newCertManager;
+            }
+            return {
+                portUsageMap: newPortUsage,
+                newChallengeRouteActive,
+                newCertManager
+            };
+        });
+    }
+    /**
+     * Update port usage map based on the provided routes
+     */
+    updatePortUsageMap(routes) {
+        const portUsage = new Map();
+        for (const route of routes) {
+            // Get the ports for this route
+            const portsConfig = Array.isArray(route.match.ports)
+                ? route.match.ports
+                : [route.match.ports];
+            // Expand port range objects to individual port numbers
+            const expandedPorts = [];
+            for (const portConfig of portsConfig) {
+                if (typeof portConfig === 'number') {
+                    expandedPorts.push(portConfig);
+                }
+                else if (typeof portConfig === 'object' && 'from' in portConfig && 'to' in portConfig) {
+                    // Expand the port range
+                    for (let p = portConfig.from; p <= portConfig.to; p++) {
+                        expandedPorts.push(p);
+                    }
+                }
+            }
+            // Use route name if available, otherwise generate a unique ID
+            const routeName = route.name || `unnamed_${Math.random().toString(36).substring(2, 9)}`;
+            // Add each port to the usage map
+            for (const port of expandedPorts) {
+                if (!portUsage.has(port)) {
+                    portUsage.set(port, new Set());
+                }
+                portUsage.get(port).add(routeName);
+            }
+        }
+        // Log port usage for debugging
+        for (const [port, routes] of portUsage.entries()) {
+            this.logger.debug(`Port ${port} is used by ${routes.size} routes: ${Array.from(routes).join(', ')}`);
+        }
+        return portUsage;
+    }
+    /**
+     * Find ports that have no routes in the new configuration
+     */
+    findOrphanedPorts(oldUsage, newUsage) {
+        const orphanedPorts = [];
+        for (const [port, routes] of oldUsage.entries()) {
+            if (!newUsage.has(port) || newUsage.get(port).size === 0) {
+                orphanedPorts.push(port);
+            }
+        }
+        return orphanedPorts;
+    }
+    /**
+     * Update NFTables routes
+     */
+    async updateNfTablesRoutes(oldRoutes, newRoutes) {
+        // Get existing routes that use NFTables and update them
+        const oldNfTablesRoutes = oldRoutes.filter(r => r.action.forwardingEngine === 'nftables');
+        const newNfTablesRoutes = newRoutes.filter(r => r.action.forwardingEngine === 'nftables');
+        // Update existing NFTables routes
+        for (const oldRoute of oldNfTablesRoutes) {
+            const newRoute = newNfTablesRoutes.find(r => r.name === oldRoute.name);
+            if (!newRoute) {
+                // Route was removed
+                await this.nftablesManager.deprovisionRoute(oldRoute);
+            }
+            else {
+                // Route was updated
+                await this.nftablesManager.updateRoute(oldRoute, newRoute);
+            }
+        }
+        // Add new NFTables routes
+        for (const newRoute of newNfTablesRoutes) {
+            const oldRoute = oldNfTablesRoutes.find(r => r.name === newRoute.name);
+            if (!oldRoute) {
+                // New route
+                await this.nftablesManager.provisionRoute(newRoute);
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route-orchestrator.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/route-orchestrator.ts"],"names":[],"mappings":"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"}

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

@@ -114,8 +114,19 @@ export class SecurityManager {
         const normalizedIPVariants = normalizeIP(ip);
         if (normalizedIPVariants.length === 0)
             return false;
-        // Normalize the pattern IPs for consistent comparison
-        const expandedPatterns = patterns.flatMap(normalizeIP);
+        // Expand shorthand patterns and normalize IPs for consistent comparison
+        const expandShorthand = (pattern) => {
+            // Expand shorthand IP patterns like '192.168.*' to '192.168.*.*'
+            if (pattern.includes('*') && !pattern.includes(':')) {
+                const parts = pattern.split('.');
+                while (parts.length < 4) {
+                    parts.push('*');
+                }
+                return parts.join('.');
+            }
+            return pattern;
+        };
+        const expandedPatterns = patterns.map(expandShorthand).flatMap(normalizeIP);
         // Check for any match between normalized IP variants and patterns
         return normalizedIPVariants.some((ipVariant) => expandedPatterns.some((pattern) => plugins.minimatch(ipVariant, pattern)));
     }
@@ -207,4 +218,4 @@ export class SecurityManager {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"security-manager.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/security-manager.ts"],"names":[],"mappings":"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"}

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

@@ -43,6 +43,7 @@ export declare class SmartProxy extends plugins.EventEmitter {
     private routeUpdateLock;
     acmeStateManager: AcmeStateManager;
     metricsCollector: MetricsCollector;
+    private routeOrchestrator;
     private portUsageMap;
     /**
      * Constructor for SmartProxy
@@ -144,17 +145,6 @@ export declare class SmartProxy extends plugins.EventEmitter {
      * Manually provision a certificate for a route
      */
     provisionCertificate(routeName: string): Promise<void>;
-    /**
-     * Update the port usage map based on the provided routes
-     *
-     * This tracks which ports are used by which routes, allowing us to
-     * detect when a port is no longer needed and can be released.
-     */
-    private updatePortUsageMap;
-    /**
-     * Find ports that have no routes in the new configuration
-     */
-    private findOrphanedPorts;
     /**
      * Force renewal of a certificate
      */