@push.rocks/smartproxy 22.4.2 → 22.6.0

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

@@ -1,145 +0,0 @@
-import * as plugins from '../../plugins.js';
-import '../../core/models/socket-augmentation.js';
-import type { IRouteContext, IHttpRouteContext, IHttp2RouteContext } from '../../core/models/route-context.js';
-
-/**
- * Context creator for NetworkProxy
- * Creates route contexts for matching and function evaluation
- */
-export class ContextCreator {
-  /**
-   * Create a route context from HTTP request information
-   */
-  public createHttpRouteContext(req: any, options: {
-    tlsVersion?: string;
-    connectionId: string;
-    clientIp: string;
-    serverIp: string;
-  }): IHttpRouteContext {
-    // Parse headers
-    const headers: Record<string, string> = {};
-    for (const [key, value] of Object.entries(req.headers)) {
-      if (typeof value === 'string') {
-        headers[key.toLowerCase()] = value;
-      } else if (Array.isArray(value) && value.length > 0) {
-        headers[key.toLowerCase()] = value[0];
-      }
-    }
-
-    // Parse domain from Host header
-    const domain = headers['host']?.split(':')[0] || '';
-
-    // Parse URL
-    const url = new URL(`http://${domain}${req.url || '/'}`);
-
-    return {
-      // Connection basics
-      port: req.socket.localPort || 0,
-      domain,
-      clientIp: options.clientIp,
-      serverIp: options.serverIp,
-
-      // HTTP specifics
-      path: url.pathname,
-      query: url.search ? url.search.substring(1) : '',
-      headers,
-
-      // TLS information
-      isTls: !!req.socket.encrypted,
-      tlsVersion: options.tlsVersion,
-
-      // Request objects
-      req,
-
-      // Metadata
-      timestamp: Date.now(),
-      connectionId: options.connectionId
-    };
-  }
-
-  /**
-   * Create a route context from HTTP/2 stream and headers
-   */
-  public createHttp2RouteContext(
-    stream: plugins.http2.ServerHttp2Stream,
-    headers: plugins.http2.IncomingHttpHeaders,
-    options: {
-      connectionId: string;
-      clientIp: string;
-      serverIp: string;
-    }
-  ): IHttp2RouteContext {
-    // Parse headers, excluding HTTP/2 pseudo-headers
-    const processedHeaders: Record<string, string> = {};
-    for (const [key, value] of Object.entries(headers)) {
-      if (!key.startsWith(':') && typeof value === 'string') {
-        processedHeaders[key.toLowerCase()] = value;
-      }
-    }
-
-    // Get domain from :authority pseudo-header
-    const authority = headers[':authority'] as string || '';
-    const domain = authority.split(':')[0];
-
-    // Get path from :path pseudo-header
-    const path = headers[':path'] as string || '/';
-
-    // Parse the path to extract query string
-    const pathParts = path.split('?');
-    const pathname = pathParts[0];
-    const query = pathParts.length > 1 ? pathParts[1] : '';
-
-    // Get the socket from the session
-    const socket = (stream.session as any)?.socket;
-
-    return {
-      // Connection basics
-      port: socket?.localPort || 0,
-      domain,
-      clientIp: options.clientIp,
-      serverIp: options.serverIp,
-
-      // HTTP specifics
-      path: pathname,
-      query,
-      headers: processedHeaders,
-
-      // HTTP/2 specific properties
-      method: headers[':method'] as string,
-      stream,
-
-      // TLS information - HTTP/2 is always on TLS in browsers
-      isTls: true,
-      tlsVersion: socket?.getTLSVersion?.() || 'TLSv1.3',
-
-      // Metadata
-      timestamp: Date.now(),
-      connectionId: options.connectionId
-    };
-  }
-
-  /**
-   * Create a basic route context from socket information
-   */
-  public createSocketRouteContext(socket: plugins.net.Socket, options: {
-    domain?: string;
-    tlsVersion?: string;
-    connectionId: string;
-  }): IRouteContext {
-    return {
-      // Connection basics
-      port: socket.localPort || 0,
-      domain: options.domain,
-      clientIp: socket.remoteAddress?.replace('::ffff:', '') || '0.0.0.0',
-      serverIp: socket.localAddress?.replace('::ffff:', '') || '0.0.0.0',
-
-      // TLS information
-      isTls: options.tlsVersion !== undefined,
-      tlsVersion: options.tlsVersion,
-
-      // Metadata
-      timestamp: Date.now(),
-      connectionId: options.connectionId
-    };
-  }
-}

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

