@push.rocks/smartproxy 19.3.2 → 19.3.4

package/ts/proxies/http-proxy/handlers/redirect-handler.ts

@@ -0,0 +1,105 @@
+import * as plugins from '../../../plugins.js';
+import type { IRouteConfig } from '../../smart-proxy/models/route-types.js';
+import type { IConnectionRecord } from '../../smart-proxy/models/interfaces.js';
+import type { ILogger } from '../models/types.js';
+import { createLogger } from '../models/types.js';
+import { HttpStatus, getStatusText } from '../models/http-types.js';
+
+export interface IRedirectHandlerContext {
+  connectionId: string;
+  connectionManager: any; // Avoid circular deps
+  settings: any;
+  logger?: ILogger;
+}
+
+/**
+ * Handles HTTP redirect routes
+ */
+export class RedirectHandler {
+  /**
+   * Handle redirect routes
+   */
+  public static async handleRedirect(
+    socket: plugins.net.Socket,
+    route: IRouteConfig,
+    context: IRedirectHandlerContext
+  ): Promise<void> {
+    const { connectionId, connectionManager, settings } = context;
+    const logger = context.logger || createLogger(settings.logLevel || 'info');
+    const action = route.action;
+
+    // We should have a redirect configuration
+    if (!action.redirect) {
+      logger.error(`[${connectionId}] Redirect action missing redirect configuration`);
+      socket.end();
+      connectionManager.cleanupConnection({ id: connectionId }, 'missing_redirect');
+      return;
+    }
+
+    // For TLS connections, we can't do redirects at the TCP level
+    // This check should be done before calling this handler
+    
+    // Wait for the first HTTP request to perform the redirect
+    const dataListeners: ((chunk: Buffer) => void)[] = [];
+
+    const httpDataHandler = (chunk: Buffer) => {
+      // Remove all data listeners to avoid duplicated processing
+      for (const listener of dataListeners) {
+        socket.removeListener('data', listener);
+      }
+
+      // Parse HTTP request to get path
+      try {
+        const headersEnd = chunk.indexOf('\r\n\r\n');
+        if (headersEnd === -1) {
+          // Not a complete HTTP request, need more data
+          socket.once('data', httpDataHandler);
+          dataListeners.push(httpDataHandler);
+          return;
+        }
+
+        const httpHeaders = chunk.slice(0, headersEnd).toString();
+        const requestLine = httpHeaders.split('\r\n')[0];
+        const [method, path] = requestLine.split(' ');
+
+        // Extract Host header
+        const hostMatch = httpHeaders.match(/Host: (.+?)(\r\n|\r|\n|$)/i);
+        const host = hostMatch ? hostMatch[1].trim() : '';
+
+        // Process the redirect URL with template variables
+        let redirectUrl = action.redirect.to;
+        redirectUrl = redirectUrl.replace(/\{domain\}/g, host);
+        redirectUrl = redirectUrl.replace(/\{path\}/g, path || '');
+        redirectUrl = redirectUrl.replace(/\{port\}/g, socket.localPort?.toString() || '80');
+
+        // Prepare the HTTP redirect response
+        const redirectResponse = [
+          `HTTP/1.1 ${action.redirect.status} Moved`,
+          `Location: ${redirectUrl}`,
+          'Connection: close',
+          'Content-Length: 0',
+          '',
+          '',
+        ].join('\r\n');
+
+        if (settings.enableDetailedLogging) {
+          logger.info(
+            `[${connectionId}] Redirecting to ${redirectUrl} with status ${action.redirect.status}`
+          );
+        }
+
+        // Send the redirect response
+        socket.end(redirectResponse);
+        connectionManager.initiateCleanupOnce({ id: connectionId }, 'redirect_complete');
+      } catch (err) {
+        logger.error(`[${connectionId}] Error processing HTTP redirect: ${err}`);
+        socket.end();
+        connectionManager.initiateCleanupOnce({ id: connectionId }, 'redirect_error');
+      }
+    };
+
+    // Setup the HTTP data handler
+    socket.once('data', httpDataHandler);
+    dataListeners.push(httpDataHandler);
+  }
+}

package/ts/proxies/http-proxy/handlers/static-handler.ts

