@push.rocks/smartproxy 19.5.18 → 19.5.20

package/readme.routing.md

@@ -0,0 +1,341 @@
+# SmartProxy Routing Architecture Unification Plan
+
+## Overview
+This document analyzes the current state of routing in SmartProxy, identifies redundancies and inconsistencies, and proposes a unified architecture.
+
+## Current State Analysis
+
+### 1. Multiple Route Manager Implementations
+
+#### 1.1 Core SharedRouteManager (`ts/core/utils/route-manager.ts`)
+- **Purpose**: Designed as a shared component for SmartProxy and NetworkProxy
+- **Features**:
+  - Port mapping and expansion (e.g., `[80, 443]` → individual routes)
+  - Comprehensive route matching (domain, path, IP, headers, TLS)
+  - Route validation and conflict detection
+  - Event emitter for route changes
+  - Detailed logging support
+- **Status**: Well-designed but underutilized
+
+#### 1.2 SmartProxy RouteManager (`ts/proxies/smart-proxy/route-manager.ts`)
+- **Purpose**: SmartProxy-specific route management
+- **Issues**:
+  - 95% duplicate code from SharedRouteManager
+  - Only difference is using `ISmartProxyOptions` instead of generic interface
+  - Contains deprecated security methods
+  - Unnecessary code duplication
+- **Status**: Should be removed in favor of SharedRouteManager
+
+#### 1.3 HttpProxy Route Management (`ts/proxies/http-proxy/`)
+- **Purpose**: HTTP-specific routing
+- **Implementation**: Minimal, inline route matching
+- **Status**: Could benefit from SharedRouteManager
+
+### 2. Multiple Router Implementations
+
+#### 2.1 ProxyRouter (`ts/routing/router/proxy-router.ts`)
+- **Purpose**: Legacy compatibility with `IReverseProxyConfig`
+- **Features**: Domain-based routing with path patterns
+- **Used by**: HttpProxy for backward compatibility
+
+#### 2.2 RouteRouter (`ts/routing/router/route-router.ts`)
+- **Purpose**: Modern routing with `IRouteConfig`
+- **Features**: Nearly identical to ProxyRouter
+- **Issues**: Code duplication with ProxyRouter
+
+### 3. Scattered Route Utilities
+
+#### 3.1 Core route-utils (`ts/core/utils/route-utils.ts`)
+- **Purpose**: Shared matching functions
+- **Features**: Domain, path, IP, CIDR matching
+- **Status**: Well-implemented, should be the single source
+
+#### 3.2 SmartProxy route-utils (`ts/proxies/smart-proxy/utils/route-utils.ts`)
+- **Purpose**: Route configuration utilities
+- **Features**: Different scope - config merging, not pattern matching
+- **Status**: Keep separate as it serves different purpose
+
+### 4. Other Route-Related Files
+- `route-patterns.ts`: Constants for route patterns
+- `route-validators.ts`: Route configuration validation
+- `route-helpers.ts`: Additional utilities
+- `route-connection-handler.ts`: Connection routing logic
+
+## Problems Identified
+
+### 1. Code Duplication
+- **SharedRouteManager vs SmartProxy RouteManager**: ~1000 lines of duplicate code
+- **ProxyRouter vs RouteRouter**: ~500 lines of duplicate code
+- **Matching logic**: Implemented in 4+ different places
+
+### 2. Inconsistent Implementations
+```typescript
+// Example: Domain matching appears in multiple places
+// 1. In route-utils.ts
+export function matchDomain(pattern: string, hostname: string): boolean
+
+// 2. In SmartProxy RouteManager
+private matchDomain(domain: string, hostname: string): boolean
+
+// 3. In ProxyRouter
+private matchesHostname(configName: string, hostname: string): boolean
+
+// 4. In RouteRouter
+private matchDomain(pattern: string, hostname: string): boolean
+```
+
+### 3. Unclear Separation of Concerns
+- Route Managers handle both storage AND matching
+- Routers also handle storage AND matching
+- No clear boundaries between layers
+
+### 4. Maintenance Burden
+- Bug fixes need to be applied in multiple places
+- New features must be implemented multiple times
+- Testing effort multiplied
+
+## Proposed Unified Architecture
+
+### Layer 1: Core Routing Components
+```
+ts/core/routing/
+├── types.ts              # All route-related types
+├── utils.ts              # All matching logic (consolidated)
+├── route-store.ts        # Route storage and indexing
+└── route-matcher.ts      # Route matching engine
+```
+
+### Layer 2: Route Management
+```
+ts/core/routing/
+└── route-manager.ts      # Single RouteManager for all proxies
+    - Uses RouteStore for storage
+    - Uses RouteMatcher for matching
+    - Provides high-level API
+```
+
+### Layer 3: HTTP Routing
+```
+ts/routing/
+└── http-router.ts        # Single HTTP router implementation
+    - Uses RouteManager for route lookup
+    - Handles HTTP-specific concerns
+    - Legacy adapter built-in
+```
+
+### Layer 4: Proxy Integration
+```
+ts/proxies/
+├── smart-proxy/
+│   └── (uses core RouteManager directly)
+├── http-proxy/
+│   └── (uses core RouteManager + HttpRouter)
+└── network-proxy/
+    └── (uses core RouteManager directly)
+```
+
+## Implementation Plan
+
+### Phase 1: Consolidate Matching Logic (Week 1)
+1. **Audit all matching implementations**
+   - Document differences in behavior
+   - Identify the most comprehensive implementation
+   - Create test suite covering all edge cases
+
+2. **Create unified matching module**
+   ```typescript
+   // ts/core/routing/matchers.ts
+   export class DomainMatcher {
+     static match(pattern: string, hostname: string): boolean
+   }
+   
+   export class PathMatcher {
+     static match(pattern: string, path: string): MatchResult
+   }
+   
+   export class IpMatcher {
+     static match(pattern: string, ip: string): boolean
+     static matchCidr(cidr: string, ip: string): boolean
+   }
+   ```
+
+3. **Update all components to use unified matchers**
+   - Replace local implementations
+   - Ensure backward compatibility
+   - Run comprehensive tests
+
+### Phase 2: Unify Route Managers (Week 2)
+1. **Enhance SharedRouteManager**
+   - Add any missing features from SmartProxy RouteManager
+   - Make it truly generic (no proxy-specific dependencies)
+   - Add adapter pattern for different options types
+
+2. **Migrate SmartProxy to use SharedRouteManager**
+   ```typescript
+   // Before
+   this.routeManager = new RouteManager(this.settings);
+   
+   // After
+   this.routeManager = new SharedRouteManager({
+     logger: this.settings.logger,
+     enableDetailedLogging: this.settings.enableDetailedLogging
+   });
+   ```
+
+3. **Remove duplicate RouteManager**
+   - Delete `ts/proxies/smart-proxy/route-manager.ts`
+   - Update all imports
+   - Verify all tests pass
+
+### Phase 3: Consolidate Routers (Week 3)
+1. **Create unified HttpRouter**
+   ```typescript
+   export class HttpRouter {
+     constructor(private routeManager: SharedRouteManager) {}
+     
+     // Modern interface
+     route(req: IncomingMessage): RouteResult
+     
+     // Legacy adapter
+     routeLegacy(config: IReverseProxyConfig): RouteResult
+   }
+   ```
+
+2. **Migrate HttpProxy**
+   - Replace both ProxyRouter and RouteRouter
+   - Use single HttpRouter with appropriate adapter
+   - Maintain backward compatibility
+
+3. **Clean up legacy code**
+   - Mark old interfaces as deprecated
+   - Add migration guides
+   - Plan removal in next major version
+
+### Phase 4: Architecture Cleanup (Week 4)
+1. **Reorganize file structure**
+   ```
+   ts/core/
+   ├── routing/
+   │   ├── index.ts
+   │   ├── types.ts
+   │   ├── matchers/
+   │   │   ├── domain.ts
+   │   │   ├── path.ts
+   │   │   ├── ip.ts
+   │   │   └── index.ts
+   │   ├── route-store.ts
+   │   ├── route-matcher.ts
+   │   └── route-manager.ts
+   └── utils/
+       └── (remove route-specific utils)
+   ```
+
+2. **Update documentation**
+   - Architecture diagrams
+   - Migration guides
+   - API documentation
+
+3. **Performance optimization**
+   - Add caching where beneficial
+   - Optimize hot paths
+   - Benchmark before/after
+
+## Migration Strategy
+
+### For SmartProxy RouteManager Users
+```typescript
+// Old way
+import { RouteManager } from './route-manager.js';
+const manager = new RouteManager(options);
+
+// New way
+import { SharedRouteManager as RouteManager } from '../core/utils/route-manager.js';
+const manager = new RouteManager({
+  logger: options.logger,
+  enableDetailedLogging: options.enableDetailedLogging
+});
+```
+
+### For Router Users
+```typescript
+// Old way
+const proxyRouter = new ProxyRouter();
+const routeRouter = new RouteRouter();
+
+// New way
+const router = new HttpRouter(routeManager);
+// Automatically handles both modern and legacy configs
+```
+
+## Success Metrics
+
+1. **Code Reduction**
+   - Target: Remove ~1,500 lines of duplicate code
+   - Measure: Lines of code before/after
+
+2. **Performance**
+   - Target: No regression in routing performance
+   - Measure: Benchmark route matching operations
+
+3. **Maintainability**
+   - Target: Single implementation for each concept
+   - Measure: Time to implement new features
+
+4. **Test Coverage**
+   - Target: 100% coverage of routing logic
+   - Measure: Coverage reports
+
+## Risks and Mitigations
+
+### Risk 1: Breaking Changes
+- **Mitigation**: Extensive adapter patterns and backward compatibility layers
+- **Testing**: Run all existing tests plus new integration tests
+
+### Risk 2: Performance Regression
+- **Mitigation**: Benchmark critical paths before changes
+- **Testing**: Load testing with production-like scenarios
+
+### Risk 3: Hidden Dependencies
+- **Mitigation**: Careful code analysis and dependency mapping
+- **Testing**: Integration tests across all proxy types
+
+## Long-term Vision
+
+### Future Enhancements
+1. **Route Caching**: LRU cache for frequently accessed routes
+2. **Route Indexing**: Trie-based indexing for faster domain matching
+3. **Route Priorities**: Explicit priority system instead of specificity
+4. **Dynamic Routes**: Support for runtime route modifications
+5. **Route Templates**: Reusable route configurations
+
+### API Evolution
+```typescript
+// Future unified routing API
+const routingEngine = new RoutingEngine({
+  stores: [fileStore, dbStore, dynamicStore],
+  matchers: [domainMatcher, pathMatcher, customMatcher],
+  cache: new LRUCache({ max: 1000 }),
+  indexes: {
+    domain: new TrieIndex(),
+    path: new RadixTree()
+  }
+});
+
+// Simple, powerful API
+const route = await routingEngine.findRoute({
+  domain: 'example.com',
+  path: '/api/v1/users',
+  ip: '192.168.1.1',
+  headers: { 'x-custom': 'value' }
+});
+```
+
+## Conclusion
+
+The current routing architecture has significant duplication and inconsistencies. By following this unification plan, we can:
+1. Reduce code by ~30%
+2. Improve maintainability
+3. Ensure consistent behavior
+4. Enable future enhancements
+
+The phased approach minimizes risk while delivering incremental value. Each phase is independently valuable and can be deployed separately.

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartproxy',
-  version: '19.5.3',
+  version: '19.5.19',
   description: 'A powerful proxy package with unified route-based configuration for high traffic management. Features include SSL/TLS support, flexible routing patterns, WebSocket handling, advanced security options, and automatic ACME certificate management.'
 }

