update

- Created ts/detection module for unified protocol detection
- Implemented TLS and HTTP detectors with fragmentation support
- Moved TLS detection logic from existing code to centralized module
- Updated RouteConnectionHandler to use ProtocolDetector for both TLS and HTTP
- Refactored ACME HTTP parsing to use detection module
- Added comprehensive tests for detection functionality
- Eliminated duplicate protocol detection code across codebase

This centralizes all non-destructive protocol detection into a single module,
improving code organization and reducing duplication between ACME and routing.

certs/static-route/meta.json

@@ -1,5 +1,5 @@
 {
-  "expiryDate": "2025-10-18T13:15:48.916Z",
-  "issueDate": "2025-07-20T13:15:48.916Z",
-  "savedAt": "2025-07-20T13:15:48.916Z"
+  "expiryDate": "2025-10-20T10:10:52.985Z",
+  "issueDate": "2025-07-22T10:10:52.985Z",
+  "savedAt": "2025-07-22T10:10:52.986Z"
 }

changelog.md

@@ -1,5 +1,40 @@
 # Changelog
 
+## 2025-07-22 - 21.1.1 - fix(detection)
+Fix SNI detection in TLS detector
+
+- Restored proper TLS detector implementation with ClientHello parsing
+- Fixed imports to use new protocols module locations
+- Added missing detectWithContext method for fragmented detection
+- Fixed method names to match BufferAccumulator interface
+- Removed unused import readUInt24BE
+
+## 2025-07-21 - 21.1.0 - feat(protocols)
+Refactor protocol utilities into centralized protocols module
+
+- Moved TLS utilities from `ts/tls/` to `ts/protocols/tls/`
+- Created centralized protocol modules for HTTP, WebSocket, Proxy, and TLS
+- Core utilities now delegate to protocol modules for parsing and utilities
+- Maintains backward compatibility through re-exports in original locations
+- Improves code organization and separation of concerns
+
+## 2025-07-22 - 21.0.0 - BREAKING_CHANGE(forwarding)
+Remove legacy forwarding module
+
+- Removed the `forwarding` namespace export from main index
+- Removed TForwardingType and all forwarding handlers
+- Consolidated route helper functions into route-helpers.ts
+- All functionality is now available through the route-based system
+- MIGRATION: Replace `import { forwarding } from '@push.rocks/smartproxy'` with direct imports of route helpers
+
+## 2025-07-21 - 20.0.2 - fix(docs)
+Update documentation to improve clarity
+
+- Enhanced readme with clearer breaking change warning for v20.0.0
+- Fixed example email address from ssl@bleu.de to ssl@example.com
+- Added load balancing and failover features to feature list
+- Improved documentation structure and examples
+
 ## 2025-07-20 - 20.0.1 - BREAKING_CHANGE(routing)
 Refactor route configuration to support multiple targets
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartproxy",
-  "version": "20.0.1",
+  "version": "21.1.2",
   "private": false,
   "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.",
   "main": "dist_ts/index.js",

test/test.acme-http-challenge.ts

@@ -124,4 +124,4 @@ tap.test('should parse HTTP headers correctly', async (tools) => {
   await proxy.stop();
 });
 
-tap.start();
+export default tap.start();

test/test.acme-http01-challenge.ts

@@ -159,4 +159,4 @@ tap.test('should return 404 for non-existent challenge tokens', async (tapTest)
   await proxy.stop();
 });
 
-tap.start();
+export default tap.start();

test/test.acme-route-creation.ts

@@ -215,4 +215,4 @@ tap.test('should handle HTTP request parsing correctly', async (tools) => {
   await proxy.stop();
 });
 
-tap.start();
+export default tap.start();

test/test.acme-simple.ts

@@ -117,4 +117,4 @@ tap.test('should configure ACME challenge route', async () => {
   expect(challengeRoute.action.socketHandler).toBeDefined();
 });
 
-tap.start();
+export default tap.start();

test/test.acme-timing-simple.ts

@@ -119,4 +119,4 @@ tap.test('should defer certificate provisioning until ports are ready', async (t
   await proxy.stop();
 });
 
-tap.start();
+export default tap.start();

test/test.certificate-provisioning.ts

@@ -238,4 +238,4 @@ tap.test('should renew certificates', async () => {
   await proxy.stop();
 });
 
-tap.start();
+export default tap.start();

test/test.certificate-simple.ts

@@ -57,4 +57,4 @@ tap.test('should handle socket handler route type', async () => {
   expect(route.action.socketHandler).toBeDefined();
 });
 
-tap.start();
+export default tap.start();

test/test.cleanup-queue-bug.node.ts

@@ -143,4 +143,4 @@ tap.test('cleanup queue bug - verify queue processing handles more than batch si
   console.log('\n✓ Test complete: Cleanup queue now correctly processes all connections');
 });
 
-tap.start();
+export default tap.start();

test/test.connect-disconnect-cleanup.node.ts

@@ -239,4 +239,4 @@ tap.test('should handle clients that error during connection', async () => {
   console.log('\n✅ PASS: Connection error cleanup working correctly!');
 });
 
-tap.start();
+export default tap.start();

test/test.connection-cleanup-comprehensive.node.ts

@@ -276,4 +276,4 @@ tap.test('comprehensive connection cleanup test - all scenarios', async () => {
   console.log('- NFTables connections');
 });
 
-tap.start();
+export default tap.start();

test/test.connection-limits.node.ts

@@ -296,4 +296,4 @@ tap.test('Cleanup and shutdown', async () => {
   allServers.length = 0;
 });
 
-tap.start();
+export default tap.start();

test/test.detection.ts

@@ -0,0 +1,146 @@
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import * as smartproxy from '../ts/index.js';
+
+tap.test('Protocol Detection - TLS Detection', async () => {
+  // Test TLS handshake detection
+  const tlsHandshake = Buffer.from([
+    0x16, // Handshake record type
+    0x03, 0x01, // TLS 1.0
+    0x00, 0x05, // Length: 5 bytes
+    0x01, // ClientHello
+    0x00, 0x00, 0x01, 0x00 // Handshake length and data
+  ]);
+  
+  const detector = new smartproxy.detection.TlsDetector();
+  expect(detector.canHandle(tlsHandshake)).toEqual(true);
+  
+  const result = detector.detect(tlsHandshake);
+  expect(result).toBeDefined();
+  expect(result?.protocol).toEqual('tls');
+  expect(result?.connectionInfo.tlsVersion).toEqual('TLSv1.0');
+});
+
+tap.test('Protocol Detection - HTTP Detection', async () => {
+  // Test HTTP request detection
+  const httpRequest = Buffer.from(
+    'GET /test HTTP/1.1\r\n' +
+    'Host: example.com\r\n' +
+    'User-Agent: TestClient/1.0\r\n' +
+    '\r\n'
+  );
+  
+  const detector = new smartproxy.detection.HttpDetector();
+  expect(detector.canHandle(httpRequest)).toEqual(true);
+  
+  const result = detector.detect(httpRequest);
+  expect(result).toBeDefined();
+  expect(result?.protocol).toEqual('http');
+  expect(result?.connectionInfo.method).toEqual('GET');
+  expect(result?.connectionInfo.path).toEqual('/test');
+  expect(result?.connectionInfo.domain).toEqual('example.com');
+});
+
+tap.test('Protocol Detection - Main Detector TLS', async () => {
+  const tlsHandshake = Buffer.from([
+    0x16, // Handshake record type
+    0x03, 0x03, // TLS 1.2
+    0x00, 0x05, // Length: 5 bytes
+    0x01, // ClientHello
+    0x00, 0x00, 0x01, 0x00 // Handshake length and data
+  ]);
+  
+  const result = await smartproxy.detection.ProtocolDetector.detect(tlsHandshake);
+  expect(result.protocol).toEqual('tls');
+  expect(result.connectionInfo.tlsVersion).toEqual('TLSv1.2');
+});
+
+tap.test('Protocol Detection - Main Detector HTTP', async () => {
+  const httpRequest = Buffer.from(
+    'POST /api/test HTTP/1.1\r\n' +
+    'Host: api.example.com\r\n' +
+    'Content-Type: application/json\r\n' +
+    'Content-Length: 2\r\n' +
+    '\r\n' +
+    '{}'
+  );
+  
+  const result = await smartproxy.detection.ProtocolDetector.detect(httpRequest);
+  expect(result.protocol).toEqual('http');
+  expect(result.connectionInfo.method).toEqual('POST');
+  expect(result.connectionInfo.path).toEqual('/api/test');
+  expect(result.connectionInfo.domain).toEqual('api.example.com');
+});
+
+tap.test('Protocol Detection - Unknown Protocol', async () => {
+  const unknownData = Buffer.from('UNKNOWN PROTOCOL DATA\r\n');
+  
+  const result = await smartproxy.detection.ProtocolDetector.detect(unknownData);
+  expect(result.protocol).toEqual('unknown');
+  expect(result.isComplete).toEqual(true);
+});
+
+tap.test('Protocol Detection - Fragmented HTTP', async () => {
+  // Create connection context
+  const context = smartproxy.detection.ProtocolDetector.createConnectionContext({
+    sourceIp: '127.0.0.1',
+    sourcePort: 12345,
+    destIp: '127.0.0.1',
+    destPort: 80,
+    socketId: 'test-connection-1'
+  });
+  
+  // First fragment
+  const fragment1 = Buffer.from('GET /test HT');
+  let result = await smartproxy.detection.ProtocolDetector.detectWithContext(
+    fragment1,
+    context
+  );
+  expect(result.protocol).toEqual('http');
+  expect(result.isComplete).toEqual(false);
+  
+  // Second fragment
+  const fragment2 = Buffer.from('TP/1.1\r\nHost: example.com\r\n\r\n');
+  result = await smartproxy.detection.ProtocolDetector.detectWithContext(
+    fragment2,
+    context
+  );
+  expect(result.protocol).toEqual('http');
+  expect(result.isComplete).toEqual(true);
+  expect(result.connectionInfo.method).toEqual('GET');
+  expect(result.connectionInfo.path).toEqual('/test');
+  expect(result.connectionInfo.domain).toEqual('example.com');
+  
+  // Clean up fragments
+  smartproxy.detection.ProtocolDetector.cleanupConnection(context);
+});
+
+tap.test('Protocol Detection - HTTP Methods', async () => {
+  const methods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'];
+  
+  for (const method of methods) {
+    const request = Buffer.from(
+      `${method} /test HTTP/1.1\r\n` +
+      'Host: example.com\r\n' +
+      '\r\n'
+    );
+    
+    const detector = new smartproxy.detection.HttpDetector();
+    const result = detector.detect(request);
+    expect(result?.connectionInfo.method).toEqual(method);
+  }
+});
+
+tap.test('Protocol Detection - Invalid Data', async () => {
+  // Binary data that's not a valid protocol
+  const binaryData = Buffer.from([0xFF, 0xFE, 0xFD, 0xFC, 0xFB]);
+  
+  const result = await smartproxy.detection.ProtocolDetector.detect(binaryData);
+  expect(result.protocol).toEqual('unknown');
+});
+
+tap.test('cleanup detection', async () => {
+  // Clean up the protocol detector instance
+  smartproxy.detection.ProtocolDetector.destroy();
+});
+
+export default tap.start();

test/test.fix-verification.ts

@@ -79,4 +79,4 @@ tap.test('should verify certificate manager callback is preserved on updateRoute
   console.log('Fix verified: Certificate manager callback is preserved on updateRoutes');
 });
 
-tap.start();
+export default tap.start();

test/test.forwarding.ts

@@ -1,9 +1,6 @@
 import { tap, expect } from '@git.zone/tstest/tapbundle';
 import * as plugins from '../ts/plugins.js';
-import type { IForwardConfig, TForwardingType } from '../ts/forwarding/config/forwarding-types.js';
 
-// First, import the components directly to avoid issues with compiled modules
-import { ForwardingHandlerFactory } from '../ts/forwarding/factory/forwarding-factory.js';
 // Import route-based helpers
 import {
   createHttpRoute,

test/test.forwarding.unit.ts

@@ -1,53 +0,0 @@
-import { tap, expect } from '@git.zone/tstest/tapbundle';
-import * as plugins from '../ts/plugins.js';
-
-// First, import the components directly to avoid issues with compiled modules
-import { ForwardingHandlerFactory } from '../ts/forwarding/factory/forwarding-factory.js';
-// Import route-based helpers from the correct location
-import {
-  createHttpRoute,
-  createHttpsTerminateRoute,
-  createHttpsPassthroughRoute,
-  createHttpToHttpsRedirect,
-  createCompleteHttpsServer,
-  createLoadBalancerRoute
-} from '../ts/proxies/smart-proxy/utils/route-patterns.js';
-
-// Create helper functions for building forwarding configs
-const helpers = {
-  httpOnly: () => ({ type: 'http-only' as const }),
-  tlsTerminateToHttp: () => ({ type: 'https-terminate-to-http' as const }),
-  tlsTerminateToHttps: () => ({ type: 'https-terminate-to-https' as const }),
-  httpsPassthrough: () => ({ type: 'https-passthrough' as const })
-};
-
-tap.test('ForwardingHandlerFactory - apply defaults based on type', async () => {
-  // HTTP-only defaults
-  const httpConfig = {
-    type: 'http-only' as const,
-    target: { host: 'localhost', port: 3000 }
-  };
-  
-  const httpWithDefaults = ForwardingHandlerFactory['applyDefaults'](httpConfig);
-  
-  expect(httpWithDefaults.port).toEqual(80);
-  expect(httpWithDefaults.socket).toEqual('/tmp/forwarding-http-only-80.sock');
-  
-  // HTTPS passthrough defaults
-  const httpsPassthroughConfig = {
-    type: 'https-passthrough' as const,
-    target: { host: 'localhost', port: 443 }
-  };
-  
-  const httpsPassthroughWithDefaults = ForwardingHandlerFactory['applyDefaults'](httpsPassthroughConfig);
-  
-  expect(httpsPassthroughWithDefaults.port).toEqual(443);
-  expect(httpsPassthroughWithDefaults.socket).toEqual('/tmp/forwarding-https-passthrough-443.sock');
-});
-
-tap.test('ForwardingHandlerFactory - factory function for handlers', async () => {
-  // @todo Implement unit tests for ForwardingHandlerFactory
-  // These tests would need proper mocking of the handlers
-});
-
-export default tap.start();

test/test.http-fix-unit.ts

@@ -180,4 +180,4 @@ tap.test('should handle ACME HTTP-01 challenges on port 80 with HttpProxy', asyn
   console.log('Test passed: ACME HTTP-01 challenges on port 80 use HttpProxy');
 });
 
-tap.start();
+export default tap.start();

test/test.http-port8080-simple.ts

@@ -242,4 +242,4 @@ tap.test('should handle ACME challenges on port 8080 with improved port binding
   }
 });
 
-tap.start();
+export default tap.start();

test/test.http-proxy-security-limits.node.ts

@@ -117,4 +117,4 @@ tap.test('Cleanup HttpProxy SecurityManager', async () => {
   securityManager.clearIPTracking();
 });
 
-tap.start();
+export default tap.start();

test/test.keepalive-support.node.ts

@@ -247,4 +247,4 @@ tap.test('keepalive support - verify keepalive connections are properly handled'
   console.log('  - Zombie detection respects keepalive settings');
 });
 
-tap.start();
+export default tap.start();

test/test.log-deduplication.node.ts

@@ -109,4 +109,4 @@ tap.test('Cleanup deduplicator', async () => {
   expect(deduplicator).toBeInstanceOf(LogDeduplicator);
 });
 
-tap.start();
+export default tap.start();

test/test.memory-leak-check.node.ts

@@ -149,4 +149,4 @@ tap.test('should not have memory leaks in long-running operations', async (tools
 });
 
 // Run with: node --expose-gc test.memory-leak-check.node.ts
-tap.start();
+export default tap.start();

test/test.memory-leak-simple.ts

@@ -57,4 +57,4 @@ tap.test('memory leak fixes verification', async () => {
   console.log('\n✅ All memory leak fixes verified!');
 });
 
-tap.start();
+export default tap.start();

test/test.memory-leak-unit.ts

@@ -128,4 +128,4 @@ tap.test('memory leak fixes - unit tests', async () => {
   console.log('\n✅ All memory leak fixes verified!');
 });
 
-tap.start();
+export default tap.start();

test/test.metrics-new.ts

@@ -258,4 +258,4 @@ tap.test('should clean up resources', async () => {
   });
 });
 
-tap.start();
+export default tap.start();

test/test.proxy-chain-simple.node.ts

@@ -192,4 +192,4 @@ tap.test('simple proxy chain test - identify connection accumulation', async ()
   expect(finalCounts.proxy2).toEqual(0);
 });
 
-tap.start();
+export default tap.start();

test/test.proxy-protocol.ts

@@ -130,4 +130,4 @@ tap.test('PROXY protocol v1 generator', async () => {
 // Skipping integration tests for now - focus on unit tests
 // Integration tests would require more complex setup and teardown
 
-tap.start();
+export default tap.start();

test/test.rapid-retry-cleanup.node.ts

@@ -198,4 +198,4 @@ tap.test('should handle routing failures without leaking connections', async ()
   console.log('\n✅ PASS: Routing failures cleaned up correctly!');
 });
 
-tap.start();
+export default tap.start();

test/test.route-callback-simple.ts

@@ -113,4 +113,4 @@ tap.test('should set update routes callback on certificate manager', async () =>
   await proxy.stop();
 });
 
-tap.start();
+export default tap.start();

test/test.route-security-unit.ts

@@ -58,4 +58,4 @@ tap.test('route security should be correctly configured', async () => {
   expect(isBlockedIPAllowed).toBeFalse();
 });
 
-tap.start();
+export default tap.start();

test/test.route-update-callback.node.ts

@@ -336,4 +336,4 @@ tap.test('real code integration test - verify fix is applied', async () => {
   console.log('Real code integration test passed - fix is correctly applied!');
 });
 
-tap.start();
+export default tap.start();

test/test.route-utils.ts

@@ -47,7 +47,7 @@ import {
   addRateLimiting,
   addBasicAuth,
   addJwtAuth
-} from '../ts/proxies/smart-proxy/utils/route-patterns.js';
+} from '../ts/proxies/smart-proxy/utils/route-helpers.js';
 
 import type {
   IRouteConfig,

test/test.shared-security-manager-limits.node.ts

@@ -154,4 +154,4 @@ tap.test('Cleanup SharedSecurityManager', async () => {
   securityManager.clearIPTracking();
 });
 
-tap.start();
+export default tap.start();

test/test.smartacme-integration.ts

@@ -51,4 +51,4 @@ tap.test('should verify SmartAcme cert managers are accessible', async () => {
   expect(memoryCertManager).toBeDefined();
 });
 
-tap.start();
+export default tap.start();

test/test.stuck-connection-cleanup.node.ts

@@ -141,4 +141,4 @@ tap.test('stuck connection cleanup - verify connections to hanging backends are
   console.log('✓ Test complete: Stuck connections are properly detected and cleaned up');
 });
 
-tap.start();
+export default tap.start();

test/test.websocket-keepalive.node.ts

@@ -155,4 +155,4 @@ tap.test('long-lived connection survival test', async (tools) => {
   console.log('✅ Long-lived connection survived past 30-second timeout!');
 });
 
-tap.start();
+export default tap.start();

test/test.zombie-connection-cleanup.node.ts

@@ -303,4 +303,4 @@ tap.test('zombie connection cleanup - verify inactivity check detects and cleans
   expect(details.inner.halfZombies.length).toEqual(0);
 });
 
-tap.start();
+export default tap.start();

ts/core/utils/proxy-protocol.ts

@@ -1,161 +1,44 @@
 import * as plugins from '../../plugins.js';
 import { logger } from './logger.js';
+import { ProxyProtocolParser as ProtocolParser, type IProxyInfo, type IProxyParseResult } from '../../protocols/proxy/index.js';
 
