Refactor routing and proxy components for improved structure and compatibility

- Removed deprecated route utility functions in favor of direct matcher usage.
- Updated imports to reflect new module structure for routing utilities.
- Consolidated route manager functionality into SharedRouteManager for better consistency.
- Eliminated legacy routing methods and interfaces, streamlining the HttpProxy and associated components.
- Enhanced WebSocket and HTTP request handling to utilize the new unified HttpRouter.
- Updated route matching logic to leverage matcher classes for domain, path, and header checks.
- Cleaned up legacy compatibility code across various modules, ensuring a more maintainable codebase.

ts/core/routing/index.ts

@@ -12,6 +12,10 @@ export * from './matchers/index.js';
 // Export specificity calculator
 export * from './specificity.js';
 
+// Export route management
+export * from './route-manager.js';
+export * from './route-utils.js';
+
 // Convenience re-exports
 export { matchers } from './matchers/index.js';
 export { RouteSpecificity } from './specificity.js';

ts/core/routing/matchers/path.ts

@@ -34,6 +34,12 @@ export class PathMatcher implements IMatcher<IPathMatchResult> {
 
     // Ensure the pattern matches from start
     regexPattern = `^${regexPattern}`;
+    
+    // If pattern doesn't end with wildcard, ensure it matches to end
+    // But only for patterns that don't have parameters or wildcards
+    if (!pattern.includes('*') && !pattern.includes(':') && !pattern.endsWith('/')) {
+      regexPattern = `${regexPattern}$`;
+    }
 
     return {
       regex: new RegExp(regexPattern),

ts/core/routing/route-manager.ts

@@ -7,19 +7,15 @@ import type {
   IRouteContext
 } from '../../proxies/smart-proxy/models/route-types.js';
 import {
-  matchDomain,
   matchRouteDomain,
-  matchPath,
-  matchIpPattern,
-  matchIpCidr,
-  isIpAuthorized,
   calculateRouteSpecificity
 } from './route-utils.js';
+import { DomainMatcher, PathMatcher, IpMatcher } from './matchers/index.js';
 
 /**
- * Result of route matching
+ * Result of route lookup
  */
-export interface IRouteMatchResult {
+export interface IRouteLookupResult {
   route: IRouteConfig;
   // Additional match parameters (path, query, etc.)
   params?: Record<string, string>;
@@ -218,7 +214,7 @@ export class SharedRouteManager extends plugins.EventEmitter {
   /**
    * Find the matching route for a connection
    */
-  public findMatchingRoute(context: IRouteContext): IRouteMatchResult | null {
+  public findMatchingRoute(context: IRouteContext): IRouteLookupResult | null {
     // Get routes for this port if using port-based filtering
     const routesToCheck = context.port 
       ? (this.portMap.get(context.port) || []) 
@@ -257,21 +253,21 @@ export class SharedRouteManager extends plugins.EventEmitter {
         ? route.match.domains
         : [route.match.domains];
 
-      if (!domains.some(domainPattern => this.matchDomain(domainPattern, context.domain!))) {
+      if (!domains.some(domainPattern => DomainMatcher.match(domainPattern, context.domain!))) {
         return false;
       }
     }
 
     // Check path match if specified
     if (route.match.path && context.path) {
-      if (!this.matchPath(route.match.path, context.path)) {
+      if (!PathMatcher.match(route.match.path, context.path).matches) {
         return false;
       }
     }
 
     // Check client IP match if specified
     if (route.match.clientIp && context.clientIp) {
-      if (!route.match.clientIp.some(ip => this.matchIpPattern(ip, context.clientIp))) {
+      if (!route.match.clientIp.some(ip => IpMatcher.match(ip, context.clientIp))) {
         return false;
       }
     }
@@ -310,37 +306,6 @@ export class SharedRouteManager extends plugins.EventEmitter {
     return true;
   }
   
-  /**
-   * Match a domain pattern against a domain
-   * @deprecated Use the matchDomain function from route-utils.js instead
-   */
-  public matchDomain(pattern: string, domain: string): boolean {
-    return matchDomain(pattern, domain);
-  }
-  
-  /**
-   * Match a path pattern against a path
-   * @deprecated Use the matchPath function from route-utils.js instead
-   */
-  public matchPath(pattern: string, path: string): boolean {
-    return matchPath(pattern, path);
-  }
-
-  /**
-   * Match an IP pattern against a pattern
-   * @deprecated Use the matchIpPattern function from route-utils.js instead
-   */
-  public matchIpPattern(pattern: string, ip: string): boolean {
-    return matchIpPattern(pattern, ip);
-  }
-  
-  /**
-   * Match an IP against a CIDR pattern
-   * @deprecated Use the matchIpCidr function from route-utils.js instead
-   */
-  public matchIpCidr(cidr: string, ip: string): boolean {
-    return matchIpCidr(cidr, ip);
-  }
   
   
   /**
@@ -471,11 +436,4 @@ export class SharedRouteManager extends plugins.EventEmitter {
     return true;
   }
   
-  /**
-   * Check if route1 is more specific than route2
-   * @deprecated Use the calculateRouteSpecificity function from route-utils.js instead
-   */
-  private isRouteMoreSpecific(match1: IRouteMatch, match2: IRouteMatch): boolean {
-    return calculateRouteSpecificity(match1) > calculateRouteSpecificity(match2);
-  }
 }

ts/core/routing/route-utils.ts

@@ -5,18 +5,11 @@
  * and additional route-specific utilities.
  */
 
-import { DomainMatcher, PathMatcher, IpMatcher, HeaderMatcher } from '../routing/matchers/index.js';
-import { RouteSpecificity } from '../routing/specificity.js';
-import type { IRouteSpecificity } from '../routing/types.js';
+import { DomainMatcher, PathMatcher, IpMatcher, HeaderMatcher } from './matchers/index.js';
+import { RouteSpecificity } from './specificity.js';
+import type { IRouteSpecificity } from './types.js';
 import type { IRouteConfig } from '../../proxies/smart-proxy/models/route-types.js';
 
-/**
- * Match a domain pattern against a domain
- * @deprecated Use DomainMatcher.match() directly
- */
-export function matchDomain(pattern: string, domain: string): boolean {
-  return DomainMatcher.match(pattern, domain);
-}
 
 /**
  * Match domains from a route against a given domain
@@ -37,56 +30,10 @@ export function matchRouteDomain(domains: string | string[] | undefined, domain:
   }
   
   const patterns = Array.isArray(domains) ? domains : [domains];
-  return patterns.some(pattern => matchDomain(pattern, domain));
+  return patterns.some(pattern => DomainMatcher.match(pattern, domain));
 }
 
-/**
- * Match a path pattern against a path
- * @deprecated Use PathMatcher.match() directly
- */
-export function matchPath(pattern: string, path: string): boolean {
-  return PathMatcher.match(pattern, path).matches;
-}
 
-// Helper functions removed - use IpMatcher internal methods instead
-
-/**
- * Match an IP against a CIDR pattern
- * @deprecated Use IpMatcher.matchCidr() directly
- */
-export function matchIpCidr(cidr: string, ip: string): boolean {
-  return IpMatcher.matchCidr(cidr, ip);
-}
-
-/**
- * Match an IP pattern against an IP
- * @deprecated Use IpMatcher.match() directly
- */
-export function matchIpPattern(pattern: string, ip: string): boolean {
-  return IpMatcher.match(pattern, ip);
-}
-
-/**
- * Match an IP against allowed and blocked IP patterns
- * @deprecated Use IpMatcher.isAuthorized() directly
- */
-export function isIpAuthorized(
-  ip: string, 
-  ipAllowList: string[] = ['*'], 
-  ipBlockList: string[] = []
-): boolean {
-  return IpMatcher.isAuthorized(ip, ipAllowList, ipBlockList);
-}
-
-/**
- * Match an HTTP header pattern against a header value
- * @deprecated Use HeaderMatcher.match() directly
- */
-export function matchHeader(pattern: string | RegExp, value: string): boolean {
-  // Convert RegExp to string pattern for HeaderMatcher
-  const stringPattern = pattern instanceof RegExp ? pattern.source : pattern;
-  return HeaderMatcher.match(stringPattern, value, { exactMatch: true });
-}
 
 /**
  * Calculate route specificity score
@@ -94,7 +41,6 @@ export function matchHeader(pattern: string | RegExp, value: string): boolean {
  * 
  * @param match Match criteria to evaluate
  * @returns Numeric specificity score
- * @deprecated Consider using RouteSpecificity.calculate() with full IRouteConfig
  */
 export function calculateRouteSpecificity(match: {
   domains?: string | string[];