@push.rocks/smartproxy 20.0.0 → 21.0.0

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

@@ -1,312 +0,0 @@
-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, createSocketWithErrorHandler, setupBidirectionalForwarding } from '../../core/utils/socket-utils.js';
-
-/**
- * Handler for HTTPS termination with HTTP backend
- */
-export class HttpsTerminateToHttpHandler extends ForwardingHandler {
-  private tlsServer: plugins.tls.Server | null = null;
-  private secureContext: plugins.tls.SecureContext | null = null;
-  
-  /**
-   * Create a new HTTPS termination with HTTP backend handler
-   * @param config The forwarding configuration
-   */
-  constructor(config: IForwardConfig) {
-    super(config);
-    
-    // Validate that this is an HTTPS terminate to HTTP configuration
-    if (config.type !== 'https-terminate-to-http') {
-      throw new Error(`Invalid configuration type for HttpsTerminateToHttpHandler: ${config.type}`);
-    }
-  }
-  
-  /**
-   * Initialize the handler, setting up TLS context
-   */
-  public async initialize(): Promise<void> {
-    // We need to load or create TLS certificates
-    if (this.config.https?.customCert) {
-      // Use custom certificate from configuration
-      this.secureContext = plugins.tls.createSecureContext({
-        key: this.config.https.customCert.key,
-        cert: this.config.https.customCert.cert
-      });
-      
-      this.emit(ForwardingHandlerEvents.CERTIFICATE_LOADED, {
-        source: 'config',
-        domain: this.config.target.host
-      });
-    } else if (this.config.acme?.enabled) {
-      // Request certificate through ACME if needed
-      this.emit(ForwardingHandlerEvents.CERTIFICATE_NEEDED, {
-        domain: Array.isArray(this.config.target.host) 
-          ? this.config.target.host[0] 
-          : this.config.target.host,
-        useProduction: this.config.acme.production || false
-      });
-      
-      // In a real implementation, we would wait for the certificate to be issued
-      // For now, we'll use a dummy context
-      this.secureContext = plugins.tls.createSecureContext({
-        key: '-----BEGIN PRIVATE KEY-----\nDummy key\n-----END PRIVATE KEY-----',
-        cert: '-----BEGIN CERTIFICATE-----\nDummy cert\n-----END CERTIFICATE-----'
-      });
-    } else {
-      throw new Error('HTTPS termination requires either a custom certificate or ACME enabled');
-    }
-  }
-  
-  /**
-   * Set the secure context for TLS termination
-   * Called when a certificate is available
-   * @param context The secure context
-   */
-  public setSecureContext(context: plugins.tls.SecureContext): void {
-    this.secureContext = context;
-  }
-  
-  /**
-   * Handle a TLS/SSL socket connection by terminating TLS and forwarding to HTTP backend
-   * @param clientSocket The incoming socket from the client
-   */
-  public handleConnection(clientSocket: plugins.net.Socket): void {
-    // Make sure we have a secure context
-    if (!this.secureContext) {
-      clientSocket.destroy(new Error('TLS secure context not initialized'));
-      return;
-    }
-    
-    const remoteAddress = clientSocket.remoteAddress || 'unknown';
-    const remotePort = clientSocket.remotePort || 0;
-    
-    // Create a TLS socket using our secure context
-    const tlsSocket = new plugins.tls.TLSSocket(clientSocket, {
-      secureContext: this.secureContext,
-      isServer: true,
-      server: this.tlsServer || undefined
-    });
-    
-    this.emit(ForwardingHandlerEvents.CONNECTED, {
-      remoteAddress,
-      remotePort,
-      tls: true
-    });
-    
-    // Variables to track connections
-    let backendSocket: plugins.net.Socket | null = null;
-    let dataBuffer = Buffer.alloc(0);
-    let connectionEstablished = false;
-    let forwardingSetup = false;
-    
-    // Set up initial error handling for TLS socket
-    const tlsCleanupHandler = (reason: string) => {
-      if (!forwardingSetup) {
-        // If forwarding not set up yet, emit disconnected and cleanup
-        this.emit(ForwardingHandlerEvents.DISCONNECTED, {
-          remoteAddress,
-          reason
-        });
-        dataBuffer = Buffer.alloc(0);
-        connectionEstablished = false;
-        
-        if (!tlsSocket.destroyed) {
-          tlsSocket.destroy();
-        }
-        if (backendSocket && !backendSocket.destroyed) {
-          backendSocket.destroy();
-        }
-      }
-      // If forwarding is setup, setupBidirectionalForwarding will handle cleanup
-    };
-    
-    setupSocketHandlers(tlsSocket, tlsCleanupHandler, undefined, 'tls');
-    
-    // Set timeout
-    const timeout = this.getTimeout();
-    tlsSocket.setTimeout(timeout);
-    
-    tlsSocket.on('timeout', () => {
-      this.emit(ForwardingHandlerEvents.ERROR, {
-        remoteAddress,
-        error: 'TLS connection timeout'
-      });
-      tlsCleanupHandler('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')) && !connectionEstablished) {
-        const target = this.getTargetFromConfig();
-        
-        // Create backend connection with immediate error handling
-        backendSocket = createSocketWithErrorHandler({
-          port: target.port,
-          host: target.host,
-          onError: (error) => {
-            this.emit(ForwardingHandlerEvents.ERROR, {
-              error: error.message,
-              code: (error as any).code || 'UNKNOWN',
-              remoteAddress,
-              target: `${target.host}:${target.port}`
-            });
-            
-            // Clean up the TLS socket since we can't forward
-            if (!tlsSocket.destroyed) {
-              tlsSocket.destroy();
-            }
-            
-            this.emit(ForwardingHandlerEvents.DISCONNECTED, {
-              remoteAddress,
-              reason: `backend_connection_failed: ${error.message}`
-            });
-          },
-          onConnect: () => {
-            connectionEstablished = true;
-            
-            // Send buffered data
-            if (dataBuffer.length > 0) {
-              backendSocket!.write(dataBuffer);
-              dataBuffer = Buffer.alloc(0);
-            }
-            
-            // Now set up bidirectional forwarding with proper cleanup
-            forwardingSetup = true;
-            setupBidirectionalForwarding(tlsSocket, backendSocket!, {
-              onCleanup: (reason) => {
-                this.emit(ForwardingHandlerEvents.DISCONNECTED, {
-                  remoteAddress,
-                  reason
-                });
-                dataBuffer = Buffer.alloc(0);
-                connectionEstablished = false;
-                forwardingSetup = false;
-              },
-              enableHalfOpen: false // Close both when one closes
-            });
-          }
-        });
-        
-        // Additional error logging for backend socket
-        backendSocket.on('error', (error) => {
-          if (!connectionEstablished) {
-            // Connection failed during setup
-            this.emit(ForwardingHandlerEvents.ERROR, {
-              remoteAddress,
-              error: `Target connection error: ${error.message}`
-            });
-          }
-          // If connected, setupBidirectionalForwarding handles cleanup
-        });
-      }
-    });
-  }
-  
-  /**
-   * Handle an HTTP request by forwarding to the HTTP backend
-   * @param req The HTTP request
-   * @param res The HTTP response
-   */
-  public handleHttpRequest(req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse): void {
-    // Check if we should redirect to HTTPS
-    if (this.config.http?.redirectToHttps) {
-      this.redirectToHttps(req, res);
-      return;
-    }
-    
-    // Get the target from configuration
-    const target = this.getTargetFromConfig();
-    
-    // Create custom headers with variable substitution
-    const variables = {
-      clientIp: req.socket.remoteAddress || 'unknown'
-    };
-    
-    // Prepare headers, merging with any custom headers from config
-    const headers = this.applyCustomHeaders(req.headers, variables);
-    
-    // Create the proxy request options
-    const options = {
-      hostname: target.host,
-      port: target.port,
-      path: req.url,
-      method: req.method,
-      headers
-    };
-    
-    // Create the proxy request
-    const proxyReq = plugins.http.request(options, (proxyRes) => {
-      // Copy status code and headers from the proxied response
-      res.writeHead(proxyRes.statusCode || 500, proxyRes.headers);
-      
-      // Pipe the proxy response to the client response
-      proxyRes.pipe(res);
-      
-      // Track response size for logging
-      let responseSize = 0;
-      proxyRes.on('data', (chunk) => {
-        responseSize += chunk.length;
-      });
-      
-      proxyRes.on('end', () => {
-        this.emit(ForwardingHandlerEvents.HTTP_RESPONSE, {
-          statusCode: proxyRes.statusCode,
-          headers: proxyRes.headers,
-          size: responseSize
-        });
-      });
-    });
-    
-    // Handle errors in the proxy request
-    proxyReq.on('error', (error) => {
-      this.emit(ForwardingHandlerEvents.ERROR, {
-        remoteAddress: req.socket.remoteAddress,
-        error: `Proxy request error: ${error.message}`
-      });
-      
-      // Send an error response if headers haven't been sent yet
-      if (!res.headersSent) {
-        res.writeHead(502, { 'Content-Type': 'text/plain' });
-        res.end(`Error forwarding request: ${error.message}`);
-      } else {
-        // Just end the response if headers have already been sent
-        res.end();
-      }
-    });
-    
-    // Track request details for logging
-    let requestSize = 0;
-    req.on('data', (chunk) => {
-      requestSize += chunk.length;
-    });
-    
-    // Log the request
-    this.emit(ForwardingHandlerEvents.HTTP_REQUEST, {
-      method: req.method,
-      url: req.url,
-      headers: req.headers,
-      remoteAddress: req.socket.remoteAddress,
-      target: `${target.host}:${target.port}`
-    });
-    
-    // Pipe the client request to the proxy request
-    if (req.readable) {
-      req.pipe(proxyReq);
-    } else {
-      proxyReq.end();
-    }
-  }
-}

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