@@ -0,0 +1,251 @@
+import * as plugins from '../../../plugins.js';
+import type { IRouteConfig } from '../../smart-proxy/models/route-types.js';
+import type { IConnectionRecord } from '../../smart-proxy/models/interfaces.js';
+import type { ILogger } from '../models/types.js';
+import { createLogger } from '../models/types.js';
+import type { IRouteContext } from '../../../core/models/route-context.js';
+import { HttpStatus, getStatusText } from '../models/http-types.js';
+
+export interface IStaticHandlerContext {
+  connectionId: string;
+  connectionManager: any; // Avoid circular deps
+  settings: any;
+  logger?: ILogger;
+}
+
+/**
+ * Handles static routes including ACME challenges
+ */
+export class StaticHandler {
+  /**
+   * Handle static routes
+   */
+  public static async handleStatic(
+    socket: plugins.net.Socket,
+    route: IRouteConfig,
+    context: IStaticHandlerContext,
+    record: IConnectionRecord
+  ): Promise<void> {
+    const { connectionId, connectionManager, settings } = context;
+    const logger = context.logger || createLogger(settings.logLevel || 'info');
+
+    if (!route.action.handler) {
+      logger.error(`[${connectionId}] Static route '${route.name}' has no handler`);
+      socket.end();
+      connectionManager.cleanupConnection(record, 'no_handler');
+      return;
+    }
+
+    let buffer = Buffer.alloc(0);
+    let processingData = false;
+
+    const handleHttpData = async (chunk: Buffer) => {
+      // Accumulate the data
+      buffer = Buffer.concat([buffer, chunk]);
+
+      // Prevent concurrent processing of the same buffer
+      if (processingData) return;
+      processingData = true;
+
+      try {
+        // Process data until we have a complete request or need more data
+        await processBuffer();
+      } finally {
+        processingData = false;
+      }
+    };
+
+    const processBuffer = async () => {
+      // Look for end of HTTP headers
+      const headerEndIndex = buffer.indexOf('\r\n\r\n');
+      if (headerEndIndex === -1) {
+        // Need more data
+        if (buffer.length > 8192) {
+          // Prevent excessive buffering
+          logger.error(`[${connectionId}] HTTP headers too large`);
+          socket.end();
+          connectionManager.cleanupConnection(record, 'headers_too_large');
+        }
+        return; // Wait for more data to arrive
+      }
+
+      // Parse the HTTP request
+      const headerBuffer = buffer.slice(0, headerEndIndex);
+      const headers = headerBuffer.toString();
+      const lines = headers.split('\r\n');
+
+      if (lines.length === 0) {
+        logger.error(`[${connectionId}] Invalid HTTP request`);
+        socket.end();
+        connectionManager.cleanupConnection(record, 'invalid_request');
+        return;
+      }
+
+      // Parse request line
+      const requestLine = lines[0];
+      const requestParts = requestLine.split(' ');
+      if (requestParts.length < 3) {
+        logger.error(`[${connectionId}] Invalid HTTP request line`);
+        socket.end();
+        connectionManager.cleanupConnection(record, 'invalid_request_line');
+        return;
+      }
+
+      const [method, path, httpVersion] = requestParts;
+
+      // Parse headers
+      const headersMap: Record<string, string> = {};
+      for (let i = 1; i < lines.length; i++) {
+        const colonIndex = lines[i].indexOf(':');
+        if (colonIndex > 0) {
+          const key = lines[i].slice(0, colonIndex).trim().toLowerCase();
+          const value = lines[i].slice(colonIndex + 1).trim();
+          headersMap[key] = value;
+        }
+      }
+
+      // Check for Content-Length to handle request body
+      const requestBodyLength = parseInt(headersMap['content-length'] || '0', 10);
+      const bodyStartIndex = headerEndIndex + 4; // Skip the \r\n\r\n
+
+      // If there's a body, ensure we have the full body
+      if (requestBodyLength > 0) {
+        const totalExpectedLength = bodyStartIndex + requestBodyLength;
+
+        // If we don't have the complete body yet, wait for more data
+        if (buffer.length < totalExpectedLength) {
+          // Implement a reasonable body size limit to prevent memory issues
+          if (requestBodyLength > 1024 * 1024) {
+            // 1MB limit
+            logger.error(`[${connectionId}] Request body too large`);
+            socket.end();
+            connectionManager.cleanupConnection(record, 'body_too_large');
+            return;
+          }
+          return; // Wait for more data
+        }
+      }
+
+      // Extract query string if present
+      let pathname = path;
+      let query: string | undefined;
+      const queryIndex = path.indexOf('?');
+      if (queryIndex !== -1) {
+        pathname = path.slice(0, queryIndex);
+        query = path.slice(queryIndex + 1);
+      }
+
+      try {
+        // Get request body if present
+        let requestBody: Buffer | undefined;
+        if (requestBodyLength > 0) {
+          requestBody = buffer.slice(bodyStartIndex, bodyStartIndex + requestBodyLength);
+        }
+
+        // Pause socket to prevent data loss during async processing
+        socket.pause();
+
+        // Remove the data listener since we're handling the request
+        socket.removeListener('data', handleHttpData);
+
+        // Build route context with parsed HTTP information
+        const context: IRouteContext = {
+          port: record.localPort,
+          domain: record.lockedDomain || headersMap['host']?.split(':')[0],
+          clientIp: record.remoteIP,
+          serverIp: socket.localAddress!,
+          path: pathname,
+          query: query,
+          headers: headersMap,
+          isTls: record.isTLS,
+          tlsVersion: record.tlsVersion,
+          routeName: route.name,
+          routeId: route.id,
+          timestamp: Date.now(),
+          connectionId,
+        };
+
+        // Since IRouteContext doesn't have a body property,
+        // we need an alternative approach to handle the body
+        let response;
+
+        if (requestBody) {
+          if (settings.enableDetailedLogging) {
+            logger.info(
+              `[${connectionId}] Processing request with body (${requestBody.length} bytes)`
+            );
+          }
+
+          // Pass the body as an additional parameter by extending the context object
+          // This is not type-safe, but it allows handlers that expect a body to work
+          const extendedContext = {
+            ...context,
+            // Provide both raw buffer and string representation
+            requestBody: requestBody,
+            requestBodyText: requestBody.toString(),
+            method: method,
+          };
+
+          // Call the handler with the extended context
+          // The handler needs to know to look for the non-standard properties
+          response = await route.action.handler(extendedContext as any);
+        } else {
+          // Call the handler with the standard context
+          const extendedContext = {
+            ...context,
+            method: method,
+          };
+          response = await route.action.handler(extendedContext as any);
+        }
+
+        // Prepare the HTTP response
+        const responseHeaders = response.headers || {};
+        const contentLength = Buffer.byteLength(response.body || '');
+        responseHeaders['Content-Length'] = contentLength.toString();
+
+        if (!responseHeaders['Content-Type']) {
+          responseHeaders['Content-Type'] = 'text/plain';
+        }
+
+        // Build the response
+        let httpResponse = `HTTP/1.1 ${response.status} ${getStatusText(response.status)}\r\n`;
+        for (const [key, value] of Object.entries(responseHeaders)) {
+          httpResponse += `${key}: ${value}\r\n`;
+        }
+        httpResponse += '\r\n';
+
+        // Send response
+        socket.write(httpResponse);
+        if (response.body) {
+          socket.write(response.body);
+        }
+        socket.end();
+
+        connectionManager.cleanupConnection(record, 'completed');
+      } catch (error) {
+        logger.error(`[${connectionId}] Error in static handler: ${error}`);
+
+        // Send error response
+        const errorResponse =
+          'HTTP/1.1 500 Internal Server Error\r\n' +
+          'Content-Type: text/plain\r\n' +
+          'Content-Length: 21\r\n' +
+          '\r\n' +
+          'Internal Server Error';
+        socket.write(errorResponse);
+        socket.end();
+
+        connectionManager.cleanupConnection(record, 'handler_error');
+      }
+    };
+
+    // Listen for data
+    socket.on('data', handleHttpData);
+
+    // Ensure cleanup on socket close
+    socket.once('close', () => {
+      socket.removeListener('data', handleHttpData);
+    });
+  }
+}
+