@@ -1,150 +0,0 @@
-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 { ILogger, ICertificateEntry } from './models/types.js';
-
-/**
- * Interface for default certificate data
- */
-export interface IDefaultCertificates {
-  key: string;
-  cert: string;
-}
-
-/**
- * Provides default SSL certificates for HttpProxy.
- * This is a minimal replacement for the deprecated CertificateManager.
- *
- * For production certificate management, use SmartCertManager instead.
- */
-export class DefaultCertificateProvider {
-  private defaultCertificates: IDefaultCertificates | null = null;
-  private certificateCache: Map<string, ICertificateEntry> = new Map();
-  private initialized = false;
-
-  constructor(private logger?: ILogger) {}
-
-  /**
-   * Load default certificates asynchronously (preferred)
-   */
-  public async loadDefaultCertificatesAsync(): Promise<IDefaultCertificates> {
-    if (this.defaultCertificates) {
-      return this.defaultCertificates;
-    }
-
-    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');
-      this.initialized = true;
-      return this.defaultCertificates;
-    } catch (error) {
-      this.logger?.warn?.(`Failed to load default certificates: ${error}`);
-      this.defaultCertificates = this.generateFallbackCertificate();
-      this.initialized = true;
-      return this.defaultCertificates;
-    }
-  }
-
-  /**
-   * Load default certificates synchronously (for backward compatibility)
-   * @deprecated Use loadDefaultCertificatesAsync instead
-   */
-  public loadDefaultCertificatesSync(): IDefaultCertificates {
-    if (this.defaultCertificates) {
-      return this.defaultCertificates;
-    }
-
-    const __dirname = path.dirname(fileURLToPath(import.meta.url));
-    const certPath = path.join(__dirname, '..', '..', '..', 'assets', 'certs');
-
-    try {
-      this.defaultCertificates = {
-        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 (sync)');
-    } catch (error) {
-      this.logger?.warn?.(`Failed to load default certificates: ${error}`);
-      this.defaultCertificates = this.generateFallbackCertificate();
-    }
-
-    this.initialized = true;
-    return this.defaultCertificates;
-  }
-
-  /**
-   * Gets the default certificates (loads synchronously if not already loaded)
-   */
-  public getDefaultCertificates(): IDefaultCertificates {
-    if (!this.defaultCertificates) {
-      return this.loadDefaultCertificatesSync();
-    }
-    return this.defaultCertificates;
-  }
-
-  /**
-   * Updates a certificate in the cache
-   */
-  public updateCertificate(domain: string, cert: string, key: string): void {
-    this.certificateCache.set(domain, {
-      cert,
-      key,
-      expires: new Date(Date.now() + 90 * 24 * 60 * 60 * 1000) // 90 days
-    });
-
-    this.logger?.info?.(`Certificate updated for ${domain}`);
-  }
-
-  /**
-   * Gets a cached certificate
-   */
-  public getCachedCertificate(domain: string): ICertificateEntry | null {
-    return this.certificateCache.get(domain) || null;
-  }
-
-  /**
-   * Gets statistics for metrics
-   */
-  public getStats(): { cachedCertificates: number; defaultCertEnabled: boolean } {
-    return {
-      cachedCertificates: this.certificateCache.size,
-      defaultCertEnabled: this.defaultCertificates !== null
-    };
-  }
-
-  /**
-   * Generate a fallback self-signed certificate placeholder
-   * Note: This is just a placeholder - real apps should provide proper certificates
-   */
-  private generateFallbackCertificate(): IDefaultCertificates {
-    this.logger?.warn?.('Using fallback self-signed certificate placeholder');
-
-    // Minimal self-signed certificate for fallback only
-    // In production, proper certificates should be provided via SmartCertManager
-    const selfSignedCert = `-----BEGIN CERTIFICATE-----
-MIIBkTCB+wIJAKHHIgIIA0/cMA0GCSqGSIb3DQEBBQUAMA0xCzAJBgNVBAYTAlVT
-MB4XDTE0MDEwMTAwMDAwMFoXDTI0MDEwMTAwMDAwMFowDTELMAkGA1UEBhMCVVMw
-gZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMRiH0VwnOH3jCV7c6JFZWYrvuqy
------END CERTIFICATE-----`;
-
-    const selfSignedKey = `-----BEGIN PRIVATE KEY-----
-MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAMRiH0VwnOH3jCV7
-c6JFZWYrvuqyALCLXj0pcr1iqNdHjegNXnkl5zjdaUjq4edNOKl7M1AlFiYjG2xk
------END PRIVATE KEY-----`;
-
-    return {
-      key: selfSignedKey,
-      cert: selfSignedCert
-    };
-  }
-}

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