@@ -1,297 +0,0 @@
-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, createSocketWithErrorHandler, setupBidirectionalForwarding } from '../../core/utils/socket-utils.js';
-
-/**
- * Handler for HTTPS termination with HTTPS backend
- */
-export class HttpsTerminateToHttpsHandler extends ForwardingHandler {
-  private secureContext: plugins.tls.SecureContext | null = null;
-  
-  /**
-   * Create a new HTTPS termination with HTTPS backend handler
-   * @param config The forwarding configuration
-   */
-  constructor(config: IForwardConfig) {
-    super(config);
-    
-    // Validate that this is an HTTPS terminate to HTTPS configuration
-    if (config.type !== 'https-terminate-to-https') {
-      throw new Error(`Invalid configuration type for HttpsTerminateToHttpsHandler: ${config.type}`);
-    }
-  }
-  
-  /**
-   * Initialize the handler, setting up TLS context
-   */
-  public async initialize(): Promise<void> {
-    // We need to load or create TLS certificates for termination
-    if (this.config.https?.customCert) {
-      // Use custom certificate from configuration
-      this.secureContext = plugins.tls.createSecureContext({
-        key: this.config.https.customCert.key,
-        cert: this.config.https.customCert.cert
-      });
-      
-      this.emit(ForwardingHandlerEvents.CERTIFICATE_LOADED, {
-        source: 'config',
-        domain: this.config.target.host
-      });
-    } else if (this.config.acme?.enabled) {
-      // Request certificate through ACME if needed
-      this.emit(ForwardingHandlerEvents.CERTIFICATE_NEEDED, {
-        domain: Array.isArray(this.config.target.host) 
-          ? this.config.target.host[0] 
-          : this.config.target.host,
-        useProduction: this.config.acme.production || false
-      });
-      
-      // In a real implementation, we would wait for the certificate to be issued
-      // For now, we'll use a dummy context
-      this.secureContext = plugins.tls.createSecureContext({
-        key: '-----BEGIN PRIVATE KEY-----\nDummy key\n-----END PRIVATE KEY-----',
-        cert: '-----BEGIN CERTIFICATE-----\nDummy cert\n-----END CERTIFICATE-----'
-      });
-    } else {
-      throw new Error('HTTPS termination requires either a custom certificate or ACME enabled');
-    }
-  }
-  
-  /**
-   * Set the secure context for TLS termination
-   * Called when a certificate is available
-   * @param context The secure context
-   */
-  public setSecureContext(context: plugins.tls.SecureContext): void {
-    this.secureContext = context;
-  }
-  
-  /**
-   * Handle a TLS/SSL socket connection by terminating TLS and creating a new TLS connection to backend
-   * @param clientSocket The incoming socket from the client
-   */
-  public handleConnection(clientSocket: plugins.net.Socket): void {
-    // Make sure we have a secure context
-    if (!this.secureContext) {
-      clientSocket.destroy(new Error('TLS secure context not initialized'));
-      return;
-    }
-    
-    const remoteAddress = clientSocket.remoteAddress || 'unknown';
-    const remotePort = clientSocket.remotePort || 0;
-    
-    // Create a TLS socket using our secure context
-    const tlsSocket = new plugins.tls.TLSSocket(clientSocket, {
-      secureContext: this.secureContext,
-      isServer: true
-    });
-    
-    this.emit(ForwardingHandlerEvents.CONNECTED, {
-      remoteAddress,
-      remotePort,
-      tls: true
-    });
-    
-    // Variable to track backend socket
-    let backendSocket: plugins.tls.TLSSocket | null = null;
-    let isConnectedToBackend = false;
-    
-    // Set up initial error handling for TLS socket
-    const tlsCleanupHandler = (reason: string) => {
-      if (!isConnectedToBackend) {
-        // If backend not connected yet, just emit disconnected event
-        this.emit(ForwardingHandlerEvents.DISCONNECTED, {
-          remoteAddress,
-          reason
-        });
-        
-        // Cleanup TLS socket if needed
-        if (!tlsSocket.destroyed) {
-          tlsSocket.destroy();
-        }
-      }
-      // If connected to backend, setupBidirectionalForwarding will handle cleanup
-    };
-    
-    setupSocketHandlers(tlsSocket, tlsCleanupHandler, undefined, 'tls');
-    
-    // Set timeout
-    const timeout = this.getTimeout();
-    tlsSocket.setTimeout(timeout);
-    
-    tlsSocket.on('timeout', () => {
-      this.emit(ForwardingHandlerEvents.ERROR, {
-        remoteAddress,
-        error: 'TLS connection timeout'
-      });
-      tlsCleanupHandler('timeout');
-    });
-    
-    // Get the target from configuration
-    const target = this.getTargetFromConfig();
-    
-    // Set up the connection to the HTTPS backend
-    const connectToBackend = () => {
-      backendSocket = plugins.tls.connect({
-        host: target.host,
-        port: target.port,
-        // In a real implementation, we would configure TLS options
-        rejectUnauthorized: false // For testing only, never use in production
-      }, () => {
-        isConnectedToBackend = true;
-        
-        this.emit(ForwardingHandlerEvents.DATA_FORWARDED, {
-          direction: 'outbound',
-          target: `${target.host}:${target.port}`,
-          tls: true
-        });
-        
-        // Set up bidirectional forwarding with proper cleanup
-        setupBidirectionalForwarding(tlsSocket, backendSocket!, {
-          onCleanup: (reason) => {
-            this.emit(ForwardingHandlerEvents.DISCONNECTED, {
-              remoteAddress,
-              reason
-            });
-          },
-          enableHalfOpen: false // Close both when one closes
-        });
-        
-        // Set timeout for backend socket
-        backendSocket!.setTimeout(timeout);
-        
-        backendSocket!.on('timeout', () => {
-          this.emit(ForwardingHandlerEvents.ERROR, {
-            remoteAddress,
-            error: 'Backend connection timeout'
-          });
-          // Let setupBidirectionalForwarding handle the cleanup
-        });
-      });
-      
-      // Handle backend connection errors
-      backendSocket.on('error', (error) => {
-        this.emit(ForwardingHandlerEvents.ERROR, {
-          remoteAddress,
-          error: `Backend connection error: ${error.message}`
-        });
-        
-        if (!isConnectedToBackend) {
-          // Connection failed, clean up TLS socket
-          if (!tlsSocket.destroyed) {
-            tlsSocket.destroy();
-          }
-          this.emit(ForwardingHandlerEvents.DISCONNECTED, {
-            remoteAddress,
-            reason: `backend_connection_failed: ${error.message}`
-          });
-        }
-        // If connected, let setupBidirectionalForwarding handle cleanup
-      });
-    };
-    
-    // Wait for the TLS handshake to complete before connecting to backend
-    tlsSocket.on('secure', () => {
-      connectToBackend();
-    });
-  }
-  
-  /**
-   * Handle an HTTP request by forwarding to the HTTPS backend
-   * @param req The HTTP request
-   * @param res The HTTP response
-   */
-  public handleHttpRequest(req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse): void {
-    // Check if we should redirect to HTTPS
-    if (this.config.http?.redirectToHttps) {
-      this.redirectToHttps(req, res);
-      return;
-    }
-    
-    // Get the target from configuration
-    const target = this.getTargetFromConfig();
-    
-    // Create custom headers with variable substitution
-    const variables = {
-      clientIp: req.socket.remoteAddress || 'unknown'
-    };
-    
-    // Prepare headers, merging with any custom headers from config
-    const headers = this.applyCustomHeaders(req.headers, variables);
-    
-    // Create the proxy request options
-    const options = {
-      hostname: target.host,
-      port: target.port,
-      path: req.url,
-      method: req.method,
-      headers,
-      // In a real implementation, we would configure TLS options
-      rejectUnauthorized: false // For testing only, never use in production
-    };
-    
-    // Create the proxy request using HTTPS
-    const proxyReq = plugins.https.request(options, (proxyRes) => {
-      // Copy status code and headers from the proxied response
-      res.writeHead(proxyRes.statusCode || 500, proxyRes.headers);
-      
-      // Pipe the proxy response to the client response
-      proxyRes.pipe(res);
-      
-      // Track response size for logging
-      let responseSize = 0;
-      proxyRes.on('data', (chunk) => {
-        responseSize += chunk.length;
-      });
-      
-      proxyRes.on('end', () => {
-        this.emit(ForwardingHandlerEvents.HTTP_RESPONSE, {
-          statusCode: proxyRes.statusCode,
-          headers: proxyRes.headers,
-          size: responseSize
-        });
-      });
-    });
-    
-    // Handle errors in the proxy request
-    proxyReq.on('error', (error) => {
-      this.emit(ForwardingHandlerEvents.ERROR, {
-        remoteAddress: req.socket.remoteAddress,
-        error: `Proxy request error: ${error.message}`
-      });
-      
-      // Send an error response if headers haven't been sent yet
-      if (!res.headersSent) {
-        res.writeHead(502, { 'Content-Type': 'text/plain' });
-        res.end(`Error forwarding request: ${error.message}`);
-      } else {
-        // Just end the response if headers have already been sent
-        res.end();
-      }
-    });
-    
-    // Track request details for logging
-    let requestSize = 0;
-    req.on('data', (chunk) => {
-      requestSize += chunk.length;
-    });
-    
-    // Log the request
-    this.emit(ForwardingHandlerEvents.HTTP_REQUEST, {
-      method: req.method,
-      url: req.url,
-      headers: req.headers,
-      remoteAddress: req.socket.remoteAddress,
-      target: `${target.host}:${target.port}`
-    });
-    
-    // Pipe the client request to the proxy request
-    if (req.readable) {
-      req.pipe(proxyReq);
-    } else {
-      proxyReq.end();
-    }
-  }
-}