package/ts/core/models/index.ts

@@ -5,3 +5,5 @@
 export * from './common-types.js';
 export * from './socket-augmentation.js';
 export * from './route-context.js';
+export * from './wrapped-socket.js';
+export * from './socket-types.js';

package/ts/core/models/socket-types.ts

@@ -0,0 +1,21 @@
+import * as net from 'net';
+import { WrappedSocket } from './wrapped-socket.js';
+
+/**
+ * Type guard to check if a socket is a WrappedSocket
+ */
+export function isWrappedSocket(socket: net.Socket | WrappedSocket): socket is WrappedSocket {
+  return socket instanceof WrappedSocket || 'socket' in socket;
+}
+
+/**
+ * Helper to get the underlying socket from either a Socket or WrappedSocket
+ */
+export function getUnderlyingSocket(socket: net.Socket | WrappedSocket): net.Socket {
+  return isWrappedSocket(socket) ? socket.socket : socket;
+}
+
+/**
+ * Type that represents either a regular socket or a wrapped socket
+ */
+export type AnySocket = net.Socket | WrappedSocket;

package/ts/core/models/wrapped-socket.ts

@@ -0,0 +1,99 @@
+import * as plugins from '../../plugins.js';
+
+/**
+ * WrappedSocket wraps a regular net.Socket to provide transparent access
+ * to the real client IP and port when behind a proxy using PROXY protocol.
+ * 
+ * This is the FOUNDATION for all PROXY protocol support and must be implemented
+ * before any protocol parsing can occur.
+ * 
+ * This implementation uses a Proxy to delegate all properties and methods
+ * to the underlying socket while allowing override of specific properties.
+ */
+export class WrappedSocket {
+  public readonly socket: plugins.net.Socket;
+  private realClientIP?: string;
+  private realClientPort?: number;
+  
+  // Make TypeScript happy by declaring the Socket methods that will be proxied
+  [key: string]: any;
+  
+  constructor(
+    socket: plugins.net.Socket,
+    realClientIP?: string,
+    realClientPort?: number
+  ) {
+    this.socket = socket;
+    this.realClientIP = realClientIP;
+    this.realClientPort = realClientPort;
+    
+    // Create a proxy that delegates everything to the underlying socket
+    return new Proxy(this, {
+      get(target, prop, receiver) {
+        // Override specific properties
+        if (prop === 'remoteAddress') {
+          return target.remoteAddress;
+        }
+        if (prop === 'remotePort') {
+          return target.remotePort;
+        }
+        if (prop === 'socket') {
+          return target.socket;
+        }
+        if (prop === 'realClientIP') {
+          return target.realClientIP;
+        }
+        if (prop === 'realClientPort') {
+          return target.realClientPort;
+        }
+        if (prop === 'isFromTrustedProxy') {
+          return target.isFromTrustedProxy;
+        }
+        if (prop === 'setProxyInfo') {
+          return target.setProxyInfo.bind(target);
+        }
+        
+        // For all other properties/methods, delegate to the underlying socket
+        const value = target.socket[prop as keyof plugins.net.Socket];
+        if (typeof value === 'function') {
+          return value.bind(target.socket);
+        }
+        return value;
+      },
+      set(target, prop, value) {
+        // Set on the underlying socket
+        (target.socket as any)[prop] = value;
+        return true;
+      }
+    }) as any;
+  }
+  
+  /**
+   * Returns the real client IP if available, otherwise the socket's remote address
+   */
+  get remoteAddress(): string | undefined {
+    return this.realClientIP || this.socket.remoteAddress;
+  }
+  
+  /**
+   * Returns the real client port if available, otherwise the socket's remote port
+   */
+  get remotePort(): number | undefined {
+    return this.realClientPort || this.socket.remotePort;
+  }
+  
+  /**
+   * Indicates if this connection came through a trusted proxy
+   */
+  get isFromTrustedProxy(): boolean {
+    return !!this.realClientIP;
+  }
+  
+  /**
+   * Updates the real client information (called after parsing PROXY protocol)
+   */
+  setProxyInfo(ip: string, port: number): void {
+    this.realClientIP = ip;
+    this.realClientPort = port;
+  }
+}