-/**
- * Interface representing parsed PROXY protocol information
- */
-export interface IProxyInfo {
-  protocol: 'TCP4' | 'TCP6' | 'UNKNOWN';
-  sourceIP: string;
-  sourcePort: number;
-  destinationIP: string;
-  destinationPort: number;
-}
-
-/**
- * Interface for parse result including remaining data
- */
-export interface IProxyParseResult {
-  proxyInfo: IProxyInfo | null;
-  remainingData: Buffer;
-}
+// Re-export types from protocols for backward compatibility
+export type { IProxyInfo, IProxyParseResult } from '../../protocols/proxy/index.js';
 
 /**
  * Parser for PROXY protocol v1 (text format)
  * Spec: https://www.haproxy.org/download/1.8/doc/proxy-protocol.txt
+ * 
+ * This class now delegates to the protocol parser but adds 
+ * smartproxy-specific features like socket reading and logging
  */
 export class ProxyProtocolParser {
-  static readonly PROXY_V1_SIGNATURE = 'PROXY ';
-  static readonly MAX_HEADER_LENGTH = 107; // Max length for v1 header
-  static readonly HEADER_TERMINATOR = '\r\n';
+  static readonly PROXY_V1_SIGNATURE = ProtocolParser.PROXY_V1_SIGNATURE;
+  static readonly MAX_HEADER_LENGTH = ProtocolParser.MAX_HEADER_LENGTH;
+  static readonly HEADER_TERMINATOR = ProtocolParser.HEADER_TERMINATOR;
   
   /**
    * Parse PROXY protocol v1 header from buffer
    * Returns proxy info and remaining data after header
    */
   static parse(data: Buffer): IProxyParseResult {
-    // Check if buffer starts with PROXY signature
-    if (!data.toString('ascii', 0, 6).startsWith(this.PROXY_V1_SIGNATURE)) {
-      return {
-        proxyInfo: null,
-        remainingData: data
-      };
-    }
-    
-    // Find header terminator
-    const headerEndIndex = data.indexOf(this.HEADER_TERMINATOR);
-    if (headerEndIndex === -1) {
-      // Header incomplete, need more data
-      if (data.length > this.MAX_HEADER_LENGTH) {
-        // Header too long, invalid
-        throw new Error('PROXY protocol header exceeds maximum length');
-      }
-      return {
-        proxyInfo: null,
-        remainingData: data
-      };
-    }
-    
-    // Extract header line
-    const headerLine = data.toString('ascii', 0, headerEndIndex);
-    const remainingData = data.slice(headerEndIndex + 2); // Skip \r\n
-    
-    // Parse header
-    const parts = headerLine.split(' ');
-    
-    if (parts.length < 2) {
-      throw new Error(`Invalid PROXY protocol header format: ${headerLine}`);
-    }
-    
-    const [signature, protocol] = parts;
-    
-    // Validate protocol
-    if (!['TCP4', 'TCP6', 'UNKNOWN'].includes(protocol)) {
-      throw new Error(`Invalid PROXY protocol: ${protocol}`);
-    }
-    
-    // For UNKNOWN protocol, ignore addresses
-    if (protocol === 'UNKNOWN') {
-      return {
-        proxyInfo: {
-          protocol: 'UNKNOWN',
-          sourceIP: '',
-          sourcePort: 0,
-          destinationIP: '',
-          destinationPort: 0
-        },
-        remainingData
-      };
-    }
-    
-    // For TCP4/TCP6, we need all 6 parts
-    if (parts.length !== 6) {
-      throw new Error(`Invalid PROXY protocol header format: ${headerLine}`);
-    }
-    
-    const [, , srcIP, dstIP, srcPort, dstPort] = parts;
-    
-    // Validate and parse ports
-    const sourcePort = parseInt(srcPort, 10);
-    const destinationPort = parseInt(dstPort, 10);
-    
-    if (isNaN(sourcePort) || sourcePort < 0 || sourcePort > 65535) {
-      throw new Error(`Invalid source port: ${srcPort}`);
-    }
-    
-    if (isNaN(destinationPort) || destinationPort < 0 || destinationPort > 65535) {
-      throw new Error(`Invalid destination port: ${dstPort}`);
-    }
-    
-    // Validate IP addresses
-    const protocolType = protocol as 'TCP4' | 'TCP6' | 'UNKNOWN';
-    if (!this.isValidIP(srcIP, protocolType)) {
-      throw new Error(`Invalid source IP for ${protocol}: ${srcIP}`);
-    }
-    
-    if (!this.isValidIP(dstIP, protocolType)) {
-      throw new Error(`Invalid destination IP for ${protocol}: ${dstIP}`);
-    }
-    
-    return {
-      proxyInfo: {
-        protocol: protocol as 'TCP4' | 'TCP6',
-        sourceIP: srcIP,
-        sourcePort,
-        destinationIP: dstIP,
-        destinationPort
-      },
-      remainingData
-    };
+    // Delegate to protocol parser
+    return ProtocolParser.parse(data);
   }
   
   /**
    * Generate PROXY protocol v1 header
    */
   static generate(info: IProxyInfo): Buffer {
-    if (info.protocol === 'UNKNOWN') {
-      return Buffer.from(`PROXY UNKNOWN\r\n`, 'ascii');
-    }
-    
-    const header = `PROXY ${info.protocol} ${info.sourceIP} ${info.destinationIP} ${info.sourcePort} ${info.destinationPort}\r\n`;
-    
-    if (header.length > this.MAX_HEADER_LENGTH) {
-      throw new Error('Generated PROXY protocol header exceeds maximum length');
-    }
-    
-    return Buffer.from(header, 'ascii');
+    // Delegate to protocol parser
+    return ProtocolParser.generate(info);
   }
   
   /**
    * Validate IP address format
    */
   private static isValidIP(ip: string, protocol: 'TCP4' | 'TCP6' | 'UNKNOWN'): boolean {
-    if (protocol === 'TCP4') {
-      return plugins.net.isIPv4(ip);
-    } else if (protocol === 'TCP6') {
-      return plugins.net.isIPv6(ip);
-    }
-    return false;
+    return ProtocolParser.isValidIP(ip, protocol);
   }
   
   /**

ts/core/utils/websocket-utils.ts

@@ -1,12 +1,13 @@
 /**
  * WebSocket utility functions
+ * 
+ * This module provides smartproxy-specific WebSocket utilities
+ * and re-exports protocol utilities from the protocols module
  */
 
-/**
- * Type for WebSocket RawData that can be different types in different environments
- * This matches the ws library's type definition
- */
-export type RawData = Buffer | ArrayBuffer | Buffer[] | any;
+// Import and re-export from protocols
+import { getMessageSize as protocolGetMessageSize, toBuffer as protocolToBuffer } from '../../protocols/websocket/index.js';
+export type { RawData } from '../../protocols/websocket/index.js';
 
 /**
  * Get the length of a WebSocket message regardless of its type
@@ -15,35 +16,9 @@ export type RawData = Buffer | ArrayBuffer | Buffer[] | any;
  * @param data - The data message from WebSocket (could be any RawData type)
  * @returns The length of the data in bytes
  */
-export function getMessageSize(data: RawData): number {
-  if (typeof data === 'string') {
-    // For string data, get the byte length
-    return Buffer.from(data, 'utf8').length;
-  } else if (data instanceof Buffer) {
-    // For Node.js Buffer
-    return data.length;
-  } else if (data instanceof ArrayBuffer) {
-    // For ArrayBuffer
-    return data.byteLength;
-  } else if (Array.isArray(data)) {
-    // For array of buffers, sum their lengths
-    return data.reduce((sum, chunk) => {
-      if (chunk instanceof Buffer) {
-        return sum + chunk.length;
-      } else if (chunk instanceof ArrayBuffer) {
-        return sum + chunk.byteLength;
-      }
-      return sum;
-    }, 0);
-  } else {
-    // For other types, try to determine the size or return 0
-    try {
-      return Buffer.from(data).length;
-    } catch (e) {
-      console.warn('Could not determine message size', e);
-      return 0;
-    }
-  }
+export function getMessageSize(data: import('../../protocols/websocket/index.js').RawData): number {
+  // Delegate to protocol implementation
+  return protocolGetMessageSize(data);
 }
 
 /**
@@ -52,30 +27,7 @@ export function getMessageSize(data: RawData): number {
  * @param data - The data message from WebSocket (could be any RawData type)
  * @returns A Buffer containing the data
  */
-export function toBuffer(data: RawData): Buffer {
-  if (typeof data === 'string') {
-    return Buffer.from(data, 'utf8');
-  } else if (data instanceof Buffer) {
-    return data;
-  } else if (data instanceof ArrayBuffer) {
-    return Buffer.from(data);
-  } else if (Array.isArray(data)) {
-    // For array of buffers, concatenate them
-    return Buffer.concat(data.map(chunk => {
-      if (chunk instanceof Buffer) {
-        return chunk;
-      } else if (chunk instanceof ArrayBuffer) {
-        return Buffer.from(chunk);
-      }
-      return Buffer.from(chunk);
-    }));
-  } else {
-    // For other types, try to convert to Buffer or return empty Buffer
-    try {
-      return Buffer.from(data);
-    } catch (e) {
-      console.warn('Could not convert message to Buffer', e);
-      return Buffer.alloc(0);
-    }
-  }
+export function toBuffer(data: import('../../protocols/websocket/index.js').RawData): Buffer {
+  // Delegate to protocol implementation
+  return protocolToBuffer(data);
 }

ts/detection/detectors/http-detector.ts

@@ -0,0 +1,114 @@
+/**
+ * HTTP Protocol Detector
+ * 
+ * Simplified HTTP detection using the new architecture
+ */
+
+import type { IProtocolDetector } from '../models/interfaces.js';
+import type { IDetectionResult, IDetectionOptions } from '../models/detection-types.js';
+import type { IProtocolDetectionResult, IConnectionContext } from '../../protocols/common/types.js';
+import type { THttpMethod } from '../../protocols/http/index.js';
+import { QuickProtocolDetector } from './quick-detector.js';
+import { RoutingExtractor } from './routing-extractor.js';
+import { DetectionFragmentManager } from '../utils/fragment-manager.js';
+
+/**
+ * Simplified HTTP detector
+ */
+export class HttpDetector implements IProtocolDetector {
+  private quickDetector = new QuickProtocolDetector();
+  private fragmentManager: DetectionFragmentManager;
+  
+  constructor(fragmentManager?: DetectionFragmentManager) {
+    this.fragmentManager = fragmentManager || new DetectionFragmentManager();
+  }
+  
+  /**
+   * Check if buffer can be handled by this detector
+   */
+  canHandle(buffer: Buffer): boolean {
+    const result = this.quickDetector.quickDetect(buffer);
+    return result.protocol === 'http' && result.confidence > 50;
+  }
+  
+  /**
+   * Get minimum bytes needed for detection
+   */
+  getMinimumBytes(): number {
+    return 4; // "GET " minimum
+  }
+  
+  /**
+   * Detect HTTP protocol from buffer
+   */
+  detect(buffer: Buffer, options?: IDetectionOptions): IDetectionResult | null {
+    // Quick detection first
+    const quickResult = this.quickDetector.quickDetect(buffer);
+    
+    if (quickResult.protocol !== 'http' || quickResult.confidence < 50) {
+      return null;
+    }
+    
+    // Check if we have complete headers first
+    const headersEnd = buffer.indexOf('\r\n\r\n');
+    const isComplete = headersEnd !== -1;
+    
+    // Extract routing information
+    const routing = RoutingExtractor.extract(buffer, 'http');
+    
+    // If we don't need full headers and we have complete headers, we can return early
+    if (quickResult.confidence >= 95 && !options?.extractFullHeaders && isComplete) {
+      return {
+        protocol: 'http',
+        connectionInfo: { 
+          protocol: 'http',
+          method: quickResult.metadata?.method as THttpMethod,
+          domain: routing?.domain,
+          path: routing?.path
+        },
+        isComplete: true
+      };
+    }
+    
+    return {
+      protocol: 'http',
+      connectionInfo: {
+        protocol: 'http',
+        domain: routing?.domain,
+        path: routing?.path,
+        method: quickResult.metadata?.method as THttpMethod
+      },
+      isComplete,
+      bytesNeeded: isComplete ? undefined : buffer.length + 512 // Need more for headers
+    };
+  }
+  
+  /**
+   * Handle fragmented detection
+   */
+  detectWithContext(
+    buffer: Buffer,
+    context: IConnectionContext,
+    options?: IDetectionOptions
+  ): IDetectionResult | null {
+    const handler = this.fragmentManager.getHandler('http');
+    const connectionId = DetectionFragmentManager.createConnectionId(context);
+    
+    // Add fragment
+    const result = handler.addFragment(connectionId, buffer);
+    
+    if (result.error) {
+      handler.complete(connectionId);
+      return null;
+    }
+    
+    // Try detection on accumulated buffer
+    const detectResult = this.detect(result.buffer!, options);
+    
+    if (detectResult && detectResult.isComplete) {
+      handler.complete(connectionId);
+    }
+    
+    return detectResult;
+  }
+}

ts/detection/detectors/quick-detector.ts

@@ -0,0 +1,148 @@
+/**
+ * Quick Protocol Detector
+ * 
+ * Lightweight protocol identification based on minimal bytes
+ * No parsing, just identification
+ */
+
+import type { IProtocolDetector, IProtocolDetectionResult } from '../../protocols/common/types.js';
+import { TlsRecordType } from '../../protocols/tls/index.js';
+import { HttpParser } from '../../protocols/http/index.js';
+
+/**
+ * Quick protocol detector for fast identification
+ */
+export class QuickProtocolDetector implements IProtocolDetector {
+  /**
+   * Check if this detector can handle the data
+   */
+  canHandle(data: Buffer): boolean {
+    return data.length >= 1;
+  }
+  
+  /**
+   * Perform quick detection based on first few bytes
+   */
+  quickDetect(data: Buffer): IProtocolDetectionResult {
+    if (data.length === 0) {
+      return {
+        protocol: 'unknown',
+        confidence: 0,
+        requiresMoreData: true
+      };
+    }
+    
+    // Check for TLS
+    const tlsResult = this.checkTls(data);
+    if (tlsResult.confidence > 80) {
+      return tlsResult;
+    }
+    
+    // Check for HTTP
+    const httpResult = this.checkHttp(data);
+    if (httpResult.confidence > 80) {
+      return httpResult;
+    }
+    
+    // Need more data or unknown
+    return {
+      protocol: 'unknown',
+      confidence: 0,
+      requiresMoreData: data.length < 20
+    };
+  }
+  
+  /**
+   * Check if data looks like TLS
+   */
+  private checkTls(data: Buffer): IProtocolDetectionResult {
+    if (data.length < 3) {
+      return {
+        protocol: 'tls',
+        confidence: 0,
+        requiresMoreData: true
+      };
+    }
+    
+    const firstByte = data[0];
+    const secondByte = data[1];
+    
+    // Check for valid TLS record type
+    const validRecordTypes = [
+      TlsRecordType.CHANGE_CIPHER_SPEC,
+      TlsRecordType.ALERT,
+      TlsRecordType.HANDSHAKE,
+      TlsRecordType.APPLICATION_DATA,
+      TlsRecordType.HEARTBEAT
+    ];
+    
+    if (!validRecordTypes.includes(firstByte)) {
+      return {
+        protocol: 'tls',
+        confidence: 0
+      };
+    }
+    
+    // Check TLS version byte (0x03 for all TLS/SSL versions)
+    if (secondByte !== 0x03) {
+      return {
+        protocol: 'tls',
+        confidence: 0
+      };
+    }
+    
+    // High confidence it's TLS
+    return {
+      protocol: 'tls',
+      confidence: 95,
+      metadata: {
+        recordType: firstByte
+      }
+    };
+  }
+  
+  /**
+   * Check if data looks like HTTP
+   */
+  private checkHttp(data: Buffer): IProtocolDetectionResult {
+    if (data.length < 3) {
+      return {
+        protocol: 'http',
+        confidence: 0,
+        requiresMoreData: true
+      };
+    }
+    
+    // Quick check for HTTP methods
+    const start = data.subarray(0, Math.min(10, data.length)).toString('ascii');
+    
+    // Check common HTTP methods
+    const httpMethods = ['GET ', 'POST ', 'PUT ', 'DELETE ', 'HEAD ', 'OPTIONS', 'PATCH ', 'CONNECT', 'TRACE '];
+    for (const method of httpMethods) {
+      if (start.startsWith(method)) {
+        return {
+          protocol: 'http',
+          confidence: 95,
+          metadata: {
+            method: method.trim()
+          }
+        };
+      }
+    }
+    
+    // Check if it might be HTTP but need more data
+    if (HttpParser.isPrintableAscii(data, Math.min(20, data.length))) {
+      // Could be HTTP, but not sure
+      return {
+        protocol: 'http',
+        confidence: 30,
+        requiresMoreData: data.length < 20
+      };
+    }
+    
+    return {
+      protocol: 'http',
+      confidence: 0
+    };
+  }
+}

ts/detection/detectors/routing-extractor.ts

@@ -0,0 +1,147 @@
+/**
+ * Routing Information Extractor
+ * 
+ * Extracts minimal routing information from protocols
+ * without full parsing
+ */
+
+import type { IRoutingInfo, IConnectionContext, TProtocolType } from '../../protocols/common/types.js';
+import { SniExtraction } from '../../protocols/tls/sni/sni-extraction.js';
+import { HttpParser } from '../../protocols/http/index.js';
+
+/**
+ * Extracts routing information from protocol data
+ */
+export class RoutingExtractor {
+  /**
+   * Extract routing info based on protocol type
+   */
+  static extract(
+    data: Buffer, 
+    protocol: TProtocolType,
+    context?: IConnectionContext
+  ): IRoutingInfo | null {
+    switch (protocol) {
+      case 'tls':
+      case 'https':
+        return this.extractTlsRouting(data, context);
+      
+      case 'http':
+        return this.extractHttpRouting(data);
+      
+      default:
+        return null;
+    }
+  }
+  
+  /**
+   * Extract routing from TLS ClientHello (SNI)
+   */
+  private static extractTlsRouting(
+    data: Buffer,
+    context?: IConnectionContext
+  ): IRoutingInfo | null {
+    try {
+      // Quick SNI extraction without full parsing
+      const sni = SniExtraction.extractSNI(data);
+      
+      if (sni) {
+        return {
+          domain: sni,
+          protocol: 'tls',
+          port: 443  // Default HTTPS port
+        };
+      }
+      
+      return null;
+    } catch (error) {
+      // Extraction failed, return null
+      return null;
+    }
+  }
+  
+  /**
+   * Extract routing from HTTP headers (Host header)
+   */
+  private static extractHttpRouting(data: Buffer): IRoutingInfo | null {
+    try {
+      // Look for first line
+      const firstLineEnd = data.indexOf('\n');
+      if (firstLineEnd === -1) {
+        return null;
+      }
+      
+      // Parse request line
+      const firstLine = data.subarray(0, firstLineEnd).toString('ascii').trim();
+      const requestLine = HttpParser.parseRequestLine(firstLine);
+      
+      if (!requestLine) {
+        return null;
+      }
+      
+      // Look for Host header
+      let pos = firstLineEnd + 1;
+      const maxSearch = Math.min(data.length, 4096); // Don't search too far
+      
+      while (pos < maxSearch) {
+        const lineEnd = data.indexOf('\n', pos);
+        if (lineEnd === -1) break;
+        
+        const line = data.subarray(pos, lineEnd).toString('ascii').trim();
+        
+        // Empty line means end of headers
+        if (line.length === 0) break;
+        
+        // Check for Host header
+        if (line.toLowerCase().startsWith('host:')) {
+          const hostValue = line.substring(5).trim();
+          const domain = HttpParser.extractDomainFromHost(hostValue);
+          
+          return {
+            domain,
+            path: requestLine.path,
+            protocol: 'http',
+            port: 80  // Default HTTP port
+          };
+        }
+        
+        pos = lineEnd + 1;
+      }
+      
+      // No Host header found, but we have the path
+      return {
+        path: requestLine.path,
+        protocol: 'http',
+        port: 80
+      };
+    } catch (error) {
+      // Extraction failed
+      return null;
+    }
+  }
+  
+  /**
+   * Try to extract domain from any protocol
+   */
+  static extractDomain(data: Buffer, hint?: TProtocolType): string | null {
+    // If we have a hint, use it
+    if (hint) {
+      const routing = this.extract(data, hint);
+      return routing?.domain || null;
+    }
+    
+    // Try TLS first (more specific)
+    const tlsRouting = this.extractTlsRouting(data);
+    if (tlsRouting?.domain) {
+      return tlsRouting.domain;
+    }
+    
+    // Try HTTP
+    const httpRouting = this.extractHttpRouting(data);
+    if (httpRouting?.domain) {
+      return httpRouting.domain;
+    }
+    
+    return null;
+  }
+}

ts/detection/detectors/tls-detector.ts

@@ -0,0 +1,223 @@
+/**
+ * TLS protocol detector
+ */
+
+// TLS detector doesn't need plugins imports
+import type { IProtocolDetector } from '../models/interfaces.js';
+import type { IDetectionResult, IDetectionOptions, IConnectionInfo } from '../models/detection-types.js';
+import { readUInt16BE } from '../utils/buffer-utils.js';
+import { tlsVersionToString } from '../utils/parser-utils.js';
+
+// Import from protocols
+import { TlsRecordType, TlsHandshakeType, TlsExtensionType } from '../../protocols/tls/index.js';
+
+// Import TLS utilities for SNI extraction from protocols
+import { SniExtraction } from '../../protocols/tls/sni/sni-extraction.js';
+import { ClientHelloParser } from '../../protocols/tls/sni/client-hello-parser.js';
+
+/**
+ * TLS detector implementation
+ */
+export class TlsDetector implements IProtocolDetector {
+  /**
+   * Minimum bytes needed to identify TLS (record header)
+   */
+  private static readonly MIN_TLS_HEADER_SIZE = 5;
+  
+  
+  /**
+   * Detect TLS protocol from buffer
+   */
+  detect(buffer: Buffer, options?: IDetectionOptions): IDetectionResult | null {
+    // Check if buffer is too small
+    if (buffer.length < TlsDetector.MIN_TLS_HEADER_SIZE) {
+      return null;
+    }
+    
+    // Check if this is a TLS record
+    if (!this.isTlsRecord(buffer)) {
+      return null;
+    }
+    
+    // Extract basic TLS info
+    const recordType = buffer[0];
+    const tlsMajor = buffer[1];
+    const tlsMinor = buffer[2];
+    const recordLength = readUInt16BE(buffer, 3);
+    
+    // Initialize connection info
+    const connectionInfo: IConnectionInfo = {
+      protocol: 'tls',
+      tlsVersion: tlsVersionToString(tlsMajor, tlsMinor) || undefined
+    };
+    
+    // If it's a handshake, try to extract more info
+    if (recordType === TlsRecordType.HANDSHAKE && buffer.length >= 6) {
+      const handshakeType = buffer[5];
+      
+      // For ClientHello, extract SNI and other info
+      if (handshakeType === TlsHandshakeType.CLIENT_HELLO) {
+        // Check if we have the complete handshake
+        const totalRecordLength = recordLength + 5; // Including TLS header
+        if (buffer.length >= totalRecordLength) {
+          // Extract SNI using existing logic
+          const sni = SniExtraction.extractSNI(buffer);
+          if (sni) {
+            connectionInfo.domain = sni;
+            connectionInfo.sni = sni;
+          }
+          
+          // Parse ClientHello for additional info
+          const parseResult = ClientHelloParser.parseClientHello(buffer);
+          if (parseResult.isValid) {
+            // Extract ALPN if present
+            const alpnExtension = parseResult.extensions.find(
+              ext => ext.type === TlsExtensionType.APPLICATION_LAYER_PROTOCOL_NEGOTIATION
+            );
+            
+            if (alpnExtension) {
+              connectionInfo.alpn = this.parseAlpnExtension(alpnExtension.data);
+            }
+            
+            // Store cipher suites if needed
+            if (parseResult.cipherSuites && options?.extractFullHeaders) {
+              connectionInfo.cipherSuites = this.parseCipherSuites(parseResult.cipherSuites);
+            }
+          }
+          
+          // Return complete result
+          return {
+            protocol: 'tls',
+            connectionInfo,
+            remainingBuffer: buffer.length > totalRecordLength 
+              ? buffer.subarray(totalRecordLength) 
+              : undefined,
+            isComplete: true
+          };
+        } else {
+          // Incomplete handshake
+          return {
+            protocol: 'tls',
+            connectionInfo,
+            isComplete: false,
+            bytesNeeded: totalRecordLength
+          };
+        }
+      }
+    }
+    
+    // For other TLS record types, just return basic info
+    return {
+      protocol: 'tls',
+      connectionInfo,
+      isComplete: true,
+      remainingBuffer: buffer.length > recordLength + 5 
+        ? buffer.subarray(recordLength + 5) 
+        : undefined
+    };
+  }
+  
+  /**
+   * Check if buffer can be handled by this detector
+   */
+  canHandle(buffer: Buffer): boolean {
+    return buffer.length >= TlsDetector.MIN_TLS_HEADER_SIZE && 
+           this.isTlsRecord(buffer);
+  }
+  
+  /**
+   * Get minimum bytes needed for detection
+   */
+  getMinimumBytes(): number {
+    return TlsDetector.MIN_TLS_HEADER_SIZE;
+  }
+  
+  /**
+   * Check if buffer contains a valid TLS record
+   */
+  private isTlsRecord(buffer: Buffer): boolean {
+    const recordType = buffer[0];
+    
+    // Check for valid record type
+    const validTypes = [
+      TlsRecordType.CHANGE_CIPHER_SPEC,
+      TlsRecordType.ALERT,
+      TlsRecordType.HANDSHAKE,
+      TlsRecordType.APPLICATION_DATA,
+      TlsRecordType.HEARTBEAT
+    ];
+    
+    if (!validTypes.includes(recordType)) {
+      return false;
+    }
+    
+    // Check TLS version bytes (should be 0x03 0x0X)
+    if (buffer[1] !== 0x03) {
+      return false;
+    }
+    
+    // Check record length is reasonable
+    const recordLength = readUInt16BE(buffer, 3);
+    if (recordLength > 16384) { // Max TLS record size
+      return false;
+    }
+    
+    return true;
+  }
+  
+  /**
+   * Parse ALPN extension data
+   */
+  private parseAlpnExtension(data: Buffer): string[] {
+    const protocols: string[] = [];
+    
+    if (data.length < 2) {
+      return protocols;
+    }
+    
+    const listLength = readUInt16BE(data, 0);
+    let offset = 2;
+    
+    while (offset < Math.min(2 + listLength, data.length)) {
+      const protoLength = data[offset];
+      offset++;
+      
+      if (offset + protoLength <= data.length) {
+        const protocol = data.subarray(offset, offset + protoLength).toString('ascii');
+        protocols.push(protocol);
+        offset += protoLength;
+      } else {
+        break;
+      }
+    }
+    
+    return protocols;
+  }
+  
+  /**
+   * Parse cipher suites
+   */
+  private parseCipherSuites(cipherData: Buffer): number[] {
+    const suites: number[] = [];
+    
+    for (let i = 0; i < cipherData.length - 1; i += 2) {
+      const suite = readUInt16BE(cipherData, i);
+      suites.push(suite);
+    }
+    
+    return suites;
+  }
+  
+  /**
+   * Detect with context for fragmented data
+   */
+  detectWithContext(
+    buffer: Buffer,
+    _context: { sourceIp?: string; sourcePort?: number; destIp?: string; destPort?: number },
+    options?: IDetectionOptions
+  ): IDetectionResult | null {
+    // This method is deprecated - TLS detection should use the fragment manager
+    // from the parent detector system, not maintain its own fragments
+    return this.detect(buffer, options);
+  }
+}

ts/detection/index.ts

@@ -0,0 +1,25 @@
+/**
+ * Centralized Protocol Detection Module
+ * 
+ * This module provides unified protocol detection capabilities for
+ * both TLS and HTTP protocols, extracting connection information
+ * without consuming the data stream.
+ */
+
+// Main detector
+export * from './protocol-detector.js';
+
+// Models
+export * from './models/detection-types.js';
+export * from './models/interfaces.js';
+
+// Individual detectors
+export * from './detectors/tls-detector.js';
+export * from './detectors/http-detector.js';
+export * from './detectors/quick-detector.js';
+export * from './detectors/routing-extractor.js';
+
+// Utilities
+export * from './utils/buffer-utils.js';
+export * from './utils/parser-utils.js';
+export * from './utils/fragment-manager.js';

ts/detection/models/detection-types.ts

@@ -0,0 +1,102 @@
+/**
+ * Type definitions for protocol detection
+ */
+
+/**
+ * Supported protocol types that can be detected
+ */
+export type TProtocolType = 'tls' | 'http' | 'unknown';
+
+/**
+ * HTTP method types
+ */
+export type THttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'CONNECT' | 'TRACE';
+
+/**
+ * TLS version identifiers
+ */
+export type TTlsVersion = 'SSLv3' | 'TLSv1.0' | 'TLSv1.1' | 'TLSv1.2' | 'TLSv1.3';
+
+/**
+ * Connection information extracted from protocol detection
+ */
+export interface IConnectionInfo {
+  /**
+   * The detected protocol type
+   */
+  protocol: TProtocolType;
+  
+  /**
+   * Domain/hostname extracted from the connection
+   * - For TLS: from SNI extension
+   * - For HTTP: from Host header
+   */
+  domain?: string;
+  
+  /**
+   * HTTP-specific fields
+   */
+  method?: THttpMethod;
+  path?: string;
+  httpVersion?: string;
+  headers?: Record<string, string>;
+  
+  /**
+   * TLS-specific fields
+   */
+  tlsVersion?: TTlsVersion;
+  sni?: string;
+  alpn?: string[];
+  cipherSuites?: number[];
+}
+
+/**
+ * Result of protocol detection
+ */
+export interface IDetectionResult {
+  /**
+   * The detected protocol type
+   */
+  protocol: TProtocolType;
+  
+  /**
+   * Extracted connection information
+   */
+  connectionInfo: IConnectionInfo;
+  
+  /**
+   * Any remaining buffer data after detection headers
+   * This can be used to continue processing the stream
+   */
+  remainingBuffer?: Buffer;
+  
+  /**
+   * Whether the detection is complete or needs more data
+   */
+  isComplete: boolean;
+  
+  /**
+   * Minimum bytes needed for complete detection (if incomplete)
+   */
+  bytesNeeded?: number;
+}
+
+/**
+ * Options for protocol detection
+ */
+export interface IDetectionOptions {
+  /**
+   * Maximum bytes to buffer for detection (default: 8192)
+   */
+  maxBufferSize?: number;
+  
+  /**
+   * Timeout for detection in milliseconds (default: 5000)
+   */
+  timeout?: number;
+  
+  /**
+   * Whether to extract full headers or just essential info
+   */
+  extractFullHeaders?: boolean;
+}

ts/detection/models/interfaces.ts

@@ -0,0 +1,115 @@
+/**
+ * Interface definitions for protocol detection components
+ */
+
+import type { IDetectionResult, IDetectionOptions } from './detection-types.js';
+
+/**
+ * Interface for protocol detectors
+ */
+export interface IProtocolDetector {
+  /**
+   * Detect protocol from buffer data
+   * @param buffer The buffer to analyze
+   * @param options Detection options
+   * @returns Detection result or null if protocol cannot be determined
+   */
+  detect(buffer: Buffer, options?: IDetectionOptions): IDetectionResult | null;
+  
+  /**
+   * Check if buffer potentially contains this protocol
+   * @param buffer The buffer to check
+   * @returns True if buffer might contain this protocol
+   */
+  canHandle(buffer: Buffer): boolean;
+  
+  /**
+   * Get the minimum bytes needed for detection
+   */
+  getMinimumBytes(): number;
+}
+
+/**
+ * Interface for connection tracking during fragmented detection
+ */
+export interface IConnectionTracker {
+  /**
+   * Connection identifier
+   */
+  id: string;
+  
+  /**
+   * Accumulated buffer data
+   */
+  buffer: Buffer;
+  
+  /**
+   * Timestamp of first data
+   */
+  startTime: number;
+  
+  /**
+   * Current detection state
+   */
+  state: 'detecting' | 'complete' | 'failed';
+  
+  /**
+   * Partial detection result (if any)
+   */
+  partialResult?: Partial<IDetectionResult>;
+}
+
+/**
+ * Interface for buffer accumulator (handles fragmented data)
+ */
+export interface IBufferAccumulator {
+  /**
+   * Add data to accumulator
+   */
+  append(data: Buffer): void;
+  
+  /**
+   * Get accumulated buffer
+   */
+  getBuffer(): Buffer;
+  
+  /**
+   * Get buffer length
+   */
+  length(): number;
+  
+  /**
+   * Clear accumulated data
+   */
+  clear(): void;
+  
+  /**
+   * Check if accumulator has enough data
+   */
+  hasMinimumBytes(minBytes: number): boolean;
+}
+
+/**
+ * Detection events
+ */
+export interface IDetectionEvents {
+  /**
+   * Emitted when protocol is successfully detected
+   */
+  detected: (result: IDetectionResult) => void;
+  
+  /**
+   * Emitted when detection fails
+   */
+  failed: (error: Error) => void;
+  
+  /**
+   * Emitted when detection times out
+   */
+  timeout: () => void;
+  
+  /**
+   * Emitted when more data is needed
+   */
+  needMoreData: (bytesNeeded: number) => void;
+}

ts/detection/protocol-detector.ts

@@ -0,0 +1,310 @@
+/**
+ * Protocol Detector
+ * 
+ * Simplified protocol detection using the new architecture
+ */
+
+import type { IDetectionResult, IDetectionOptions } from './models/detection-types.js';
+import type { IConnectionContext } from '../protocols/common/types.js';
+import { TlsDetector } from './detectors/tls-detector.js';
+import { HttpDetector } from './detectors/http-detector.js';
+import { DetectionFragmentManager } from './utils/fragment-manager.js';
+
+/**
+ * Main protocol detector class
+ */
+export class ProtocolDetector {
+  private static instance: ProtocolDetector;
+  private fragmentManager: DetectionFragmentManager;
+  private tlsDetector: TlsDetector;
+  private httpDetector: HttpDetector;
+  private connectionProtocols: Map<string, 'tls' | 'http'> = new Map();
+  
+  constructor() {
+    this.fragmentManager = new DetectionFragmentManager();
+    this.tlsDetector = new TlsDetector();
+    this.httpDetector = new HttpDetector(this.fragmentManager);
+  }
+  
+  private static getInstance(): ProtocolDetector {
+    if (!this.instance) {
+      this.instance = new ProtocolDetector();
+    }
+    return this.instance;
+  }
+  
+  /**
+   * Detect protocol from buffer data
+   */
+  static async detect(buffer: Buffer, options?: IDetectionOptions): Promise<IDetectionResult> {
+    return this.getInstance().detectInstance(buffer, options);
+  }
+  
+  private async detectInstance(buffer: Buffer, options?: IDetectionOptions): Promise<IDetectionResult> {
+    // Quick sanity check
+    if (!buffer || buffer.length === 0) {
+      return {
+        protocol: 'unknown',
+        connectionInfo: { protocol: 'unknown' },
+        isComplete: true
+      };
+    }
+    
+    // Try TLS detection first (more specific)
+    if (this.tlsDetector.canHandle(buffer)) {
+      const tlsResult = this.tlsDetector.detect(buffer, options);
+      if (tlsResult) {
+        return tlsResult;
+      }
+    }
+    
+    // Try HTTP detection
+    if (this.httpDetector.canHandle(buffer)) {
+      const httpResult = this.httpDetector.detect(buffer, options);
+      if (httpResult) {
+        return httpResult;
+      }
+    }
+    
+    // Neither TLS nor HTTP
+    return {
+      protocol: 'unknown',
+      connectionInfo: { protocol: 'unknown' },
+      isComplete: true
+    };
+  }
+  
+  /**
+   * Detect protocol with connection tracking for fragmented data
+   * @deprecated Use detectWithContext instead
+   */
+  static async detectWithConnectionTracking(
+    buffer: Buffer,
+    connectionId: string,
+    options?: IDetectionOptions
+  ): Promise<IDetectionResult> {
+    // Convert connection ID to context
+    const context: IConnectionContext = {
+      id: connectionId,
+      sourceIp: 'unknown',
+      sourcePort: 0,
+      destIp: 'unknown',
+      destPort: 0,
+      timestamp: Date.now()
+    };
+    
+    return this.getInstance().detectWithContextInstance(buffer, context, options);
+  }
+  
+  /**
+   * Detect protocol with connection context for fragmented data
+   */
+  static async detectWithContext(
+    buffer: Buffer,
+    context: IConnectionContext,
+    options?: IDetectionOptions
+  ): Promise<IDetectionResult> {
+    return this.getInstance().detectWithContextInstance(buffer, context, options);
+  }
+  
+  private async detectWithContextInstance(
+    buffer: Buffer,
+    context: IConnectionContext,
+    options?: IDetectionOptions
+  ): Promise<IDetectionResult> {
+    // Quick sanity check
+    if (!buffer || buffer.length === 0) {
+      return {
+        protocol: 'unknown',
+        connectionInfo: { protocol: 'unknown' },
+        isComplete: true
+      };
+    }
+    
+    const connectionId = DetectionFragmentManager.createConnectionId(context);
+    
+    // Check if we already know the protocol for this connection
+    const knownProtocol = this.connectionProtocols.get(connectionId);
+    
+    if (knownProtocol === 'http') {
+      const result = this.httpDetector.detectWithContext(buffer, context, options);
+      if (result) {
+        if (result.isComplete) {
+          this.connectionProtocols.delete(connectionId);
+        }
+        return result;
+      }
+    } else if (knownProtocol === 'tls') {
+      // Handle TLS with fragment accumulation
+      const handler = this.fragmentManager.getHandler('tls');
+      const fragmentResult = handler.addFragment(connectionId, buffer);
+      
+      if (fragmentResult.error) {
+        handler.complete(connectionId);
+        this.connectionProtocols.delete(connectionId);
+        return {
+          protocol: 'unknown',
+          connectionInfo: { protocol: 'unknown' },
+          isComplete: true
+        };
+      }
+      
+      const result = this.tlsDetector.detect(fragmentResult.buffer!, options);
+      if (result) {
+        if (result.isComplete) {
+          handler.complete(connectionId);
+          this.connectionProtocols.delete(connectionId);
+        }
+        return result;
+      }
+    }
+    
+    // If we don't know the protocol yet, try to detect it
+    if (!knownProtocol) {
+      // First peek to determine protocol type
+      if (this.tlsDetector.canHandle(buffer)) {
+        this.connectionProtocols.set(connectionId, 'tls');
+        // Handle TLS with fragment accumulation
+        const handler = this.fragmentManager.getHandler('tls');
+        const fragmentResult = handler.addFragment(connectionId, buffer);
+        
+        if (fragmentResult.error) {
+          handler.complete(connectionId);
+          this.connectionProtocols.delete(connectionId);
+          return {
+            protocol: 'unknown',
+            connectionInfo: { protocol: 'unknown' },
+            isComplete: true
+          };
+        }
+        
+        const result = this.tlsDetector.detect(fragmentResult.buffer!, options);
+        if (result) {
+          if (result.isComplete) {
+            handler.complete(connectionId);
+            this.connectionProtocols.delete(connectionId);
+          }
+          return result;
+        }
+      }
+      
+      if (this.httpDetector.canHandle(buffer)) {
+        this.connectionProtocols.set(connectionId, 'http');
+        const result = this.httpDetector.detectWithContext(buffer, context, options);
+        if (result) {
+          if (result.isComplete) {
+            this.connectionProtocols.delete(connectionId);
+          }
+          return result;
+        }
+      }
+    }
+    
+    // Can't determine protocol
+    return {
+      protocol: 'unknown',
+      connectionInfo: { protocol: 'unknown' },
+      isComplete: false,
+      bytesNeeded: Math.max(
+        this.tlsDetector.getMinimumBytes(),
+        this.httpDetector.getMinimumBytes()
+      )
+    };
+  }
+  
+  /**
+   * Clean up resources
+   */
+  static cleanup(): void {
+    this.getInstance().cleanupInstance();
+  }
+  
+  private cleanupInstance(): void {
+    this.fragmentManager.cleanup();
+  }
+  
+  /**
+   * Destroy detector instance
+   */
+  static destroy(): void {
+    this.getInstance().destroyInstance();
+    this.instance = null as any;
+  }
+  
+  private destroyInstance(): void {
+    this.fragmentManager.destroy();
+  }
+  
+  /**
+   * Clean up old connection tracking entries
+   * 
+   * @param _maxAge Maximum age in milliseconds (default: 30 seconds)
+   */
+  static cleanupConnections(_maxAge: number = 30000): void {
+    // Cleanup is now handled internally by the fragment manager
+    this.getInstance().fragmentManager.cleanup();
+  }
+  
+  /**
+   * Clean up fragments for a specific connection
+   */
+  static cleanupConnection(context: IConnectionContext): void {
+    const instance = this.getInstance();
+    const connectionId = DetectionFragmentManager.createConnectionId(context);
+    
+    // Clean up both TLS and HTTP fragments for this connection
+    instance.fragmentManager.getHandler('tls').complete(connectionId);
+    instance.fragmentManager.getHandler('http').complete(connectionId);
+    
+    // Remove from connection protocols tracking
+    instance.connectionProtocols.delete(connectionId);
+  }
+  
+  /**
+   * Extract domain from connection info
+   */
+  static extractDomain(connectionInfo: any): string | undefined {
+    return connectionInfo.domain || connectionInfo.sni || connectionInfo.host;
+  }
+  
+  /**
+   * Create a connection ID from connection parameters
+   * @deprecated Use createConnectionContext instead
+   */
+  static createConnectionId(params: {
+    sourceIp?: string;
+    sourcePort?: number;
+    destIp?: string;
+    destPort?: number;
+    socketId?: string;
+  }): string {
+    // If socketId is provided, use it
+    if (params.socketId) {
+      return params.socketId;
+    }
+    
+    // Otherwise create from connection tuple
+    const { sourceIp = 'unknown', sourcePort = 0, destIp = 'unknown', destPort = 0 } = params;
+    return `${sourceIp}:${sourcePort}-${destIp}:${destPort}`;
+  }
+  
+  /**
+   * Create a connection context from parameters
+   */
+  static createConnectionContext(params: {
+    sourceIp?: string;
+    sourcePort?: number;
+    destIp?: string;
+    destPort?: number;
+    socketId?: string;
+  }): IConnectionContext {
+    return {
+      id: params.socketId,
+      sourceIp: params.sourceIp || 'unknown',
+      sourcePort: params.sourcePort || 0,
+      destIp: params.destIp || 'unknown',
+      destPort: params.destPort || 0,
+      timestamp: Date.now()
+    };
+  }
+}

ts/detection/utils/buffer-utils.ts

@@ -0,0 +1,141 @@
+/**
+ * Buffer manipulation utilities for protocol detection
+ */
+
+// Import from protocols
+import { HttpParser } from '../../protocols/http/index.js';
+
+/**
+ * BufferAccumulator class for handling fragmented data
+ */
+export class BufferAccumulator {
+  private chunks: Buffer[] = [];
+  private totalLength = 0;
+  
+  /**
+   * Append data to the accumulator
+   */
+  append(data: Buffer): void {
+    this.chunks.push(data);
+    this.totalLength += data.length;
+  }
+  
+  /**
+   * Get the accumulated buffer
+   */
+  getBuffer(): Buffer {
+    if (this.chunks.length === 0) {
+      return Buffer.alloc(0);
+    }
+    if (this.chunks.length === 1) {
+      return this.chunks[0];
+    }
+    return Buffer.concat(this.chunks, this.totalLength);
+  }
+  
+  /**
+   * Get current buffer length
+   */
+  length(): number {
+    return this.totalLength;
+  }
+  
+  /**
+   * Clear all accumulated data
+   */
+  clear(): void {
+    this.chunks = [];
+    this.totalLength = 0;
+  }
+  
+  /**
+   * Check if accumulator has minimum bytes
+   */
+  hasMinimumBytes(minBytes: number): boolean {
+    return this.totalLength >= minBytes;
+  }
+}
+
+/**
+ * Read a big-endian 16-bit integer from buffer
+ */
+export function readUInt16BE(buffer: Buffer, offset: number): number {
+  if (offset + 2 > buffer.length) {
+    throw new Error('Buffer too short for UInt16BE read');
+  }
+  return (buffer[offset] << 8) | buffer[offset + 1];
+}
+
+/**
+ * Read a big-endian 24-bit integer from buffer
+ */
+export function readUInt24BE(buffer: Buffer, offset: number): number {
+  if (offset + 3 > buffer.length) {
+    throw new Error('Buffer too short for UInt24BE read');
+  }
+  return (buffer[offset] << 16) | (buffer[offset + 1] << 8) | buffer[offset + 2];
+}
+
+/**
+ * Find a byte sequence in a buffer
+ */
+export function findSequence(buffer: Buffer, sequence: Buffer, startOffset = 0): number {
+  if (sequence.length === 0) {
+    return startOffset;
+  }
+  
+  const searchLength = buffer.length - sequence.length + 1;
+  for (let i = startOffset; i < searchLength; i++) {
+    let found = true;
+    for (let j = 0; j < sequence.length; j++) {
+      if (buffer[i + j] !== sequence[j]) {
+        found = false;
+        break;
+      }
+    }
+    if (found) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+/**
+ * Extract a line from buffer (up to CRLF or LF)
+ */
+export function extractLine(buffer: Buffer, startOffset = 0): { line: string; nextOffset: number } | null {
+  // Delegate to protocol parser
+  return HttpParser.extractLine(buffer, startOffset);
+}
+
+/**
+ * Check if buffer starts with a string (case-insensitive)
+ */
+export function startsWithString(buffer: Buffer, str: string, offset = 0): boolean {
+  if (offset + str.length > buffer.length) {
+    return false;
+  }
+  
+  const bufferStr = buffer.slice(offset, offset + str.length).toString('utf8');
+  return bufferStr.toLowerCase() === str.toLowerCase();
+}
+
+/**
+ * Safe buffer slice that doesn't throw on out-of-bounds
+ */
+export function safeSlice(buffer: Buffer, start: number, end?: number): Buffer {
+  const safeStart = Math.max(0, Math.min(start, buffer.length));
+  const safeEnd = end === undefined 
+    ? buffer.length 
+    : Math.max(safeStart, Math.min(end, buffer.length));
+    
+  return buffer.slice(safeStart, safeEnd);
+}
+
+/**
+ * Check if buffer contains printable ASCII
+ */
+export function isPrintableAscii(buffer: Buffer, length?: number): boolean {
+  // Delegate to protocol parser
+  return HttpParser.isPrintableAscii(buffer, length);
+}

ts/detection/utils/fragment-manager.ts

@@ -0,0 +1,64 @@
+/**
+ * Fragment Manager for Detection Module
+ * 
+ * Manages fragmented protocol data using the shared fragment handler
+ */
+
+import { FragmentHandler, type IFragmentOptions } from '../../protocols/common/fragment-handler.js';
+import type { IConnectionContext } from '../../protocols/common/types.js';
+
+/**
+ * Detection-specific fragment manager
+ */
+export class DetectionFragmentManager {
+  private tlsFragments: FragmentHandler;
+  private httpFragments: FragmentHandler;
+  
+  constructor() {
+    // Configure fragment handlers with appropriate limits
+    const tlsOptions: IFragmentOptions = {
+      maxBufferSize: 16384,  // TLS record max size
+      timeout: 5000,
+      cleanupInterval: 30000
+    };
+    
+    const httpOptions: IFragmentOptions = {
+      maxBufferSize: 8192,   // HTTP header reasonable limit
+      timeout: 5000,
+      cleanupInterval: 30000
+    };
+    
+    this.tlsFragments = new FragmentHandler(tlsOptions);
+    this.httpFragments = new FragmentHandler(httpOptions);
+  }
+  
+  /**
+   * Get fragment handler for protocol type
+   */
+  getHandler(protocol: 'tls' | 'http'): FragmentHandler {
+    return protocol === 'tls' ? this.tlsFragments : this.httpFragments;
+  }
+  
+  /**
+   * Create connection ID from context
+   */
+  static createConnectionId(context: IConnectionContext): string {
+    return context.id || `${context.sourceIp}:${context.sourcePort}-${context.destIp}:${context.destPort}`;
+  }
+  
+  /**
+   * Clean up all handlers
+   */
+  cleanup(): void {
+    this.tlsFragments.cleanup();
+    this.httpFragments.cleanup();
+  }
+  
+  /**
+   * Destroy all handlers
+   */
+  destroy(): void {
+    this.tlsFragments.destroy();
+    this.httpFragments.destroy();
+  }
+}

ts/detection/utils/parser-utils.ts

@@ -0,0 +1,77 @@
+/**
+ * Parser utilities for protocol detection
+ * Now delegates to protocol modules for actual parsing
+ */
+
+import type { THttpMethod, TTlsVersion } from '../models/detection-types.js';
+import { HttpParser, HTTP_METHODS, HTTP_VERSIONS } from '../../protocols/http/index.js';
+import { tlsVersionToString as protocolTlsVersionToString } from '../../protocols/tls/index.js';
+
+// Re-export constants for backward compatibility
+export { HTTP_METHODS, HTTP_VERSIONS };
+
+/**
+ * Parse HTTP request line
+ */
+export function parseHttpRequestLine(line: string): {
+  method: THttpMethod;
+  path: string;
+  version: string;
+} | null {
+  // Delegate to protocol parser
+  const result = HttpParser.parseRequestLine(line);
+  return result ? {
+    method: result.method as THttpMethod,
+    path: result.path,
+    version: result.version
+  } : null;
+}
+
+/**
+ * Parse HTTP header line
+ */
+export function parseHttpHeader(line: string): { name: string; value: string } | null {
+  // Delegate to protocol parser
+  return HttpParser.parseHeaderLine(line);
+}
+
+/**
+ * Parse HTTP headers from lines
+ */
+export function parseHttpHeaders(lines: string[]): Record<string, string> {
+  // Delegate to protocol parser
+  return HttpParser.parseHeaders(lines);
+}
+
+/**
+ * Convert TLS version bytes to version string
+ */
+export function tlsVersionToString(major: number, minor: number): TTlsVersion | null {
+  // Delegate to protocol parser
+  return protocolTlsVersionToString(major, minor) as TTlsVersion;
+}
+
+/**
+ * Extract domain from Host header value
+ */
+export function extractDomainFromHost(hostHeader: string): string {
+  // Delegate to protocol parser
+  return HttpParser.extractDomainFromHost(hostHeader);
+}
+
+/**
+ * Validate domain name
+ */
+export function isValidDomain(domain: string): boolean {
+  // Delegate to protocol parser
+  return HttpParser.isValidDomain(domain);
+}
+
+/**
+ * Check if string is a valid HTTP method
+ */
+export function isHttpMethod(str: string): str is THttpMethod {
+  // Delegate to protocol parser
+  return HttpParser.isHttpMethod(str) && (str as THttpMethod) !== undefined;
+}
+

ts/forwarding/config/forwarding-types.ts

@@ -1,76 +0,0 @@
-import type * as plugins from '../../plugins.js';
-
-/**
- * The primary forwarding types supported by SmartProxy
- * Used for configuration compatibility
- */
-export type TForwardingType =
-  | 'http-only'                // HTTP forwarding only (no HTTPS)
-  | 'https-passthrough'        // Pass-through TLS traffic (SNI forwarding)
-  | 'https-terminate-to-http'  // Terminate TLS and forward to HTTP backend
-  | 'https-terminate-to-https'; // Terminate TLS and forward to HTTPS backend
-
-/**
- * Event types emitted by forwarding handlers
- */
-export enum ForwardingHandlerEvents {
-  CONNECTED = 'connected',
-  DISCONNECTED = 'disconnected',
-  ERROR = 'error',
-  DATA_FORWARDED = 'data-forwarded',
-  HTTP_REQUEST = 'http-request',
-  HTTP_RESPONSE = 'http-response',
-  CERTIFICATE_NEEDED = 'certificate-needed',
-  CERTIFICATE_LOADED = 'certificate-loaded'
-}
-
-/**
- * Base interface for forwarding handlers
- */
-export interface IForwardingHandler extends plugins.EventEmitter {
-  initialize(): Promise<void>;
-  handleConnection(socket: plugins.net.Socket): void;
-  handleHttpRequest(req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse): void;
-}
-
-// Route-based helpers are now available directly from route-patterns.ts
-import {
-  createHttpRoute,
-  createHttpsTerminateRoute,
-  createHttpsPassthroughRoute,
-  createHttpToHttpsRedirect,
-  createCompleteHttpsServer,
-  createLoadBalancerRoute
-} from '../../proxies/smart-proxy/utils/route-patterns.js';
-
-export {
-  createHttpRoute,
-  createHttpsTerminateRoute,
-  createHttpsPassthroughRoute,
-  createHttpToHttpsRedirect,
-  createCompleteHttpsServer,
-  createLoadBalancerRoute
-};
-
-// Note: Legacy helper functions have been removed
-// Please use the route-based helpers instead:
-// - createHttpRoute
-// - createHttpsTerminateRoute
-// - createHttpsPassthroughRoute
-// - createHttpToHttpsRedirect
-import type { IRouteConfig } from '../../proxies/smart-proxy/models/route-types.js';
-
-// For backward compatibility, kept only the basic configuration interface
-export interface IForwardConfig {
-  type: TForwardingType;
-  target: {
-    host: string | string[];
-    port: number | 'preserve' | ((ctx: any) => number);
-  };
-  http?: any;
-  https?: any;
-  acme?: any;
-  security?: any;
-  advanced?: any;
-  [key: string]: any;
-}

ts/forwarding/config/index.ts

@@ -1,26 +0,0 @@
-/**
- * Forwarding configuration exports
- *
- * Note: The legacy domain-based configuration has been replaced by route-based configuration.
- * See /ts/proxies/smart-proxy/models/route-types.ts for the new route-based configuration.
- */
-
-export type { 
-  TForwardingType,
-  IForwardConfig,
-  IForwardingHandler
-} from './forwarding-types.js';
-
-export { 
-  ForwardingHandlerEvents
-} from './forwarding-types.js';
-
-// Import route helpers from route-patterns instead of deleted route-helpers
-export {
-  createHttpRoute,
-  createHttpsTerminateRoute,
-  createHttpsPassthroughRoute,
-  createHttpToHttpsRedirect,
-  createCompleteHttpsServer,
-  createLoadBalancerRoute
-} from '../../proxies/smart-proxy/utils/route-patterns.js';

ts/forwarding/factory/forwarding-factory.ts

@@ -1,189 +0,0 @@
-import type { IForwardConfig } from '../config/forwarding-types.js';
-import { ForwardingHandler } from '../handlers/base-handler.js';
-import { HttpForwardingHandler } from '../handlers/http-handler.js';
-import { HttpsPassthroughHandler } from '../handlers/https-passthrough-handler.js';
-import { HttpsTerminateToHttpHandler } from '../handlers/https-terminate-to-http-handler.js';
-import { HttpsTerminateToHttpsHandler } from '../handlers/https-terminate-to-https-handler.js';
-
-/**
- * Factory for creating forwarding handlers based on the configuration type
- */
-export class ForwardingHandlerFactory {
-  /**
-   * Create a forwarding handler based on the configuration
-   * @param config The forwarding configuration
-   * @returns The appropriate forwarding handler
-   */
-  public static createHandler(config: IForwardConfig): ForwardingHandler {
-    // Create the appropriate handler based on the forwarding type
-    switch (config.type) {
-      case 'http-only':
-        return new HttpForwardingHandler(config);
-
-      case 'https-passthrough':
-        return new HttpsPassthroughHandler(config);
-
-      case 'https-terminate-to-http':
-        return new HttpsTerminateToHttpHandler(config);
-
-      case 'https-terminate-to-https':
-        return new HttpsTerminateToHttpsHandler(config);
-
-      default:
-        // Type system should prevent this, but just in case:
-        throw new Error(`Unknown forwarding type: ${(config as any).type}`);
-    }
-  }
-
-  /**
-   * Apply default values to a forwarding configuration based on its type
-   * @param config The original forwarding configuration
-   * @returns A configuration with defaults applied
-   */
-  public static applyDefaults(config: IForwardConfig): IForwardConfig {
-    // Create a deep copy of the configuration
-    const result: IForwardConfig = JSON.parse(JSON.stringify(config));
-    
-    // Apply defaults based on forwarding type
-    switch (config.type) {
-      case 'http-only':
-        // Set defaults for HTTP-only mode
-        result.http = {
-          enabled: true,
-          ...config.http
-        };
-        // Set default port and socket if not provided
-        if (!result.port) {
-          result.port = 80;
-        }
-        if (!result.socket) {
-          result.socket = `/tmp/forwarding-${config.type}-${result.port}.sock`;
-        }
-        break;
-        
-      case 'https-passthrough':
-        // Set defaults for HTTPS passthrough
-        result.https = {
-          forwardSni: true,
-          ...config.https
-        };
-        // SNI forwarding doesn't do HTTP
-        result.http = {
-          enabled: false,
-          ...config.http
-        };
-        // Set default port and socket if not provided
-        if (!result.port) {
-          result.port = 443;
-        }
-        if (!result.socket) {
-          result.socket = `/tmp/forwarding-${config.type}-${result.port}.sock`;
-        }
-        break;
-        
-      case 'https-terminate-to-http':
-        // Set defaults for HTTPS termination to HTTP
-        result.https = {
-          ...config.https
-        };
-        // Support HTTP access by default in this mode
-        result.http = {
-          enabled: true,
-          redirectToHttps: true,
-          ...config.http
-        };
-        // Enable ACME by default
-        result.acme = {
-          enabled: true,
-          maintenance: true,
-          ...config.acme
-        };
-        // Set default port and socket if not provided
-        if (!result.port) {
-          result.port = 443;
-        }
-        if (!result.socket) {
-          result.socket = `/tmp/forwarding-${config.type}-${result.port}.sock`;
-        }
-        break;
-        
-      case 'https-terminate-to-https':
-        // Similar to terminate-to-http but with different target handling
-        result.https = {
-          ...config.https
-        };
-        result.http = {
-          enabled: true,
-          redirectToHttps: true,
-          ...config.http
-        };
-        result.acme = {
-          enabled: true,
-          maintenance: true,
-          ...config.acme
-        };
-        // Set default port and socket if not provided
-        if (!result.port) {
-          result.port = 443;
-        }
-        if (!result.socket) {
-          result.socket = `/tmp/forwarding-${config.type}-${result.port}.sock`;
-        }
-        break;
-    }
-    
-    return result;
-  }
-  
-  /**
-   * Validate a forwarding configuration
-   * @param config The configuration to validate
-   * @throws Error if the configuration is invalid
-   */
-  public static validateConfig(config: IForwardConfig): void {
-    // Validate common properties
-    if (!config.target) {
-      throw new Error('Forwarding configuration must include a target');
-    }
-    
-    if (!config.target.host || (Array.isArray(config.target.host) && config.target.host.length === 0)) {
-      throw new Error('Target must include a host or array of hosts');
-    }
-    
-    // Validate port if it's a number
-    if (typeof config.target.port === 'number') {
-      if (config.target.port <= 0 || config.target.port > 65535) {
-        throw new Error('Target must include a valid port (1-65535)');
-      }
-    } else if (config.target.port !== 'preserve' && typeof config.target.port !== 'function') {
-      throw new Error('Target port must be a number, "preserve", or a function');
-    }
-    
-    // Type-specific validation
-    switch (config.type) {
-      case 'http-only':
-        // HTTP-only needs http.enabled to be true
-        if (config.http?.enabled === false) {
-          throw new Error('HTTP-only forwarding must have HTTP enabled');
-        }
-        break;
-        
-      case 'https-passthrough':
-        // HTTPS passthrough doesn't support HTTP
-        if (config.http?.enabled === true) {
-          throw new Error('HTTPS passthrough does not support HTTP');
-        }
-        
-        // HTTPS passthrough doesn't work with ACME
-        if (config.acme?.enabled === true) {
-          throw new Error('HTTPS passthrough does not support ACME');
-        }
-        break;
-        
-      case 'https-terminate-to-http':
-      case 'https-terminate-to-https':
-        // These modes support all options, nothing specific to validate
-        break;
-    }
-  }
-}

ts/forwarding/factory/index.ts

@@ -1,5 +0,0 @@
-/**
- * Forwarding factory implementations
- */
-
-export { ForwardingHandlerFactory } from './forwarding-factory.js';

ts/forwarding/handlers/base-handler.ts

@@ -1,155 +0,0 @@
-import * as plugins from '../../plugins.js';
-import type {
-  IForwardConfig,
-  IForwardingHandler
-} from '../config/forwarding-types.js';
-import { ForwardingHandlerEvents } from '../config/forwarding-types.js';
-
-/**
- * Base class for all forwarding handlers
- */
-export abstract class ForwardingHandler extends plugins.EventEmitter implements IForwardingHandler {
-  /**
-   * Create a new ForwardingHandler
-   * @param config The forwarding configuration
-   */
-  constructor(protected config: IForwardConfig) {
-    super();
-  }
-  
-  /**
-   * Initialize the handler
-   * Base implementation does nothing, subclasses should override as needed
-   */
-  public async initialize(): Promise<void> {
-    // Base implementation - no initialization needed
-  }
-
-  /**
-   * Handle a new socket connection
-   * @param socket The incoming socket connection
-   */
-  public abstract handleConnection(socket: plugins.net.Socket): void;
-  
-  /**
-   * Handle an HTTP request
-   * @param req The HTTP request
-   * @param res The HTTP response
-   */
-  public abstract handleHttpRequest(req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse): void;
-  
-  /**
-   * Get a target from the configuration, supporting round-robin selection
-   * @param incomingPort Optional incoming port for 'preserve' mode
-   * @returns A resolved target object with host and port
-   */
-  protected getTargetFromConfig(incomingPort: number = 80): { host: string, port: number } {
-    const { target } = this.config;
-    
-    // Handle round-robin host selection
-    if (Array.isArray(target.host)) {
-      if (target.host.length === 0) {
-        throw new Error('No target hosts specified');
-      }
-      
-      // Simple round-robin selection
-      const randomIndex = Math.floor(Math.random() * target.host.length);
-      return {
-        host: target.host[randomIndex],
-        port: this.resolvePort(target.port, incomingPort)
-      };
-    }
-    
-    // Single host
-    return {
-      host: target.host,
-      port: this.resolvePort(target.port, incomingPort)
-    };
-  }
-  
-  /**
-   * Resolves a port value, handling 'preserve' and function ports
-   * @param port The port value to resolve
-   * @param incomingPort Optional incoming port to use for 'preserve' mode
-   */
-  protected resolvePort(
-    port: number | 'preserve' | ((ctx: any) => number), 
-    incomingPort: number = 80
-  ): number {
-    if (typeof port === 'function') {
-      try {
-        // Create a minimal context for the function that includes the incoming port
-        const ctx = { port: incomingPort };
-        return port(ctx);
-      } catch (err) {
-        console.error('Error resolving port function:', err);
-        return incomingPort; // Fall back to incoming port
-      }
-    } else if (port === 'preserve') {
-      return incomingPort; // Use the actual incoming port for 'preserve'
-    } else {
-      return port;
-    }
-  }
-
-  /**
-   * Redirect an HTTP request to HTTPS
-   * @param req The HTTP request
-   * @param res The HTTP response
-   */
-  protected redirectToHttps(req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse): void {
-    const host = req.headers.host || '';
-    const path = req.url || '/';
-    const redirectUrl = `https://${host}${path}`;
-    
-    res.writeHead(301, {
-      'Location': redirectUrl,
-      'Cache-Control': 'no-cache'
-    });
-    res.end(`Redirecting to ${redirectUrl}`);
-    
-    this.emit(ForwardingHandlerEvents.HTTP_RESPONSE, {
-      statusCode: 301,
-      headers: { 'Location': redirectUrl },
-      size: 0
-    });
-  }
-  
-  /**
-   * Apply custom headers from configuration
-   * @param headers The original headers
-   * @param variables Variables to replace in the headers
-   * @returns The headers with custom values applied
-   */
-  protected applyCustomHeaders(
-    headers: Record<string, string | string[] | undefined>,
-    variables: Record<string, string>
-  ): Record<string, string | string[] | undefined> {
-    const customHeaders = this.config.advanced?.headers || {};
-    const result = { ...headers };
-    
-    // Apply custom headers with variable substitution
-    for (const [key, value] of Object.entries(customHeaders)) {
-      if (typeof value !== 'string') continue;
-
-      let processedValue = value;
-
-      // Replace variables in the header value
-      for (const [varName, varValue] of Object.entries(variables)) {
-        processedValue = processedValue.replace(`{${varName}}`, varValue);
-      }
-
-      result[key] = processedValue;
-    }
-    
-    return result;
-  }
-  
-  /**
-   * Get the timeout for this connection from configuration
-   * @returns Timeout in milliseconds
-   */
-  protected getTimeout(): number {
-    return this.config.advanced?.timeout || 60000; // Default: 60 seconds
-  }
-}

ts/forwarding/handlers/http-handler.ts

@@ -1,163 +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 } from '../../core/utils/socket-utils.js';
-
-/**
- * Handler for HTTP-only forwarding
- */
-export class HttpForwardingHandler extends ForwardingHandler {
-  /**
-   * Create a new HTTP forwarding handler
-   * @param config The forwarding configuration
-   */
-  constructor(config: IForwardConfig) {
-    super(config);
-
-    // Validate that this is an HTTP-only configuration
-    if (config.type !== 'http-only') {
-      throw new Error(`Invalid configuration type for HttpForwardingHandler: ${config.type}`);
-    }
-  }
-
-  /**
-   * Initialize the handler
-   * HTTP handler doesn't need special initialization
-   */
-  public async initialize(): Promise<void> {
-    // Basic initialization from parent class
-    await super.initialize();
-  }
-  
-  /**
-   * Handle a raw socket connection
-   * HTTP handler doesn't do much with raw sockets as it mainly processes
-   * parsed HTTP requests
-   */
-  public handleConnection(socket: plugins.net.Socket): void {
-    // For HTTP, we mainly handle parsed requests, but we can still set up
-    // some basic connection tracking
-    const remoteAddress = socket.remoteAddress || 'unknown';
-    const localPort = socket.localPort || 80;
-    
-    // Set up socket handlers with proper cleanup
-    const handleClose = (reason: string) => {
-      this.emit(ForwardingHandlerEvents.DISCONNECTED, {
-        remoteAddress,
-        reason
-      });
-    };
-    
-    // Use custom timeout handler that doesn't close the socket
-    setupSocketHandlers(socket, handleClose, () => {
-      // For HTTP, we can be more aggressive with timeouts since connections are shorter
-      // But still don't close immediately - let the connection finish naturally
-      console.warn(`HTTP socket timeout from ${remoteAddress}`);
-    }, 'http');
-    
-    socket.on('error', (error) => {
-      this.emit(ForwardingHandlerEvents.ERROR, {
-        remoteAddress,
-        error: error.message
-      });
-    });
-    
-    this.emit(ForwardingHandlerEvents.CONNECTED, {
-      remoteAddress,
-      localPort
-    });
-  }
-  
-  /**
-   * Handle an HTTP request
-   * @param req The HTTP request
-   * @param res The HTTP response
-   */
-  public handleHttpRequest(req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse): void {
-    // Get the local port from the request (for 'preserve' port handling)
-    const localPort = req.socket.localPort || 80;
-    
-    // Get the target from configuration, passing the incoming port
-    const target = this.getTargetFromConfig(localPort);
-    
-    // Create a custom headers object with variables for 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 bytes 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();
-    }
-  }
-}

ts/forwarding/handlers/https-passthrough-handler.ts

@@ -1,185 +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 { createIndependentSocketHandlers, setupSocketHandlers, createSocketWithErrorHandler } from '../../core/utils/socket-utils.js';
-
-/**
- * Handler for HTTPS passthrough (SNI forwarding without termination)
- */
-export class HttpsPassthroughHandler extends ForwardingHandler {
-  /**
-   * Create a new HTTPS passthrough handler
-   * @param config The forwarding configuration
-   */
-  constructor(config: IForwardConfig) {
-    super(config);
-
-    // Validate that this is an HTTPS passthrough configuration
-    if (config.type !== 'https-passthrough') {
-      throw new Error(`Invalid configuration type for HttpsPassthroughHandler: ${config.type}`);
-    }
-  }
-
-  /**
-   * Initialize the handler
-   * HTTPS passthrough handler doesn't need special initialization
-   */
-  public async initialize(): Promise<void> {
-    // Basic initialization from parent class
-    await super.initialize();
-  }
-  
-  /**
-   * Handle a TLS/SSL socket connection by forwarding it without termination
-   * @param clientSocket The incoming socket from the client
-   */
-  public handleConnection(clientSocket: plugins.net.Socket): void {
-    // Get the target from configuration
-    const target = this.getTargetFromConfig();
-    
-    // Log the connection
-    const remoteAddress = clientSocket.remoteAddress || 'unknown';
-    const remotePort = clientSocket.remotePort || 0;
-    
-    this.emit(ForwardingHandlerEvents.CONNECTED, {
-      remoteAddress,
-      remotePort,
-      target: `${target.host}:${target.port}`
-    });
-    
-    // Track data transfer for logging
-    let bytesSent = 0;
-    let bytesReceived = 0;
-    let serverSocket: plugins.net.Socket | null = null;
-    let cleanupClient: ((reason: string) => Promise<void>) | null = null;
-    let cleanupServer: ((reason: string) => Promise<void>) | null = null;
-    
-    // Create a connection to the target server with immediate error handling
-    serverSocket = createSocketWithErrorHandler({
-      port: target.port,
-      host: target.host,
-      onError: async (error) => {
-        // Server connection failed - clean up client socket immediately
-        this.emit(ForwardingHandlerEvents.ERROR, {
-          error: error.message,
-          code: (error as any).code || 'UNKNOWN',
-          remoteAddress,
-          target: `${target.host}:${target.port}`
-        });
-        
-        // Clean up the client socket since we can't forward
-        if (!clientSocket.destroyed) {
-          clientSocket.destroy();
-        }
-        
-        this.emit(ForwardingHandlerEvents.DISCONNECTED, {
-          remoteAddress,
-          bytesSent: 0,
-          bytesReceived: 0,
-          reason: `server_connection_failed: ${error.message}`
-        });
-      },
-      onConnect: () => {
-        // Connection successful - set up forwarding handlers
-        const handlers = createIndependentSocketHandlers(
-          clientSocket,
-          serverSocket!,
-          (reason) => {
-            this.emit(ForwardingHandlerEvents.DISCONNECTED, {
-              remoteAddress,
-              bytesSent,
-              bytesReceived,
-              reason
-            });
-          }
-        );
-        
-        cleanupClient = handlers.cleanupClient;
-        cleanupServer = handlers.cleanupServer;
-        
-        // Setup handlers with custom timeout handling that doesn't close connections
-        const timeout = this.getTimeout();
-        
-        setupSocketHandlers(clientSocket, cleanupClient, (socket) => {
-          // Just reset timeout, don't close
-          socket.setTimeout(timeout);
-        }, 'client');
-        
-        setupSocketHandlers(serverSocket!, cleanupServer, (socket) => {
-          // Just reset timeout, don't close  
-          socket.setTimeout(timeout);
-        }, 'server');
-        
-        // Forward data from client to server
-        clientSocket.on('data', (data) => {
-          bytesSent += data.length;
-          
-          // Check if server socket is writable
-          if (serverSocket && serverSocket.writable) {
-            const flushed = serverSocket.write(data);
-            
-            // Handle backpressure
-            if (!flushed) {
-              clientSocket.pause();
-              serverSocket.once('drain', () => {
-                clientSocket.resume();
-              });
-            }
-          }
-          
-          this.emit(ForwardingHandlerEvents.DATA_FORWARDED, {
-            direction: 'outbound',
-            bytes: data.length,
-            total: bytesSent
-          });
-        });
-        
-        // Forward data from server to client
-        serverSocket!.on('data', (data) => {
-          bytesReceived += data.length;
-          
-          // Check if client socket is writable
-          if (clientSocket.writable) {
-            const flushed = clientSocket.write(data);
-            
-            // Handle backpressure
-            if (!flushed) {
-              serverSocket!.pause();
-              clientSocket.once('drain', () => {
-                serverSocket!.resume();
-              });
-            }
-          }
-          
-          this.emit(ForwardingHandlerEvents.DATA_FORWARDED, {
-            direction: 'inbound',
-            bytes: data.length,
-            total: bytesReceived
-          });
-        });
-        
-        // Set initial timeouts - they will be reset on each timeout event  
-        clientSocket.setTimeout(timeout);
-        serverSocket!.setTimeout(timeout);
-      }
-    });
-  }
-  
-  /**
-   * Handle an HTTP request - HTTPS passthrough doesn't support HTTP
-   * @param req The HTTP request
-   * @param res The HTTP response
-   */
-  public handleHttpRequest(_req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse): void {
-    // HTTPS passthrough doesn't support HTTP requests
-    res.writeHead(404, { 'Content-Type': 'text/plain' });
-    res.end('HTTP not supported for this domain');
-    
-    this.emit(ForwardingHandlerEvents.HTTP_RESPONSE, {
-      statusCode: 404,
-      headers: { 'Content-Type': 'text/plain' },
-      size: 'HTTP not supported for this domain'.length
-    });
-  }
-}

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();
-    }
-  }
-}

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();
-    }
-  }
-}

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';

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';