package/ts/forwarding/handlers/index.ts

@@ -1,9 +0,0 @@
-/**
- * Forwarding handler implementations
- */
-
-export { ForwardingHandler } from './base-handler.js';
-export { HttpForwardingHandler } from './http-handler.js';
-export { HttpsPassthroughHandler } from './https-passthrough-handler.js';
-export { HttpsTerminateToHttpHandler } from './https-terminate-to-http-handler.js';
-export { HttpsTerminateToHttpsHandler } from './https-terminate-to-https-handler.js';

package/ts/forwarding/index.ts

@@ -1,35 +0,0 @@
-/**
- * Forwarding system module
- * Provides a flexible and type-safe way to configure and manage various forwarding strategies
- */
-
-// Export handlers
-export { ForwardingHandler } from './handlers/base-handler.js';
-export * from './handlers/http-handler.js';
-export * from './handlers/https-passthrough-handler.js';
-export * from './handlers/https-terminate-to-http-handler.js';
-export * from './handlers/https-terminate-to-https-handler.js';
-
-// Export factory
-export * from './factory/forwarding-factory.js';
-
-// Export types - these include TForwardingType and IForwardConfig
-export type { 
-  TForwardingType,
-  IForwardConfig,
-  IForwardingHandler
-} from './config/forwarding-types.js';
-
-export { 
-  ForwardingHandlerEvents
-} from './config/forwarding-types.js';
-
-// Export route helpers directly from route-patterns
-export {
-  createHttpRoute,
-  createHttpsTerminateRoute,
-  createHttpsPassthroughRoute,
-  createHttpToHttpsRedirect,
-  createCompleteHttpsServer,
-  createLoadBalancerRoute
-} from '../proxies/smart-proxy/utils/route-patterns.js';