@push.rocks/smartproxy 19.6.6 → 19.6.8

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

@@ -1,5 +1,5 @@
 import * as plugins from '../../plugins.js';
-import type { ISmartProxyOptions } from './models/interfaces.js';
+import type { SmartProxy } from './smart-proxy.js';
 
 /**
  * Handles security aspects like IP tracking, rate limiting, and authorization
@@ -8,7 +8,7 @@ export class SecurityManager {
   private connectionsByIP: Map<string, Set<string>> = new Map();
   private connectionRateByIP: Map<string, number[]> = new Map();
 
-  constructor(private settings: ISmartProxyOptions) {}
+  constructor(private smartProxy: SmartProxy) {}
   
   /**
    * Get connections count by IP
@@ -36,7 +36,7 @@ export class SecurityManager {
     this.connectionRateByIP.set(ip, timestamps);
 
     // Check if rate exceeds limit
-    return timestamps.length <= this.settings.connectionRateLimitPerMinute!;
+    return timestamps.length <= this.smartProxy.settings.connectionRateLimitPerMinute!;
   }
   
   /**
@@ -137,23 +137,23 @@ export class SecurityManager {
   public validateIP(ip: string): { allowed: boolean; reason?: string } {
     // Check connection count limit
     if (
-      this.settings.maxConnectionsPerIP &&
-      this.getConnectionCountByIP(ip) >= this.settings.maxConnectionsPerIP
+      this.smartProxy.settings.maxConnectionsPerIP &&
+      this.getConnectionCountByIP(ip) >= this.smartProxy.settings.maxConnectionsPerIP
     ) {
       return {
         allowed: false,
-        reason: `Maximum connections per IP (${this.settings.maxConnectionsPerIP}) exceeded`
+        reason: `Maximum connections per IP (${this.smartProxy.settings.maxConnectionsPerIP}) exceeded`
       };
     }
 
     // Check connection rate limit
     if (
-      this.settings.connectionRateLimitPerMinute && 
+      this.smartProxy.settings.connectionRateLimitPerMinute && 
       !this.checkConnectionRate(ip)
     ) {
       return {
         allowed: false,
-        reason: `Connection rate limit (${this.settings.connectionRateLimitPerMinute}/min) exceeded`
+        reason: `Connection rate limit (${this.smartProxy.settings.connectionRateLimitPerMinute}/min) exceeded`
       };
     }
     

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

@@ -29,7 +29,7 @@ import { AcmeStateManager } from './acme-state-manager.js';
 
 // Import metrics collector
 import { MetricsCollector } from './metrics-collector.js';
-import type { IProxyStats } from './models/metrics-types.js';
+import type { IMetrics } from './models/metrics-types.js';
 
 /**
  * SmartProxy - Pure route-based API
@@ -52,24 +52,24 @@ export class SmartProxy extends plugins.EventEmitter {
   
   // Component managers
   public connectionManager: ConnectionManager;
-  private securityManager: SecurityManager;
-  private tlsManager: TlsManager;
-  private httpProxyBridge: HttpProxyBridge;
-  private timeoutManager: TimeoutManager;
-  public routeManager: RouteManager; // Made public for route management
-  public routeConnectionHandler: RouteConnectionHandler; // Made public for metrics
-  private nftablesManager: NFTablesManager;
+  public securityManager: SecurityManager;
+  public tlsManager: TlsManager;
+  public httpProxyBridge: HttpProxyBridge;
+  public timeoutManager: TimeoutManager;
+  public routeManager: RouteManager;
+  public routeConnectionHandler: RouteConnectionHandler;
+  public nftablesManager: NFTablesManager;
   
   // Certificate manager for ACME and static certificates
-  private certManager: SmartCertManager | null = null;
+  public certManager: SmartCertManager | null = null;
   
   // Global challenge route tracking
   private globalChallengeRouteActive: boolean = false;
   private routeUpdateLock: any = null; // Will be initialized as AsyncMutex
-  private acmeStateManager: AcmeStateManager;
+  public acmeStateManager: AcmeStateManager;
   
   // Metrics collector
-  private metricsCollector: MetricsCollector;
+  public metricsCollector: MetricsCollector;
   
   // Track port usage across route updates
   private portUsageMap: Map<number, Set<string>> = new Map();
@@ -161,13 +161,9 @@ export class SmartProxy extends plugins.EventEmitter {
     }
     
     // Initialize component managers
-    this.timeoutManager = new TimeoutManager(this.settings);
-    this.securityManager = new SecurityManager(this.settings);
-    this.connectionManager = new ConnectionManager(
-      this.settings, 
-      this.securityManager, 
-      this.timeoutManager
-    );
+    this.timeoutManager = new TimeoutManager(this);
+    this.securityManager = new SecurityManager(this);
+    this.connectionManager = new ConnectionManager(this);
     
     // Create the route manager with SharedRouteManager API
     // Create a logger adapter to match ILogger interface
@@ -186,25 +182,17 @@ export class SmartProxy extends plugins.EventEmitter {
 
     
     // Create other required components
-    this.tlsManager = new TlsManager(this.settings);
-    this.httpProxyBridge = new HttpProxyBridge(this.settings);
+    this.tlsManager = new TlsManager(this);
+    this.httpProxyBridge = new HttpProxyBridge(this);
     
     // Initialize connection handler with route support
-    this.routeConnectionHandler = new RouteConnectionHandler(
-      this.settings,
-      this.connectionManager,
-      this.securityManager,
-      this.tlsManager,
-      this.httpProxyBridge,
-      this.timeoutManager,
-      this.routeManager
-    );
+    this.routeConnectionHandler = new RouteConnectionHandler(this);
 
     // Initialize port manager
-    this.portManager = new PortManager(this.settings, this.routeConnectionHandler);
+    this.portManager = new PortManager(this);
     
     // Initialize NFTablesManager
-    this.nftablesManager = new NFTablesManager(this.settings);
+    this.nftablesManager = new NFTablesManager(this);
     
     // Initialize route update mutex for synchronization
     this.routeUpdateLock = new Mutex();
@@ -213,7 +201,10 @@ export class SmartProxy extends plugins.EventEmitter {
     this.acmeStateManager = new AcmeStateManager();
     
     // Initialize metrics collector with reference to this SmartProxy instance
-    this.metricsCollector = new MetricsCollector(this);
+    this.metricsCollector = new MetricsCollector(this, {
+      sampleIntervalMs: this.settings.metrics?.sampleIntervalMs,
+      retentionSeconds: this.settings.metrics?.retentionSeconds
+    });
   }
   
   /**
@@ -922,11 +913,11 @@ export class SmartProxy extends plugins.EventEmitter {
   }
   
   /**
-   * Get proxy statistics and metrics
+   * Get proxy metrics with clean API
    * 
-   * @returns IProxyStats interface with various metrics methods
+   * @returns IMetrics interface with grouped metrics methods
    */
