refactor(socket-utils): replace direct socket cleanup with centralized cleanupSocket utility across connection management

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

@@ -4,6 +4,7 @@ import { SecurityManager } from './security-manager.js';
 import { TimeoutManager } from './timeout-manager.js';
 import { logger } from '../../core/utils/logger.js';
 import { LifecycleComponent } from '../../core/utils/lifecycle-component.js';
+import { cleanupSocket } from '../../core/utils/socket-utils.js';
 
 /**
  * Manages connection lifecycle, tracking, and cleanup with performance optimizations
@@ -278,10 +279,10 @@ export class ConnectionManager extends LifecycleComponent {
       }
 
       // Handle socket cleanup without delay
-      this.cleanupSocketImmediate(record, 'incoming', record.incoming);
+      cleanupSocket(record.incoming, `${record.id}-incoming`);
       
       if (record.outgoing) {
-        this.cleanupSocketImmediate(record, 'outgoing', record.outgoing);
+        cleanupSocket(record.outgoing, `${record.id}-outgoing`);
       }
 
       // Clear pendingData to avoid memory leaks
@@ -313,23 +314,6 @@ export class ConnectionManager extends LifecycleComponent {
     }
   }
   
-  /**
-   * Helper method to clean up a socket immediately
-   */
-  private cleanupSocketImmediate(record: IConnectionRecord, side: 'incoming' | 'outgoing', socket: plugins.net.Socket): void {
-    try {
-      if (!socket.destroyed) {
-        socket.destroy();
-      }
-    } catch (err) {
-      logger.log('error', `Error destroying ${side} socket: ${err}`, { 
-        connectionId: record.id, 
-        side, 
-        error: err, 
-        component: 'connection-manager' 
-      });
-    }
-  }
   
   /**
    * Creates a generic error handler for incoming or outgoing sockets
@@ -552,19 +536,13 @@ export class ConnectionManager extends LifecycleComponent {
             record.cleanupTimer = undefined;
           }
 
-          // Immediate destruction
+          // Immediate destruction using socket-utils
           if (record.incoming) {
-            record.incoming.removeAllListeners();
-            if (!record.incoming.destroyed) {
-              record.incoming.destroy();
-            }
+            cleanupSocket(record.incoming, `${record.id}-incoming-shutdown`);
           }
 
           if (record.outgoing) {
-            record.outgoing.removeAllListeners();
-            if (!record.outgoing.destroyed) {
-              record.outgoing.destroy();
-            }
+            cleanupSocket(record.outgoing, `${record.id}-outgoing-shutdown`);
           }
         } catch (err) {
           logger.log('error', `Error during connection cleanup: ${err}`, { 

ts/proxies/smart-proxy/port-manager.ts

@@ -2,6 +2,7 @@ import * as plugins from '../../plugins.js';
 import type { ISmartProxyOptions } from './models/interfaces.js';
 import { RouteConnectionHandler } from './route-connection-handler.js';
 import { logger } from '../../core/utils/logger.js';
+import { cleanupSocket } from '../../core/utils/socket-utils.js';
 
 /**
  * PortManager handles the dynamic creation and removal of port listeners
@@ -64,8 +65,7 @@ export class PortManager {
     const server = plugins.net.createServer((socket) => {
       // Check if shutting down
       if (this.isShuttingDown) {
-        socket.end();
-        socket.destroy();
+        cleanupSocket(socket, 'port-manager-shutdown');
         return;
       }
       

ts/proxies/smart-proxy/route-connection-handler.ts

@@ -9,7 +9,7 @@ import { TlsManager } from './tls-manager.js';
 import { HttpProxyBridge } from './http-proxy-bridge.js';
 import { TimeoutManager } from './timeout-manager.js';
 import { RouteManager } from './route-manager.js';
-import type { ForwardingHandler } from '../../forwarding/handlers/base-handler.js';
+import { cleanupSocket } from '../../core/utils/socket-utils.js';
 
 /**
  * Handles new connection processing and setup logic with support for route-based configuration
@@ -84,8 +84,7 @@ export class RouteConnectionHandler {
     const ipValidation = this.securityManager.validateIP(remoteIP);
     if (!ipValidation.allowed) {
       logger.log('warn', `Connection rejected`, { remoteIP, reason: ipValidation.reason, component: 'route-handler' });
-      socket.end();
-      socket.destroy();
+      cleanupSocket(socket, `rejected-${ipValidation.reason}`);
       return;
     }
 
@@ -825,16 +824,16 @@ export class RouteConnectionHandler {
     // Track event listeners added by the handler so we can clean them up
     const originalOn = socket.on.bind(socket);
     const originalOnce = socket.once.bind(socket);
-    const trackedListeners: Array<{event: string; listener: Function}> = [];
+    const trackedListeners: Array<{event: string; listener: (...args: any[]) => void}> = [];
     
     // Override socket.on to track listeners
-    socket.on = function(event: string, listener: Function) {
+    socket.on = function(event: string, listener: (...args: any[]) => void) {
       trackedListeners.push({event, listener});
       return originalOn(event, listener);
     } as any;
     
     // Override socket.once to track listeners
-    socket.once = function(event: string, listener: Function) {
+    socket.once = function(event: string, listener: (...args: any[]) => void) {
       trackedListeners.push({event, listener});
       return originalOnce(event, listener);
     } as any;
@@ -1265,7 +1264,7 @@ export class RouteConnectionHandler {
           connectionId,
           serverName,
           connInfo,
-          (connectionId, reason) => this.connectionManager.initiateCleanupOnce(record, reason)
+          (_connectionId, reason) => this.connectionManager.initiateCleanupOnce(record, reason)
         );
 
         // Store the handler in the connection record so we can remove it during cleanup