ts/index.ts

@@ -32,7 +32,8 @@ export * from './core/models/common-types.js';
 export type { IAcmeOptions } from './proxies/smart-proxy/models/interfaces.js';
 
 // Modular exports for new architecture
-export * as forwarding from './forwarding/index.js';
 // Certificate module has been removed - use SmartCertManager instead
 export * as tls from './tls/index.js';
 export * as routing from './routing/index.js';
+export * as detection from './detection/index.js';
+export * as protocols from './protocols/index.js';

ts/protocols/common/fragment-handler.ts

@@ -0,0 +1,163 @@
+/**
+ * Shared Fragment Handler for Protocol Detection
+ * 
+ * Provides unified fragment buffering and reassembly for protocols
+ * that may span multiple TCP packets.
+ */
+
+import { Buffer } from 'buffer';
+
+/**
+ * Fragment tracking information
+ */
+export interface IFragmentInfo {
+  buffer: Buffer;
+  timestamp: number;
+  connectionId: string;
+}
+
+/**
+ * Options for fragment handling
+ */
+export interface IFragmentOptions {
+  maxBufferSize?: number;
+  timeout?: number;
+  cleanupInterval?: number;
+}
+
+/**
+ * Result of fragment processing
+ */
+export interface IFragmentResult {
+  isComplete: boolean;
+  buffer?: Buffer;
+  needsMoreData: boolean;
+  error?: string;
+}
+
+/**
+ * Shared fragment handler for protocol detection
+ */
+export class FragmentHandler {
+  private fragments = new Map<string, IFragmentInfo>();
+  private cleanupTimer?: NodeJS.Timeout;
+  
+  constructor(private options: IFragmentOptions = {}) {
+    // Start cleanup timer if not already running
+    if (options.cleanupInterval && !this.cleanupTimer) {
+      this.cleanupTimer = setInterval(
+        () => this.cleanup(),
+        options.cleanupInterval
+      );
+    }
+  }
+  
+  /**
+   * Add a fragment for a connection
+   */
+  addFragment(connectionId: string, fragment: Buffer): IFragmentResult {
+    const existing = this.fragments.get(connectionId);
+    
+    if (existing) {
+      // Append to existing buffer
+      const newBuffer = Buffer.concat([existing.buffer, fragment]);
+      
+      // Check size limit
+      const maxSize = this.options.maxBufferSize || 65536;
+      if (newBuffer.length > maxSize) {
+        this.fragments.delete(connectionId);
+        return {
+          isComplete: false,
+          needsMoreData: false,
+          error: 'Buffer size exceeded maximum allowed'
+        };
+      }
+      
+      // Update fragment info
+      this.fragments.set(connectionId, {
+        buffer: newBuffer,
+        timestamp: Date.now(),
+        connectionId
+      });
+      
+      return {
+        isComplete: false,
+        buffer: newBuffer,
+        needsMoreData: true
+      };
+    } else {
+      // New fragment
+      this.fragments.set(connectionId, {
+        buffer: fragment,
+        timestamp: Date.now(),
+        connectionId
+      });
+      
+      return {
+        isComplete: false,
+        buffer: fragment,
+        needsMoreData: true
+      };
+    }
+  }
+  
+  /**
+   * Get the current buffer for a connection
+   */
+  getBuffer(connectionId: string): Buffer | undefined {
+    return this.fragments.get(connectionId)?.buffer;
+  }
+  
+  /**
+   * Mark a connection as complete and clean up
+   */
+  complete(connectionId: string): void {
+    this.fragments.delete(connectionId);
+  }
+  
+  /**
+   * Check if we're tracking a connection
+   */
+  hasConnection(connectionId: string): boolean {
+    return this.fragments.has(connectionId);
+  }
+  
+  /**
+   * Clean up expired fragments
+   */
+  cleanup(): void {
+    const now = Date.now();
+    const timeout = this.options.timeout || 5000;
+    
+    for (const [connectionId, info] of this.fragments.entries()) {
+      if (now - info.timestamp > timeout) {
+        this.fragments.delete(connectionId);
+      }
+    }
+  }
+  
+  /**
+   * Clear all fragments
+   */
+  clear(): void {
+    this.fragments.clear();
+  }
+  
+  /**
+   * Destroy the handler and clean up resources
+   */
+  destroy(): void {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = undefined;
+    }
+    this.clear();
+  }
+  
+  /**
+   * Get the number of tracked connections
+   */
+  get size(): number {
+    return this.fragments.size;
+  }
+}

