fix(network-proxy, route-utils, route-manager): Normalize IPv6-mapped IPv4 addresses in IP matching functions and remove deprecated legacy configuration methods in NetworkProxy. Update route-utils and route-manager to compare both canonical and IPv6-mapped IP forms, adjust tests accordingly, and clean up legacy exports.

ts/core/models/route-context.ts

@@ -1,3 +1,5 @@
+import * as plugins from '../../plugins.js';
+
 /**
  * Shared Route Context Interface
  * 
@@ -42,8 +44,8 @@ export interface IRouteContext {
  * Used only in NetworkProxy for HTTP request handling
  */
 export interface IHttpRouteContext extends IRouteContext {
-  req?: any; // http.IncomingMessage 
-  res?: any; // http.ServerResponse
+  req?: plugins.http.IncomingMessage;
+  res?: plugins.http.ServerResponse;
   method?: string; // HTTP method (GET, POST, etc.)
 }
 
@@ -52,7 +54,7 @@ export interface IHttpRouteContext extends IRouteContext {
  * Used only in NetworkProxy for HTTP/2 request handling
  */
 export interface IHttp2RouteContext extends IHttpRouteContext {
-  stream?: any; // http2.Http2Stream
+  stream?: plugins.http2.ServerHttp2Stream;
   headers?: Record<string, string>; // HTTP/2 pseudo-headers like :method, :path
 }
 

ts/core/utils/route-utils.ts

@@ -13,8 +13,8 @@
  * @returns Whether the domain matches the pattern
  */
 export function matchDomain(pattern: string, domain: string): boolean {
-  // Handle exact match
-  if (pattern === domain) {
+  // Handle exact match (case-insensitive)
+  if (pattern.toLowerCase() === domain.toLowerCase()) {
     return true;
   }
 
@@ -139,9 +139,13 @@ export function matchIpCidr(cidr: string, ip: string): boolean {
   try {
     const { subnet, bits } = parsed;
     
+    // Normalize IPv6-mapped IPv4 addresses
+    const normalizedIp = ip.startsWith('::ffff:') ? ip.substring(7) : ip;
+    const normalizedSubnet = subnet.startsWith('::ffff:') ? subnet.substring(7) : subnet;
+    
     // Convert IP addresses to numeric values
-    const ipNum = ipToNumber(ip);
-    const subnetNum = ipToNumber(subnet);
+    const ipNum = ipToNumber(normalizedIp);
+    const subnetNum = ipToNumber(normalizedSubnet);
     
     // Calculate subnet mask
     const maskNum = ~(2 ** (32 - bits) - 1);
@@ -161,26 +165,41 @@ export function matchIpCidr(cidr: string, ip: string): boolean {
  * @returns Whether the IP matches the pattern
  */
 export function matchIpPattern(pattern: string, ip: string): boolean {
-  // Handle exact match
-  if (pattern === ip) {
+  // Normalize IPv6-mapped IPv4 addresses
+  const normalizedIp = ip.startsWith('::ffff:') ? ip.substring(7) : ip;
+  const normalizedPattern = pattern.startsWith('::ffff:') ? pattern.substring(7) : pattern;
+  
+  // Handle exact match with all variations
+  if (pattern === ip || normalizedPattern === normalizedIp || 
+      pattern === normalizedIp || normalizedPattern === ip) {
     return true;
   }
   
   // Handle "all" wildcard
-  if (pattern === '*') {
+  if (pattern === '*' || normalizedPattern === '*') {
     return true;
   }
   
   // Handle CIDR notation (e.g., 192.168.1.0/24)
   if (pattern.includes('/')) {
-    return matchIpCidr(pattern, ip);
+    return matchIpCidr(pattern, normalizedIp) || 
+           (normalizedPattern !== pattern && matchIpCidr(normalizedPattern, normalizedIp));
   }
   
   // Handle glob pattern (e.g., 192.168.1.*)
   if (pattern.includes('*')) {
     const regexPattern = pattern.replace(/\./g, '\\.').replace(/\*/g, '.*');
     const regex = new RegExp(`^${regexPattern}$`);
-    return regex.test(ip);
+    if (regex.test(ip) || regex.test(normalizedIp)) {
+      return true;
+    }
+    
+    // If pattern was normalized, also test with normalized pattern
+    if (normalizedPattern !== pattern) {
+      const normalizedRegexPattern = normalizedPattern.replace(/\./g, '\\.').replace(/\*/g, '.*');
+      const normalizedRegex = new RegExp(`^${normalizedRegexPattern}$`);
+      return normalizedRegex.test(ip) || normalizedRegex.test(normalizedIp);
+    }
   }
   
   return false;