@push.rocks/smartproxy 19.5.5 → 19.5.7

package/ts/core/utils/lifecycle-component.ts

@@ -9,6 +9,7 @@ export abstract class LifecycleComponent {
     target: any; 
     event: string; 
     handler: Function;
+    actualHandler?: Function; // The actual handler registered (may be wrapped)
     once?: boolean;
   }> = [];
   private childComponents: Set<LifecycleComponent> = new Set();
@@ -21,7 +22,11 @@ export abstract class LifecycleComponent {
   protected setTimeout(handler: Function, timeout: number): NodeJS.Timeout {
     if (this.isShuttingDown) {
       // Return a dummy timer if shutting down
-      return setTimeout(() => {}, 0);
+      const dummyTimer = setTimeout(() => {}, 0);
+      if (typeof dummyTimer.unref === 'function') {
+        dummyTimer.unref();
+      }
+      return dummyTimer;
     }
 
     const wrappedHandler = () => {
@@ -33,6 +38,12 @@ export abstract class LifecycleComponent {
 
     const timer = setTimeout(wrappedHandler, timeout);
     this.timers.add(timer);
+    
+    // Allow process to exit even with timer
+    if (typeof timer.unref === 'function') {
+      timer.unref();
+    }
+    
     return timer;
   }
 
@@ -42,7 +53,12 @@ export abstract class LifecycleComponent {
   protected setInterval(handler: Function, interval: number): NodeJS.Timeout {
     if (this.isShuttingDown) {
       // Return a dummy timer if shutting down
-      return setInterval(() => {}, interval);
+      const dummyTimer = setInterval(() => {}, interval);
+      if (typeof dummyTimer.unref === 'function') {
+        dummyTimer.unref();
+      }
+      clearInterval(dummyTimer); // Clear immediately since we don't need it
+      return dummyTimer;
     }
 
     const wrappedHandler = () => {
@@ -121,11 +137,12 @@ export abstract class LifecycleComponent {
       throw new Error('Target must support on() or addEventListener()');
     }
 
-    // Store the original handler in our tracking (not the wrapped one)
+    // Store both the original handler and the actual handler registered
     this.listeners.push({ 
       target, 
       event, 
       handler,
+      actualHandler, // The handler that was actually registered (may be wrapped)
       once: options?.once 
     });
   }
@@ -208,12 +225,15 @@ export abstract class LifecycleComponent {
     this.intervals.clear();
 
     // Remove all event listeners
-    for (const { target, event, handler } of this.listeners) {
+    for (const { target, event, handler, actualHandler } of this.listeners) {
+      // Use actualHandler if available (for wrapped handlers), otherwise use the original handler
+      const handlerToRemove = actualHandler || handler;
+      
       // All listeners need to be removed, including 'once' listeners that might not have fired
       if (typeof target.removeListener === 'function') {
-        target.removeListener(event, handler);
+        target.removeListener(event, handlerToRemove);
       } else if (typeof target.removeEventListener === 'function') {
-        target.removeEventListener(event, handler);
+        target.removeEventListener(event, handlerToRemove);
       }
     }
     this.listeners = [];

package/ts/core/utils/socket-utils.ts

@@ -0,0 +1,96 @@
+import * as plugins from '../../plugins.js';
+
+/**
+ * Safely cleanup a socket by removing all listeners and destroying it
+ * @param socket The socket to cleanup
+ * @param socketName Optional name for logging
+ */
+export function cleanupSocket(socket: plugins.net.Socket | plugins.tls.TLSSocket | null, socketName?: string): void {
+  if (!socket) return;
+  
+  try {
+    // Remove all event listeners
+    socket.removeAllListeners();
+    
+    // Unpipe any streams
+    socket.unpipe();
+    
+    // Destroy if not already destroyed
+    if (!socket.destroyed) {
+      socket.destroy();
+    }
+  } catch (err) {
+    console.error(`Error cleaning up socket${socketName ? ` (${socketName})` : ''}: ${err}`);
+  }
+}
+
+/**
+ * Create a cleanup handler for paired sockets (client and server)
+ * @param clientSocket The client socket
+ * @param serverSocket The server socket (optional)
+ * @param onCleanup Optional callback when cleanup is done
+ * @returns A cleanup function that can be called multiple times safely
+ */
+export function createSocketCleanupHandler(
+  clientSocket: plugins.net.Socket | plugins.tls.TLSSocket,
+  serverSocket?: plugins.net.Socket | plugins.tls.TLSSocket | null,
+  onCleanup?: (reason: string) => void
+): (reason: string) => void {
+  let cleanedUp = false;
+  
+  return (reason: string) => {
+    if (cleanedUp) return;
+    cleanedUp = true;
+    
+    // Cleanup both sockets
+    cleanupSocket(clientSocket, 'client');
+    if (serverSocket) {
+      cleanupSocket(serverSocket, 'server');
+    }
+    
+    // Call cleanup callback if provided
+    if (onCleanup) {
+      onCleanup(reason);
+    }
+  };
+}
+
+/**
+ * Setup socket error and close handlers with proper cleanup
+ * @param socket The socket to setup handlers for
+ * @param handleClose The cleanup function to call
+ * @param errorPrefix Optional prefix for error messages
+ */
+export function setupSocketHandlers(
+  socket: plugins.net.Socket | plugins.tls.TLSSocket,
+  handleClose: (reason: string) => void,
+  errorPrefix?: string
+): void {
+  socket.on('error', (error) => {
+    const prefix = errorPrefix || 'Socket';
+    handleClose(`${prefix}_error: ${error.message}`);
+  });
+  
+  socket.on('close', () => {
+    const prefix = errorPrefix || 'socket';
+    handleClose(`${prefix}_closed`);
+  });
+  
+  socket.on('timeout', () => {
+    const prefix = errorPrefix || 'socket';
+    handleClose(`${prefix}_timeout`);
+  });
+}
+
+/**
+ * Pipe two sockets together with proper cleanup on either end
+ * @param socket1 First socket
+ * @param socket2 Second socket
+ */
+export function pipeSockets(
+  socket1: plugins.net.Socket | plugins.tls.TLSSocket,
+  socket2: plugins.net.Socket | plugins.tls.TLSSocket
+): void {
+  socket1.pipe(socket2);
+  socket2.pipe(socket1);
+}

package/ts/forwarding/handlers/http-handler.ts

@@ -2,6 +2,7 @@ import * as plugins from '../../plugins.js';
 import { ForwardingHandler } from './base-handler.js';
 import type { IForwardConfig } from '../config/forwarding-types.js';
 import { ForwardingHandlerEvents } from '../config/forwarding-types.js';
+import { setupSocketHandlers } from '../../core/utils/socket-utils.js';
 
 /**
  * Handler for HTTP-only forwarding
@@ -40,12 +41,15 @@ export class HttpForwardingHandler extends ForwardingHandler {
     const remoteAddress = socket.remoteAddress || 'unknown';
     const localPort = socket.localPort || 80;
     
-    socket.on('close', (hadError) => {
+    // Set up socket handlers with proper cleanup
+    const handleClose = (reason: string) => {
       this.emit(ForwardingHandlerEvents.DISCONNECTED, {
         remoteAddress,
-        hadError
+        reason
       });
-    });
+    };
+    
+    setupSocketHandlers(socket, handleClose, 'http');
     
     socket.on('error', (error) => {
       this.emit(ForwardingHandlerEvents.ERROR, {

package/ts/forwarding/handlers/https-passthrough-handler.ts

@@ -2,6 +2,7 @@ import * as plugins from '../../plugins.js';
 import { ForwardingHandler } from './base-handler.js';
 import type { IForwardConfig } from '../config/forwarding-types.js';
 import { ForwardingHandlerEvents } from '../config/forwarding-types.js';
+import { createSocketCleanupHandler, setupSocketHandlers, pipeSockets } from '../../core/utils/socket-utils.js';
 
 /**
  * Handler for HTTPS passthrough (SNI forwarding without termination)
@@ -50,35 +51,23 @@ export class HttpsPassthroughHandler extends ForwardingHandler {
     // Create a connection to the target server
     const serverSocket = plugins.net.connect(target.port, target.host);
     
-    // Handle errors on the server socket
-    serverSocket.on('error', (error) => {
-      this.emit(ForwardingHandlerEvents.ERROR, {
-        remoteAddress,
-        error: `Target connection error: ${error.message}`
-      });
-      
-      // Close the client socket if it's still open
-      if (!clientSocket.destroyed) {
-        clientSocket.destroy();
-      }
-    });
+    // Track data transfer for logging
+    let bytesSent = 0;
+    let bytesReceived = 0;
     
-    // Handle errors on the client socket
-    clientSocket.on('error', (error) => {
-      this.emit(ForwardingHandlerEvents.ERROR, {
+    // Create cleanup handler with our utility
+    const handleClose = createSocketCleanupHandler(clientSocket, serverSocket, (reason) => {
+      this.emit(ForwardingHandlerEvents.DISCONNECTED, {
         remoteAddress,
-        error: `Client connection error: ${error.message}`
+        bytesSent,
+        bytesReceived,
+        reason
       });
-      
-      // Close the server socket if it's still open
-      if (!serverSocket.destroyed) {
-        serverSocket.destroy();
-      }
     });
     
-    // Track data transfer for logging
-    let bytesSent = 0;
-    let bytesReceived = 0;
+    // Setup error and close handlers for both sockets
+    setupSocketHandlers(serverSocket, handleClose, 'server');
+    setupSocketHandlers(clientSocket, handleClose, 'client');
     
     // Forward data from client to server
     clientSocket.on('data', (data) => {
@@ -128,48 +117,10 @@ export class HttpsPassthroughHandler extends ForwardingHandler {
       });
     });
     
-    // Handle connection close
-    const handleClose = () => {
-      if (!clientSocket.destroyed) {
-        clientSocket.destroy();
-      }
-      
-      if (!serverSocket.destroyed) {
-        serverSocket.destroy();
-      }
-      
-      this.emit(ForwardingHandlerEvents.DISCONNECTED, {
-        remoteAddress,
-        bytesSent,
-        bytesReceived
-      });
-    };
-    
-    // Set up close handlers
-    clientSocket.on('close', handleClose);
-    serverSocket.on('close', handleClose);
-    
     // Set timeouts
     const timeout = this.getTimeout();
     clientSocket.setTimeout(timeout);
     serverSocket.setTimeout(timeout);
-    
-    // Handle timeouts
-    clientSocket.on('timeout', () => {
-      this.emit(ForwardingHandlerEvents.ERROR, {
-        remoteAddress,
-        error: 'Client connection timeout'
-      });
-      handleClose();
-    });
-    
-    serverSocket.on('timeout', () => {
-      this.emit(ForwardingHandlerEvents.ERROR, {
-        remoteAddress,
-        error: 'Server connection timeout'
-      });
-      handleClose();
-    });
   }
   
   /**

package/ts/forwarding/handlers/https-terminate-to-http-handler.ts

@@ -2,6 +2,7 @@ import * as plugins from '../../plugins.js';
 import { ForwardingHandler } from './base-handler.js';
 import type { IForwardConfig } from '../config/forwarding-types.js';
 import { ForwardingHandlerEvents } from '../config/forwarding-types.js';
+import { createSocketCleanupHandler, setupSocketHandlers } from '../../core/utils/socket-utils.js';
 
 /**
  * Handler for HTTPS termination with HTTP backend
@@ -95,76 +96,87 @@ export class HttpsTerminateToHttpHandler extends ForwardingHandler {
       tls: true
     });
     
-    // Handle TLS errors
-    tlsSocket.on('error', (error) => {
-      this.emit(ForwardingHandlerEvents.ERROR, {
+    // Variables to track connections
+    let backendSocket: plugins.net.Socket | null = null;
+    let dataBuffer = Buffer.alloc(0);
+    let connectionEstablished = false;
+    
+    // Create cleanup handler for all sockets
+    const handleClose = createSocketCleanupHandler(tlsSocket, backendSocket, (reason) => {
+      this.emit(ForwardingHandlerEvents.DISCONNECTED, {
         remoteAddress,
-        error: `TLS error: ${error.message}`
+        reason
       });
-      
-      if (!tlsSocket.destroyed) {
-        tlsSocket.destroy();
-      }
+      dataBuffer = Buffer.alloc(0);
+      connectionEstablished = false;
     });
     
-    // The TLS socket will now emit HTTP traffic that can be processed
-    // In a real implementation, we would create an HTTP parser and handle
-    // the requests here, but for simplicity, we'll just log the data
+    // Set up error handling with our cleanup utility
+    setupSocketHandlers(tlsSocket, handleClose, 'tls');
     
-    let dataBuffer = Buffer.alloc(0);
+    // Set timeout
+    const timeout = this.getTimeout();
+    tlsSocket.setTimeout(timeout);
+    
+    tlsSocket.on('timeout', () => {
+      this.emit(ForwardingHandlerEvents.ERROR, {
+        remoteAddress,
+        error: 'TLS connection timeout'
+      });
+      handleClose('timeout');
+    });
     
+    // Handle TLS data
     tlsSocket.on('data', (data) => {
+      // If backend connection already established, just forward the data
+      if (connectionEstablished && backendSocket && !backendSocket.destroyed) {
+        backendSocket.write(data);
+        return;
+      }
+      
       // Append to buffer
       dataBuffer = Buffer.concat([dataBuffer, data]);
       
       // Very basic HTTP parsing - in a real implementation, use http-parser
-      if (dataBuffer.includes(Buffer.from('\r\n\r\n'))) {
+      if (dataBuffer.includes(Buffer.from('\r\n\r\n')) && !connectionEstablished) {
         const target = this.getTargetFromConfig();
         
-        // Simple example: forward the data to an HTTP server
-        const socket = plugins.net.connect(target.port, target.host, () => {
-          socket.write(dataBuffer);
-          dataBuffer = Buffer.alloc(0);
+        // Create backend connection
+        backendSocket = plugins.net.connect(target.port, target.host, () => {
+          connectionEstablished = true;
+          
+          // Send buffered data
+          if (dataBuffer.length > 0) {
+            backendSocket!.write(dataBuffer);
+            dataBuffer = Buffer.alloc(0);
+          }
           
           // Set up bidirectional data flow
-          tlsSocket.pipe(socket);
-          socket.pipe(tlsSocket);
+          tlsSocket.pipe(backendSocket!);
+          backendSocket!.pipe(tlsSocket);
         });
         
-        socket.on('error', (error) => {
+        // Update the cleanup handler with the backend socket
+        const newHandleClose = createSocketCleanupHandler(tlsSocket, backendSocket, (reason) => {
+          this.emit(ForwardingHandlerEvents.DISCONNECTED, {
+            remoteAddress,
+            reason
+          });
+          dataBuffer = Buffer.alloc(0);
+          connectionEstablished = false;
+        });
+        
+        // Set up handlers for backend socket
+        setupSocketHandlers(backendSocket, newHandleClose, 'backend');
+        
+        backendSocket.on('error', (error) => {
           this.emit(ForwardingHandlerEvents.ERROR, {
             remoteAddress,
             error: `Target connection error: ${error.message}`
           });
-          
-          if (!tlsSocket.destroyed) {
-            tlsSocket.destroy();
-          }
         });
       }
     });
-    
-    // Handle close
-    tlsSocket.on('close', () => {
-      this.emit(ForwardingHandlerEvents.DISCONNECTED, {
-        remoteAddress
-      });
-    });
-    
-    // Set timeout
-    const timeout = this.getTimeout();
-    tlsSocket.setTimeout(timeout);
-    
-    tlsSocket.on('timeout', () => {
-      this.emit(ForwardingHandlerEvents.ERROR, {
-        remoteAddress,
-        error: 'TLS connection timeout'
-      });
-      
-      if (!tlsSocket.destroyed) {
-        tlsSocket.destroy();
-      }
-    });
   }
   
   /**

package/ts/forwarding/handlers/https-terminate-to-https-handler.ts

@@ -2,6 +2,7 @@ import * as plugins from '../../plugins.js';
 import { ForwardingHandler } from './base-handler.js';
 import type { IForwardConfig } from '../config/forwarding-types.js';
 import { ForwardingHandlerEvents } from '../config/forwarding-types.js';
+import { createSocketCleanupHandler, setupSocketHandlers } from '../../core/utils/socket-utils.js';
 
 /**
  * Handler for HTTPS termination with HTTPS backend
@@ -93,28 +94,38 @@ export class HttpsTerminateToHttpsHandler extends ForwardingHandler {
       tls: true
     });
     
-    // Handle TLS errors
-    tlsSocket.on('error', (error) => {
-      this.emit(ForwardingHandlerEvents.ERROR, {
+    // Variable to track backend socket
+    let backendSocket: plugins.tls.TLSSocket | null = null;
+    
+    // Create cleanup handler for both sockets
+    const handleClose = createSocketCleanupHandler(tlsSocket, backendSocket, (reason) => {
+      this.emit(ForwardingHandlerEvents.DISCONNECTED, {
         remoteAddress,
-        error: `TLS error: ${error.message}`
+        reason
       });
-      
-      if (!tlsSocket.destroyed) {
-        tlsSocket.destroy();
-      }
     });
     
-    // The TLS socket will now emit HTTP traffic that can be processed
-    // In a real implementation, we would create an HTTP parser and handle
-    // the requests here, but for simplicity, we'll just forward the data
+    // Set up error handling with our cleanup utility
+    setupSocketHandlers(tlsSocket, handleClose, 'tls');
+    
+    // Set timeout
+    const timeout = this.getTimeout();
+    tlsSocket.setTimeout(timeout);
+    
+    tlsSocket.on('timeout', () => {
+      this.emit(ForwardingHandlerEvents.ERROR, {
+        remoteAddress,
+        error: 'TLS connection timeout'
+      });
+      handleClose('timeout');
+    });
     
     // Get the target from configuration
     const target = this.getTargetFromConfig();
     
     // Set up the connection to the HTTPS backend
     const connectToBackend = () => {
-      const backendSocket = plugins.tls.connect({
+      backendSocket = plugins.tls.connect({
         host: target.host,
         port: target.port,
         // In a real implementation, we would configure TLS options
@@ -127,30 +138,29 @@ export class HttpsTerminateToHttpsHandler extends ForwardingHandler {
         });
         
         // Set up bidirectional data flow
-        tlsSocket.pipe(backendSocket);
-        backendSocket.pipe(tlsSocket);
+        tlsSocket.pipe(backendSocket!);
+        backendSocket!.pipe(tlsSocket);
       });
       
+      // Update the cleanup handler with the backend socket
+      const newHandleClose = createSocketCleanupHandler(tlsSocket, backendSocket, (reason) => {
+        this.emit(ForwardingHandlerEvents.DISCONNECTED, {
+          remoteAddress,
+          reason
+        });
+      });
+      
+      // Set up handlers for backend socket
+      setupSocketHandlers(backendSocket, newHandleClose, 'backend');
+      
       backendSocket.on('error', (error) => {
         this.emit(ForwardingHandlerEvents.ERROR, {
           remoteAddress,
           error: `Backend connection error: ${error.message}`
         });
-        
-        if (!tlsSocket.destroyed) {
-          tlsSocket.destroy();
-        }
-      });
-      
-      // Handle close
-      backendSocket.on('close', () => {
-        if (!tlsSocket.destroyed) {
-          tlsSocket.destroy();
-        }
       });
       
-      // Set timeout
-      const timeout = this.getTimeout();
+      // Set timeout for backend socket
       backendSocket.setTimeout(timeout);
       
       backendSocket.on('timeout', () => {
@@ -158,10 +168,7 @@ export class HttpsTerminateToHttpsHandler extends ForwardingHandler {
           remoteAddress,
           error: 'Backend connection timeout'
         });
-        
-        if (!backendSocket.destroyed) {
-          backendSocket.destroy();
-        }
+        newHandleClose('backend_timeout');
       });
     };
     
@@ -169,28 +176,6 @@ export class HttpsTerminateToHttpsHandler extends ForwardingHandler {
     tlsSocket.on('secure', () => {
       connectToBackend();
     });
-    
-    // Handle close
-    tlsSocket.on('close', () => {
-      this.emit(ForwardingHandlerEvents.DISCONNECTED, {
-        remoteAddress
-      });
-    });
-    
-    // Set timeout
-    const timeout = this.getTimeout();
-    tlsSocket.setTimeout(timeout);
-    
-    tlsSocket.on('timeout', () => {
-      this.emit(ForwardingHandlerEvents.ERROR, {
-        remoteAddress,
-        error: 'TLS connection timeout'
-      });
-      
-      if (!tlsSocket.destroyed) {
-        tlsSocket.destroy();
-      }
-    });
   }
   
   /**

package/ts/proxies/http-proxy/connection-pool.ts

@@ -1,5 +1,6 @@
 import * as plugins from '../../plugins.js';
 import { type IHttpProxyOptions, type IConnectionEntry, type ILogger, createLogger } from './models/types.js';
+import { cleanupSocket } from '../../core/utils/socket-utils.js';
 
 /**
  * Manages a pool of backend connections for efficient reuse
@@ -133,14 +134,7 @@ export class ConnectionPool {
         if ((connection.isIdle && now - connection.lastUsed > idleTimeout) ||
             connections.length > (this.options.connectionPoolSize || 50)) {
           
-          try {
-            if (!connection.socket.destroyed) {
-              connection.socket.end();
-              connection.socket.destroy();
-            }
-          } catch (err) {
-            this.logger.error(`Error destroying pooled connection to ${host}`, err);
-          }
+          cleanupSocket(connection.socket, `pool-${host}-idle`);
           
           connections.shift(); // Remove from pool
           removed++;
@@ -170,14 +164,7 @@ export class ConnectionPool {
       this.logger.debug(`Closing ${connections.length} connections to ${host}`);
       
       for (const connection of connections) {
-        try {
-          if (!connection.socket.destroyed) {
-            connection.socket.end();
-            connection.socket.destroy();
-          }
-        } catch (error) {
-          this.logger.error(`Error closing connection to ${host}:`, error);
-        }
+        cleanupSocket(connection.socket, `pool-${host}-close`);
       }
     }
     

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

@@ -18,6 +18,7 @@ import { RequestHandler, type IMetricsTracker } from './request-handler.js';
 import { WebSocketHandler } from './websocket-handler.js';
 import { ProxyRouter } from '../../routing/router/index.js';
 import { RouteRouter } from '../../routing/router/route-router.js';
+import { cleanupSocket } from '../../core/utils/socket-utils.js';
 import { FunctionCache } from './function-cache.js';
 
 /**
@@ -520,11 +521,7 @@ export class HttpProxy implements IMetricsTracker {
     
     // Close all tracked sockets
     for (const socket of this.socketMap.getArray()) {
-      try {
-        socket.destroy();
-      } catch (error) {
-        this.logger.error('Error destroying socket', error);
-      }
+      cleanupSocket(socket, 'http-proxy-stop');
     }
     
     // Close all connection pool connections