ts/protocols/common/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Common Protocol Infrastructure
+ * 
+ * Shared utilities and types for protocol handling
+ */
+
+export * from './fragment-handler.js';
+export * from './types.js';

ts/protocols/common/types.ts

@@ -0,0 +1,76 @@
+/**
+ * Common Protocol Types
+ * 
+ * Shared types used across different protocol implementations
+ */
+
+/**
+ * Supported protocol types
+ */
+export type TProtocolType = 'tls' | 'http' | 'https' | 'websocket' | 'unknown';
+
+/**
+ * Protocol detection result
+ */
+export interface IProtocolDetectionResult {
+  protocol: TProtocolType;
+  confidence: number; // 0-100
+  requiresMoreData?: boolean;
+  metadata?: {
+    version?: string;
+    method?: string;
+    [key: string]: any;
+  };
+}
+
+/**
+ * Routing information extracted from protocols
+ */
+export interface IRoutingInfo {
+  domain?: string;
+  port?: number;
+  path?: string;
+  protocol: TProtocolType;
+}
+
+/**
+ * Connection context for protocol operations
+ */
+export interface IConnectionContext {
+  id: string;
+  sourceIp?: string;
+  sourcePort?: number;
+  destIp?: string;
+  destPort?: number;
+  timestamp?: number;
+}
+
+/**
+ * Protocol detection options
+ */
+export interface IProtocolDetectionOptions {
+  quickMode?: boolean;        // Only do minimal detection
+  extractRouting?: boolean;   // Extract routing information
+  maxWaitTime?: number;       // Max time to wait for complete data
+  maxBufferSize?: number;     // Max buffer size for fragmented data
+}
+
+/**
+ * Base interface for protocol detectors
+ */
+export interface IProtocolDetector {
+  /**
+   * Check if this detector can handle the data
+   */
+  canHandle(data: Buffer): boolean;
+  
+  /**
+   * Perform quick detection (first few bytes only)
+   */
+  quickDetect(data: Buffer): IProtocolDetectionResult;
+  
+  /**
+   * Extract routing information if possible
+   */
+  extractRouting?(data: Buffer, context?: IConnectionContext): IRoutingInfo | null;
+}