-  public getStats(): IProxyStats {
+  public getMetrics(): IMetrics {
     return this.metricsCollector;
   }
   

package/ts/proxies/smart-proxy/throughput-tracker.ts

@@ -0,0 +1,144 @@
+import type { IThroughputSample, IThroughputData, IThroughputHistoryPoint } from './models/metrics-types.js';
+
+/**
+ * Tracks throughput data using time-series sampling
+ */
+export class ThroughputTracker {
+  private samples: IThroughputSample[] = [];
+  private readonly maxSamples: number;
+  private accumulatedBytesIn: number = 0;
+  private accumulatedBytesOut: number = 0;
+  private lastSampleTime: number = 0;
+  
+  constructor(retentionSeconds: number = 3600) {
+    // Keep samples for the retention period at 1 sample per second
+    this.maxSamples = retentionSeconds;
+  }
+  
+  /**
+   * Record bytes transferred (called on every data transfer)
+   */
+  public recordBytes(bytesIn: number, bytesOut: number): void {
+    this.accumulatedBytesIn += bytesIn;
+    this.accumulatedBytesOut += bytesOut;
+  }
+  
+  /**
+   * Take a sample of accumulated bytes (called every second)
+   */
+  public takeSample(): void {
+    const now = Date.now();
+    
+    // Record accumulated bytes since last sample
+    this.samples.push({
+      timestamp: now,
+      bytesIn: this.accumulatedBytesIn,
+      bytesOut: this.accumulatedBytesOut
+    });
+    
+    // Reset accumulators
+    this.accumulatedBytesIn = 0;
+    this.accumulatedBytesOut = 0;
+    this.lastSampleTime = now;
+    
+    // Maintain circular buffer - remove oldest samples
+    if (this.samples.length > this.maxSamples) {
+      this.samples.shift();
+    }
+  }
+  
+  /**
+   * Get throughput rate over specified window (bytes per second)
+   */
+  public getRate(windowSeconds: number): IThroughputData {
+    if (this.samples.length === 0) {
+      return { in: 0, out: 0 };
+    }
+    
+    const now = Date.now();
+    const windowStart = now - (windowSeconds * 1000);
+    
+    // Find samples within the window
+    const relevantSamples = this.samples.filter(s => s.timestamp > windowStart);
+    
+    if (relevantSamples.length === 0) {
+      return { in: 0, out: 0 };
+    }
+    
+    // Sum bytes in the window
+    const totalBytesIn = relevantSamples.reduce((sum, s) => sum + s.bytesIn, 0);
+    const totalBytesOut = relevantSamples.reduce((sum, s) => sum + s.bytesOut, 0);
+    
+    // Calculate actual window duration (might be less than requested if not enough data)
+    const actualWindowSeconds = Math.min(
+      windowSeconds,
+      (now - relevantSamples[0].timestamp) / 1000
+    );
+    
+    // Avoid division by zero
+    if (actualWindowSeconds === 0) {
+      return { in: 0, out: 0 };
+    }
+    
+    return {
+      in: Math.round(totalBytesIn / actualWindowSeconds),
+      out: Math.round(totalBytesOut / actualWindowSeconds)
+    };
+  }
+  
+  /**
+   * Get throughput history for specified duration
+   */
+  public getHistory(durationSeconds: number): IThroughputHistoryPoint[] {
+    const now = Date.now();
+    const startTime = now - (durationSeconds * 1000);
+    
+    // Filter samples within duration
+    const relevantSamples = this.samples.filter(s => s.timestamp > startTime);
+    
+    // Convert to history points with per-second rates
+    const history: IThroughputHistoryPoint[] = [];
+    
+    for (let i = 0; i < relevantSamples.length; i++) {
+      const sample = relevantSamples[i];
+      
+      // For the first sample or samples after gaps, we can't calculate rate
+      if (i === 0 || sample.timestamp - relevantSamples[i - 1].timestamp > 2000) {
+        history.push({
+          timestamp: sample.timestamp,
+          in: sample.bytesIn,
+          out: sample.bytesOut
+        });
+      } else {
+        // Calculate rate based on time since previous sample
+        const prevSample = relevantSamples[i - 1];
+        const timeDelta = (sample.timestamp - prevSample.timestamp) / 1000;
+        
+        history.push({
+          timestamp: sample.timestamp,
+          in: Math.round(sample.bytesIn / timeDelta),
+          out: Math.round(sample.bytesOut / timeDelta)
+        });
+      }
+    }
+    
+    return history;
+  }
+  
+  /**
+   * Clear all samples
+   */
+  public clear(): void {
+    this.samples = [];
+    this.accumulatedBytesIn = 0;
+    this.accumulatedBytesOut = 0;
+    this.lastSampleTime = 0;
+  }
+  
+  /**
+   * Get sample count for debugging
+   */
+  public getSampleCount(): number {
+    return this.samples.length;
+  }
+}

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

@@ -1,10 +1,11 @@
-import type { IConnectionRecord, ISmartProxyOptions } from './models/interfaces.js';
+import type { IConnectionRecord } from './models/interfaces.js';
+import type { SmartProxy } from './smart-proxy.js';
 
 /**
  * Manages timeouts and inactivity tracking for connections
  */
 export class TimeoutManager {
-  constructor(private settings: ISmartProxyOptions) {}
+  constructor(private smartProxy: SmartProxy) {}
   
   /**
    * Ensure timeout values don't exceed Node.js max safe integer
@@ -41,16 +42,16 @@ export class TimeoutManager {
    * Calculate effective inactivity timeout based on connection type
    */
   public getEffectiveInactivityTimeout(record: IConnectionRecord): number {
-    let effectiveTimeout = this.settings.inactivityTimeout || 14400000; // 4 hours default
+    let effectiveTimeout = this.smartProxy.settings.inactivityTimeout || 14400000; // 4 hours default
     
     // For immortal keep-alive connections, use an extremely long timeout
-    if (record.hasKeepAlive && this.settings.keepAliveTreatment === 'immortal') {
+    if (record.hasKeepAlive && this.smartProxy.settings.keepAliveTreatment === 'immortal') {
       return Number.MAX_SAFE_INTEGER;
     }
     
     // For extended keep-alive connections, apply multiplier
-    if (record.hasKeepAlive && this.settings.keepAliveTreatment === 'extended') {
-      const multiplier = this.settings.keepAliveInactivityMultiplier || 6;
+    if (record.hasKeepAlive && this.smartProxy.settings.keepAliveTreatment === 'extended') {
+      const multiplier = this.smartProxy.settings.keepAliveInactivityMultiplier || 6;
       effectiveTimeout = effectiveTimeout * multiplier;
     }
     
@@ -63,23 +64,23 @@ export class TimeoutManager {
   public getEffectiveMaxLifetime(record: IConnectionRecord): number {
     // Use route-specific timeout if available from the routeConfig
     const baseTimeout = record.routeConfig?.action.advanced?.timeout ||
-                        this.settings.maxConnectionLifetime ||
+                        this.smartProxy.settings.maxConnectionLifetime ||
                         86400000; // 24 hours default
     
     // For immortal keep-alive connections, use an extremely long lifetime
-    if (record.hasKeepAlive && this.settings.keepAliveTreatment === 'immortal') {
+    if (record.hasKeepAlive && this.smartProxy.settings.keepAliveTreatment === 'immortal') {
       return Number.MAX_SAFE_INTEGER;
     }
     
     // For extended keep-alive connections, use the extended lifetime setting
-    if (record.hasKeepAlive && this.settings.keepAliveTreatment === 'extended') {
+    if (record.hasKeepAlive && this.smartProxy.settings.keepAliveTreatment === 'extended') {
       return this.ensureSafeTimeout(
-        this.settings.extendedKeepAliveLifetime || 7 * 24 * 60 * 60 * 1000 // 7 days default
+        this.smartProxy.settings.extendedKeepAliveLifetime || 7 * 24 * 60 * 60 * 1000 // 7 days default
       );
     }
     
     // Apply randomization if enabled
-    if (this.settings.enableRandomizedTimeouts) {
+    if (this.smartProxy.settings.enableRandomizedTimeouts) {
       return this.randomizeTimeout(baseTimeout);
     }
     
@@ -93,12 +94,17 @@ export class TimeoutManager {
   public setupConnectionTimeout(
     record: IConnectionRecord,
     onTimeout: (record: IConnectionRecord, reason: string) => void
-  ): NodeJS.Timeout {
+  ): NodeJS.Timeout | null {
     // Clear any existing timer
     if (record.cleanupTimer) {
       clearTimeout(record.cleanupTimer);
     }
     
+    // Skip timeout for immortal keep-alive connections
+    if (record.hasKeepAlive && this.smartProxy.settings.keepAliveTreatment === 'immortal') {
+      return null;
+    }
+    
     // Calculate effective timeout
     const effectiveLifetime = this.getEffectiveMaxLifetime(record);
     
@@ -127,7 +133,7 @@ export class TimeoutManager {
     effectiveTimeout: number;
   } {
     // Skip for connections with inactivity check disabled
-    if (this.settings.disableInactivityCheck) {
+    if (this.smartProxy.settings.disableInactivityCheck) {
       return {
         isInactive: false,
         shouldWarn: false,
@@ -137,7 +143,7 @@ export class TimeoutManager {
     }
     
     // Skip for immortal keep-alive connections
-    if (record.hasKeepAlive && this.settings.keepAliveTreatment === 'immortal') {
+    if (record.hasKeepAlive && this.smartProxy.settings.keepAliveTreatment === 'immortal') {
       return {
         isInactive: false,
         shouldWarn: false,
@@ -171,7 +177,7 @@ export class TimeoutManager {
    */
   public applySocketTimeouts(record: IConnectionRecord): void {
     // Skip for immortal keep-alive connections
-    if (record.hasKeepAlive && this.settings.keepAliveTreatment === 'immortal') {
+    if (record.hasKeepAlive && this.smartProxy.settings.keepAliveTreatment === 'immortal') {
       // Disable timeouts completely for immortal connections
       record.incoming.setTimeout(0);
       if (record.outgoing) {
@@ -181,7 +187,7 @@ export class TimeoutManager {
     }
     
     // Apply normal timeouts
-    const timeout = this.ensureSafeTimeout(this.settings.socketTimeout || 3600000); // 1 hour default
+    const timeout = this.ensureSafeTimeout(this.smartProxy.settings.socketTimeout || 3600000); // 1 hour default
     record.incoming.setTimeout(timeout);
     if (record.outgoing) {
       record.outgoing.setTimeout(timeout);

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

@@ -1,6 +1,6 @@
 import * as plugins from '../../plugins.js';
-import type { ISmartProxyOptions } from './models/interfaces.js';
 import { SniHandler } from '../../tls/sni/sni-handler.js';
+import type { SmartProxy } from './smart-proxy.js';
 
 /**
  * Interface for connection information used for SNI extraction
@@ -16,7 +16,7 @@ interface IConnectionInfo {
  * Manages TLS-related operations including SNI extraction and validation
  */
 export class TlsManager {
-  constructor(private settings: ISmartProxyOptions) {}
+  constructor(private smartProxy: SmartProxy) {}
   
   /**
    * Check if a data chunk appears to be a TLS handshake
@@ -44,7 +44,7 @@ export class TlsManager {
     return SniHandler.processTlsPacket(
       chunk,
       connInfo,
-      this.settings.enableTlsDebugLogging || false,
+      this.smartProxy.settings.enableTlsDebugLogging || false,
       previousDomain
     );
   }
@@ -58,19 +58,19 @@ export class TlsManager {
     hasSNI: boolean
   ): { shouldBlock: boolean; reason?: string } {
     // Skip if session tickets are allowed
-    if (this.settings.allowSessionTicket !== false) {
+    if (this.smartProxy.settings.allowSessionTicket !== false) {
       return { shouldBlock: false };
     }
     
     // Check for session resumption attempt
     const resumptionInfo = SniHandler.hasSessionResumption(
       chunk,
-      this.settings.enableTlsDebugLogging || false
+      this.smartProxy.settings.enableTlsDebugLogging || false
     );
     
     // If this is a resumption attempt without SNI, block it
     if (resumptionInfo.isResumption && !hasSNI && !resumptionInfo.hasSNI) {
-      if (this.settings.enableTlsDebugLogging) {
+      if (this.smartProxy.settings.enableTlsDebugLogging) {
         console.log(
           `[${connectionId}] Session resumption detected without SNI and allowSessionTicket=false. ` +
           `Terminating connection to force new TLS handshake.`
@@ -104,7 +104,7 @@ export class TlsManager {
       const newSNI = SniHandler.extractSNIWithResumptionSupport(
         chunk,
         connInfo,
-        this.settings.enableTlsDebugLogging || false
+        this.smartProxy.settings.enableTlsDebugLogging || false
       );
 
       // Skip if no SNI was found
@@ -112,14 +112,14 @@ export class TlsManager {
 
       // Check for SNI mismatch
       if (newSNI !== expectedDomain) {
-        if (this.settings.enableTlsDebugLogging) {
+        if (this.smartProxy.settings.enableTlsDebugLogging) {
           console.log(
             `[${connectionId}] Renegotiation with different SNI: ${expectedDomain} -> ${newSNI}. ` +
             `Terminating connection - SNI domain switching is not allowed.`
           );
         }
         return { hasMismatch: true, extractedSNI: newSNI };
-      } else if (this.settings.enableTlsDebugLogging) {
+      } else if (this.smartProxy.settings.enableTlsDebugLogging) {
         console.log(
           `[${connectionId}] Renegotiation detected with same SNI: ${newSNI}. Allowing.`
         );
@@ -175,13 +175,13 @@ export class TlsManager {
       // Check for session resumption
       const resumptionInfo = SniHandler.hasSessionResumption(
         chunk,
-        this.settings.enableTlsDebugLogging || false
+        this.smartProxy.settings.enableTlsDebugLogging || false
       );
       
       // Extract SNI
       const sni = SniHandler.extractSNI(
         chunk,
-        this.settings.enableTlsDebugLogging || false
+        this.smartProxy.settings.enableTlsDebugLogging || false
       );
       
       // Update result

package/ts/routing/router/http-router.ts

@@ -168,7 +168,7 @@ export class HttpRouter {
         if (pathResult.matches) {
           return {
             route,
-            pathMatch: path,
+            pathMatch: pathResult.pathMatch || path,
             pathParams: pathResult.params,
             pathRemainder: pathResult.pathRemainder
           };