@push.rocks/smartproxy 19.5.4 → 19.5.6

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/plugins.ts

@@ -4,11 +4,12 @@ import * as fs from 'fs';
 import * as http from 'http';
 import * as https from 'https';
 import * as net from 'net';
+import * as path from 'path';
 import * as tls from 'tls';
 import * as url from 'url';
 import * as http2 from 'http2';
 
-export { EventEmitter, fs, http, https, net, tls, url, http2 };
+export { EventEmitter, fs, http, https, net, path, tls, url, http2 };
 
 // tsclass scope
 import * as tsclass from '@tsclass/tsclass';

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

@@ -2,6 +2,7 @@ import * as plugins from '../../plugins.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
+import { AsyncFileSystem } from '../../core/utils/fs-utils.js';
 import { type IHttpProxyOptions, type ICertificateEntry, type ILogger, createLogger } from './models/types.js';
 import type { IRouteConfig } from '../smart-proxy/models/route-types.js';
 
@@ -17,6 +18,7 @@ export class CertificateManager {
   private certificateStoreDir: string;
   private logger: ILogger;
   private httpsServer: plugins.https.Server | null = null;
+  private initialized = false;
 
   constructor(private options: IHttpProxyOptions) {
     this.certificateStoreDir = path.resolve(options.acme?.certificateStore || './certs');
@@ -24,6 +26,15 @@ export class CertificateManager {
     
     this.logger.warn('CertificateManager is deprecated - use SmartCertManager instead');
     
+    // Initialize synchronously for backward compatibility but log warning
+    this.initializeSync();
+  }
+
+  /**
+   * Synchronous initialization for backward compatibility
+   * @deprecated This uses sync filesystem operations which block the event loop
+   */
+  private initializeSync(): void {
     // Ensure certificate store directory exists
     try {
       if (!fs.existsSync(this.certificateStoreDir)) {
@@ -36,9 +47,28 @@ export class CertificateManager {
     
     this.loadDefaultCertificates();
   }
+
+  /**
+   * Async initialization - preferred method
+   */
+  public async initialize(): Promise<void> {
+    if (this.initialized) return;
+    
+    // Ensure certificate store directory exists
+    try {
+      await AsyncFileSystem.ensureDir(this.certificateStoreDir);
+      this.logger.info(`Ensured certificate store directory: ${this.certificateStoreDir}`);
+    } catch (error) {
+      this.logger.warn(`Failed to create certificate store directory: ${error}`);
+    }
+    
+    await this.loadDefaultCertificatesAsync();
+    this.initialized = true;
+  }
   
   /**
    * Loads default certificates from the filesystem
+   * @deprecated This uses sync filesystem operations which block the event loop
    */
   public loadDefaultCertificates(): void {
     const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -49,7 +79,28 @@ export class CertificateManager {
         key: fs.readFileSync(path.join(certPath, 'key.pem'), 'utf8'),
         cert: fs.readFileSync(path.join(certPath, 'cert.pem'), 'utf8')
       };
-      this.logger.info('Loaded default certificates from filesystem');
+      this.logger.info('Loaded default certificates from filesystem (sync - deprecated)');
+    } catch (error) {
+      this.logger.error(`Failed to load default certificates: ${error}`);
+      this.generateSelfSignedCertificate();
+    }
+  }
+
+  /**
+   * Loads default certificates from the filesystem asynchronously
+   */
+  public async loadDefaultCertificatesAsync(): Promise<void> {
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    const certPath = path.join(__dirname, '..', '..', '..', 'assets', 'certs');
+
+    try {
+      const [key, cert] = await Promise.all([
+        AsyncFileSystem.readFile(path.join(certPath, 'key.pem')),
+        AsyncFileSystem.readFile(path.join(certPath, 'cert.pem'))
+      ]);
+      
+      this.defaultCertificates = { key, cert };
+      this.logger.info('Loaded default certificates from filesystem (async)');
     } catch (error) {
       this.logger.error(`Failed to load default certificates: ${error}`);
       this.generateSelfSignedCertificate();

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