ts/protocols/http/constants.ts

@@ -0,0 +1,219 @@
+/**
+ * HTTP Protocol Constants
+ */
+
+/**
+ * HTTP methods
+ */
+export const HTTP_METHODS = [
+  'GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS', 'CONNECT', 'TRACE'
+] as const;
+
+export type THttpMethod = typeof HTTP_METHODS[number];
+
+/**
+ * HTTP version strings
+ */
+export const HTTP_VERSIONS = ['HTTP/1.0', 'HTTP/1.1', 'HTTP/2', 'HTTP/3'] as const;
+
+export type THttpVersion = typeof HTTP_VERSIONS[number];
+
+/**
+ * HTTP status codes
+ */
+export enum HttpStatus {
+  // 1xx Informational
+  CONTINUE = 100,
+  SWITCHING_PROTOCOLS = 101,
+  PROCESSING = 102,
+  EARLY_HINTS = 103,
+  
+  // 2xx Success
+  OK = 200,
+  CREATED = 201,
+  ACCEPTED = 202,
+  NON_AUTHORITATIVE_INFORMATION = 203,
+  NO_CONTENT = 204,
+  RESET_CONTENT = 205,
+  PARTIAL_CONTENT = 206,
+  MULTI_STATUS = 207,
+  ALREADY_REPORTED = 208,
+  IM_USED = 226,
+  
+  // 3xx Redirection
+  MULTIPLE_CHOICES = 300,
+  MOVED_PERMANENTLY = 301,
+  FOUND = 302,
+  SEE_OTHER = 303,
+  NOT_MODIFIED = 304,
+  USE_PROXY = 305,
+  TEMPORARY_REDIRECT = 307,
+  PERMANENT_REDIRECT = 308,
+  
+  // 4xx Client Error
+  BAD_REQUEST = 400,
+  UNAUTHORIZED = 401,
+  PAYMENT_REQUIRED = 402,
+  FORBIDDEN = 403,
+  NOT_FOUND = 404,
+  METHOD_NOT_ALLOWED = 405,
+  NOT_ACCEPTABLE = 406,
+  PROXY_AUTHENTICATION_REQUIRED = 407,
+  REQUEST_TIMEOUT = 408,
+  CONFLICT = 409,
+  GONE = 410,
+  LENGTH_REQUIRED = 411,
+  PRECONDITION_FAILED = 412,
+  PAYLOAD_TOO_LARGE = 413,
+  URI_TOO_LONG = 414,
+  UNSUPPORTED_MEDIA_TYPE = 415,
+  RANGE_NOT_SATISFIABLE = 416,
+  EXPECTATION_FAILED = 417,
+  IM_A_TEAPOT = 418,
+  MISDIRECTED_REQUEST = 421,
+  UNPROCESSABLE_ENTITY = 422,
+  LOCKED = 423,
+  FAILED_DEPENDENCY = 424,
+  TOO_EARLY = 425,
+  UPGRADE_REQUIRED = 426,
+  PRECONDITION_REQUIRED = 428,
+  TOO_MANY_REQUESTS = 429,
+  REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
+  UNAVAILABLE_FOR_LEGAL_REASONS = 451,
+  
+  // 5xx Server Error
+  INTERNAL_SERVER_ERROR = 500,
+  NOT_IMPLEMENTED = 501,
+  BAD_GATEWAY = 502,
+  SERVICE_UNAVAILABLE = 503,
+  GATEWAY_TIMEOUT = 504,
+  HTTP_VERSION_NOT_SUPPORTED = 505,
+  VARIANT_ALSO_NEGOTIATES = 506,
+  INSUFFICIENT_STORAGE = 507,
+  LOOP_DETECTED = 508,
+  NOT_EXTENDED = 510,
+  NETWORK_AUTHENTICATION_REQUIRED = 511,
+}
+
+/**
+ * HTTP status text mapping
+ */
+export const HTTP_STATUS_TEXT: Record<HttpStatus, string> = {
+  // 1xx
+  [HttpStatus.CONTINUE]: 'Continue',
+  [HttpStatus.SWITCHING_PROTOCOLS]: 'Switching Protocols',
+  [HttpStatus.PROCESSING]: 'Processing',
+  [HttpStatus.EARLY_HINTS]: 'Early Hints',
+  
+  // 2xx
+  [HttpStatus.OK]: 'OK',
+  [HttpStatus.CREATED]: 'Created',
+  [HttpStatus.ACCEPTED]: 'Accepted',
+  [HttpStatus.NON_AUTHORITATIVE_INFORMATION]: 'Non-Authoritative Information',
+  [HttpStatus.NO_CONTENT]: 'No Content',
+  [HttpStatus.RESET_CONTENT]: 'Reset Content',
+  [HttpStatus.PARTIAL_CONTENT]: 'Partial Content',
+  [HttpStatus.MULTI_STATUS]: 'Multi-Status',
+  [HttpStatus.ALREADY_REPORTED]: 'Already Reported',
+  [HttpStatus.IM_USED]: 'IM Used',
+  
+  // 3xx
+  [HttpStatus.MULTIPLE_CHOICES]: 'Multiple Choices',
+  [HttpStatus.MOVED_PERMANENTLY]: 'Moved Permanently',
+  [HttpStatus.FOUND]: 'Found',
+  [HttpStatus.SEE_OTHER]: 'See Other',
+  [HttpStatus.NOT_MODIFIED]: 'Not Modified',
+  [HttpStatus.USE_PROXY]: 'Use Proxy',
+  [HttpStatus.TEMPORARY_REDIRECT]: 'Temporary Redirect',
+  [HttpStatus.PERMANENT_REDIRECT]: 'Permanent Redirect',
+  
+  // 4xx
+  [HttpStatus.BAD_REQUEST]: 'Bad Request',
+  [HttpStatus.UNAUTHORIZED]: 'Unauthorized',
+  [HttpStatus.PAYMENT_REQUIRED]: 'Payment Required',
+  [HttpStatus.FORBIDDEN]: 'Forbidden',
+  [HttpStatus.NOT_FOUND]: 'Not Found',
+  [HttpStatus.METHOD_NOT_ALLOWED]: 'Method Not Allowed',
+  [HttpStatus.NOT_ACCEPTABLE]: 'Not Acceptable',
+  [HttpStatus.PROXY_AUTHENTICATION_REQUIRED]: 'Proxy Authentication Required',
+  [HttpStatus.REQUEST_TIMEOUT]: 'Request Timeout',
+  [HttpStatus.CONFLICT]: 'Conflict',
+  [HttpStatus.GONE]: 'Gone',
+  [HttpStatus.LENGTH_REQUIRED]: 'Length Required',
+  [HttpStatus.PRECONDITION_FAILED]: 'Precondition Failed',
+  [HttpStatus.PAYLOAD_TOO_LARGE]: 'Payload Too Large',
+  [HttpStatus.URI_TOO_LONG]: 'URI Too Long',
+  [HttpStatus.UNSUPPORTED_MEDIA_TYPE]: 'Unsupported Media Type',
+  [HttpStatus.RANGE_NOT_SATISFIABLE]: 'Range Not Satisfiable',
+  [HttpStatus.EXPECTATION_FAILED]: 'Expectation Failed',
+  [HttpStatus.IM_A_TEAPOT]: "I'm a teapot",
+  [HttpStatus.MISDIRECTED_REQUEST]: 'Misdirected Request',
+  [HttpStatus.UNPROCESSABLE_ENTITY]: 'Unprocessable Entity',
+  [HttpStatus.LOCKED]: 'Locked',
+  [HttpStatus.FAILED_DEPENDENCY]: 'Failed Dependency',
+  [HttpStatus.TOO_EARLY]: 'Too Early',
+  [HttpStatus.UPGRADE_REQUIRED]: 'Upgrade Required',
+  [HttpStatus.PRECONDITION_REQUIRED]: 'Precondition Required',
+  [HttpStatus.TOO_MANY_REQUESTS]: 'Too Many Requests',
+  [HttpStatus.REQUEST_HEADER_FIELDS_TOO_LARGE]: 'Request Header Fields Too Large',
+  [HttpStatus.UNAVAILABLE_FOR_LEGAL_REASONS]: 'Unavailable For Legal Reasons',
+  
+  // 5xx
+  [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',
+  [HttpStatus.HTTP_VERSION_NOT_SUPPORTED]: 'HTTP Version Not Supported',
+  [HttpStatus.VARIANT_ALSO_NEGOTIATES]: 'Variant Also Negotiates',
+  [HttpStatus.INSUFFICIENT_STORAGE]: 'Insufficient Storage',
+  [HttpStatus.LOOP_DETECTED]: 'Loop Detected',
+  [HttpStatus.NOT_EXTENDED]: 'Not Extended',
+  [HttpStatus.NETWORK_AUTHENTICATION_REQUIRED]: 'Network Authentication Required',
+};
+
+/**
+ * Common HTTP headers
+ */
+export const HTTP_HEADERS = {
+  // Request headers
+  HOST: 'host',
+  USER_AGENT: 'user-agent',
+  ACCEPT: 'accept',
+  ACCEPT_LANGUAGE: 'accept-language',
+  ACCEPT_ENCODING: 'accept-encoding',
+  AUTHORIZATION: 'authorization',
+  CACHE_CONTROL: 'cache-control',
+  CONNECTION: 'connection',
+  CONTENT_TYPE: 'content-type',
+  CONTENT_LENGTH: 'content-length',
+  COOKIE: 'cookie',
+  
+  // Response headers
+  SET_COOKIE: 'set-cookie',
+  LOCATION: 'location',
+  SERVER: 'server',
+  DATE: 'date',
+  EXPIRES: 'expires',
+  LAST_MODIFIED: 'last-modified',
+  ETAG: 'etag',
+  
+  // CORS headers
+  ACCESS_CONTROL_ALLOW_ORIGIN: 'access-control-allow-origin',
+  ACCESS_CONTROL_ALLOW_METHODS: 'access-control-allow-methods',
+  ACCESS_CONTROL_ALLOW_HEADERS: 'access-control-allow-headers',
+  
+  // Security headers
+  STRICT_TRANSPORT_SECURITY: 'strict-transport-security',
+  X_CONTENT_TYPE_OPTIONS: 'x-content-type-options',
+  X_FRAME_OPTIONS: 'x-frame-options',
+  X_XSS_PROTECTION: 'x-xss-protection',
+  CONTENT_SECURITY_POLICY: 'content-security-policy',
+} as const;
+
+/**
+ * Get HTTP status text
+ */
+export function getStatusText(status: HttpStatus): string {
+  return HTTP_STATUS_TEXT[status] || 'Unknown';
+}

ts/protocols/http/index.ts

@@ -0,0 +1,8 @@
+/**
+ * HTTP Protocol Module
+ * Generic HTTP protocol knowledge and parsing utilities
+ */
+
+export * from './constants.js';
+export * from './types.js';
+export * from './parser.js';

ts/protocols/http/parser.ts

@@ -0,0 +1,219 @@
+/**
+ * HTTP Protocol Parser
+ * Generic HTTP parsing utilities
+ */
+
+import { HTTP_METHODS, type THttpMethod, type THttpVersion } from './constants.js';
+import type { IHttpRequestLine, IHttpHeader } from './types.js';
+
+/**
+ * HTTP parser utilities
+ */
+export class HttpParser {
+  /**
+   * Check if string is a valid HTTP method
+   */
+  static isHttpMethod(str: string): str is THttpMethod {
+    return HTTP_METHODS.includes(str as THttpMethod);
+  }
+  
+  /**
+   * Parse HTTP request line
+   */
+  static parseRequestLine(line: string): IHttpRequestLine | null {
+    const parts = line.trim().split(' ');
+    
+    if (parts.length !== 3) {
+      return null;
+    }
+    
+    const [method, path, version] = parts;
+    
+    // Validate method
+    if (!this.isHttpMethod(method)) {
+      return null;
+    }
+    
+    // Validate version
+    if (!version.startsWith('HTTP/')) {
+      return null;
+    }
+    
+    return {
+      method: method as THttpMethod,
+      path,
+      version: version as THttpVersion
+    };
+  }
+  
+  /**
+   * Parse HTTP header line
+   */
+  static parseHeaderLine(line: string): IHttpHeader | null {
+    const colonIndex = line.indexOf(':');
+    
+    if (colonIndex === -1) {
+      return null;
+    }
+    
+    const name = line.slice(0, colonIndex).trim();
+    const value = line.slice(colonIndex + 1).trim();
+    
+    if (!name) {
+      return null;
+    }
+    
+    return { name, value };
+  }
+  
+  /**
+   * Parse HTTP headers from lines
+   */
+  static parseHeaders(lines: string[]): Record<string, string> {
+    const headers: Record<string, string> = {};
+    
+    for (const line of lines) {
+      const header = this.parseHeaderLine(line);
+      if (header) {
+        // Convert header names to lowercase for consistency
+        headers[header.name.toLowerCase()] = header.value;
+      }
+    }
+    
+    return headers;
+  }
+  
+  /**
+   * Extract domain from Host header value
+   */
+  static extractDomainFromHost(hostHeader: string): string {
+    // Remove port if present
+    const colonIndex = hostHeader.lastIndexOf(':');
+    if (colonIndex !== -1) {
+      // Check if it's not part of IPv6 address
+      const beforeColon = hostHeader.slice(0, colonIndex);
+      if (!beforeColon.includes(']')) {
+        return beforeColon;
+      }
+    }
+    return hostHeader;
+  }
+  
+  /**
+   * Validate domain name
+   */
+  static isValidDomain(domain: string): boolean {
+    // Basic domain validation
+    if (!domain || domain.length > 253) {
+      return false;
+    }
+    
+    // Check for valid characters and structure
+    const domainRegex = /^(?!-)[A-Za-z0-9-]{1,63}(?<!-)(\.[A-Za-z0-9-]{1,63})*$/;
+    return domainRegex.test(domain);
+  }
+  
+  /**
+   * Extract line from buffer
+   */
+  static extractLine(buffer: Buffer, offset: number = 0): { line: string; nextOffset: number } | null {
+    // Look for CRLF
+    const crlfIndex = buffer.indexOf('\r\n', offset);
+    if (crlfIndex === -1) {
+      // Look for just LF
+      const lfIndex = buffer.indexOf('\n', offset);
+      if (lfIndex === -1) {
+        return null;
+      }
+      
+      return {
+        line: buffer.slice(offset, lfIndex).toString('utf8'),
+        nextOffset: lfIndex + 1
+      };
+    }
+    
+    return {
+      line: buffer.slice(offset, crlfIndex).toString('utf8'),
+      nextOffset: crlfIndex + 2
+    };
+  }
+  
+  /**
+   * Check if buffer contains printable ASCII
+   */
+  static isPrintableAscii(buffer: Buffer, length?: number): boolean {
+    const checkLength = Math.min(length || buffer.length, buffer.length);
+    
+    for (let i = 0; i < checkLength; i++) {
+      const byte = buffer[i];
+      // Allow printable ASCII (32-126) plus tab (9), LF (10), and CR (13)
+      if (byte < 32 || byte > 126) {
+        if (byte !== 9 && byte !== 10 && byte !== 13) {
+          return false;
+        }
+      }
+    }
+    
+    return true;
+  }
+  
+  /**
+   * Quick check if buffer starts with HTTP method
+   */
+  static quickCheck(buffer: Buffer): boolean {
+    if (buffer.length < 3) {
+      return false;
+    }
+    
+    // Check common HTTP methods
+    const start = buffer.slice(0, 7).toString('ascii');
+    return start.startsWith('GET ') ||
+           start.startsWith('POST ') ||
+           start.startsWith('PUT ') ||
+           start.startsWith('DELETE ') ||
+           start.startsWith('HEAD ') ||
+           start.startsWith('OPTIONS') ||
+           start.startsWith('PATCH ') ||
+           start.startsWith('CONNECT') ||
+           start.startsWith('TRACE ');
+  }
+  
+  /**
+   * Parse query string
+   */
+  static parseQueryString(queryString: string): Record<string, string> {
+    const params: Record<string, string> = {};
+    
+    if (!queryString) {
+      return params;
+    }
+    
+    // Remove leading '?' if present
+    if (queryString.startsWith('?')) {
+      queryString = queryString.slice(1);
+    }
+    
+    const pairs = queryString.split('&');
+    for (const pair of pairs) {
+      const [key, value] = pair.split('=');
+      if (key) {
+        params[decodeURIComponent(key)] = value ? decodeURIComponent(value) : '';
+      }
+    }
+    
+    return params;
+  }
+  
+  /**
+   * Build query string from params
+   */
+  static buildQueryString(params: Record<string, string>): string {
+    const pairs: string[] = [];
+    
+    for (const [key, value] of Object.entries(params)) {
+      pairs.push(`${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+    }
+    
+    return pairs.length > 0 ? '?' + pairs.join('&') : '';
+  }
+}

ts/protocols/http/types.ts

@@ -0,0 +1,70 @@
+/**
+ * HTTP Protocol Type Definitions
+ */
+
+import type { THttpMethod, THttpVersion, HttpStatus } from './constants.js';
+
+/**
+ * HTTP request line structure
+ */
+export interface IHttpRequestLine {
+  method: THttpMethod;
+  path: string;
+  version: THttpVersion;
+}
+
+/**
+ * HTTP response line structure
+ */
+export interface IHttpResponseLine {
+  version: THttpVersion;
+  status: HttpStatus;
+  statusText: string;
+}
+
+/**
+ * HTTP header structure
+ */
+export interface IHttpHeader {
+  name: string;
+  value: string;
+}
+
+/**
+ * HTTP message structure (base for request and response)
+ */
+export interface IHttpMessage {
+  headers: Record<string, string>;
+  body?: Buffer;
+}
+
+/**
+ * HTTP request structure
+ */
+export interface IHttpRequest extends IHttpMessage {
+  method: THttpMethod;
+  path: string;
+  version: THttpVersion;
+  query?: Record<string, string>;
+}
+
+/**
+ * HTTP response structure  
+ */
+export interface IHttpResponse extends IHttpMessage {
+  status: HttpStatus;
+  statusText: string;
+  version: THttpVersion;
+}
+
+/**
+ * Parsed URL structure
+ */
+export interface IParsedUrl {
+  protocol?: string;
+  hostname?: string;
+  port?: number;
+  path?: string;
+  query?: string;
+  fragment?: string;
+}

ts/protocols/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Protocol-specific modules for smartproxy
+ * 
+ * This directory contains generic protocol knowledge separated from
+ * smartproxy-specific implementation details.
+ */
+
+export * as common from './common/index.js';
+export * as tls from './tls/index.js';
+export * as http from './http/index.js';
+export * as proxy from './proxy/index.js';
+export * as websocket from './websocket/index.js';

ts/protocols/proxy/index.ts

@@ -0,0 +1,7 @@
+/**
+ * PROXY Protocol Module
+ * HAProxy PROXY protocol implementation
+ */
+
+export * from './types.js';
+export * from './parser.js';

ts/protocols/proxy/parser.ts

@@ -0,0 +1,183 @@
+/**
+ * PROXY Protocol Parser
+ * Implementation of HAProxy PROXY protocol v1 (text format)
+ * Spec: https://www.haproxy.org/download/1.8/doc/proxy-protocol.txt
+ */
+
+import type { IProxyInfo, IProxyParseResult, TProxyProtocol } from './types.js';
+
+/**
+ * PROXY protocol parser
+ */
+export class ProxyProtocolParser {
+  static readonly PROXY_V1_SIGNATURE = 'PROXY ';
+  static readonly MAX_HEADER_LENGTH = 107; // Max length for v1 header
+  static readonly HEADER_TERMINATOR = '\r\n';
+  
+  /**
+   * Parse PROXY protocol v1 header from buffer
+   * Returns proxy info and remaining data after header
+   */
+  static parse(data: Buffer): IProxyParseResult {
+    // Check if buffer starts with PROXY signature
+    if (!data.toString('ascii', 0, 6).startsWith(this.PROXY_V1_SIGNATURE)) {
+      return {
+        proxyInfo: null,
+        remainingData: data
+      };
+    }
+    
+    // Find header terminator
+    const headerEndIndex = data.indexOf(this.HEADER_TERMINATOR);
+    if (headerEndIndex === -1) {
+      // Header incomplete, need more data
+      if (data.length > this.MAX_HEADER_LENGTH) {
+        // Header too long, invalid
+        throw new Error('PROXY protocol header exceeds maximum length');
+      }
+      return {
+        proxyInfo: null,
+        remainingData: data
+      };
+    }
+    
+    // Extract header line
+    const headerLine = data.toString('ascii', 0, headerEndIndex);
+    const remainingData = data.slice(headerEndIndex + 2); // Skip \r\n
+    
+    // Parse header
+    const parts = headerLine.split(' ');
+    
+    if (parts.length < 2) {
+      throw new Error(`Invalid PROXY protocol header format: ${headerLine}`);
+    }
+    
+    const [signature, protocol] = parts;
+    
+    // Validate protocol
+    if (!['TCP4', 'TCP6', 'UNKNOWN'].includes(protocol)) {
+      throw new Error(`Invalid PROXY protocol: ${protocol}`);
+    }
+    
+    // For UNKNOWN protocol, ignore addresses
+    if (protocol === 'UNKNOWN') {
+      return {
+        proxyInfo: {
+          protocol: 'UNKNOWN',
+          sourceIP: '',
+          sourcePort: 0,
+          destinationIP: '',
+          destinationPort: 0
+        },
+        remainingData
+      };
+    }
+    
+    // For TCP4/TCP6, we need all 6 parts
+    if (parts.length !== 6) {
+      throw new Error(`Invalid PROXY protocol header format: ${headerLine}`);
+    }
+    
+    const [, , srcIP, dstIP, srcPort, dstPort] = parts;
+    
+    // Validate and parse ports
+    const sourcePort = parseInt(srcPort, 10);
+    const destinationPort = parseInt(dstPort, 10);
+    
+    if (isNaN(sourcePort) || sourcePort < 0 || sourcePort > 65535) {
+      throw new Error(`Invalid source port: ${srcPort}`);
+    }
+    
+    if (isNaN(destinationPort) || destinationPort < 0 || destinationPort > 65535) {
+      throw new Error(`Invalid destination port: ${dstPort}`);
+    }
+    
+    // Validate IP addresses
+    const protocolType = protocol as TProxyProtocol;
+    if (!this.isValidIP(srcIP, protocolType)) {
+      throw new Error(`Invalid source IP for ${protocol}: ${srcIP}`);
+    }
+    
+    if (!this.isValidIP(dstIP, protocolType)) {
+      throw new Error(`Invalid destination IP for ${protocol}: ${dstIP}`);
+    }
+    
+    return {
+      proxyInfo: {
+        protocol: protocolType,
+        sourceIP: srcIP,
+        sourcePort,
+        destinationIP: dstIP,
+        destinationPort
+      },
+      remainingData
+    };
+  }
+  
+  /**
+   * Generate PROXY protocol v1 header
+   */
+  static generate(info: IProxyInfo): Buffer {
+    if (info.protocol === 'UNKNOWN') {
+      return Buffer.from(`PROXY UNKNOWN\r\n`, 'ascii');
+    }
+    
+    const header = `PROXY ${info.protocol} ${info.sourceIP} ${info.destinationIP} ${info.sourcePort} ${info.destinationPort}\r\n`;
+    
+    if (header.length > this.MAX_HEADER_LENGTH) {
+      throw new Error('Generated PROXY protocol header exceeds maximum length');
+    }
+    
+    return Buffer.from(header, 'ascii');
+  }
+  
+  /**
+   * Validate IP address format
+   */
+  static isValidIP(ip: string, protocol: TProxyProtocol): boolean {
+    if (protocol === 'TCP4') {
+      return this.isIPv4(ip);
+    } else if (protocol === 'TCP6') {
+      return this.isIPv6(ip);
+    }
+    return false;
+  }
+  
+  /**
+   * Check if string is valid IPv4
+   */
+  static isIPv4(ip: string): boolean {
+    const parts = ip.split('.');
+    if (parts.length !== 4) return false;
+    
+    for (const part of parts) {
+      const num = parseInt(part, 10);
+      if (isNaN(num) || num < 0 || num > 255 || part !== num.toString()) {
+        return false;
+      }
+    }
+    return true;
+  }
+  
+  /**
+   * Check if string is valid IPv6
+   */
+  static isIPv6(ip: string): boolean {
+    // Basic IPv6 validation
+    const ipv6Regex = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/;
+    return ipv6Regex.test(ip);
+  }
+  
+  /**
+   * Create a connection ID string for tracking
+   */
+  static createConnectionId(connectionInfo: {
+    sourceIp?: string;
+    sourcePort?: number;
+    destIp?: string;
+    destPort?: number;
+  }): string {
+    const { sourceIp, sourcePort, destIp, destPort } = connectionInfo;
+    return `${sourceIp}:${sourcePort}-${destIp}:${destPort}`;
+  }
+}

ts/protocols/proxy/types.ts

@@ -0,0 +1,53 @@
+/**
+ * PROXY Protocol Type Definitions
+ * Based on HAProxy PROXY protocol specification
+ */
+
+/**
+ * PROXY protocol version
+ */
+export type TProxyProtocolVersion = 'v1' | 'v2';
+
+/**
+ * Connection protocol type
+ */
+export type TProxyProtocol = 'TCP4' | 'TCP6' | 'UNKNOWN';
+
+/**
+ * Interface representing parsed PROXY protocol information
+ */
+export interface IProxyInfo {
+  protocol: TProxyProtocol;
+  sourceIP: string;
+  sourcePort: number;
+  destinationIP: string;
+  destinationPort: number;
+}
+
+/**
+ * Interface for parse result including remaining data
+ */
+export interface IProxyParseResult {
+  proxyInfo: IProxyInfo | null;
+  remainingData: Buffer;
+}
+
+/**
+ * PROXY protocol v2 header format
+ */
+export interface IProxyV2Header {
+  signature: Buffer;
+  versionCommand: number;
+  family: number;
+  length: number;
+}
+
+/**
+ * Connection information for PROXY protocol
+ */
+export interface IProxyConnectionInfo {
+  sourceIp?: string;
+  sourcePort?: number;
+  destIp?: string;
+  destPort?: number;
+}

ts/protocols/tls/alerts/tls-alert.ts

@@ -1,4 +1,4 @@
-import * as plugins from '../../plugins.js';
+import * as plugins from '../../../plugins.js';
 import { TlsAlertLevel, TlsAlertDescription, TlsVersion } from '../utils/tls-utils.js';
 
 /**

ts/protocols/tls/index.ts

@@ -0,0 +1,37 @@
+/**
+ * TLS Protocol Module
+ * Contains generic TLS protocol knowledge including parsers, constants, and utilities
+ */
+
+// Export all sub-modules
+export * from './alerts/index.js';
+export * from './sni/index.js';
+export * from './utils/index.js';
+
+// Re-export main utilities and types for convenience
+export { 
+  TlsUtils,
+  TlsRecordType,
+  TlsHandshakeType,
+  TlsExtensionType,
+  TlsAlertLevel,
+  TlsAlertDescription,
+  TlsVersion
+} from './utils/tls-utils.js';
+export { TlsAlert } from './alerts/tls-alert.js';
+export { ClientHelloParser } from './sni/client-hello-parser.js';
+export { SniExtraction } from './sni/sni-extraction.js';
+
+// Export tlsVersionToString helper
+export function tlsVersionToString(major: number, minor: number): string | null {
+  if (major === 0x03) {
+    switch (minor) {
+      case 0x00: return 'SSLv3';
+      case 0x01: return 'TLSv1.0';
+      case 0x02: return 'TLSv1.1';
+      case 0x03: return 'TLSv1.2';
+      case 0x04: return 'TLSv1.3';
+    }
+  }
+  return null;
+}

ts/protocols/tls/sni/index.ts

@@ -0,0 +1,6 @@
+/**
+ * TLS SNI (Server Name Indication) protocol utilities
+ */
+
+export * from './client-hello-parser.js';
+export * from './sni-extraction.js';

ts/protocols/tls/utils/tls-utils.ts

@@ -1,4 +1,4 @@
-import * as plugins from '../../plugins.js';
+import * as plugins from '../../../plugins.js';
 
 /**
  * TLS record types as defined in various RFCs

ts/protocols/websocket/constants.ts

@@ -0,0 +1,60 @@
+/**
+ * WebSocket Protocol Constants
+ * Based on RFC 6455
+ */
+
+/**
+ * WebSocket opcode types
+ */
+export enum WebSocketOpcode {
+  CONTINUATION = 0x0,
+  TEXT = 0x1,
+  BINARY = 0x2,
+  CLOSE = 0x8,
+  PING = 0x9,
+  PONG = 0xa,
+}
+
+/**
+ * WebSocket close codes
+ */
+export enum WebSocketCloseCode {
+  NORMAL_CLOSURE = 1000,
+  GOING_AWAY = 1001,
+  PROTOCOL_ERROR = 1002,
+  UNSUPPORTED_DATA = 1003,
+  NO_STATUS_RECEIVED = 1005,
+  ABNORMAL_CLOSURE = 1006,
+  INVALID_FRAME_PAYLOAD_DATA = 1007,
+  POLICY_VIOLATION = 1008,
+  MESSAGE_TOO_BIG = 1009,
+  MISSING_EXTENSION = 1010,
+  INTERNAL_ERROR = 1011,
+  SERVICE_RESTART = 1012,
+  TRY_AGAIN_LATER = 1013,
+  BAD_GATEWAY = 1014,
+  TLS_HANDSHAKE = 1015,
+}
+
+/**
+ * WebSocket protocol version
+ */
+export const WEBSOCKET_VERSION = 13;
+
+/**
+ * WebSocket magic string for handshake
+ */
+export const WEBSOCKET_MAGIC_STRING = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';
+
+/**
+ * WebSocket headers
+ */
+export const WEBSOCKET_HEADERS = {
+  UPGRADE: 'upgrade',
+  CONNECTION: 'connection',
+  SEC_WEBSOCKET_KEY: 'sec-websocket-key',
+  SEC_WEBSOCKET_VERSION: 'sec-websocket-version',
+  SEC_WEBSOCKET_ACCEPT: 'sec-websocket-accept',
+  SEC_WEBSOCKET_PROTOCOL: 'sec-websocket-protocol',
+  SEC_WEBSOCKET_EXTENSIONS: 'sec-websocket-extensions',
+} as const;

ts/protocols/websocket/index.ts

@@ -0,0 +1,8 @@
+/**
+ * WebSocket Protocol Module
+ * WebSocket protocol utilities and constants
+ */
+
+export * from './constants.js';
+export * from './types.js';
+export * from './utils.js';

ts/protocols/websocket/types.ts

@@ -0,0 +1,53 @@
+/**
+ * WebSocket Protocol Type Definitions
+ */
+
+import type { WebSocketOpcode, WebSocketCloseCode } from './constants.js';
+
+/**
+ * WebSocket frame header
+ */
+export interface IWebSocketFrameHeader {
+  fin: boolean;
+  rsv1: boolean;
+  rsv2: boolean;
+  rsv3: boolean;
+  opcode: WebSocketOpcode;
+  masked: boolean;
+  payloadLength: number;
+  maskingKey?: Buffer;
+}
+
+/**
+ * WebSocket frame
+ */
+export interface IWebSocketFrame {
+  header: IWebSocketFrameHeader;
+  payload: Buffer;
+}
+
+/**
+ * WebSocket close frame payload
+ */
+export interface IWebSocketClosePayload {
+  code: WebSocketCloseCode;
+  reason?: string;
+}
+
+/**
+ * WebSocket handshake request headers
+ */
+export interface IWebSocketHandshakeHeaders {
+  upgrade: string;
+  connection: string;
+  'sec-websocket-key': string;
+  'sec-websocket-version': string;
+  'sec-websocket-protocol'?: string;
+  'sec-websocket-extensions'?: string;
+  [key: string]: string | undefined;
+}
+
+/**
+ * Type for WebSocket raw data (matching ws library)
+ */
+export type RawData = Buffer | ArrayBuffer | Buffer[] | any;

ts/protocols/websocket/utils.ts

@@ -0,0 +1,98 @@
+/**
+ * WebSocket Protocol Utilities
+ */
+
+import * as crypto from 'crypto';
+import { WEBSOCKET_MAGIC_STRING } from './constants.js';
+import type { RawData } from './types.js';
+
+/**
+ * Get the length of a WebSocket message regardless of its type
+ * (handles all possible WebSocket message data types)
+ */
+export function getMessageSize(data: RawData): number {
+  if (typeof data === 'string') {
+    // For string data, get the byte length
+    return Buffer.from(data, 'utf8').length;
+  } else if (data instanceof Buffer) {
+    // For Node.js Buffer
+    return data.length;
+  } else if (data instanceof ArrayBuffer) {
+    // For ArrayBuffer
+    return data.byteLength;
+  } else if (Array.isArray(data)) {
+    // For array of buffers, sum their lengths
+    return data.reduce((sum, chunk) => {
+      if (chunk instanceof Buffer) {
+        return sum + chunk.length;
+      } else if (chunk instanceof ArrayBuffer) {
+        return sum + chunk.byteLength;
+      }
+      return sum;
+    }, 0);
+  } else {
+    // For other types, try to determine the size or return 0
+    try {
+      return Buffer.from(data).length;
+    } catch (e) {
+      return 0;
+    }
+  }
+}
+
+/**
+ * Convert any raw WebSocket data to Buffer for consistent handling
+ */
+export function toBuffer(data: RawData): Buffer {
+  if (typeof data === 'string') {
+    return Buffer.from(data, 'utf8');
+  } else if (data instanceof Buffer) {
+    return data;
+  } else if (data instanceof ArrayBuffer) {
+    return Buffer.from(data);
+  } else if (Array.isArray(data)) {
+    // For array of buffers, concatenate them
+    return Buffer.concat(data.map(chunk => {
+      if (chunk instanceof Buffer) {
+        return chunk;
+      } else if (chunk instanceof ArrayBuffer) {
+        return Buffer.from(chunk);
+      }
+      return Buffer.from(chunk);
+    }));
+  } else {
+    // For other types, try to convert to Buffer or return empty Buffer
+    try {
+      return Buffer.from(data);
+    } catch (e) {
+      return Buffer.alloc(0);
+    }
+  }
+}
+
+/**
+ * Generate WebSocket accept key from client key
+ */
+export function generateAcceptKey(clientKey: string): string {
+  const hash = crypto.createHash('sha1');
+  hash.update(clientKey + WEBSOCKET_MAGIC_STRING);
+  return hash.digest('base64');
+}
+
+/**
+ * Validate WebSocket upgrade request
+ */
+export function isWebSocketUpgrade(headers: Record<string, string>): boolean {
+  const upgrade = headers['upgrade'];
+  const connection = headers['connection'];
+  
+  return upgrade?.toLowerCase() === 'websocket' && 
+         connection?.toLowerCase().includes('upgrade');
+}
+
+/**
+ * Generate random WebSocket key for client handshake
+ */
+export function generateWebSocketKey(): string {
+  return crypto.randomBytes(16).toString('base64');
+}

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

@@ -1,4 +1,6 @@
 import * as plugins from '../../../plugins.js';
+// Import from protocols for consistent status codes
+import { HttpStatus as ProtocolHttpStatus, getStatusText as getProtocolStatusText } from '../../../protocols/http/index.js';
 
 /**
  * HTTP-specific event types
@@ -10,34 +12,33 @@ export enum HttpEvents {
   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,
-}
+
+// Re-export for backward compatibility with subset of commonly used codes
+export const HttpStatus = {
+  OK: ProtocolHttpStatus.OK,
+  MOVED_PERMANENTLY: ProtocolHttpStatus.MOVED_PERMANENTLY,
+  FOUND: ProtocolHttpStatus.FOUND,
+  TEMPORARY_REDIRECT: ProtocolHttpStatus.TEMPORARY_REDIRECT,
+  PERMANENT_REDIRECT: ProtocolHttpStatus.PERMANENT_REDIRECT,
+  BAD_REQUEST: ProtocolHttpStatus.BAD_REQUEST,
+  UNAUTHORIZED: ProtocolHttpStatus.UNAUTHORIZED,
+  FORBIDDEN: ProtocolHttpStatus.FORBIDDEN,
+  NOT_FOUND: ProtocolHttpStatus.NOT_FOUND,
+  METHOD_NOT_ALLOWED: ProtocolHttpStatus.METHOD_NOT_ALLOWED,
+  REQUEST_TIMEOUT: ProtocolHttpStatus.REQUEST_TIMEOUT,
+  TOO_MANY_REQUESTS: ProtocolHttpStatus.TOO_MANY_REQUESTS,
+  INTERNAL_SERVER_ERROR: ProtocolHttpStatus.INTERNAL_SERVER_ERROR,
+  NOT_IMPLEMENTED: ProtocolHttpStatus.NOT_IMPLEMENTED,
+  BAD_GATEWAY: ProtocolHttpStatus.BAD_GATEWAY,
+  SERVICE_UNAVAILABLE: ProtocolHttpStatus.SERVICE_UNAVAILABLE,
+  GATEWAY_TIMEOUT: ProtocolHttpStatus.GATEWAY_TIMEOUT,
+} as const;
 
 /**
  * Base error class for HTTP-related errors
  */
 export class HttpError extends Error {
-  constructor(message: string, public readonly statusCode: HttpStatus = HttpStatus.INTERNAL_SERVER_ERROR) {
+  constructor(message: string, public readonly statusCode: number = HttpStatus.INTERNAL_SERVER_ERROR) {
     super(message);
     this.name = 'HttpError';
   }
@@ -61,7 +62,7 @@ export class CertificateError extends HttpError {
  * Error related to server operations
  */
 export class ServerError extends HttpError {
-  constructor(message: string, public readonly code?: string, statusCode: HttpStatus = HttpStatus.INTERNAL_SERVER_ERROR) {
+  constructor(message: string, public readonly code?: string, statusCode: number = HttpStatus.INTERNAL_SERVER_ERROR) {
     super(message, statusCode);
     this.name = 'ServerError';
   }
@@ -93,7 +94,7 @@ export class NotFoundError extends HttpError {
 export interface IRedirectConfig {
   source: string;           // Source path or pattern
   destination: string;      // Destination URL  
-  type: HttpStatus;         // Redirect status code
+  type: number;             // Redirect status code
   preserveQuery?: boolean;  // Whether to preserve query parameters
 }
 
@@ -115,30 +116,12 @@ export interface IRouterConfig {
  */
 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';
+export function getStatusText(status: number): string {
+  return getProtocolStatusText(status as ProtocolHttpStatus);
 }
 
 // Legacy interfaces for backward compatibility

ts/proxies/smart-proxy/connection-manager.ts

@@ -5,6 +5,7 @@ import { connectionLogDeduplicator } from '../../core/utils/log-deduplicator.js'
 import { LifecycleComponent } from '../../core/utils/lifecycle-component.js';
 import { cleanupSocket } from '../../core/utils/socket-utils.js';
 import { WrappedSocket } from '../../core/models/wrapped-socket.js';
+import { ProtocolDetector } from '../../detection/index.js';
 import type { SmartProxy } from './smart-proxy.js';
 
 /**
@@ -323,6 +324,18 @@ export class ConnectionManager extends LifecycleComponent {
         this.smartProxy.metricsCollector.removeConnection(record.id);
       }
 
+      // Clean up protocol detection fragments
+      const context = ProtocolDetector.createConnectionContext({
+        sourceIp: record.remoteIP,
+        sourcePort: record.incoming?.remotePort || 0,
+        destIp: record.incoming?.localAddress || '',
+        destPort: record.localPort,
+        socketId: record.id
+      });
+      
+      // Clean up any pending detection fragments for this connection
+      ProtocolDetector.cleanupConnection(context);
+
       if (record.cleanupTimer) {
         clearTimeout(record.cleanupTimer);
         record.cleanupTimer = undefined;

ts/proxies/smart-proxy/models/interfaces.ts

@@ -16,7 +16,6 @@ export interface IAcmeOptions {
   routeForwards?: any[];
 }
 import type { IRouteConfig } from './route-types.js';
-import type { TForwardingType } from '../../../forwarding/config/forwarding-types.js';
 
 /**
  * Provision object for static or HTTP-01 certificate
@@ -196,4 +195,11 @@ export interface IConnectionRecord {
   
   // NFTables tracking
   nftablesHandled?: boolean; // Whether this connection is being handled by NFTables at kernel level
+  
+  // HTTP-specific information (extracted from protocol detection)
+  httpInfo?: {
+    method?: string;
+    path?: string;
+    headers?: Record<string, string>;
+  };
 }

ts/proxies/smart-proxy/models/route-types.ts

@@ -1,6 +1,5 @@
 import * as plugins from '../../../plugins.js';
 // Certificate types removed - use local definition
-import type { TForwardingType } from '../../../forwarding/config/forwarding-types.js';
 import type { PortRange } from '../../../proxies/nftables-proxy/models/interfaces.js';
 import type { IRouteContext } from '../../../core/models/route-context.js';
 

ts/proxies/smart-proxy/route-connection-handler.ts

@@ -10,6 +10,7 @@ import { WrappedSocket } from '../../core/models/wrapped-socket.js';
 import { getUnderlyingSocket } from '../../core/models/socket-types.js';
 import { ProxyProtocolParser } from '../../core/utils/proxy-protocol.js';
 import type { SmartProxy } from './smart-proxy.js';
+import { ProtocolDetector } from '../../detection/index.js';
 
 /**
  * Handles new connection processing and setup logic with support for route-based configuration
@@ -301,11 +302,27 @@ export class RouteConnectionHandler {
     });
 
     // Handler for processing initial data (after potential PROXY protocol)
-    const processInitialData = (chunk: Buffer) => {
+    const processInitialData = async (chunk: Buffer) => {
+      // Create connection context for protocol detection
+      const context = ProtocolDetector.createConnectionContext({
+        sourceIp: record.remoteIP,
+        sourcePort: socket.remotePort || 0,
+        destIp: socket.localAddress || '',
+        destPort: socket.localPort || 0,
+        socketId: record.id
+      });
+      
+      const detectionResult = await ProtocolDetector.detectWithContext(
+        chunk,
+        context,
+        { extractFullHeaders: false } // Only extract essential info for routing
+      );
+      
       // Block non-TLS connections on port 443
-      if (!this.smartProxy.tlsManager.isTlsHandshake(chunk) && localPort === 443) {
-        logger.log('warn', `Non-TLS connection ${connectionId} detected on port 443. Terminating connection - only TLS traffic is allowed on standard HTTPS port.`, {
-          connectionId,
+      if (localPort === 443 && detectionResult.protocol !== 'tls') {
+        logger.log('warn', `Non-TLS connection ${record.id} detected on port 443. Terminating connection - only TLS traffic is allowed on standard HTTPS port.`, {
+          connectionId: record.id,
+          detectedProtocol: detectionResult.protocol,
           message: 'Terminating connection - only TLS traffic is allowed on standard HTTPS port.',
           component: 'route-handler'
         });
@@ -318,71 +335,78 @@ export class RouteConnectionHandler {
         return;
       }
 
-      // Check if this looks like a TLS handshake
+      // Extract domain and protocol info
       let serverName = '';
-      if (this.smartProxy.tlsManager.isTlsHandshake(chunk)) {
+      if (detectionResult.protocol === 'tls') {
         record.isTLS = true;
+        serverName = detectionResult.connectionInfo.domain || '';
         
-        // Check for ClientHello to extract SNI
-        if (this.smartProxy.tlsManager.isClientHello(chunk)) {
-          // Create connection info for SNI extraction
-          const connInfo = {
-            sourceIp: record.remoteIP,
-            sourcePort: socket.remotePort || 0,
-            destIp: socket.localAddress || '',
-            destPort: socket.localPort || 0,
-          };
+        // Lock the connection to the negotiated SNI
+        record.lockedDomain = serverName;
 
-          // Extract SNI
-          serverName = this.smartProxy.tlsManager.extractSNI(chunk, connInfo) || '';
-
-          // Lock the connection to the negotiated SNI
-          record.lockedDomain = serverName;
-
-          // Check if we should reject connections without SNI
-          if (!serverName && this.smartProxy.settings.allowSessionTicket === false) {
-            logger.log('warn', `No SNI detected in TLS ClientHello for connection ${connectionId}; sending TLS alert`, {
-              connectionId,
-              component: 'route-handler'
-            });
-            if (record.incomingTerminationReason === null) {
-              record.incomingTerminationReason = 'session_ticket_blocked_no_sni';
-              this.smartProxy.connectionManager.incrementTerminationStat(
-                'incoming',
-                'session_ticket_blocked_no_sni'
-              );
-            }
-            const alert = Buffer.from([0x15, 0x03, 0x03, 0x00, 0x02, 0x01, 0x70]);
-            try {
-              // Count the alert bytes being sent
-              record.bytesSent += alert.length;
-              if (this.smartProxy.metricsCollector) {
-                this.smartProxy.metricsCollector.recordBytes(record.id, 0, alert.length);
-              }
-              
-              socket.cork();
-              socket.write(alert);
-              socket.uncork();
-              socket.end();
-            } catch {
-              socket.end();
-            }
-            this.smartProxy.connectionManager.cleanupConnection(record, 'session_ticket_blocked_no_sni');
-            return;
+        // Check if we should reject connections without SNI
+        if (!serverName && this.smartProxy.settings.allowSessionTicket === false) {
+          logger.log('warn', `No SNI detected in TLS ClientHello for connection ${record.id}; sending TLS alert`, {
+            connectionId: record.id,
+            component: 'route-handler'
+          });
+          if (record.incomingTerminationReason === null) {
+            record.incomingTerminationReason = 'session_ticket_blocked_no_sni';
+            this.smartProxy.connectionManager.incrementTerminationStat(
+              'incoming',
+              'session_ticket_blocked_no_sni'
+            );
           }
+          const alert = Buffer.from([0x15, 0x03, 0x03, 0x00, 0x02, 0x01, 0x70]);
+          try {
+            // Count the alert bytes being sent
+            record.bytesSent += alert.length;
+            if (this.smartProxy.metricsCollector) {
+              this.smartProxy.metricsCollector.recordBytes(record.id, 0, alert.length);
+            }
             
-          if (this.smartProxy.settings.enableDetailedLogging) {
-            logger.log('info', `TLS connection with SNI`, {
-              connectionId,
-              serverName: serverName || '(empty)',
-              component: 'route-handler'
-            });
+            socket.cork();
+            socket.write(alert);
+            socket.uncork();
+            socket.end();
+          } catch {
+            socket.end();
           }
+          this.smartProxy.connectionManager.cleanupConnection(record, 'session_ticket_blocked_no_sni');
+          return;
+        }
+
+        if (this.smartProxy.settings.enableDetailedLogging) {
+          logger.log('info', `TLS connection with SNI`, {
+            connectionId: record.id,
+            serverName: serverName || '(empty)',
+            component: 'route-handler'
+          });
+        }
+      } else if (detectionResult.protocol === 'http') {
+        // For HTTP, extract domain from Host header
+        serverName = detectionResult.connectionInfo.domain || '';
+        
+        // Store HTTP-specific info for later use
+        record.httpInfo = {
+          method: detectionResult.connectionInfo.method,
+          path: detectionResult.connectionInfo.path,
+          headers: detectionResult.connectionInfo.headers
+        };
+        
+        if (this.smartProxy.settings.enableDetailedLogging) {
+          logger.log('info', `HTTP connection detected`, {
+            connectionId: record.id,
+            domain: serverName || '(no host header)',
+            method: detectionResult.connectionInfo.method,
+            path: detectionResult.connectionInfo.path,
+            component: 'route-handler'
+          });
         }
       }
 
       // Find the appropriate route for this connection
-      this.routeConnection(socket, record, serverName, chunk);
+      this.routeConnection(socket, record, serverName, chunk, detectionResult);
     };
 
     // First data handler to capture initial TLS handshake or PROXY protocol
@@ -454,7 +478,8 @@ export class RouteConnectionHandler {
     socket: plugins.net.Socket | WrappedSocket,
     record: IConnectionRecord,
     serverName: string,
-    initialChunk?: Buffer
+    initialChunk?: Buffer,
+    detectionResult?: any // Using any temporarily to avoid circular dependency issues
   ): void {
     const connectionId = record.id;
     const localPort = record.localPort;
@@ -635,7 +660,7 @@ export class RouteConnectionHandler {
     // Handle the route based on its action type
     switch (route.action.type) {
       case 'forward':
-        return this.handleForwardAction(socket, record, route, initialChunk);
+        return this.handleForwardAction(socket, record, route, initialChunk, detectionResult);
 
       case 'socket-handler':
         logger.log('info', `Handling socket-handler action for route ${route.name}`, {
@@ -738,7 +763,8 @@ export class RouteConnectionHandler {
     socket: plugins.net.Socket | WrappedSocket,
     record: IConnectionRecord,
     route: IRouteConfig,
-    initialChunk?: Buffer
+    initialChunk?: Buffer,
+    detectionResult?: any // Using any temporarily to avoid circular dependency issues
   ): void {
     const connectionId = record.id;
     const action = route.action as IRouteAction;
@@ -819,14 +845,11 @@ export class RouteConnectionHandler {
     // Create context for target selection
     const targetSelectionContext = {
       port: record.localPort,
-      path: undefined, // Will be populated from HTTP headers if available
-      headers: undefined, // Will be populated from HTTP headers if available
-      method: undefined // Will be populated from HTTP headers if available
+      path: record.httpInfo?.path,
+      headers: record.httpInfo?.headers,
+      method: record.httpInfo?.method
     };
     
-    // TODO: Extract path, headers, and method from initialChunk if it's HTTP
-    // For now, we'll select based on port only
-    
     const selectedTarget = this.selectTarget(action.targets, targetSelectionContext);
     if (!selectedTarget) {
       logger.log('error', `No matching target found for connection ${connectionId}`, {

ts/proxies/smart-proxy/tls-manager.ts

@@ -1,5 +1,6 @@
 import * as plugins from '../../plugins.js';
 import { SniHandler } from '../../tls/sni/sni-handler.js';
+import { ProtocolDetector, TlsDetector } from '../../detection/index.js';
 import type { SmartProxy } from './smart-proxy.js';
 
 /**

ts/proxies/smart-proxy/utils/index.ts

@@ -14,23 +14,12 @@ export * from './route-validators.js';
 // Export route utilities for route operations
 export * from './route-utils.js';
 
-// Export route patterns with renamed exports to avoid conflicts
-import {
-  createWebSocketRoute as createWebSocketPatternRoute,
-  createLoadBalancerRoute as createLoadBalancerPatternRoute,
-  createApiGatewayRoute,
-  addRateLimiting,
-  addBasicAuth,
-  addJwtAuth
-} from './route-patterns.js';
-
+// Export additional functions from route-helpers that weren't already exported
 export {
-  createWebSocketPatternRoute,
-  createLoadBalancerPatternRoute,
   createApiGatewayRoute,
   addRateLimiting,
   addBasicAuth,
   addJwtAuth
-};
+} from './route-helpers.js';
 
 // Migration utilities have been removed as they are no longer needed

ts/proxies/smart-proxy/utils/route-helpers.ts

@@ -20,6 +20,8 @@
 
 import * as plugins from '../../../plugins.js';
 import type { IRouteConfig, IRouteMatch, IRouteAction, IRouteTarget, TPortRange, IRouteContext } from '../models/route-types.js';
+import { mergeRouteConfigs } from './route-utils.js';
+import { ProtocolDetector, HttpDetector } from '../../../detection/index.js';
 
 /**
  * Create an HTTP-only route configuration
@@ -211,26 +213,62 @@ export function createCompleteHttpsServer(
 /**
  * Create a load balancer route (round-robin between multiple backend hosts)
  * @param domains Domain(s) to match
- * @param hosts Array of backend hosts to load balance between
- * @param port Backend port
- * @param options Additional route options
+ * @param backendsOrHosts Array of backend servers OR array of host strings (legacy)
+ * @param portOrOptions Port number (legacy) OR options object
+ * @param options Additional route options (legacy)
  * @returns Route configuration object
  */
 export function createLoadBalancerRoute(
   domains: string | string[],
-  hosts: string[],
-  port: number,
-  options: {
+  backendsOrHosts: Array<{ host: string; port: number }> | string[],
+  portOrOptions?: number | {
+    tls?: {
+      mode: 'passthrough' | 'terminate' | 'terminate-and-reencrypt';
+      certificate?: 'auto' | { key: string; cert: string };
+    };
+    useTls?: boolean;
+    certificate?: 'auto' | { key: string; cert: string };
+    algorithm?: 'round-robin' | 'least-connections' | 'ip-hash';
+    healthCheck?: {
+      path: string;
+      interval: number;
+      timeout: number;
+      unhealthyThreshold: number;
+      healthyThreshold: number;
+    };
+    [key: string]: any;
+  },
+  options?: {
     tls?: {
       mode: 'passthrough' | 'terminate' | 'terminate-and-reencrypt';
       certificate?: 'auto' | { key: string; cert: string };
     };
     [key: string]: any;
-  } = {}
+  }
 ): IRouteConfig {
+  // Handle legacy signature: (domains, hosts[], port, options)
+  let backends: Array<{ host: string; port: number }>;
+  let finalOptions: any;
+  
+  if (Array.isArray(backendsOrHosts) && backendsOrHosts.length > 0 && typeof backendsOrHosts[0] === 'string') {
+    // Legacy signature
+    const hosts = backendsOrHosts as string[];
+    const port = portOrOptions as number;
+    backends = hosts.map(host => ({ host, port }));
+    finalOptions = options || {};
+  } else {
+    // New signature
+    backends = backendsOrHosts as Array<{ host: string; port: number }>;
+    finalOptions = (portOrOptions as any) || {};
+  }
+  
+  // Extract hosts and ensure all backends use the same port
+  const port = backends[0].port;
+  const hosts = backends.map(backend => backend.host);
+  
   // Create route match
   const match: IRouteMatch = {
-    ports: options.match?.ports || (options.tls ? 443 : 80),
+    ports: finalOptions.match?.ports || (finalOptions.tls || finalOptions.useTls ? 443 : 80),
     domains
   };
 
@@ -247,10 +285,18 @@ export function createLoadBalancerRoute(
   };
 
   // Add TLS configuration if provided
-  if (options.tls) {
+  if (finalOptions.tls || finalOptions.useTls) {
     action.tls = {
-      mode: options.tls.mode,
-      certificate: options.tls.certificate || 'auto'
+      mode: finalOptions.tls?.mode || 'terminate',
+      certificate: finalOptions.tls?.certificate || finalOptions.certificate || 'auto'
+    };
+  }
+
+  // Add load balancing options
+  if (finalOptions.algorithm || finalOptions.healthCheck) {
+    action.loadBalancing = {
+      algorithm: finalOptions.algorithm || 'round-robin',
+      healthCheck: finalOptions.healthCheck
     };
   }
 
@@ -258,8 +304,8 @@ export function createLoadBalancerRoute(
   return {
     match,
     action,
-    name: options.name || `Load Balancer for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
-    ...options
+    name: finalOptions.name || `Load Balancer for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+    ...finalOptions
   };
 }
 
@@ -339,16 +385,26 @@ export function createApiRoute(
 /**
  * Create a WebSocket route configuration
  * @param domains Domain(s) to match
- * @param wsPath WebSocket path (e.g., "/ws")
- * @param target Target WebSocket server host and port
- * @param options Additional route options
+ * @param targetOrPath Target server OR WebSocket path (legacy)
+ * @param targetOrOptions Target server (legacy) OR options
+ * @param options Additional route options (legacy)
  * @returns Route configuration object
  */
 export function createWebSocketRoute(
   domains: string | string[],
-  wsPath: string,
-  target: { host: string | string[]; port: number },
-  options: {
+  targetOrPath: { host: string | string[]; port: number } | string,
+  targetOrOptions?: { host: string | string[]; port: number } | {
+    useTls?: boolean;
+    certificate?: 'auto' | { key: string; cert: string };
+    path?: string;
+    httpPort?: number | number[];
+    httpsPort?: number | number[];
+    pingInterval?: number;
+    pingTimeout?: number;
+    name?: string;
+    [key: string]: any;
+  },
+  options?: {
     useTls?: boolean;
     certificate?: 'auto' | { key: string; cert: string };
     httpPort?: number | number[];
@@ -357,16 +413,33 @@ export function createWebSocketRoute(
     pingTimeout?: number;
     name?: string;
     [key: string]: any;
-  } = {}
+  }
 ): IRouteConfig {
+  // Handle different signatures
+  let target: { host: string | string[]; port: number };
+  let wsPath: string;
+  let finalOptions: any;
+  
+  if (typeof targetOrPath === 'string') {
+    // Legacy signature: (domains, path, target, options)
+    wsPath = targetOrPath;
+    target = targetOrOptions as { host: string | string[]; port: number };
+    finalOptions = options || {};
+  } else {
+    // New signature: (domains, target, options)
+    target = targetOrPath;
+    finalOptions = (targetOrOptions as any) || {};
+    wsPath = finalOptions.path || '/ws';
+  }
+  
   // Normalize WebSocket path
   const normalizedPath = wsPath.startsWith('/') ? wsPath : `/${wsPath}`;
 
   // Create route match
   const match: IRouteMatch = {
-    ports: options.useTls
-      ? (options.httpsPort || 443)
-      : (options.httpPort || 80),
+    ports: finalOptions.useTls
+      ? (finalOptions.httpsPort || 443)
+      : (finalOptions.httpPort || 80),
     domains,
     path: normalizedPath
   };
@@ -377,16 +450,16 @@ export function createWebSocketRoute(
     targets: [target],
     websocket: {
       enabled: true,
-      pingInterval: options.pingInterval || 30000, // 30 seconds
-      pingTimeout: options.pingTimeout || 5000    // 5 seconds
+      pingInterval: finalOptions.pingInterval || 30000, // 30 seconds
+      pingTimeout: finalOptions.pingTimeout || 5000    // 5 seconds
     }
   };
 
   // Add TLS configuration if using HTTPS
-  if (options.useTls) {
+  if (finalOptions.useTls) {
     action.tls = {
       mode: 'terminate',
-      certificate: options.certificate || 'auto'
+      certificate: finalOptions.certificate || 'auto'
     };
   }
 
@@ -394,9 +467,9 @@ export function createWebSocketRoute(
   return {
     match,
     action,
-    name: options.name || `WebSocket Route ${normalizedPath} for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
-    priority: options.priority || 100, // Higher priority for WebSocket routes
-    ...options
+    name: finalOptions.name || `WebSocket Route ${normalizedPath} for ${Array.isArray(domains) ? domains.join(', ') : domains}`,
+    priority: finalOptions.priority || 100, // Higher priority for WebSocket routes
+    ...finalOptions
   };
 }
 
@@ -884,83 +957,91 @@ export const SocketHandlers = {
   
   /**
    * HTTP redirect handler
+   * Now uses the centralized detection module for HTTP parsing
    */
   httpRedirect: (locationTemplate: string, statusCode: number = 301) => (socket: plugins.net.Socket, context: IRouteContext) => {
-    let buffer = '';
+    const connectionId = ProtocolDetector.createConnectionId({
+      socketId: context.connectionId || `${Date.now()}-${Math.random()}`
+    });
     
-    socket.once('data', (data) => {
-      buffer += data.toString();
+    socket.once('data', async (data) => {
+      // Use detection module for parsing
+      const detectionResult = await ProtocolDetector.detectWithConnectionTracking(
+        data,
+        connectionId,
+        { extractFullHeaders: false } // We only need method and path
+      );
       
-      const lines = buffer.split('\r\n');
-      const requestLine = lines[0];
-      const [method, path] = requestLine.split(' ');
+      if (detectionResult.protocol === 'http' && detectionResult.connectionInfo.path) {
+        const method = detectionResult.connectionInfo.method || 'GET';
+        const path = detectionResult.connectionInfo.path || '/';
         
-      const domain = context.domain || 'localhost';
-      const port = context.port;
+        const domain = context.domain || 'localhost';
+        const port = context.port;
         
-      let finalLocation = locationTemplate
-        .replace('{domain}', domain)
-        .replace('{port}', String(port))
-        .replace('{path}', path)
-        .replace('{clientIp}', context.clientIp);
+        let finalLocation = locationTemplate
+          .replace('{domain}', domain)
+          .replace('{port}', String(port))
+          .replace('{path}', path)
+          .replace('{clientIp}', context.clientIp);
         
-      const message = `Redirecting to ${finalLocation}`;
-      const response = [
-        `HTTP/1.1 ${statusCode} ${statusCode === 301 ? 'Moved Permanently' : 'Found'}`,
-        `Location: ${finalLocation}`,
-        'Content-Type: text/plain',
-        `Content-Length: ${message.length}`,
-        'Connection: close',
-        '',
-        message
-      ].join('\r\n');
+        const message = `Redirecting to ${finalLocation}`;
+        const response = [
+          `HTTP/1.1 ${statusCode} ${statusCode === 301 ? 'Moved Permanently' : 'Found'}`,
+          `Location: ${finalLocation}`,
+          'Content-Type: text/plain',
+          `Content-Length: ${message.length}`,
+          'Connection: close',
+          '',
+          message
+        ].join('\r\n');
+        
+        socket.write(response);
+      } else {
+        // Not a valid HTTP request, close connection
+        socket.write('HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n');
+      }
       
-      socket.write(response);
       socket.end();
+      // Clean up detection state
+      ProtocolDetector.cleanupConnections();
     });
   },
   
   /**
    * HTTP server handler for ACME challenges and other HTTP needs
+   * Now uses the centralized detection module for HTTP parsing
    */
   httpServer: (handler: (req: { method: string; url: string; headers: Record<string, string>; body?: string }, res: { status: (code: number) => void; header: (name: string, value: string) => void; send: (data: string) => void; end: () => void }) => void) => (socket: plugins.net.Socket, context: IRouteContext) => {
-    let buffer = '';
     let requestParsed = false;
+    const connectionId = ProtocolDetector.createConnectionId({
+      socketId: context.connectionId || `${Date.now()}-${Math.random()}`
+    });
     
-    socket.on('data', (data) => {
+    const processData = async (data: Buffer) => {
       if (requestParsed) return; // Only handle the first request
       
-      buffer += data.toString();
+      // Use HttpDetector for parsing
+      const detectionResult = await ProtocolDetector.detectWithConnectionTracking(
+        data,
+        connectionId,
+        { extractFullHeaders: true }
+      );
       
-      // Check if we have a complete HTTP request
-      const headerEndIndex = buffer.indexOf('\r\n\r\n');
-      if (headerEndIndex === -1) return; // Need more data
-      
-      requestParsed = true;
-      
-      // Parse the HTTP request
-      const headerPart = buffer.substring(0, headerEndIndex);
-      const bodyPart = buffer.substring(headerEndIndex + 4);
-      
-      const lines = headerPart.split('\r\n');
-      const [method, url] = lines[0].split(' ');
-      
-      const headers: Record<string, string> = {};
-      for (let i = 1; i < lines.length; i++) {
-        const colonIndex = lines[i].indexOf(':');
-        if (colonIndex > 0) {
-          const name = lines[i].substring(0, colonIndex).trim().toLowerCase();
-          const value = lines[i].substring(colonIndex + 1).trim();
-          headers[name] = value;
-        }
+      if (detectionResult.protocol !== 'http' || !detectionResult.isComplete) {
+        // Not a complete HTTP request yet
+        return;
       }
       
-      // Create request object
+      requestParsed = true;
+      const connInfo = detectionResult.connectionInfo;
+      
+      // Create request object from detection result
       const req = {
-        method: method || 'GET',
-        url: url || '/',
-        headers,
-        body: bodyPart
+        method: connInfo.method || 'GET',
+        url: connInfo.path || '/',
+        headers: connInfo.headers || {},
+        body: detectionResult.remainingBuffer?.toString() || ''
       };
       
       // Create response object
@@ -1021,12 +1102,168 @@ export const SocketHandlers = {
           res.send('Internal Server Error');
         }
       }
-    });
+    };
+    
+    socket.on('data', processData);
     
     socket.on('error', () => {
       if (!requestParsed) {
         socket.end();
       }
     });
+    
+    socket.on('close', () => {
+      // Clean up detection state
+      ProtocolDetector.cleanupConnections();
+    });
   }
 };
+
+/**
+ * Create an API Gateway route pattern
+ * @param domains Domain(s) to match
+ * @param apiBasePath Base path for API endpoints (e.g., '/api')
+ * @param target Target host and port
+ * @param options Additional route options
+ * @returns API route configuration
+ */
+export function createApiGatewayRoute(
+  domains: string | string[],
+  apiBasePath: string,
+  target: { host: string | string[]; port: number },
+  options: {
+    useTls?: boolean;
+    certificate?: 'auto' | { key: string; cert: string };
+    addCorsHeaders?: boolean;
+    [key: string]: any;
+  } = {}
+): IRouteConfig {
+  // Normalize apiBasePath to ensure it starts with / and doesn't end with /
+  const normalizedPath = apiBasePath.startsWith('/') 
+    ? apiBasePath 
+    : `/${apiBasePath}`;
+  
+  // Add wildcard to path to match all API endpoints
+  const apiPath = normalizedPath.endsWith('/') 
+    ? `${normalizedPath}*` 
+    : `${normalizedPath}/*`;
+  
+  // Create base route
+  const baseRoute = options.useTls
+    ? createHttpsTerminateRoute(domains, target, {
+        certificate: options.certificate || 'auto'
+      })
+    : createHttpRoute(domains, target);
+  
+  // Add API-specific configurations
+  const apiRoute: Partial<IRouteConfig> = {
+    match: {
+      ...baseRoute.match,
+      path: apiPath
+    },
+    name: options.name || `API Gateway: ${apiPath} -> ${Array.isArray(target.host) ? target.host.join(', ') : target.host}:${target.port}`,
+    priority: options.priority || 100 // Higher priority for specific path matching
+  };
+  
+  // Add CORS headers if requested
+  if (options.addCorsHeaders) {
+    apiRoute.headers = {
+      response: {
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+        'Access-Control-Max-Age': '86400'
+      }
+    };
+  }
+  
+  return mergeRouteConfigs(baseRoute, apiRoute);
+}
+
+/**
+ * Create a rate limiting route pattern
+ * @param baseRoute Base route to add rate limiting to
+ * @param rateLimit Rate limiting configuration
+ * @returns Route with rate limiting
+ */
+export function addRateLimiting(
+  baseRoute: IRouteConfig,
+  rateLimit: {
+    maxRequests: number;
+    window: number; // Time window in seconds
+    keyBy?: 'ip' | 'path' | 'header';
+    headerName?: string; // Required if keyBy is 'header'
+    errorMessage?: string;
+  }
+): IRouteConfig {
+  return mergeRouteConfigs(baseRoute, {
+    security: {
+      rateLimit: {
+        enabled: true,
+        maxRequests: rateLimit.maxRequests,
+        window: rateLimit.window,
+        keyBy: rateLimit.keyBy || 'ip',
+        headerName: rateLimit.headerName,
+        errorMessage: rateLimit.errorMessage || 'Rate limit exceeded. Please try again later.'
+      }
+    }
+  });
+}
+
+/**
+ * Create a basic authentication route pattern
+ * @param baseRoute Base route to add authentication to
+ * @param auth Authentication configuration
+ * @returns Route with basic authentication
+ */
+export function addBasicAuth(
+  baseRoute: IRouteConfig,
+  auth: {
+    users: Array<{ username: string; password: string }>;
+    realm?: string;
+    excludePaths?: string[];
+  }
+): IRouteConfig {
+  return mergeRouteConfigs(baseRoute, {
+    security: {
+      basicAuth: {
+        enabled: true,
+        users: auth.users,
+        realm: auth.realm || 'Restricted Area',
+        excludePaths: auth.excludePaths || []
+      }
+    }
+  });
+}
+
+/**
+ * Create a JWT authentication route pattern
+ * @param baseRoute Base route to add JWT authentication to
+ * @param jwt JWT authentication configuration
+ * @returns Route with JWT authentication
+ */
+export function addJwtAuth(
+  baseRoute: IRouteConfig,
+  jwt: {
+    secret: string;
+    algorithm?: string;
+    issuer?: string;
+    audience?: string;
+    expiresIn?: number; // Time in seconds
+    excludePaths?: string[];
+  }
+): IRouteConfig {
+  return mergeRouteConfigs(baseRoute, {
+    security: {
+      jwtAuth: {
+        enabled: true,
+        secret: jwt.secret,
+        algorithm: jwt.algorithm || 'HS256',
+        issuer: jwt.issuer,
+        audience: jwt.audience,
+        expiresIn: jwt.expiresIn,
+        excludePaths: jwt.excludePaths || []
+      }
+    }
+  });
+}

ts/proxies/smart-proxy/utils/route-patterns.ts

@@ -1,403 +0,0 @@
-/**
- * Route Patterns
- * 
- * This file provides pre-defined route patterns for common use cases.
- * These patterns can be used as templates for creating route configurations.
- */
-
-import type { IRouteConfig, IRouteMatch, IRouteAction, IRouteTarget } from '../models/route-types.js';
-import { mergeRouteConfigs } from './route-utils.js';
-import { SocketHandlers } from './route-helpers.js';
-
-/**
- * Create a basic HTTP route configuration
- */
-export function createHttpRoute(
-  domains: string | string[],
-  target: { host: string | string[]; port: number | 'preserve' | ((ctx: any) => number) },
-  options: Partial<IRouteConfig> = {}
-): IRouteConfig {
-  const route: IRouteConfig = {
-    match: {
-      domains,
-      ports: 80
-    },
-    action: {
-      type: 'forward',
-      targets: [{
-        host: target.host,
-        port: target.port
-      }]
-    },
-    name: options.name || `HTTP: ${Array.isArray(domains) ? domains.join(', ') : domains}`
-  };
-
-  return mergeRouteConfigs(route, options);
-}
-
-/**
- * Create an HTTPS route with TLS termination
- */
-export function createHttpsTerminateRoute(
-  domains: string | string[],
-  target: { host: string | string[]; port: number | 'preserve' | ((ctx: any) => number) },
-  options: Partial<IRouteConfig> & {
-    certificate?: 'auto' | { key: string; cert: string };
-    reencrypt?: boolean;
-  } = {}
-): IRouteConfig {
-  const route: IRouteConfig = {
-    match: {
-      domains,
-      ports: 443
-    },
-    action: {
-      type: 'forward',
-      targets: [{
-        host: target.host,
-        port: target.port
-      }],
-      tls: {
-        mode: options.reencrypt ? 'terminate-and-reencrypt' : 'terminate',
-        certificate: options.certificate || 'auto'
-      }
-    },
-    name: options.name || `HTTPS (terminate): ${Array.isArray(domains) ? domains.join(', ') : domains}`
-  };
-
-  return mergeRouteConfigs(route, options);
-}
-
-/**
- * Create an HTTPS route with TLS passthrough
- */
-export function createHttpsPassthroughRoute(
-  domains: string | string[],
-  target: { host: string | string[]; port: number | 'preserve' | ((ctx: any) => number) },
-  options: Partial<IRouteConfig> = {}
-): IRouteConfig {
-  const route: IRouteConfig = {
-    match: {
-      domains,
-      ports: 443
-    },
-    action: {
-      type: 'forward',
-      targets: [{
-        host: target.host,
-        port: target.port
-      }],
-      tls: {
-        mode: 'passthrough'
-      }
-    },
-    name: options.name || `HTTPS (passthrough): ${Array.isArray(domains) ? domains.join(', ') : domains}`
-  };
-
-  return mergeRouteConfigs(route, options);
-}
-
-/**
- * Create an HTTP to HTTPS redirect route
- */
-export function createHttpToHttpsRedirect(
-  domains: string | string[],
-  options: Partial<IRouteConfig> & {
-    redirectCode?: 301 | 302 | 307 | 308;
-    preservePath?: boolean;
-  } = {}
-): IRouteConfig {
-  const route: IRouteConfig = {
-    match: {
-      domains,
-      ports: 80
-    },
-    action: {
-      type: 'socket-handler',
-      socketHandler: SocketHandlers.httpRedirect(
-        options.preservePath ? 'https://{domain}{path}' : 'https://{domain}',
-        options.redirectCode || 301
-      )
-    },
-    name: options.name || `HTTP to HTTPS redirect: ${Array.isArray(domains) ? domains.join(', ') : domains}`
-  };
-
-  return mergeRouteConfigs(route, options);
-}
-
-/**
- * Create a complete HTTPS server with redirect from HTTP
- */
-export function createCompleteHttpsServer(
-  domains: string | string[],
-  target: { host: string | string[]; port: number | 'preserve' | ((ctx: any) => number) },
-  options: Partial<IRouteConfig> & {
-    certificate?: 'auto' | { key: string; cert: string };
-    tlsMode?: 'terminate' | 'passthrough' | 'terminate-and-reencrypt';
-    redirectCode?: 301 | 302 | 307 | 308;
-  } = {}
-): IRouteConfig[] {
-  // Create the TLS route based on the selected mode
-  const tlsRoute = options.tlsMode === 'passthrough' 
-    ? createHttpsPassthroughRoute(domains, target, options)
-    : createHttpsTerminateRoute(domains, target, {
-        ...options,
-        reencrypt: options.tlsMode === 'terminate-and-reencrypt'
-      });
-  
-  // Create the HTTP to HTTPS redirect route
-  const redirectRoute = createHttpToHttpsRedirect(domains, {
-    redirectCode: options.redirectCode,
-    preservePath: true
-  });
-  
-  return [tlsRoute, redirectRoute];
-}
-
-/**
- * Create an API Gateway route pattern
- * @param domains Domain(s) to match
- * @param apiBasePath Base path for API endpoints (e.g., '/api')
- * @param target Target host and port
- * @param options Additional route options
- * @returns API route configuration
- */
-export function createApiGatewayRoute(
-  domains: string | string[],
-  apiBasePath: string,
-  target: { host: string | string[]; port: number },
-  options: {
-    useTls?: boolean;
-    certificate?: 'auto' | { key: string; cert: string };
-    addCorsHeaders?: boolean;
-    [key: string]: any;
-  } = {}
-): IRouteConfig {
-  // Normalize apiBasePath to ensure it starts with / and doesn't end with /
-  const normalizedPath = apiBasePath.startsWith('/') 
-    ? apiBasePath 
-    : `/${apiBasePath}`;
-  
-  // Add wildcard to path to match all API endpoints
-  const apiPath = normalizedPath.endsWith('/') 
-    ? `${normalizedPath}*` 
-    : `${normalizedPath}/*`;
-  
-  // Create base route
-  const baseRoute = options.useTls
-    ? createHttpsTerminateRoute(domains, target, {
-        certificate: options.certificate || 'auto'
-      })
-    : createHttpRoute(domains, target);
-  
-  // Add API-specific configurations
-  const apiRoute: Partial<IRouteConfig> = {
-    match: {
-      ...baseRoute.match,
-      path: apiPath
-    },
-    name: options.name || `API Gateway: ${apiPath} -> ${Array.isArray(target.host) ? target.host.join(', ') : target.host}:${target.port}`,
-    priority: options.priority || 100 // Higher priority for specific path matching
-  };
-  
-  // Add CORS headers if requested
-  if (options.addCorsHeaders) {
-    apiRoute.headers = {
-      response: {
-        'Access-Control-Allow-Origin': '*',
-        'Access-Control-Allow-Methods': 'GET, POST, PUT, DELETE, OPTIONS',
-        'Access-Control-Allow-Headers': 'Content-Type, Authorization',
-        'Access-Control-Max-Age': '86400'
-      }
-    };
-  }
-  
-  return mergeRouteConfigs(baseRoute, apiRoute);
-}
-
-/**
- * Create a WebSocket route pattern
- * @param domains Domain(s) to match
- * @param target WebSocket server host and port
- * @param options Additional route options
- * @returns WebSocket route configuration
- */
-export function createWebSocketRoute(
-  domains: string | string[],
-  target: { host: string | string[]; port: number },
-  options: {
-    useTls?: boolean;
-    certificate?: 'auto' | { key: string; cert: string };
-    path?: string;
-    [key: string]: any;
-  } = {}
-): IRouteConfig {
-  // Create base route
-  const baseRoute = options.useTls
-    ? createHttpsTerminateRoute(domains, target, {
-        certificate: options.certificate || 'auto'
-      })
-    : createHttpRoute(domains, target);
-  
-  // Add WebSocket-specific configurations
-  const wsRoute: Partial<IRouteConfig> = {
-    match: {
-      ...baseRoute.match,
-      path: options.path || '/ws',
-      headers: {
-        'Upgrade': 'websocket'
-      }
-    },
-    action: {
-      ...baseRoute.action,
-      websocket: {
-        enabled: true,
-        pingInterval: options.pingInterval || 30000, // 30 seconds
-        pingTimeout: options.pingTimeout || 5000    // 5 seconds
-      }
-    },
-    name: options.name || `WebSocket: ${Array.isArray(domains) ? domains.join(', ') : domains} -> ${Array.isArray(target.host) ? target.host.join(', ') : target.host}:${target.port}`,
-    priority: options.priority || 100 // Higher priority for WebSocket routes
-  };
-  
-  return mergeRouteConfigs(baseRoute, wsRoute);
-}
-
-/**
- * Create a load balancer route pattern
- * @param domains Domain(s) to match
- * @param backends Array of backend servers
- * @param options Additional route options
- * @returns Load balancer route configuration
- */
-export function createLoadBalancerRoute(
-  domains: string | string[],
-  backends: Array<{ host: string; port: number }>,
-  options: {
-    useTls?: boolean;
-    certificate?: 'auto' | { key: string; cert: string };
-    algorithm?: 'round-robin' | 'least-connections' | 'ip-hash';
-    healthCheck?: {
-      path: string;
-      interval: number;
-      timeout: number;
-      unhealthyThreshold: number;
-      healthyThreshold: number;
-    };
-    [key: string]: any;
-  } = {}
-): IRouteConfig {
-  // Extract hosts and ensure all backends use the same port
-  const port = backends[0].port;
-  const hosts = backends.map(backend => backend.host);
-  
-  // Create route with multiple hosts for load balancing
-  const baseRoute = options.useTls
-    ? createHttpsTerminateRoute(domains, { host: hosts, port }, {
-        certificate: options.certificate || 'auto'
-      })
-    : createHttpRoute(domains, { host: hosts, port });
-  
-  // Add load balancing specific configurations
-  const lbRoute: Partial<IRouteConfig> = {
-    action: {
-      ...baseRoute.action,
-      loadBalancing: {
-        algorithm: options.algorithm || 'round-robin',
-        healthCheck: options.healthCheck
-      }
-    },
-    name: options.name || `Load Balancer: ${Array.isArray(domains) ? domains.join(', ') : domains}`,
-    priority: options.priority || 50
-  };
-  
-  return mergeRouteConfigs(baseRoute, lbRoute);
-}
-
-/**
- * Create a rate limiting route pattern
- * @param baseRoute Base route to add rate limiting to
- * @param rateLimit Rate limiting configuration
- * @returns Route with rate limiting
- */
-export function addRateLimiting(
-  baseRoute: IRouteConfig,
-  rateLimit: {
-    maxRequests: number;
-    window: number; // Time window in seconds
-    keyBy?: 'ip' | 'path' | 'header';
-    headerName?: string; // Required if keyBy is 'header'
-    errorMessage?: string;
-  }
-): IRouteConfig {
-  return mergeRouteConfigs(baseRoute, {
-    security: {
-      rateLimit: {
-        enabled: true,
-        maxRequests: rateLimit.maxRequests,
-        window: rateLimit.window,
-        keyBy: rateLimit.keyBy || 'ip',
-        headerName: rateLimit.headerName,
-        errorMessage: rateLimit.errorMessage || 'Rate limit exceeded. Please try again later.'
-      }
-    }
-  });
-}
-
-/**
- * Create a basic authentication route pattern
- * @param baseRoute Base route to add authentication to
- * @param auth Authentication configuration
- * @returns Route with basic authentication
- */
-export function addBasicAuth(
-  baseRoute: IRouteConfig,
-  auth: {
-    users: Array<{ username: string; password: string }>;
-    realm?: string;
-    excludePaths?: string[];
-  }
-): IRouteConfig {
-  return mergeRouteConfigs(baseRoute, {
-    security: {
-      basicAuth: {
-        enabled: true,
-        users: auth.users,
-        realm: auth.realm || 'Restricted Area',
-        excludePaths: auth.excludePaths || []
-      }
-    }
-  });
-}
-
-/**
- * Create a JWT authentication route pattern
- * @param baseRoute Base route to add JWT authentication to
- * @param jwt JWT authentication configuration
- * @returns Route with JWT authentication
- */
-export function addJwtAuth(
-  baseRoute: IRouteConfig,
-  jwt: {
-    secret: string;
-    algorithm?: string;
-    issuer?: string;
-    audience?: string;
-    expiresIn?: number; // Time in seconds
-    excludePaths?: string[];
-  }
-): IRouteConfig {
-  return mergeRouteConfigs(baseRoute, {
-    security: {
-      jwtAuth: {
-        enabled: true,
-        secret: jwt.secret,
-        algorithm: jwt.algorithm || 'HS256',
-        issuer: jwt.issuer,
-        audience: jwt.audience,
-        expiresIn: jwt.expiresIn,
-        excludePaths: jwt.excludePaths || []
-      }
-    }
-  });
-}

ts/tls/index.ts

@@ -1,22 +1,18 @@
 /**
- * TLS module providing SNI extraction, TLS alerts, and other TLS-related utilities
+ * TLS module for smartproxy
+ * Re-exports protocol components and provides smartproxy-specific functionality
  */
 
-// Export TLS alert functionality
-export * from './alerts/tls-alert.js';
+// Re-export all protocol components from protocols/tls
+export * from '../protocols/tls/index.js';
 
-// Export SNI handling
+// Export smartproxy-specific SNI handler
 export * from './sni/sni-handler.js';
-export * from './sni/sni-extraction.js';
-export * from './sni/client-hello-parser.js';
-
-// Export TLS utilities
-export * from './utils/tls-utils.js';
 
 // Create a namespace for SNI utilities
 import { SniHandler } from './sni/sni-handler.js';
-import { SniExtraction } from './sni/sni-extraction.js';
-import { ClientHelloParser } from './sni/client-hello-parser.js';
+import { SniExtraction } from '../protocols/tls/sni/sni-extraction.js';
+import { ClientHelloParser } from '../protocols/tls/sni/client-hello-parser.js';
 
 // Export utility objects for convenience
 export const SNI = {