@push.rocks/smartproxy 19.6.2 → 19.6.7

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

@@ -1,11 +1,10 @@
 import * as plugins from '../../plugins.js';
-import type { IConnectionRecord, ISmartProxyOptions } from './models/interfaces.js';
-import { SecurityManager } from './security-manager.js';
-import { TimeoutManager } from './timeout-manager.js';
+import type { IConnectionRecord } from './models/interfaces.js';
 import { logger } from '../../core/utils/logger.js';
 import { LifecycleComponent } from '../../core/utils/lifecycle-component.js';
 import { cleanupSocket } from '../../core/utils/socket-utils.js';
 import { WrappedSocket } from '../../core/models/wrapped-socket.js';
+import type { SmartProxy } from './smart-proxy.js';
 
 /**
  * Manages connection lifecycle, tracking, and cleanup with performance optimizations
@@ -29,17 +28,15 @@ export class ConnectionManager extends LifecycleComponent {
   private cleanupTimer: NodeJS.Timeout | null = null;
 
   constructor(
-    private settings: ISmartProxyOptions,
-    private securityManager: SecurityManager,
-    private timeoutManager: TimeoutManager
+    private smartProxy: SmartProxy
   ) {
     super();
     
     // Set reasonable defaults for connection limits
-    this.maxConnections = settings.defaults?.security?.maxConnections || 10000; 
+    this.maxConnections = smartProxy.settings.defaults?.security?.maxConnections || 10000; 
     
     // Start inactivity check timer if not disabled
-    if (!settings.disableInactivityCheck) {
+    if (!smartProxy.settings.disableInactivityCheck) {
       this.startInactivityCheckTimer();
     }
   }
@@ -108,10 +105,10 @@ export class ConnectionManager extends LifecycleComponent {
    */
   public trackConnection(connectionId: string, record: IConnectionRecord): void {
     this.connectionRecords.set(connectionId, record);
-    this.securityManager.trackConnectionByIP(record.remoteIP, connectionId);
+    this.smartProxy.securityManager.trackConnectionByIP(record.remoteIP, connectionId);
     
     // Schedule inactivity check
-    if (!this.settings.disableInactivityCheck) {
+    if (!this.smartProxy.settings.disableInactivityCheck) {
       this.scheduleInactivityCheck(connectionId, record);
     }
   }
@@ -120,14 +117,14 @@ export class ConnectionManager extends LifecycleComponent {
    * Schedule next inactivity check for a connection
    */
   private scheduleInactivityCheck(connectionId: string, record: IConnectionRecord): void {
-    let timeout = this.settings.inactivityTimeout!;
+    let timeout = this.smartProxy.settings.inactivityTimeout!;
     
     if (record.hasKeepAlive) {
-      if (this.settings.keepAliveTreatment === 'immortal') {
+      if (this.smartProxy.settings.keepAliveTreatment === 'immortal') {
         // Don't schedule check for immortal connections
         return;
-      } else if (this.settings.keepAliveTreatment === 'extended') {
-        const multiplier = this.settings.keepAliveInactivityMultiplier || 6;
+      } else if (this.smartProxy.settings.keepAliveTreatment === 'extended') {
+        const multiplier = this.smartProxy.settings.keepAliveInactivityMultiplier || 6;
         timeout = timeout * multiplier;
       }
     }
@@ -172,7 +169,7 @@ export class ConnectionManager extends LifecycleComponent {
    * Initiates cleanup once for a connection
    */
   public initiateCleanupOnce(record: IConnectionRecord, reason: string = 'normal'): void {
-    if (this.settings.enableDetailedLogging) {
+    if (this.smartProxy.settings.enableDetailedLogging) {
       logger.log('info', `Connection cleanup initiated`, { 
         connectionId: record.id, 
         remoteIP: record.remoteIP, 
@@ -253,7 +250,12 @@ export class ConnectionManager extends LifecycleComponent {
       this.nextInactivityCheck.delete(record.id);
 
       // Track connection termination
-      this.securityManager.removeConnectionByIP(record.remoteIP, record.id);
+      this.smartProxy.securityManager.removeConnectionByIP(record.remoteIP, record.id);
+      
+      // Remove from metrics tracking
+      if (this.smartProxy.metricsCollector) {
+        this.smartProxy.metricsCollector.removeConnection(record.id);
+      }
 
       if (record.cleanupTimer) {
         clearTimeout(record.cleanupTimer);
@@ -334,7 +336,7 @@ export class ConnectionManager extends LifecycleComponent {
       this.connectionRecords.delete(record.id);
 
       // Log connection details
-      if (this.settings.enableDetailedLogging) {
+      if (this.smartProxy.settings.enableDetailedLogging) {
         logger.log('info', 
           `Connection terminated: ${record.remoteIP}:${record.localPort} (${reason}) - ` +
           `${plugins.prettyMs(duration)}, IN: ${record.bytesReceived}B, OUT: ${record.bytesSent}B`, 
@@ -414,7 +416,7 @@ export class ConnectionManager extends LifecycleComponent {
    */
   public handleClose(side: 'incoming' | 'outgoing', record: IConnectionRecord) {
     return () => {
-      if (this.settings.enableDetailedLogging) {
+      if (this.smartProxy.settings.enableDetailedLogging) {
         logger.log('info', `Connection closed on ${side} side`, {
           connectionId: record.id,
           side,
@@ -553,9 +555,9 @@ export class ConnectionManager extends LifecycleComponent {
       const inactivityTime = now - record.lastActivity;
       
       // Use extended timeout for extended-treatment keep-alive connections
-      let effectiveTimeout = this.settings.inactivityTimeout!;
-      if (record.hasKeepAlive && this.settings.keepAliveTreatment === 'extended') {
-        const multiplier = this.settings.keepAliveInactivityMultiplier || 6;
+      let effectiveTimeout = this.smartProxy.settings.inactivityTimeout!;
+      if (record.hasKeepAlive && this.smartProxy.settings.keepAliveTreatment === 'extended') {
+        const multiplier = this.smartProxy.settings.keepAliveInactivityMultiplier || 6;
         effectiveTimeout = effectiveTimeout * multiplier;
       }
 

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

@@ -1,14 +1,15 @@
 import * as plugins from '../../plugins.js';
 import { HttpProxy } from '../http-proxy/index.js';
 import { setupBidirectionalForwarding } from '../../core/utils/socket-utils.js';
-import type { IConnectionRecord, ISmartProxyOptions } from './models/interfaces.js';
+import type { IConnectionRecord } from './models/interfaces.js';
 import type { IRouteConfig } from './models/route-types.js';
 import { WrappedSocket } from '../../core/models/wrapped-socket.js';
+import type { SmartProxy } from './smart-proxy.js';
 
 export class HttpProxyBridge {
   private httpProxy: HttpProxy | null = null;
 
-  constructor(private settings: ISmartProxyOptions) {}
+  constructor(private smartProxy: SmartProxy) {}
   
   /**
    * Get the HttpProxy instance
@@ -21,18 +22,18 @@ export class HttpProxyBridge {
    * Initialize HttpProxy instance
    */
   public async initialize(): Promise<void> {
-    if (!this.httpProxy && this.settings.useHttpProxy && this.settings.useHttpProxy.length > 0) {
+    if (!this.httpProxy && this.smartProxy.settings.useHttpProxy && this.smartProxy.settings.useHttpProxy.length > 0) {
       const httpProxyOptions: any = {
-        port: this.settings.httpProxyPort!,
+        port: this.smartProxy.settings.httpProxyPort!,
         portProxyIntegration: true,
-        logLevel: this.settings.enableDetailedLogging ? 'debug' : 'info'
+        logLevel: this.smartProxy.settings.enableDetailedLogging ? 'debug' : 'info'
       };
 
       this.httpProxy = new HttpProxy(httpProxyOptions);
-      console.log(`Initialized HttpProxy on port ${this.settings.httpProxyPort}`);
+      console.log(`Initialized HttpProxy on port ${this.smartProxy.settings.httpProxyPort}`);
 
       // Apply route configurations to HttpProxy
-      await this.syncRoutesToHttpProxy(this.settings.routes || []);
+      await this.syncRoutesToHttpProxy(this.smartProxy.settings.routes || []);
     }
   }
   
@@ -51,7 +52,7 @@ export class HttpProxyBridge {
           : [route.match.ports];
         
         return routePorts.some(port => 
-          this.settings.useHttpProxy?.includes(port)
+          this.smartProxy.settings.useHttpProxy?.includes(port)
         );
       })
       .map(route => this.routeToHttpProxyConfig(route));