package/ts/proxies/{network-proxy/network-proxy.ts → http-proxy/http-proxy.ts}

@@ -5,7 +5,7 @@ import {
   convertLegacyConfigToRouteConfig
 } from './models/types.js';
 import type {
-  INetworkProxyOptions,
+  IHttpProxyOptions,
   ILogger,
   IReverseProxyConfig
 } from './models/types.js';
@@ -16,21 +16,22 @@ import { CertificateManager } from './certificate-manager.js';
 import { ConnectionPool } from './connection-pool.js';
 import { RequestHandler, type IMetricsTracker } from './request-handler.js';
 import { WebSocketHandler } from './websocket-handler.js';
-import { ProxyRouter } from '../../http/router/index.js';
-import { RouteRouter } from '../../http/router/route-router.js';
+import { ProxyRouter } from '../../routing/router/index.js';
+import { RouteRouter } from '../../routing/router/route-router.js';
 import { FunctionCache } from './function-cache.js';
 
 /**
- * NetworkProxy provides a reverse proxy with TLS termination, WebSocket support,
+ * HttpProxy provides a reverse proxy with TLS termination, WebSocket support,
  * automatic certificate management, and high-performance connection pooling.
+ * Handles all HTTP/HTTPS traffic including redirects, ACME challenges, and static routes.
  */