@@ -1,279 +0,0 @@
-import type { IRouteContext } from '../../core/models/route-context.js';
-import type { ILogger } from './models/types.js';
-
-/**
- * Interface for cached function result
- */
-interface ICachedResult<T> {
-  value: T;
-  expiry: number;
-  hash: string;
-}
-
-/**
- * Function cache for NetworkProxy function-based targets
- * 
- * This cache improves performance for function-based targets by storing
- * the results of function evaluations and reusing them for similar contexts.
- */
-export class FunctionCache {
-  // Cache storage
-  private hostCache: Map<string, ICachedResult<string | string[]>> = new Map();
-  private portCache: Map<string, ICachedResult<number>> = new Map();
-  
-  // Maximum number of entries to store in each cache
-  private maxCacheSize: number;
-  
-  // Default TTL for cache entries in milliseconds (default: 5 seconds)
-  private defaultTtl: number;
-  
-  // Logger
-  private logger: ILogger;
-  
-  // Cleanup interval timer
-  private cleanupInterval: NodeJS.Timeout | null = null;
-  
-  /**
-   * Creates a new function cache
-   * 
-   * @param logger Logger for debug output
-   * @param options Cache options
-   */
-  constructor(
-    logger: ILogger,
-    options: {
-      maxCacheSize?: number;
-      defaultTtl?: number;
-    } = {}
-  ) {
-    this.logger = logger;
-    this.maxCacheSize = options.maxCacheSize || 1000;
-    this.defaultTtl = options.defaultTtl || 5000; // 5 seconds default
-    
-    // Start the cache cleanup timer
-    this.cleanupInterval = setInterval(() => this.cleanupCache(), 30000); // Cleanup every 30 seconds
-    
-    // Make sure the interval doesn't keep the process alive
-    if (this.cleanupInterval.unref) {
-      this.cleanupInterval.unref();
-    }
-  }
-  
-  /**
-   * Compute a hash for a context object
-   * This is used to identify similar contexts for caching
-   * 
-   * @param context The route context to hash
-   * @param functionId Identifier for the function (usually route name or ID)
-   * @returns A string hash
-   */
-  private computeContextHash(context: IRouteContext, functionId: string): string {
-    // Extract relevant properties for the hash
-    const hashBase = {
-      functionId,
-      port: context.port,
-      domain: context.domain,
-      clientIp: context.clientIp,
-      path: context.path,
-      query: context.query,
-      isTls: context.isTls,
-      tlsVersion: context.tlsVersion
-    };
-    
-    // Generate a hash string
-    return JSON.stringify(hashBase);
-  }
-  
-  /**
-   * Get cached host result for a function and context
-   * 
-   * @param context Route context
-   * @param functionId Identifier for the function
-   * @returns Cached host value or undefined if not found
-   */
-  public getCachedHost(context: IRouteContext, functionId: string): string | string[] | undefined {
-    const hash = this.computeContextHash(context, functionId);
-    const cached = this.hostCache.get(hash);
-    
-    // Return if no cached value or expired
-    if (!cached || cached.expiry < Date.now()) {
-      if (cached) {
-        // If expired, remove from cache
-        this.hostCache.delete(hash);
-        this.logger.debug(`Cache miss (expired) for host function: ${functionId}`);
-      } else {
-        this.logger.debug(`Cache miss for host function: ${functionId}`);
-      }
-      return undefined;
-    }
-    
-    this.logger.debug(`Cache hit for host function: ${functionId}`);
-    return cached.value;
-  }
-  
-  /**
-   * Get cached port result for a function and context
-   * 
-   * @param context Route context
-   * @param functionId Identifier for the function
-   * @returns Cached port value or undefined if not found
-   */
-  public getCachedPort(context: IRouteContext, functionId: string): number | undefined {
-    const hash = this.computeContextHash(context, functionId);
-    const cached = this.portCache.get(hash);
-    
-    // Return if no cached value or expired
-    if (!cached || cached.expiry < Date.now()) {
-      if (cached) {
-        // If expired, remove from cache
-        this.portCache.delete(hash);
-        this.logger.debug(`Cache miss (expired) for port function: ${functionId}`);
-      } else {
-        this.logger.debug(`Cache miss for port function: ${functionId}`);
-      }
-      return undefined;
-    }
-    
-    this.logger.debug(`Cache hit for port function: ${functionId}`);
-    return cached.value;
-  }
-  
-  /**
-   * Store a host function result in the cache
-   * 
-   * @param context Route context
-   * @param functionId Identifier for the function
-   * @param value Host value to cache
-   * @param ttl Optional TTL in milliseconds
-   */
-  public cacheHost(
-    context: IRouteContext,
-    functionId: string,
-    value: string | string[],
-    ttl?: number
-  ): void {
-    const hash = this.computeContextHash(context, functionId);
-    const expiry = Date.now() + (ttl || this.defaultTtl);
-    
-    // Check if we need to prune the cache before adding
-    if (this.hostCache.size >= this.maxCacheSize) {
-      this.pruneOldestEntries(this.hostCache);
-    }
-    
-    // Store the result
-    this.hostCache.set(hash, { value, expiry, hash });
-    this.logger.debug(`Cached host function result for: ${functionId}`);
-  }
-  
-  /**
-   * Store a port function result in the cache
-   * 
-   * @param context Route context
-   * @param functionId Identifier for the function
-   * @param value Port value to cache
-   * @param ttl Optional TTL in milliseconds
-   */
-  public cachePort(
-    context: IRouteContext,
-    functionId: string,
-    value: number,
-    ttl?: number
-  ): void {
-    const hash = this.computeContextHash(context, functionId);
-    const expiry = Date.now() + (ttl || this.defaultTtl);
-    
-    // Check if we need to prune the cache before adding
-    if (this.portCache.size >= this.maxCacheSize) {
-      this.pruneOldestEntries(this.portCache);
-    }
-    
-    // Store the result
-    this.portCache.set(hash, { value, expiry, hash });
-    this.logger.debug(`Cached port function result for: ${functionId}`);
-  }
-  
-  /**
-   * Remove expired entries from the cache
-   */
-  private cleanupCache(): void {
-    const now = Date.now();
-    let expiredCount = 0;
-    
-    // Clean up host cache
-    for (const [hash, cached] of this.hostCache.entries()) {
-      if (cached.expiry < now) {
-        this.hostCache.delete(hash);
-        expiredCount++;
-      }
-    }
-    
-    // Clean up port cache
-    for (const [hash, cached] of this.portCache.entries()) {
-      if (cached.expiry < now) {
-        this.portCache.delete(hash);
-        expiredCount++;
-      }
-    }
-    
-    if (expiredCount > 0) {
-      this.logger.debug(`Cleaned up ${expiredCount} expired cache entries`);
-    }
-  }
-  
-  /**
-   * Prune oldest entries from a cache map
-   * Used when the cache exceeds the maximum size
-   * 
-   * @param cache The cache map to prune
-   */
-  private pruneOldestEntries<T>(cache: Map<string, ICachedResult<T>>): void {
-    // Find the oldest entries
-    const now = Date.now();
-    const itemsToRemove = Math.floor(this.maxCacheSize * 0.2); // Remove 20% of the cache
-    
-    // Convert to array for sorting
-    const entries = Array.from(cache.entries());
-    
-    // Sort by expiry (oldest first)
-    entries.sort((a, b) => a[1].expiry - b[1].expiry);
-    
-    // Remove oldest entries
-    const toRemove = entries.slice(0, itemsToRemove);
-    for (const [hash] of toRemove) {
-      cache.delete(hash);
-    }
-    
-    this.logger.debug(`Pruned ${toRemove.length} oldest cache entries`);
-  }
-  
-  /**
-   * Get current cache stats
-   */
-  public getStats(): { hostCacheSize: number; portCacheSize: number } {
-    return {
-      hostCacheSize: this.hostCache.size,
-      portCacheSize: this.portCache.size
-    };
-  }
-  
-  /**
-   * Clear all cached entries
-   */
-  public clearCache(): void {
-    this.hostCache.clear();
-    this.portCache.clear();
-    this.logger.info('Function cache cleared');
-  }
-  
-  /**
-   * Destroy the cache and cleanup resources
-   */
-  public destroy(): void {
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
-      this.cleanupInterval = null;
-    }
-    this.clearCache();
-    this.logger.debug('Function cache destroyed');
-  }
-}

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

@@ -1,5 +0,0 @@
-/**
- * HTTP handlers for various route types
- */
-
-// Empty - all handlers have been removed