feat(socket-utils): implement socket cleanup utilities and enhance socket handling in forwarding handlers

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

@@ -128,10 +128,24 @@ export class HttpProxyBridge {
     proxySocket.pipe(socket);
     
     // Handle cleanup
+    let cleanedUp = false;
     const cleanup = (reason: string) => {
+      if (cleanedUp) return;
+      cleanedUp = true;
+      
+      // Remove all event listeners to prevent memory leaks
+      socket.removeAllListeners('end');
+      socket.removeAllListeners('error');
+      proxySocket.removeAllListeners('end');
+      proxySocket.removeAllListeners('error');
+      
       socket.unpipe(proxySocket);
       proxySocket.unpipe(socket);
-      proxySocket.destroy();
+      
+      if (!proxySocket.destroyed) {
+        proxySocket.destroy();
+      }
+      
       cleanupCallback(reason);
     };
     

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

@@ -822,6 +822,38 @@ export class RouteConnectionHandler {
       return;
     }
     
+    // 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}> = [];
+    
+    // Override socket.on to track listeners
+    socket.on = function(event: string, listener: Function) {
+      trackedListeners.push({event, listener});
+      return originalOn(event, listener);
+    } as any;
+    
+    // Override socket.once to track listeners
+    socket.once = function(event: string, listener: Function) {
+      trackedListeners.push({event, listener});
+      return originalOnce(event, listener);
+    } as any;
+    
+    // Set up automatic cleanup when socket closes
+    const cleanupHandler = () => {
+      // Remove all tracked listeners
+      for (const {event, listener} of trackedListeners) {
+        socket.removeListener(event, listener);
+      }
+      // Restore original methods
+      socket.on = originalOn;
+      socket.once = originalOnce;
+    };
+    
+    // Listen for socket close to trigger cleanup
+    originalOnce('close', cleanupHandler);
+    originalOnce('error', cleanupHandler);
+    
     // Create route context for the handler
     const routeContext = this.createRouteContext({
       connectionId: record.id,
@@ -855,6 +887,8 @@ export class RouteConnectionHandler {
               error: error.message,
               component: 'route-handler'
             });
+            // Remove all event listeners before destroying to prevent memory leaks
+            socket.removeAllListeners();
             if (!socket.destroyed) {
               socket.destroy();
             }
@@ -875,6 +909,8 @@ export class RouteConnectionHandler {
         error: error.message,
         component: 'route-handler'
       });
+      // Remove all event listeners before destroying to prevent memory leaks
+      socket.removeAllListeners();
       if (!socket.destroyed) {
         socket.destroy();
       }