-export class NetworkProxy implements IMetricsTracker {
+export class HttpProxy implements IMetricsTracker {
   // Provide a minimal JSON representation to avoid circular references during deep equality checks
   public toJSON(): any {
     return {};
   }
   // Configuration
-  public options: INetworkProxyOptions;
+  public options: IHttpProxyOptions;
   public routes: IRouteConfig[] = [];
 
   // Server instances (HTTP/2 with HTTP/1 fallback)
@@ -66,9 +67,9 @@ export class NetworkProxy implements IMetricsTracker {
   private logger: ILogger;
 
   /**
-   * Creates a new NetworkProxy instance
+   * Creates a new HttpProxy instance
    */
-  constructor(optionsArg: INetworkProxyOptions) {
+  constructor(optionsArg: IHttpProxyOptions) {
     // Set default options
     this.options = {
       port: optionsArg.port,
@@ -155,7 +156,7 @@ export class NetworkProxy implements IMetricsTracker {
   }
 
   /**
-   * Returns the port number this NetworkProxy is listening on
+   * Returns the port number this HttpProxy is listening on
    * Useful for SmartProxy to determine where to forward connections
    */
   public getListeningPort(): number {
@@ -202,7 +203,7 @@ export class NetworkProxy implements IMetricsTracker {
 
   /**
    * Returns current server metrics
-   * Useful for SmartProxy to determine which NetworkProxy to use for load balancing
+   * Useful for SmartProxy to determine which HttpProxy to use for load balancing
    */
   public getMetrics(): any {
     return {
@@ -259,7 +260,7 @@ export class NetworkProxy implements IMetricsTracker {
     // Start the server
     return new Promise((resolve) => {
       this.httpsServer.listen(this.options.port, () => {
-        this.logger.info(`NetworkProxy started on port ${this.options.port}`);
+        this.logger.info(`HttpProxy started on port ${this.options.port}`);
         resolve();
       });
     });
@@ -352,7 +353,7 @@ export class NetworkProxy implements IMetricsTracker {
   }
 
   /**
-   * Updates the route configurations - this is the primary method for configuring NetworkProxy
+   * Updates the route configurations - this is the primary method for configuring HttpProxy
    * @param routes The new route configurations to use
    */
   public async updateRouteConfigs(routes: IRouteConfig[]): Promise<void> {
@@ -503,7 +504,7 @@ export class NetworkProxy implements IMetricsTracker {
    * Stops the proxy server
    */
   public async stop(): Promise<void> {
-    this.logger.info('Stopping NetworkProxy server');
+    this.logger.info('Stopping HttpProxy server');
     
     // Clear intervals
     if (this.metricsInterval) {
@@ -534,7 +535,7 @@ export class NetworkProxy implements IMetricsTracker {
     // Close the HTTPS server
     return new Promise((resolve) => {
       this.httpsServer.close(() => {
-        this.logger.info('NetworkProxy server stopped successfully');
+        this.logger.info('HttpProxy server stopped successfully');
         resolve();
       });
     });

package/ts/proxies/{network-proxy → http-proxy}/index.ts

@@ -1,11 +1,11 @@
 /**
- * NetworkProxy implementation
+ * HttpProxy implementation
  */
 // Re-export models
 export * from './models/index.js';
 
-// Export NetworkProxy and supporting classes
-export { NetworkProxy } from './network-proxy.js';
+// Export HttpProxy and supporting classes
+export { HttpProxy } from './http-proxy.js';
 export { CertificateManager } from './certificate-manager.js';
 export { ConnectionPool } from './connection-pool.js';
 export { RequestHandler } from './request-handler.js';

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

@@ -0,0 +1,165 @@
+import * as plugins from '../../../plugins.js';
+
+/**
+ * HTTP-specific event types
+ */
+export enum HttpEvents {
+  REQUEST_RECEIVED = 'request-received',
+  REQUEST_FORWARDED = 'request-forwarded',
+  REQUEST_HANDLED = 'request-handled',
+  REQUEST_ERROR = 'request-error',
+}
+
+/**
+ * HTTP status codes as an enum for better type safety
+ */
+export enum HttpStatus {
+  OK = 200,
+  MOVED_PERMANENTLY = 301,
+  FOUND = 302,
+  TEMPORARY_REDIRECT = 307,
+  PERMANENT_REDIRECT = 308,
+  BAD_REQUEST = 400,
+  UNAUTHORIZED = 401,
+  FORBIDDEN = 403,
+  NOT_FOUND = 404,
+  METHOD_NOT_ALLOWED = 405,
+  REQUEST_TIMEOUT = 408,
+  TOO_MANY_REQUESTS = 429,
+  INTERNAL_SERVER_ERROR = 500,
+  NOT_IMPLEMENTED = 501,
+  BAD_GATEWAY = 502,
+  SERVICE_UNAVAILABLE = 503,
+  GATEWAY_TIMEOUT = 504,
+}
+
+/**
+ * Base error class for HTTP-related errors
+ */
+export class HttpError extends Error {
+  constructor(message: string, public readonly statusCode: HttpStatus = HttpStatus.INTERNAL_SERVER_ERROR) {
+    super(message);
+    this.name = 'HttpError';
+  }
+}
+
+/**
+ * Error related to certificate operations
+ */
+export class CertificateError extends HttpError {
+  constructor(
+    message: string,
+    public readonly domain: string,
+    public readonly isRenewal: boolean = false
+  ) {
+    super(`${message} for domain ${domain}${isRenewal ? ' (renewal)' : ''}`, HttpStatus.INTERNAL_SERVER_ERROR);
+    this.name = 'CertificateError';
+  }
+}
+
+/**
+ * Error related to server operations
+ */
+export class ServerError extends HttpError {
+  constructor(message: string, public readonly code?: string, statusCode: HttpStatus = HttpStatus.INTERNAL_SERVER_ERROR) {
+    super(message, statusCode);
+    this.name = 'ServerError';
+  }
+}
+
+/**
+ * Error for bad requests
+ */
+export class BadRequestError extends HttpError {
+  constructor(message: string) {
+    super(message, HttpStatus.BAD_REQUEST);
+    this.name = 'BadRequestError';
+  }
+}
+
+/**
+ * Error for not found resources
+ */
+export class NotFoundError extends HttpError {
+  constructor(message: string = 'Resource not found') {
+    super(message, HttpStatus.NOT_FOUND);
+    this.name = 'NotFoundError';
+  }
+}
+
+/**
+ * Redirect configuration for HTTP requests
+ */
+export interface IRedirectConfig {
+  source: string;           // Source path or pattern
+  destination: string;      // Destination URL  
+  type: HttpStatus;         // Redirect status code
+  preserveQuery?: boolean;  // Whether to preserve query parameters
+}
+
+/**
+ * HTTP router configuration
+ */
+export interface IRouterConfig {
+  routes: Array<{
+    path: string;
+    method?: string;
+    handler: (req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse) => void | Promise<void>;
+  }>;
+  notFoundHandler?: (req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse) => void;
+  errorHandler?: (error: Error, req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse) => void;
+}
+
+/**
+ * HTTP request method types
+ */
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'CONNECT' | 'TRACE';
+
+/**
+ * Helper function to get HTTP status text
+ */
+export function getStatusText(status: HttpStatus): string {
+  const statusTexts: Record<HttpStatus, string> = {
+    [HttpStatus.OK]: 'OK',
+    [HttpStatus.MOVED_PERMANENTLY]: 'Moved Permanently',
+    [HttpStatus.FOUND]: 'Found',
+    [HttpStatus.TEMPORARY_REDIRECT]: 'Temporary Redirect',
+    [HttpStatus.PERMANENT_REDIRECT]: 'Permanent Redirect',
+    [HttpStatus.BAD_REQUEST]: 'Bad Request',
+    [HttpStatus.UNAUTHORIZED]: 'Unauthorized',
+    [HttpStatus.FORBIDDEN]: 'Forbidden',
+    [HttpStatus.NOT_FOUND]: 'Not Found',
+    [HttpStatus.METHOD_NOT_ALLOWED]: 'Method Not Allowed',
+    [HttpStatus.REQUEST_TIMEOUT]: 'Request Timeout',
+    [HttpStatus.TOO_MANY_REQUESTS]: 'Too Many Requests',
+    [HttpStatus.INTERNAL_SERVER_ERROR]: 'Internal Server Error',
+    [HttpStatus.NOT_IMPLEMENTED]: 'Not Implemented',
+    [HttpStatus.BAD_GATEWAY]: 'Bad Gateway',
+    [HttpStatus.SERVICE_UNAVAILABLE]: 'Service Unavailable',
+    [HttpStatus.GATEWAY_TIMEOUT]: 'Gateway Timeout',
+  };
+  return statusTexts[status] || 'Unknown';
+}
+
+// Legacy interfaces for backward compatibility
+export interface IDomainOptions {
+  domainName: string;
+  sslRedirect: boolean;
+  acmeMaintenance: boolean;
+  forward?: { ip: string; port: number };
+  acmeForward?: { ip: string; port: number };
+}
+
+export interface IDomainCertificate {
+  options: IDomainOptions;
+  certObtained: boolean;
+  obtainingInProgress: boolean;
+  certificate?: string;
+  privateKey?: string;
+  expiryDate?: Date;
+  lastRenewalAttempt?: Date;
+}
+
+// Backward compatibility exports
+export { HttpError as Port80HandlerError };
+export { CertificateError as CertError };

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

@@ -0,0 +1,5 @@
+/**
+ * HttpProxy models
+ */
+export * from './types.js';
+export * from './http-types.js';

package/ts/proxies/{network-proxy → http-proxy}/models/types.ts

@@ -16,9 +16,9 @@ import type { IRouteConfig } from '../../smart-proxy/models/route-types.js';
 import type { IRouteContext } from '../../../core/models/route-context.js';
 
 /**
- * Configuration options for NetworkProxy
+ * Configuration options for HttpProxy
  */
-export interface INetworkProxyOptions {
+export interface IHttpProxyOptions {
   port: number;
   maxConnections?: number;
   keepAliveTimeout?: number;

package/ts/proxies/{network-proxy → http-proxy}/request-handler.ts

@@ -1,14 +1,14 @@
 import * as plugins from '../../plugins.js';
 import '../../core/models/socket-augmentation.js';
 import {
-  type INetworkProxyOptions,
+  type IHttpProxyOptions,
   type ILogger,
   createLogger,
   type IReverseProxyConfig,
   RouteManager
 } from './models/types.js';
 import { ConnectionPool } from './connection-pool.js';
-import { ProxyRouter } from '../../http/router/index.js';
+import { ProxyRouter } from '../../routing/router/index.js';
 import { ContextCreator } from './context-creator.js';
 import { HttpRequestHandler } from './http-request-handler.js';
 import { Http2RequestHandler } from './http2-request-handler.js';
@@ -46,7 +46,7 @@ export class RequestHandler {
   public securityManager: SecurityManager;
 
   constructor(
-    private options: INetworkProxyOptions,
+    private options: IHttpProxyOptions,
     private connectionPool: ConnectionPool,
     private legacyRouter: ProxyRouter, // Legacy router for backward compatibility
     private routeManager?: RouteManager,