package/ts/core/routing/index.ts

@@ -0,0 +1,21 @@
+/**
+ * Unified routing module
+ * Provides all routing functionality in a centralized location
+ */
+
+// Export all types
+export * from './types.js';
+
+// Export all matchers
+export * from './matchers/index.js';
+
+// Export specificity calculator
+export * from './specificity.js';
+
+// Export route management
+export * from './route-manager.js';
+export * from './route-utils.js';
+
+// Convenience re-exports
+export { matchers } from './matchers/index.js';
+export { RouteSpecificity } from './specificity.js';

package/ts/core/routing/matchers/domain.ts

@@ -0,0 +1,119 @@
+import type { IMatcher, IDomainMatchOptions } from '../types.js';
+
+/**
+ * DomainMatcher provides comprehensive domain matching functionality
+ * Supporting exact matches, wildcards, and case-insensitive matching
+ */
+export class DomainMatcher implements IMatcher<boolean, IDomainMatchOptions> {
+  private static wildcardToRegex(pattern: string): RegExp {
+    // Escape special regex characters except *
+    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+    // Replace * with regex equivalent
+    const regexPattern = escaped.replace(/\*/g, '.*');
+    return new RegExp(`^${regexPattern}$`, 'i');
+  }
+
+  /**
+   * Match a domain pattern against a hostname
+   * @param pattern The pattern to match (supports wildcards like *.example.com)
+   * @param hostname The hostname to test
+   * @param options Matching options
+   * @returns true if the hostname matches the pattern
+   */
+  static match(
+    pattern: string, 
+    hostname: string, 
+    options: IDomainMatchOptions = {}
+  ): boolean {
+    // Handle null/undefined cases
+    if (!pattern || !hostname) {
+      return false;
+    }
+
+    // Normalize inputs
+    const normalizedPattern = pattern.toLowerCase().trim();
+    const normalizedHostname = hostname.toLowerCase().trim();
+
+    // Remove trailing dots (FQDN normalization)
+    const cleanPattern = normalizedPattern.replace(/\.$/, '');
+    const cleanHostname = normalizedHostname.replace(/\.$/, '');
+
+    // Exact match (most common case)
+    if (cleanPattern === cleanHostname) {
+      return true;
+    }
+
+    // Wildcard matching
+    if (options.allowWildcards !== false && cleanPattern.includes('*')) {
+      const regex = this.wildcardToRegex(cleanPattern);
+      return regex.test(cleanHostname);
+    }
+
+    // No match
+    return false;
+  }
+
+  /**
+   * Check if a pattern contains wildcards
+   */
+  static isWildcardPattern(pattern: string): boolean {
+    return pattern.includes('*');
+  }
+
+  /**
+   * Calculate the specificity of a domain pattern
+   * Higher values mean more specific patterns
+   */
+  static calculateSpecificity(pattern: string): number {
+    if (!pattern) return 0;
+
+    let score = 0;
+    
+    // Exact domains are most specific
+    if (!pattern.includes('*')) {
+      score += 100;
+    }
+    
+    // Count domain segments
+    const segments = pattern.split('.');
+    score += segments.length * 10;
+    
+    // Penalize wildcards based on position
+    if (pattern.startsWith('*')) {
+      score -= 50; // Leading wildcard is very generic
+    } else if (pattern.includes('*')) {
+      score -= 20; // Wildcard elsewhere is less generic
+    }
+    
+    // Bonus for longer patterns
+    score += pattern.length;
+    
+    return score;
+  }
+
+  /**
+   * Find all matching patterns from a list
+   * Returns patterns sorted by specificity (most specific first)
+   */
+  static findAllMatches(
+    patterns: string[], 
+    hostname: string,
+    options: IDomainMatchOptions = {}
+  ): string[] {
+    const matches = patterns.filter(pattern => 
+      this.match(pattern, hostname, options)
+    );
+
+    // Sort by specificity (highest first)
+    return matches.sort((a, b) => 
+      this.calculateSpecificity(b) - this.calculateSpecificity(a)
+    );
+  }
+
+  /**
+   * Instance method for interface compliance
+   */
+  match(pattern: string, hostname: string, options?: IDomainMatchOptions): boolean {
+    return DomainMatcher.match(pattern, hostname, options);
+  }
+}