19.5.13

The previous fix only addressed ForwardingHandler classes but missed the critical setupDirectConnection() method in route-connection-handler.ts where SmartProxy actually handles connections. This caused active connections to rise indefinitely on ECONNREFUSED errors.

Changes:
- Import createSocketWithErrorHandler in route-connection-handler.ts
- Replace net.connect() with createSocketWithErrorHandler() in setupDirectConnection()
- Properly clean up connection records when server connection fails
- Add connectionFailed flag to prevent setup of failed connections

This ensures connection records are cleaned up immediately when backend connections fail, preventing memory leaks.

certs/static-route/cert.pem

@@ -0,0 +1,3 @@
+-----BEGIN CERTIFICATE-----
+MIIC...
+-----END CERTIFICATE-----

certs/static-route/key.pem

@@ -0,0 +1,3 @@
+-----BEGIN PRIVATE KEY-----
+MIIE...
+-----END PRIVATE KEY-----

certs/static-route/meta.json

@@ -0,0 +1,5 @@
+{
+  "expiryDate": "2025-08-30T08:11:10.101Z",
+  "issueDate": "2025-06-01T08:11:10.101Z",
+  "savedAt": "2025-06-01T08:11:10.102Z"
+}

docs/porthandling.md

@@ -1,468 +0,0 @@
-# SmartProxy Port Handling
-
-This document covers all the port handling capabilities in SmartProxy, including port range specification, dynamic port mapping, and runtime port management.
-
-## Port Range Syntax
-
-SmartProxy offers flexible port range specification through the `TPortRange` type, which can be defined in three different ways:
-
-### 1. Single Port
-
-```typescript
-// Match a single port
-{
-  match: {
-    ports: 443
-  }
-}
-```
-
-### 2. Array of Specific Ports
-
-```typescript
-// Match multiple specific ports
-{
-  match: {
-    ports: [80, 443, 8080]
-  }
-}
-```
-
-### 3. Port Range
-
-```typescript
-// Match a range of ports
-{
-  match: {
-    ports: [{ from: 8000, to: 8100 }]
-  }
-}
-```
-
-### 4. Mixed Port Specifications
-
-You can combine different port specification methods in a single rule:
-
-```typescript
-// Match both specific ports and port ranges
-{
-  match: {
-    ports: [80, 443, { from: 8000, to: 8100 }]
-  }
-}
-```
-
-## Port Forwarding Options
-
-SmartProxy offers several ways to handle port forwarding from source to target:
-
-### 1. Static Port Forwarding
-
-Forward to a fixed target port:
-
-```typescript
-{
-  action: {
-    type: 'forward',
-    target: {
-      host: 'backend.example.com',
-      port: 8080
-    }
-  }
-}
-```
-
-### 2. Preserve Source Port
-
-Forward to the same port on the target:
-
-```typescript
-{
-  action: {
-    type: 'forward',
-    target: {
-      host: 'backend.example.com',
-      port: 'preserve'
-    }
-  }
-}
-```
-
-### 3. Dynamic Port Mapping
-
-Use a function to determine the target port based on connection context:
-
-```typescript
-{
-  action: {
-    type: 'forward',
-    target: {
-      host: 'backend.example.com',
-      port: (context) => {
-        // Calculate port based on request details
-        return 8000 + (context.port % 100);
-      }
-    }
-  }
-}
-```
-
-## Port Selection Context
-
-When using dynamic port mapping functions, you have access to a rich context object that provides details about the connection:
-
-```typescript
-interface IRouteContext {
-  // Connection information
-  port: number;          // The matched incoming port
-  domain?: string;       // The domain from SNI or Host header
-  clientIp: string;      // The client's IP address
-  serverIp: string;      // The server's IP address
-  path?: string;         // URL path (for HTTP connections)
-  query?: string;        // Query string (for HTTP connections)
-  headers?: Record<string, string>; // HTTP headers (for HTTP connections)
-
-  // TLS information
-  isTls: boolean;        // Whether the connection is TLS
-  tlsVersion?: string;   // TLS version if applicable
-
-  // Route information
-  routeName?: string;    // The name of the matched route
-  routeId?: string;      // The ID of the matched route
-
-  // Additional properties
-  timestamp: number;     // The request timestamp
-  connectionId: string;  // Unique connection identifier
-}
-```
-
-## Common Port Mapping Patterns
-
-### 1. Port Offset Mapping
-
-Forward traffic to target ports with a fixed offset:
-
-```typescript
-{
-  action: {
-    type: 'forward',
-    target: {
-      host: 'backend.example.com',
-      port: (context) => context.port + 1000
-    }
-  }
-}
-```
-
-### 2. Domain-Based Port Mapping
-
-Forward to different backend ports based on the domain:
-
-```typescript
-{
-  action: {
-    type: 'forward',
-    target: {
-      host: 'backend.example.com',
-      port: (context) => {
-        switch (context.domain) {
-          case 'api.example.com': return 8001;
-          case 'admin.example.com': return 8002;
-          case 'staging.example.com': return 8003;
-          default: return 8000;
-        }
-      }
-    }
-  }
-}
-```
-
-### 3. Load Balancing with Hash-Based Distribution
-
-Distribute connections across a port range using a deterministic hash function:
-
-```typescript
-{
-  action: {
-    type: 'forward',
-    target: {
-      host: 'backend.example.com',
-      port: (context) => {
-        // Simple hash function to ensure consistent mapping
-        const hostname = context.domain || '';
-        const hash = hostname.split('').reduce((a, b) => a + b.charCodeAt(0), 0);
-        return 8000 + (hash % 10); // Map to ports 8000-8009
-      }
-    }
-  }
-}
-```
-
-## IPv6-Mapped IPv4 Compatibility
-
-SmartProxy automatically handles IPv6-mapped IPv4 addresses for optimal compatibility. When a connection from an IPv4 address (e.g., `192.168.1.1`) arrives as an IPv6-mapped address (`::ffff:192.168.1.1`), the system normalizes these addresses for consistent matching.
-
-This is particularly important when:
-
-1. Matching client IP restrictions in route configurations
-2. Preserving source IP for outgoing connections
-3. Tracking connections and rate limits
-
-No special configuration is needed - the system handles this normalization automatically.
-
-## Dynamic Port Management
-
-SmartProxy allows for runtime port configuration changes without requiring a restart.
-
-### Adding and Removing Ports
-
-```typescript
-// Get the SmartProxy instance
-const proxy = new SmartProxy({ /* config */ });
-
-// Add a new listening port
-await proxy.addListeningPort(8081);
-
-// Remove a listening port
-await proxy.removeListeningPort(8082);
-```
-
-### Runtime Route Updates
-
-```typescript
-// Get current routes
-const currentRoutes = proxy.getRoutes();
-
-// Add new route for the new port
-const newRoute = {
-  name: 'New Dynamic Route',
-  match: {
-    ports: 8081,
-    domains: ['dynamic.example.com']
-  },
-  action: {
-    type: 'forward',
-    target: {
-      host: 'backend.example.com',
-      port: 9000
-    }
-  }
-};
-
-// Update the route configuration
-await proxy.updateRoutes([...currentRoutes, newRoute]);
-
-// Remove routes for a specific port
-const routesWithout8082 = currentRoutes.filter(route => {
-  const ports = proxy.routeManager.expandPortRange(route.match.ports);
-  return !ports.includes(8082);
-});
-await proxy.updateRoutes(routesWithout8082);
-```
-
-## Performance Considerations
-
-### Port Range Expansion
-
-When using large port ranges, SmartProxy uses internal caching to optimize performance. For example, a range like `{ from: 1000, to: 2000 }` is expanded only once and then cached for future use.
-
-### Port Range Validation
-
-The system automatically validates port ranges to ensure:
-
-1. Port numbers are within the valid range (1-65535)
-2. The "from" value is not greater than the "to" value in range specifications
-3. Port ranges do not contain duplicate entries
-
-Invalid port ranges will be logged as warnings and skipped during configuration.
-
-## Configuration Recipes
-
-### Global Port Range
-
-Listen on a large range of ports and forward to the same ports on a backend:
-
-```typescript
-{
-  name: 'Global port range forwarding',
-  match: {
-    ports: [{ from: 8000, to: 9000 }]
-  },
-  action: {
-    type: 'forward',
-    target: {
-      host: 'backend.example.com',
-      port: 'preserve'
-    }
-  }
-}
-```
-
-### Domain-Specific Port Ranges
-
-Different port ranges for different domain groups:
-
-```typescript
-[
-  {
-    name: 'API port range',
-    match: {
-      ports: [{ from: 8000, to: 8099 }]
-    },
-    action: {
-      type: 'forward',
-      target: {
-        host: 'api.backend.example.com',
-        port: 'preserve'
-      }
-    }
-  },
-  {
-    name: 'Admin port range',
-    match: {
-      ports: [{ from: 9000, to: 9099 }]
-    },
-    action: {
-      type: 'forward',
-      target: {
-        host: 'admin.backend.example.com',
-        port: 'preserve'
-      }
-    }
-  }
-]
-```
-
-### Mixed Internal/External Port Forwarding
-
-Forward specific high-numbered ports to standard ports on internal servers:
-
-```typescript
-[
-  {
-    name: 'Web server forwarding',
-    match: {
-      ports: [8080, 8443]
-    },
-    action: {
-      type: 'forward',
-      target: {
-        host: 'web.internal',
-        port: (context) => context.port === 8080 ? 80 : 443
-      }
-    }
-  },
-  {
-    name: 'Database forwarding',
-    match: {
-      ports: [15432]
-    },
-    action: {
-      type: 'forward',
-      target: {
-        host: 'db.internal',
-        port: 5432
-      }
-    }
-  }
-]
-```
-
-## Debugging Port Configurations
-
-When troubleshooting port forwarding issues, enable detailed logging:
-
-```typescript
-const proxy = new SmartProxy({
-  routes: [ /* your routes */ ],
-  enableDetailedLogging: true
-});
-```
-
-This will log:
-- Port configuration during startup
-- Port matching decisions during routing
-- Dynamic port function results
-- Connection details including source and target ports
-
-## Port Security Considerations
-
-### Restricting Ports
-
-For security, you may want to restrict which ports can be accessed by specific clients:
-
-```typescript
-{
-  name: 'Restricted port range',
-  match: {
-    ports: [{ from: 8000, to: 9000 }],
-    clientIp: ['10.0.0.0/8'] // Only internal network can access these ports
-  },
-  action: {
-    type: 'forward',
-    target: {
-      host: 'internal.example.com',
-      port: 'preserve'
-    }
-  }
-}
-```
-
-### Rate Limiting by Port
-
-Apply different rate limits for different port ranges:
-
-```typescript
-{
-  name: 'API ports with rate limiting',
-  match: {
-    ports: [{ from: 8000, to: 8100 }]
-  },
-  action: {
-    type: 'forward',
-    target: {
-      host: 'api.example.com',
-      port: 'preserve'
-    },
-    security: {
-      rateLimit: {
-        enabled: true,
-        maxRequests: 100,
-        window: 60 // 60 seconds
-      }
-    }
-  }
-}
-```
-
-## Best Practices
-
-1. **Use Specific Port Ranges**: Instead of large ranges (e.g., 1-65535), use specific ranges for specific purposes
-
-2. **Prioritize Routes**: When multiple routes could match, use the `priority` field to ensure the most specific route is matched first
-
-3. **Name Your Routes**: Use descriptive names to make debugging easier, especially when using port ranges
-
-4. **Use Preserve Port Where Possible**: Using `port: 'preserve'` is more efficient and easier to maintain than creating multiple specific mappings
-
-5. **Limit Dynamic Port Functions**: While powerful, complex port functions can be harder to debug; prefer simple map or math-based functions
-
-6. **Use Port Variables**: For complex setups, define your port ranges as variables for easier maintenance:
-
-```typescript
-const API_PORTS = [{ from: 8000, to: 8099 }];
-const ADMIN_PORTS = [{ from: 9000, to: 9099 }];
-
-const routes = [
-  {
-    name: 'API Routes',
-    match: { ports: API_PORTS, /* ... */ },
-    // ...
-  },
-  {
-    name: 'Admin Routes',
-    match: { ports: ADMIN_PORTS, /* ... */ },
-    // ...
-  }
-];
-```

examples/dynamic-port-management.ts

@@ -1,130 +0,0 @@
-/**
- * Dynamic Port Management Example
- * 
- * This example demonstrates how to dynamically add and remove ports
- * while SmartProxy is running, without requiring a restart.
- */
-
-import { SmartProxy } from '../dist_ts/index.js';
-
-async function main() {
-  // Create a SmartProxy instance with initial routes
-  const proxy = new SmartProxy({
-    routes: [
-      // Initial route on port 8080
-      {
-        match: { 
-          ports: 8080,
-          domains: ['example.com', '*.example.com']
-        },
-        action: {
-          type: 'forward',
-          target: { host: 'localhost', port: 3000 }
-        },
-        name: 'Initial HTTP Route'
-      }
-    ]
-  });
-
-  // Start the proxy
-  await proxy.start();
-  console.log('SmartProxy started with initial configuration');
-  console.log('Listening on ports:', proxy.getListeningPorts());
-
-  // Wait 3 seconds
-  console.log('Waiting 3 seconds before adding a new port...');
-  await new Promise(resolve => setTimeout(resolve, 3000));
-
-  // Add a new port listener without changing routes yet
-  await proxy.addListeningPort(8081);
-  console.log('Added port 8081 without any routes yet');
-  console.log('Now listening on ports:', proxy.getListeningPorts());
-
-  // Wait 3 more seconds
-  console.log('Waiting 3 seconds before adding a route for the new port...');
-  await new Promise(resolve => setTimeout(resolve, 3000));
-
-  // Get current routes and add a new one for port 8081
-  const currentRoutes = proxy.settings.routes;
-  
-  // Create a new route for port 8081
-  const newRoute = {
-    match: { 
-      ports: 8081,
-      domains: ['api.example.com']
-    },
-    action: {
-      type: 'forward',
-      target: { host: 'localhost', port: 4000 }
-    },
-    name: 'API Route'
-  };
-
-  // Update routes to include the new one
-  await proxy.updateRoutes([...currentRoutes, newRoute]);
-  console.log('Added new route for port 8081');
-
-  // Wait 3 more seconds
-  console.log('Waiting 3 seconds before adding another port through updateRoutes...');
-  await new Promise(resolve => setTimeout(resolve, 3000));
-
-  // Add a completely new port via updateRoutes, which will automatically start listening
-  const thirdRoute = {
-    match: { 
-      ports: 8082,
-      domains: ['admin.example.com']
-    },
-    action: {
-      type: 'forward',
-      target: { host: 'localhost', port: 5000 }
-    },
-    name: 'Admin Route'
-  };
-
-  // Update routes again to include the third route
-  await proxy.updateRoutes([...currentRoutes, newRoute, thirdRoute]);
-  console.log('Added new route for port 8082 through updateRoutes');
-  console.log('Now listening on ports:', proxy.getListeningPorts());
-
-  // Wait 3 more seconds
-  console.log('Waiting 3 seconds before removing port 8081...');
-  await new Promise(resolve => setTimeout(resolve, 3000));
-
-  // Remove a port without changing routes
-  await proxy.removeListeningPort(8081);
-  console.log('Removed port 8081 (but route still exists)');
-  console.log('Now listening on ports:', proxy.getListeningPorts());
-
-  // Wait 3 more seconds
-  console.log('Waiting 3 seconds before stopping all routes on port 8082...');
-  await new Promise(resolve => setTimeout(resolve, 3000));
-
-  // Remove all routes for port 8082
-  const routesWithout8082 = currentRoutes.filter(route => {
-    // Check if this route includes port 8082
-    const ports = proxy.routeManager.expandPortRange(route.match.ports);
-    return !ports.includes(8082);
-  });
-
-  // Update routes without any for port 8082
-  await proxy.updateRoutes([...routesWithout8082, newRoute]);
-  console.log('Removed routes for port 8082 through updateRoutes');
-  console.log('Now listening on ports:', proxy.getListeningPorts());
-
-  // Show statistics
-  console.log('Statistics:', proxy.getStatistics());
-
-  // Wait 3 more seconds, then shut down
-  console.log('Waiting 3 seconds before shutdown...');
-  await new Promise(resolve => setTimeout(resolve, 3000));
-
-  // Stop the proxy
-  await proxy.stop();
-  console.log('SmartProxy stopped');
-}
-
-// Run the example
-main().catch(err => {
-  console.error('Error in example:', err);
-  process.exit(1);
-});

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartproxy",
-  "version": "18.0.0",
+  "version": "19.5.13",
   "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",
@@ -9,24 +9,26 @@
   "author": "Lossless GmbH",
   "license": "MIT",
   "scripts": {
-    "test": "(tstest test/)",
+    "test": "(tstest test/**/test*.ts --verbose --timeout 60 --logfile)",
     "build": "(tsbuild tsfolders --allowimplicitany)",
     "format": "(gitzone format)",
     "buildDocs": "tsdoc"
   },
   "devDependencies": {
-    "@git.zone/tsbuild": "^2.3.2",
+    "@git.zone/tsbuild": "^2.6.4",
     "@git.zone/tsrun": "^1.2.44",
-    "@git.zone/tstest": "^1.0.77",
-    "@push.rocks/tapbundle": "^6.0.3",
-    "@types/node": "^22.15.3",
+    "@git.zone/tstest": "^2.3.1",
+    "@types/node": "^22.15.29",
     "typescript": "^5.8.3"
   },
   "dependencies": {
     "@push.rocks/lik": "^6.2.2",
-    "@push.rocks/smartacme": "^7.3.2",
+    "@push.rocks/smartacme": "^8.0.0",
+    "@push.rocks/smartcrypto": "^2.0.4",
     "@push.rocks/smartdelay": "^3.0.5",
-    "@push.rocks/smartnetwork": "^4.0.1",
+    "@push.rocks/smartfile": "^11.2.5",
+    "@push.rocks/smartlog": "^3.1.8",
+    "@push.rocks/smartnetwork": "^4.0.2",
     "@push.rocks/smartpromise": "^4.2.3",
     "@push.rocks/smartrequest": "^2.1.0",
     "@push.rocks/smartstring": "^4.0.15",

readme.hints.md

@@ -4,6 +4,12 @@
 - Package: `@push.rocks/smartproxy` – high-performance proxy supporting HTTP(S), TCP, WebSocket, and ACME integration.
 - Written in TypeScript, compiled output in `dist_ts/`, uses ESM with NodeNext resolution.
 
+## Important: ACME Configuration in v19.0.0
+- **Breaking Change**: ACME configuration must be placed within individual route TLS settings, not at the top level
+- Route-level ACME config is the ONLY way to enable SmartAcme initialization
+- SmartCertManager requires email in route config for certificate acquisition
+- Top-level ACME configuration is ignored in v19.0.0
+
 ## Repository Structure
 - `ts/` – TypeScript source files:
   - `index.ts` exports main modules.
@@ -24,10 +30,72 @@
 - Test: `pnpm test` (runs `tstest test/`).
 - Format: `pnpm format` (runs `gitzone format`).
 
-## Testing Framework
-- Uses `@push.rocks/tapbundle` (`tap`, `expect`, `expactAsync`).
-- Test files: must start with `test.` and use `.ts` extension.
-- Run specific tests via `tsx`, e.g., `tsx test/test.router.ts`.
+## How to Test
+
+### Test Structure
+Tests use tapbundle from `@git.zone/tstest`. The correct pattern is:
+
+```typescript
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+
+tap.test('test description', async () => {
+  // Test logic here
+  expect(someValue).toEqual(expectedValue);
+});
+
+// IMPORTANT: Must end with tap.start()
+tap.start();
+```
+
+### Expect Syntax (from @push.rocks/smartexpect)
+```typescript
+// Type assertions
+expect('hello').toBeTypeofString();
+expect(42).toBeTypeofNumber();
+
+// Equality
+expect('hithere').toEqual('hithere');
+
+// Negated assertions
+expect(1).not.toBeTypeofString();
+
+// Regular expressions
+expect('hithere').toMatch(/hi/);
+
+// Numeric comparisons
+expect(5).toBeGreaterThan(3);
+expect(0.1 + 0.2).toBeCloseTo(0.3, 10);
+
+// Arrays
+expect([1, 2, 3]).toContain(2);
+expect([1, 2, 3]).toHaveLength(3);
+
+// Async assertions
+await expect(asyncFunction()).resolves.toEqual('expected');
+await expect(asyncFunction()).resolves.withTimeout(5000).toBeTypeofString();
+
+// Complex object navigation
+expect(complexObject)
+  .property('users')
+  .arrayItem(0)
+  .property('name')
+  .toEqual('Alice');
+```
+
+### Test Modifiers
+- `tap.only.test()` - Run only this test
+- `tap.skip.test()` - Skip a test
+- `tap.timeout()` - Set test-specific timeout
+
+### Running Tests
+- All tests: `pnpm test`
+- Specific test: `tsx test/test.router.ts`
+- With options: `tstest test/**/*.ts --verbose --timeout 60`
+
+### Test File Requirements
+- Must start with `test.` prefix
+- Must use `.ts` extension
+- Must call `tap.start()` at the end
 
 ## Coding Conventions
 - Import modules via `plugins.ts`:
@@ -57,8 +125,343 @@
 - CLI entrypoint (`cli.js`) supports command-line usage (ACME, proxy controls).
 - ACME and certificate handling via `Port80Handler` and `helpers.certificates.ts`.
 
+## ACME/Certificate Configuration Example (v19.0.0)
+```typescript
+const proxy = new SmartProxy({
+  routes: [{
+    name: 'example.com',
+    match: { domains: 'example.com', ports: 443 },
+    action: {
+      type: 'forward',
+      target: { host: 'localhost', port: 8080 },
+      tls: {
+        mode: 'terminate',
+        certificate: 'auto',
+        acme: {  // ACME config MUST be here, not at top level
+          email: 'ssl@example.com',
+          useProduction: false,
+          challengePort: 80
+        }
+      }
+    }
+  }]
+});
+```
+
 ## TODOs / Considerations
 - Ensure import extensions in source match build outputs (`.ts` vs `.js`).
 - Update `plugins.ts` when adding new dependencies.
 - Maintain test coverage for new routing or proxy features.
-- Keep `ts/` and `dist_ts/` in sync after refactors.
+- Keep `ts/` and `dist_ts/` in sync after refactors.
+- Consider implementing top-level ACME config support for backward compatibility
+
+## HTTP-01 ACME Challenge Fix (v19.3.8)
+
+### Issue
+Non-TLS connections on ports configured in `useHttpProxy` were not being forwarded to HttpProxy. This caused ACME HTTP-01 challenges to fail when the ACME port (usually 80) was included in `useHttpProxy`.
+
+### Root Cause
+In the `RouteConnectionHandler.handleForwardAction` method, only connections with TLS settings (mode: 'terminate' or 'terminate-and-reencrypt') were being forwarded to HttpProxy. Non-TLS connections were always handled as direct connections, even when the port was configured for HttpProxy.
+
+### Solution
+Added a check for non-TLS connections on ports listed in `useHttpProxy`:
+```typescript
+// No TLS settings - check if this port should use HttpProxy
+const isHttpProxyPort = this.settings.useHttpProxy?.includes(record.localPort);
+
+if (isHttpProxyPort && this.httpProxyBridge.getHttpProxy()) {
+  // Forward non-TLS connections to HttpProxy if configured
+  this.httpProxyBridge.forwardToHttpProxy(/*...*/);
+  return;
+}
+```
+
+### Test Coverage
+- `test/test.http-fix-unit.ts` - Unit tests verifying the fix
+- Tests confirm that non-TLS connections on HttpProxy ports are properly forwarded
+- Tests verify that non-HttpProxy ports still use direct connections
+
+### Configuration Example
+```typescript
+const proxy = new SmartProxy({
+  useHttpProxy: [80], // Enable HttpProxy for port 80
+  httpProxyPort: 8443,
+  acme: {
+    email: 'ssl@example.com',
+    port: 80
+  },
+  routes: [
+    // Your routes here
+  ]
+});
+```
+
+## ACME Certificate Provisioning Timing Fix (v19.3.9)
+
+### Issue
+Certificate provisioning would start before ports were listening, causing ACME HTTP-01 challenges to fail with connection refused errors.
+
+### Root Cause
+SmartProxy initialization sequence:
+1. Certificate manager initialized → immediately starts provisioning
+2. Ports start listening (too late for ACME challenges)
+
+### Solution
+Deferred certificate provisioning until after ports are ready:
+```typescript
+// SmartCertManager.initialize() now skips automatic provisioning
+// SmartProxy.start() calls provisionAllCertificates() directly after ports are listening
+```
+
+### Test Coverage
+- `test/test.acme-timing-simple.ts` - Verifies proper timing sequence
+
+### Migration
+Update to v19.3.9+, no configuration changes needed.
+
+## Socket Handler Race Condition Fix (v19.5.0)
+
+### Issue
+Initial data chunks were being emitted before async socket handlers had completed setup, causing data loss when handlers performed async operations before setting up data listeners.
+
+### Root Cause
+The `handleSocketHandlerAction` method was using `process.nextTick` to emit initial chunks regardless of whether the handler was sync or async. This created a race condition where async handlers might not have their listeners ready when the initial data was emitted.
+
+### Solution
+Differentiated between sync and async handlers:
+```typescript
+const result = route.action.socketHandler(socket);
+
+if (result instanceof Promise) {
+  // Async handler - wait for completion before emitting initial data
+  result.then(() => {
+    if (initialChunk && initialChunk.length > 0) {
+      socket.emit('data', initialChunk);
+    }
+  }).catch(/*...*/);
+} else {
+  // Sync handler - use process.nextTick as before
+  if (initialChunk && initialChunk.length > 0) {
+    process.nextTick(() => {
+      socket.emit('data', initialChunk);
+    });
+  }
+}
+```
+
+### Test Coverage
+- `test/test.socket-handler-race.ts` - Specifically tests async handlers with delayed listener setup
+- Verifies that initial data is received even when handler sets up listeners after async work
+
+### Usage Note
+Socket handlers require initial data from the client to trigger routing (not just a TLS handshake). Clients must send at least one byte of data for the handler to be invoked.
+
+## Route-Specific Security Implementation (v19.5.3)
+
+### Issue
+Route-specific security configurations (ipAllowList, ipBlockList, authentication) were defined in the route types but not enforced at runtime.
+
+### Root Cause
+The RouteConnectionHandler only checked global IP validation but didn't enforce route-specific security rules after matching a route.
+
+### Solution
+Added security checks after route matching:
+```typescript
+// Apply route-specific security checks
+const routeSecurity = route.action.security || route.security;
+if (routeSecurity) {
+  // Check IP allow/block lists
+  if (routeSecurity.ipAllowList || routeSecurity.ipBlockList) {
+    const isIPAllowed = this.securityManager.isIPAuthorized(
+      remoteIP,
+      routeSecurity.ipAllowList || [],
+      routeSecurity.ipBlockList || []
+    );
+    
+    if (!isIPAllowed) {
+      socket.end();
+      this.connectionManager.cleanupConnection(record, 'route_ip_blocked');
+      return;
+    }
+  }
+}
+```
+
+### Test Coverage
+- `test/test.route-security-unit.ts` - Unit tests verifying SecurityManager.isIPAuthorized logic
+- Tests confirm IP allow/block lists work correctly with glob patterns
+
+### Configuration Example
+```typescript
+const routes: IRouteConfig[] = [{
+  name: 'secure-api',
+  match: { ports: 8443, domains: 'api.example.com' },
+  action: {
+    type: 'forward',
+    target: { host: 'localhost', port: 3000 },
+    security: {
+      ipAllowList: ['192.168.1.*', '10.0.0.0/8'],    // Allow internal IPs
+      ipBlockList: ['192.168.1.100'],                // But block specific IP
+      maxConnections: 100,                            // Per-route limit (TODO)
+      authentication: {                               // HTTP-only, requires TLS termination
+        type: 'basic',
+        credentials: [{ username: 'api', password: 'secret' }]
+      }
+    }
+  }
+}];
+```
+
+### Notes
+- IP lists support glob patterns (via minimatch): `192.168.*`, `10.?.?.1`
+- Block lists take precedence over allow lists
+- Authentication requires TLS termination (cannot be enforced on passthrough/direct connections)
+- Per-route connection limits are not yet implemented
+- Security is defined at the route level (route.security), not in the action
+- Route matching is based solely on match criteria; security is enforced after matching
+
+## Performance Issues Investigation (v19.5.3+)
+
+### Critical Blocking Operations Found
+1. **Busy Wait Loop** in `ts/proxies/nftables-proxy/nftables-proxy.ts:235-238`
+   - Blocks entire event loop with `while (Date.now() < waitUntil) {}`
+   - Should use `await new Promise(resolve => setTimeout(resolve, delay))`
+
+2. **Synchronous Filesystem Operations**
+   - Certificate management uses `fs.existsSync()`, `fs.mkdirSync()`, `fs.readFileSync()`
+   - NFTables proxy uses `execSync()` for system commands
+   - Certificate store uses `ensureDirSync()`, `fileExistsSync()`, `removeManySync()`
+
+3. **Memory Leak Risks**
+   - Several `setInterval()` calls without storing references for cleanup
+   - Event listeners added without proper cleanup in error paths
+   - Missing `removeAllListeners()` calls in some connection cleanup scenarios
+
+### Performance Recommendations
+- Replace all sync filesystem operations with async alternatives
+- Fix the busy wait loop immediately (critical event loop blocker)
+- Add proper cleanup for all timers and event listeners
+- Consider worker threads for CPU-intensive operations
+- See `readme.problems.md` for detailed analysis and recommendations
+
+## Performance Optimizations Implemented (Phase 1 - v19.6.0)
+
+### 1. Async Utilities Created (`ts/core/utils/async-utils.ts`)
+- **delay()**: Non-blocking alternative to busy wait loops
+- **retryWithBackoff()**: Retry operations with exponential backoff
+- **withTimeout()**: Execute operations with timeout protection
+- **parallelLimit()**: Run async operations with concurrency control
+- **debounceAsync()**: Debounce async functions
+- **AsyncMutex**: Ensure exclusive access to resources
+- **CircuitBreaker**: Protect against cascading failures
+
+### 2. Filesystem Utilities Created (`ts/core/utils/fs-utils.ts`)
+- **AsyncFileSystem**: Complete async filesystem operations
+  - exists(), ensureDir(), readFile(), writeFile()
+  - readJSON(), writeJSON() with proper error handling
+  - copyFile(), moveFile(), removeDir()
+  - Stream creation and file listing utilities
+
+### 3. Critical Fixes Applied
+
+#### Busy Wait Loop Fixed
+- **Location**: `ts/proxies/nftables-proxy/nftables-proxy.ts:235-238`
+- **Fix**: Replaced `while (Date.now() < waitUntil) {}` with `await delay(ms)`
+- **Impact**: Unblocks event loop, massive performance improvement
+
+#### Certificate Manager Migration
+- **File**: `ts/proxies/http-proxy/certificate-manager.ts`
+- Added async initialization method
+- Kept sync methods for backward compatibility with deprecation warnings
+- Added `loadDefaultCertificatesAsync()` method
+
+#### Certificate Store Migration  
+- **File**: `ts/proxies/smart-proxy/cert-store.ts`
+- Replaced all `fileExistsSync`, `ensureDirSync`, `removeManySync`
+- Used parallel operations with `Promise.all()` for better performance
+- Improved error handling and async JSON operations
+
+#### NFTables Proxy Improvements
+- Added deprecation warnings to sync methods
+- Created `executeWithTempFile()` helper for common pattern
+- Started migration of sync filesystem operations to async
+- Added import for delay and AsyncFileSystem utilities
+
+### 4. Backward Compatibility Maintained
+- All sync methods retained with deprecation warnings
+- Existing APIs unchanged, new async methods added alongside
+- Feature flags prepared for gradual rollout
+
+### 5. Phase 1 Completion Status
+✅ **Phase 1 COMPLETE** - All critical performance fixes have been implemented:
+- ✅ Fixed busy wait loop in nftables-proxy.ts  
+- ✅ Created async utilities (delay, retry, timeout, parallelLimit, mutex, circuit breaker)
+- ✅ Created filesystem utilities (AsyncFileSystem with full async operations)
+- ✅ Migrated all certificate management to async operations
+- ✅ Migrated nftables-proxy filesystem operations to async (except stopSync for exit handlers)
+- ✅ All tests passing for new utilities
+
+### 6. Phase 2 Progress Status
+🔨 **Phase 2 IN PROGRESS** - Resource Lifecycle Management:
+- ✅ Created LifecycleComponent base class for automatic resource cleanup
+- ✅ Created BinaryHeap data structure for priority queue operations
+- ✅ Created EnhancedConnectionPool with backpressure and health checks
+- ✅ Cleaned up legacy code (removed ts/common/, event-utils.ts, event-system.ts)
+- 📋 TODO: Migrate existing components to extend LifecycleComponent
+- 📋 TODO: Add integration tests for resource management
+
+### 7. Next Steps (Remaining Work)
+- **Phase 2 (cont)**: Migrate components to use LifecycleComponent
+- **Phase 3**: Add worker threads for CPU-intensive operations  
+- **Phase 4**: Performance monitoring dashboard
+
+## Socket Error Handling Fix (v19.5.11+)
+
+### Issue
+Server crashed with unhandled 'error' event when backend connections failed (ECONNREFUSED). Also caused memory leak with rising active connection count as failed connections weren't cleaned up properly.
+
+### Root Cause
+1. **Race Condition**: In forwarding handlers, sockets were created with `net.connect()` but error handlers were attached later, creating a window where errors could crash the server
+2. **Incomplete Cleanup**: When server connections failed, client sockets weren't properly cleaned up, leaving connection records in memory
+
+### Solution
+Created `createSocketWithErrorHandler()` utility that attaches error handlers immediately:
+```typescript
+// Before (race condition):
+const socket = net.connect(port, host);
+// ... other code ...
+socket.on('error', handler); // Too late!
+
+// After (safe):
+const socket = createSocketWithErrorHandler({
+  port, host,
+  onError: (error) => {
+    // Handle error immediately
+    clientSocket.destroy();
+  },
+  onConnect: () => {
+    // Set up forwarding
+  }
+});
+```
+
+### Changes Made
+1. **New Utility**: `ts/core/utils/socket-utils.ts` - Added `createSocketWithErrorHandler()`
+2. **Updated Handlers**:
+   - `https-passthrough-handler.ts` - Uses safe socket creation
+   - `https-terminate-to-http-handler.ts` - Uses safe socket creation
+3. **Connection Cleanup**: Client sockets destroyed immediately on server connection failure
+
+### Test Coverage
+- `test/test.socket-error-handling.node.ts` - Verifies server doesn't crash on ECONNREFUSED
+- `test/test.forwarding-error-fix.node.ts` - Tests forwarding handlers handle errors gracefully
+
+### Configuration
+No configuration changes needed. The fix is transparent to users.
+
+### Important Note
+The fix was applied in two places:
+1. **ForwardingHandler classes** (`https-passthrough-handler.ts`, etc.) - These are standalone forwarding utilities
+2. **SmartProxy route-connection-handler** (`route-connection-handler.ts`) - This is where the actual SmartProxy connection handling happens
+
+The critical fix for SmartProxy was in `setupDirectConnection()` method in route-connection-handler.ts, which now uses `createSocketWithErrorHandler()` to properly handle connection failures and clean up connection records.

readme.plan.md

@@ -1,146 +1,165 @@
-# SmartProxy Interface Consolidation Plan
+# SmartProxy Socket Handling Fix Plan
 
-## Overview
+Reread CLAUDE.md file for guidelines
 
-This document outlines a plan to consolidate duplicate and inconsistent interfaces in the SmartProxy codebase, specifically the `IRouteSecurity` interface which is defined twice with different properties. This inconsistency caused issues with security checks for port forwarding. The goal is to unify these interfaces, use consistent property naming, and improve code maintainability.
+## Implementation Summary (COMPLETED)
 
-## Problem Description
+The critical socket handling issues have been fixed:
 
-We currently have two separate `IRouteSecurity` interfaces defined in `ts/proxies/smart-proxy/models/route-types.ts`:
+1. **Prevented Server Crashes**: Created `createSocketWithErrorHandler()` utility that attaches error handlers immediately upon socket creation, preventing unhandled ECONNREFUSED errors from crashing the server.
 
-1. **First definition** (lines 116-122) - Used in IRouteAction:
-   ```typescript
-   export interface IRouteSecurity {
-     allowedIps?: string[];
-     blockedIps?: string[];
-     maxConnections?: number;
-     authentication?: IRouteAuthentication;
-   }
-   ```
+2. **Fixed Memory Leaks**: Updated forwarding handlers to properly clean up client sockets when server connections fail, ensuring connection records are removed from tracking.
 
-2. **Second definition** (lines 253-272) - Used directly in IRouteConfig:
-   ```typescript
-   export interface IRouteSecurity {
-     rateLimit?: IRouteRateLimit;
-     basicAuth?: {...};
-     jwtAuth?: {...};
-     ipAllowList?: string[];
-     ipBlockList?: string[];
-   }
-   ```
+3. **Key Changes Made**:
+   - Added `createSocketWithErrorHandler()` in `socket-utils.ts`
+   - Updated `https-passthrough-handler.ts` to use safe socket creation
+   - Updated `https-terminate-to-http-handler.ts` to use safe socket creation
+   - Ensured client sockets are destroyed when server connections fail
+   - Connection cleanup now triggered by socket close events
 
-This duplication with inconsistent naming (`allowedIps` vs `ipAllowList` and `blockedIps` vs `ipBlockList`) caused routing issues when IP security checks were used, as we had to implement a workaround to check both property names.
+4. **Test Results**: Server no longer crashes on ECONNREFUSED errors, and connections are properly cleaned up.
+
+## Problem Summary
+
+The SmartProxy server is experiencing critical issues:
+1. **Server crashes** due to unhandled socket connection errors (ECONNREFUSED)
+2. **Memory leak** with steadily rising active connection count
+3. **Race conditions** between socket creation and error handler attachment
+4. **Orphaned sockets** when server connections fail
+
+## Root Causes
+
+### 1. Delayed Error Handler Attachment
+- Sockets created without immediate error handlers
+- Error events can fire before handlers attached
+- Causes uncaught exceptions and server crashes
+
+### 2. Incomplete Cleanup Logic
+- Client sockets not cleaned up when server connection fails
+- Connection counter only decrements after BOTH sockets close
+- Failed server connections leave orphaned client sockets
+
+### 3. Missing Global Error Handlers
+- No process-level uncaughtException handler
+- No process-level unhandledRejection handler
+- Any unhandled error crashes entire server
 
 ## Implementation Plan
 
-### Phase 1: Interface Consolidation
+### Phase 1: Prevent Server Crashes (Critical)
 
-1. **Create a unified interface definition:**
-   - Create one comprehensive `IRouteSecurity` interface that includes all properties
-   - Use consistent property naming (standardize on `ipAllowList` and `ipBlockList`)
-   - Add proper documentation for each property
-   - Remove the duplicate interface definition
-   
-2. **Update references to use the unified interface:**
-   - Update all code that references the old interface properties
-   - Update all configurations to use the new property names
-   - Ensure implementation in `route-manager.ts` uses the correct property names
+#### 1.1 Add Global Error Handlers
+- [x] ~~Add global error handlers in main entry point~~ (Removed per user request - no global handlers)
+- [x] Log errors with context
+- [x] ~~Implement graceful shutdown sequence~~ (Removed - handled locally)
 
-### Phase 2: Code and Documentation Updates
+#### 1.2 Fix Socket Creation Race Condition
+- [x] Modify socket creation to attach error handlers immediately
+- [x] Update all forwarding handlers (https-passthrough, http, etc.)
+- [x] Ensure error handlers attached in same tick as socket creation
 
-1. **Update type usages and documentation:**
-   - Update all code that creates or uses security configurations
-   - Update documentation to reflect the new interface structure
-   - Add examples of the correct property usage
-   - Document the breaking change in changelog.md
+### Phase 2: Fix Memory Leaks (High Priority)
 
-2. **Add tests:**
-   - Update existing tests to use the new property names
-   - Add test cases for all security configuration scenarios
-   - Verify that port range configurations with security settings work correctly
+#### 2.1 Fix Connection Cleanup Logic
+- [x] Clean up client socket immediately if server connection fails
+- [x] Decrement connection counter on any socket failure (handled by socket close events)
+- [x] Implement proper cleanup for half-open connections
 
-## Implementation Steps
+#### 2.2 Improve Socket Utils
+- [x] Create new utility function for safe socket creation with immediate error handling
+- [x] Update createIndependentSocketHandlers to handle immediate failures
+- [ ] Add connection tracking debug utilities
 
+### Phase 3: Comprehensive Testing (Important)
+
+#### 3.1 Create Test Cases
+- [x] Test ECONNREFUSED scenario
+- [ ] Test timeout handling
+- [ ] Test half-open connections
+- [ ] Test rapid connect/disconnect cycles
+
+#### 3.2 Add Monitoring
+- [ ] Add connection leak detection
+- [ ] Add metrics for connection lifecycle
+- [ ] Add debug logging for socket state transitions
+
+## Detailed Implementation Steps
+
+### Step 1: Global Error Handlers (ts/proxies/smart-proxy/smart-proxy.ts)
 ```typescript
-// Step 1: Define the unified interface
-export interface IRouteSecurity {
-  // Access control lists
-  ipAllowList?: string[];        // IP addresses that are allowed to connect
-  ipBlockList?: string[];        // IP addresses that are blocked from connecting
-  
-  // Connection limits
-  maxConnections?: number;       // Maximum concurrent connections
-  
-  // Authentication
-  authentication?: IRouteAuthentication;
-  
-  // Rate limiting
-  rateLimit?: IRouteRateLimit;
-  
-  // Authentication methods
-  basicAuth?: {
-    enabled: boolean;
-    users: Array<{ username: string; password: string }>;
-    realm?: string;
-    excludePaths?: string[];
-  };
-  
-  jwtAuth?: {
-    enabled: boolean;
-    secret: string;
-    algorithm?: string;
-    issuer?: string;
-    audience?: string;
-    expiresIn?: number;
-    excludePaths?: string[];
-  };
+// Add in constructor or start method
+process.on('uncaughtException', (error) => {
+  logger.log('error', 'Uncaught exception', { error });
+  // Graceful shutdown
+});
+
+process.on('unhandledRejection', (reason, promise) => {
+  logger.log('error', 'Unhandled rejection', { reason, promise });
+});
+```
+
+### Step 2: Safe Socket Creation Utility (ts/core/utils/socket-utils.ts)
+```typescript
+export function createSocketWithErrorHandler(
+  options: net.NetConnectOpts,
+  onError: (err: Error) => void
+): net.Socket {
+  const socket = net.connect(options);
+  socket.on('error', onError);
+  return socket;
 }
 ```
 
-Update `isClientIpAllowed` method to use only the new property names:
+### Step 3: Fix HttpsPassthroughHandler (ts/forwarding/handlers/https-passthrough-handler.ts)
+- Replace direct socket creation with safe creation
+- Handle server connection failures immediately
+- Clean up client socket on server connection failure
 
-```typescript
-private isClientIpAllowed(route: IRouteConfig, clientIp: string): boolean {
-  const security = route.action.security;
-  
-  if (!security) {
-    return true; // No security settings means allowed
-  }
-  
-  // Check blocked IPs first
-  if (security.ipBlockList && security.ipBlockList.length > 0) {
-    for (const pattern of security.ipBlockList) {
-      if (this.matchIpPattern(pattern, clientIp)) {
-        return false; // IP is blocked
-      }
-    }
-  }
-  
-  // If there are allowed IPs, check them
-  if (security.ipAllowList && security.ipAllowList.length > 0) {
-    for (const pattern of security.ipAllowList) {
-      if (this.matchIpPattern(pattern, clientIp)) {
-        return true; // IP is allowed
-      }
-    }
-    return false; // IP not in allowed list
-  }
-  
-  // No allowed IPs specified, so IP is allowed
-  return true;
-}
-```
+### Step 4: Fix Connection Counting
+- Decrement on ANY socket close, not just when both close
+- Track failed connections separately
+- Add connection state tracking
 
-## Expected Benefits
+### Step 5: Update All Handlers
+- [ ] https-passthrough-handler.ts
+- [ ] http-handler.ts
+- [ ] https-terminate-to-http-handler.ts
+- [ ] https-terminate-to-https-handler.ts
+- [ ] route-connection-handler.ts
 
-- **Improved Consistency**: Single, unified interface with consistent property naming
-- **Better Type Safety**: Eliminating confusing duplicate interface definitions
-- **Reduced Errors**: Prevent misunderstandings about which property names to use
-- **Forward Compatibility**: Clearer path for future security enhancements
-- **Better Developer Experience**: Simplified interface with comprehensive documentation
+## Success Criteria
+
+1. **No server crashes** on ECONNREFUSED or other socket errors
+2. **Active connections** remain stable (no steady increase)
+3. **All sockets** properly cleaned up on errors
+4. **Memory usage** remains stable under load
+5. **Graceful handling** of all error scenarios
 
 ## Testing Plan
 
-1. Test with existing configurations using both old and new property names
-2. Create specific test cases for port ranges with different security configurations
-3. Verify that port forwarding with IP allow lists works correctly with the unified interface
+1. Simulate ECONNREFUSED by targeting closed ports
+2. Monitor active connection count over time
+3. Stress test with rapid connections
+4. Test with unreachable hosts
+5. Test with slow/timing out connections
+
+## Rollback Plan
+
+If issues arise:
+1. Revert socket creation changes
+2. Keep global error handlers (they add safety)
+3. Add more detailed logging for debugging
+4. Implement fixes incrementally
+
+## Timeline
+
+- Phase 1: Immediate (prevents crashes)
+- Phase 2: Within 24 hours (fixes leaks)
+- Phase 3: Within 48 hours (ensures stability)
+
+## Notes
+
+- The race condition is the most critical issue
+- Connection counting logic needs complete overhaul
+- Consider using a connection state machine for clarity
+- Add connection lifecycle events for debugging

readme.problems.md

@@ -0,0 +1,170 @@
+# SmartProxy Performance Issues Report
+
+## Executive Summary
+This report identifies performance issues and blocking operations in the SmartProxy codebase that could impact scalability and responsiveness under high load.
+
+## Critical Issues
+
+### 1. **Synchronous Filesystem Operations**
+These operations block the event loop and should be replaced with async alternatives:
+
+#### Certificate Management
+- `ts/proxies/http-proxy/certificate-manager.ts:29`: `fs.existsSync()` 
+- `ts/proxies/http-proxy/certificate-manager.ts:30`: `fs.mkdirSync()`
+- `ts/proxies/http-proxy/certificate-manager.ts:49-50`: `fs.readFileSync()` for loading certificates
+
+#### NFTables Proxy
+- `ts/proxies/nftables-proxy/nftables-proxy.ts`: Multiple uses of `execSync()` for system commands
+- `ts/proxies/nftables-proxy/nftables-proxy.ts`: Multiple `fs.writeFileSync()` and `fs.unlinkSync()` operations
+
+#### Certificate Store
+- `ts/proxies/smart-proxy/cert-store.ts:8`: `ensureDirSync()`
+- `ts/proxies/smart-proxy/cert-store.ts:15,31,76`: `fileExistsSync()`
+- `ts/proxies/smart-proxy/cert-store.ts:77`: `removeManySync()`
+
+### 2. **Event Loop Blocking Operations**
+
+#### Busy Wait Loop
+- `ts/proxies/nftables-proxy/nftables-proxy.ts:235-238`: 
+  ```typescript
+  const waitUntil = Date.now() + retryDelayMs;
+  while (Date.now() < waitUntil) {
+    // busy wait - blocks event loop completely
+  }
+  ```
+  This is extremely problematic as it blocks the entire Node.js event loop.
+
+### 3. **Potential Memory Leaks**
+
+#### Timer Management Issues
+Several timers are created without proper cleanup:
+- `ts/proxies/http-proxy/function-cache.ts`: `setInterval()` without storing reference for cleanup
+- `ts/proxies/http-proxy/request-handler.ts`: `setInterval()` for rate limit cleanup without cleanup
+- `ts/core/utils/shared-security-manager.ts`: `cleanupInterval` stored but no cleanup method
+
+#### Event Listener Accumulation
+- Multiple instances of event listeners being added without corresponding cleanup
+- Connection handlers add listeners without always removing them on connection close
+
+### 4. **Connection Pool Management**
+
+#### ConnectionPool (ts/proxies/http-proxy/connection-pool.ts)
+**Good practices observed:**
+- Proper connection lifecycle management
+- Periodic cleanup of idle connections
+- Connection limits enforcement
+
+**Potential issues:**
+- No backpressure mechanism when pool is full
+- Synchronous sorting operation in `cleanupConnectionPool()` could be slow with many connections
+
+### 5. **Resource Management Issues**
+
+#### Socket Cleanup
+- Some error paths don't properly clean up sockets
+- Missing `removeAllListeners()` in some error scenarios could lead to memory leaks
+
+#### Timeout Management
+- Inconsistent timeout handling across different components
+- Some sockets created without timeout settings
+
+### 6. **JSON Operations on Large Objects**
+- `ts/proxies/smart-proxy/cert-store.ts:21`: `JSON.parse()` on certificate metadata
+- `ts/proxies/smart-proxy/cert-store.ts:71`: `JSON.stringify()` with pretty printing
+- `ts/proxies/http-proxy/function-cache.ts:76`: `JSON.stringify()` for cache keys (called frequently)
+
+## Recommendations
+
+### Immediate Actions (High Priority)
+
+1. **Replace Synchronous Operations**
+   ```typescript
+   // Instead of:
+   if (fs.existsSync(path)) { ... }
+   
+   // Use:
+   try {
+     await fs.promises.access(path);
+     // file exists
+   } catch {
+     // file doesn't exist
+   }
+   ```
+
+2. **Fix Busy Wait Loop**
+   ```typescript
+   // Instead of:
+   while (Date.now() < waitUntil) { }
+   
+   // Use:
+   await new Promise(resolve => setTimeout(resolve, retryDelayMs));
+   ```
+
+3. **Add Timer Cleanup**
+   ```typescript
+   class Component {
+     private cleanupTimer?: NodeJS.Timeout;
+     
+     start() {
+       this.cleanupTimer = setInterval(() => { ... }, 60000);
+     }
+     
+     stop() {
+       if (this.cleanupTimer) {
+         clearInterval(this.cleanupTimer);
+         this.cleanupTimer = undefined;
+       }
+     }
+   }
+   ```
+
+### Medium Priority
+
+1. **Optimize JSON Operations**
+   - Cache JSON.stringify results for frequently used objects
+   - Consider using faster hashing for cache keys (e.g., crypto.createHash)
+   - Use streaming JSON parsers for large objects
+
+2. **Improve Connection Pool**
+   - Implement backpressure/queueing when pool is full
+   - Use a heap or priority queue for connection management instead of sorting
+
+3. **Standardize Resource Cleanup**
+   - Create a base class for components with lifecycle management
+   - Ensure all event listeners are removed on cleanup
+   - Add abort controllers for better cancellation support
+
+### Long-term Improvements
+
+1. **Worker Threads**
+   - Move CPU-intensive operations to worker threads
+   - Consider using worker pools for NFTables operations
+
+2. **Monitoring and Metrics**
+   - Add performance monitoring for event loop lag
+   - Track connection pool utilization
+   - Monitor memory usage patterns
+
+3. **Graceful Degradation**
+   - Implement circuit breakers for backend connections
+   - Add request queuing with overflow protection
+   - Implement adaptive timeout strategies
+
+## Impact Assessment
+
+These issues primarily affect:
+- **Scalability**: Blocking operations limit concurrent connection handling
+- **Responsiveness**: Event loop blocking causes latency spikes
+- **Stability**: Memory leaks could cause crashes under sustained load
+- **Resource Usage**: Inefficient resource management increases memory/CPU usage
+
+## Testing Recommendations
+
+1. Load test with high connection counts (10k+ concurrent)
+2. Monitor event loop lag under stress
+3. Test long-running scenarios to detect memory leaks
+4. Benchmark with async vs sync operations to measure improvement
+
+## Conclusion
+
+While SmartProxy has good architectural design and many best practices, the identified blocking operations and resource management issues could significantly impact performance under high load. The most critical issues (busy wait loop and synchronous filesystem operations) should be addressed immediately.

test/core/utils/test.async-utils.ts

@@ -0,0 +1,200 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import { 
+  delay, 
+  retryWithBackoff, 
+  withTimeout, 
+  parallelLimit,
+  debounceAsync,
+  AsyncMutex,
+  CircuitBreaker
+} from '../../../ts/core/utils/async-utils.js';
+
+tap.test('delay should pause execution for specified milliseconds', async () => {
+  const startTime = Date.now();
+  await delay(100);
+  const elapsed = Date.now() - startTime;
+  
+  // Allow some tolerance for timing
+  expect(elapsed).toBeGreaterThan(90);
+  expect(elapsed).toBeLessThan(150);
+});
+
+tap.test('retryWithBackoff should retry failed operations', async () => {
+  let attempts = 0;
+  const operation = async () => {
+    attempts++;
+    if (attempts < 3) {
+      throw new Error('Test error');
+    }
+    return 'success';
+  };
+  
+  const result = await retryWithBackoff(operation, {
+    maxAttempts: 3,
+    initialDelay: 10
+  });
+  
+  expect(result).toEqual('success');
+  expect(attempts).toEqual(3);
+});
+
+tap.test('retryWithBackoff should throw after max attempts', async () => {
+  let attempts = 0;
+  const operation = async () => {
+    attempts++;
+    throw new Error('Always fails');
+  };
+  
+  let error: Error | null = null;
+  try {
+    await retryWithBackoff(operation, {
+      maxAttempts: 2,
+      initialDelay: 10
+    });
+  } catch (e: any) {
+    error = e;
+  }
+  
+  expect(error).not.toBeNull();
+  expect(error?.message).toEqual('Always fails');
+  expect(attempts).toEqual(2);
+});
+
+tap.test('withTimeout should complete operations within timeout', async () => {
+  const operation = async () => {
+    await delay(50);
+    return 'completed';
+  };
+  
+  const result = await withTimeout(operation, 100);
+  expect(result).toEqual('completed');
+});
+
+tap.test('withTimeout should throw on timeout', async () => {
+  const operation = async () => {
+    await delay(200);
+    return 'never happens';
+  };
+  
+  let error: Error | null = null;
+  try {
+    await withTimeout(operation, 50);
+  } catch (e: any) {
+    error = e;
+  }
+  
+  expect(error).not.toBeNull();
+  expect(error?.message).toContain('timed out');
+});
+
+tap.test('parallelLimit should respect concurrency limit', async () => {
+  let concurrent = 0;
+  let maxConcurrent = 0;
+  
+  const items = [1, 2, 3, 4, 5, 6];
+  const operation = async (item: number) => {
+    concurrent++;
+    maxConcurrent = Math.max(maxConcurrent, concurrent);
+    await delay(50);
+    concurrent--;
+    return item * 2;
+  };
+  
+  const results = await parallelLimit(items, operation, 2);
+  
+  expect(results).toEqual([2, 4, 6, 8, 10, 12]);
+  expect(maxConcurrent).toBeLessThan(3);
+  expect(maxConcurrent).toBeGreaterThan(0);
+});
+
+tap.test('debounceAsync should debounce function calls', async () => {
+  let callCount = 0;
+  const fn = async (value: string) => {
+    callCount++;
+    return value;
+  };
+  
+  const debounced = debounceAsync(fn, 50);
+  
+  // Make multiple calls quickly
+  debounced('a');
+  debounced('b');
+  debounced('c');
+  const result = await debounced('d');
+  
+  // Wait a bit to ensure no more calls
+  await delay(100);
+  
+  expect(result).toEqual('d');
+  expect(callCount).toEqual(1); // Only the last call should execute
+});
+
+tap.test('AsyncMutex should ensure exclusive access', async () => {
+  const mutex = new AsyncMutex();
+  const results: number[] = [];
+  
+  const operation = async (value: number) => {
+    await mutex.runExclusive(async () => {
+      results.push(value);
+      await delay(10);
+      results.push(value * 10);
+    });
+  };
+  
+  // Run operations concurrently
+  await Promise.all([
+    operation(1),
+    operation(2),
+    operation(3)
+  ]);
+  
+  // Results should show sequential execution
+  expect(results).toEqual([1, 10, 2, 20, 3, 30]);
+});
+
+tap.test('CircuitBreaker should open after failures', async () => {
+  const breaker = new CircuitBreaker({
+    failureThreshold: 2,
+    resetTimeout: 100
+  });
+  
+  let attempt = 0;
+  const failingOperation = async () => {
+    attempt++;
+    throw new Error('Test failure');
+  };
+  
+  // First two failures
+  for (let i = 0; i < 2; i++) {
+    try {
+      await breaker.execute(failingOperation);
+    } catch (e) {
+      // Expected
+    }
+  }
+  
+  expect(breaker.isOpen()).toBeTrue();
+  
+  // Next attempt should fail immediately
+  let error: Error | null = null;
+  try {
+    await breaker.execute(failingOperation);
+  } catch (e: any) {
+    error = e;
+  }
+  
+  expect(error?.message).toEqual('Circuit breaker is open');
+  expect(attempt).toEqual(2); // Operation not called when circuit is open
+  
+  // Wait for reset timeout
+  await delay(150);
+  
+  // Circuit should be half-open now, allowing one attempt
+  const successOperation = async () => 'success';
+  const result = await breaker.execute(successOperation);
+  
+  expect(result).toEqual('success');
+  expect(breaker.getState()).toEqual('closed');
+});
+
+tap.start();

test/core/utils/test.binary-heap.ts

@@ -0,0 +1,206 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import { BinaryHeap } from '../../../ts/core/utils/binary-heap.js';
+
+interface TestItem {
+  id: string;
+  priority: number;
+  value: string;
+}
+
+tap.test('should create empty heap', async () => {
+  const heap = new BinaryHeap<number>((a, b) => a - b);
+  
+  expect(heap.size).toEqual(0);
+  expect(heap.isEmpty()).toBeTrue();
+  expect(heap.peek()).toBeUndefined();
+});
+
+tap.test('should insert and extract in correct order', async () => {
+  const heap = new BinaryHeap<number>((a, b) => a - b);
+  
+  heap.insert(5);
+  heap.insert(3);
+  heap.insert(7);
+  heap.insert(1);
+  heap.insert(9);
+  heap.insert(4);
+  
+  expect(heap.size).toEqual(6);
+  
+  // Extract in ascending order
+  expect(heap.extract()).toEqual(1);
+  expect(heap.extract()).toEqual(3);
+  expect(heap.extract()).toEqual(4);
+  expect(heap.extract()).toEqual(5);
+  expect(heap.extract()).toEqual(7);
+  expect(heap.extract()).toEqual(9);
+  expect(heap.extract()).toBeUndefined();
+});
+
+tap.test('should work with custom objects and comparator', async () => {
+  const heap = new BinaryHeap<TestItem>(
+    (a, b) => a.priority - b.priority,
+    (item) => item.id
+  );
+  
+  heap.insert({ id: 'a', priority: 5, value: 'five' });
+  heap.insert({ id: 'b', priority: 2, value: 'two' });
+  heap.insert({ id: 'c', priority: 8, value: 'eight' });
+  heap.insert({ id: 'd', priority: 1, value: 'one' });
+  
+  const first = heap.extract();
+  expect(first?.priority).toEqual(1);
+  expect(first?.value).toEqual('one');
+  
+  const second = heap.extract();
+  expect(second?.priority).toEqual(2);
+  expect(second?.value).toEqual('two');
+});
+
+tap.test('should support reverse order (max heap)', async () => {
+  const heap = new BinaryHeap<number>((a, b) => b - a);
+  
+  heap.insert(5);
+  heap.insert(3);
+  heap.insert(7);
+  heap.insert(1);
+  heap.insert(9);
+  
+  // Extract in descending order
+  expect(heap.extract()).toEqual(9);
+  expect(heap.extract()).toEqual(7);
+  expect(heap.extract()).toEqual(5);
+});
+
+tap.test('should extract by predicate', async () => {
+  const heap = new BinaryHeap<TestItem>((a, b) => a.priority - b.priority);
+  
+  heap.insert({ id: 'a', priority: 5, value: 'five' });
+  heap.insert({ id: 'b', priority: 2, value: 'two' });
+  heap.insert({ id: 'c', priority: 8, value: 'eight' });
+  
+  const extracted = heap.extractIf(item => item.id === 'b');
+  expect(extracted?.id).toEqual('b');
+  expect(heap.size).toEqual(2);
+  
+  // Should not find it again
+  const notFound = heap.extractIf(item => item.id === 'b');
+  expect(notFound).toBeUndefined();
+});
+
+tap.test('should extract by key', async () => {
+  const heap = new BinaryHeap<TestItem>(
+    (a, b) => a.priority - b.priority,
+    (item) => item.id
+  );
+  
+  heap.insert({ id: 'a', priority: 5, value: 'five' });
+  heap.insert({ id: 'b', priority: 2, value: 'two' });
+  heap.insert({ id: 'c', priority: 8, value: 'eight' });
+  
+  expect(heap.hasKey('b')).toBeTrue();
+  
+  const extracted = heap.extractByKey('b');
+  expect(extracted?.id).toEqual('b');
+  expect(heap.size).toEqual(2);
+  expect(heap.hasKey('b')).toBeFalse();
+  
+  // Should not find it again
+  const notFound = heap.extractByKey('b');
+  expect(notFound).toBeUndefined();
+});
+
+tap.test('should throw when using key operations without extractKey', async () => {
+  const heap = new BinaryHeap<TestItem>((a, b) => a.priority - b.priority);
+  
+  heap.insert({ id: 'a', priority: 5, value: 'five' });
+  
+  let error: Error | null = null;
+  try {
+    heap.extractByKey('a');
+  } catch (e: any) {
+    error = e;
+  }
+  
+  expect(error).not.toBeNull();
+  expect(error?.message).toContain('extractKey function must be provided');
+});
+
+tap.test('should handle duplicates correctly', async () => {
+  const heap = new BinaryHeap<number>((a, b) => a - b);
+  
+  heap.insert(5);
+  heap.insert(5);
+  heap.insert(5);
+  heap.insert(3);
+  heap.insert(7);
+  
+  expect(heap.size).toEqual(5);
+  expect(heap.extract()).toEqual(3);
+  expect(heap.extract()).toEqual(5);
+  expect(heap.extract()).toEqual(5);
+  expect(heap.extract()).toEqual(5);
+  expect(heap.extract()).toEqual(7);
+});
+
+tap.test('should convert to array without modifying heap', async () => {
+  const heap = new BinaryHeap<number>((a, b) => a - b);
+  
+  heap.insert(5);
+  heap.insert(3);
+  heap.insert(7);
+  
+  const array = heap.toArray();
+  expect(array).toContain(3);
+  expect(array).toContain(5);
+  expect(array).toContain(7);
+  expect(array.length).toEqual(3);
+  
+  // Heap should still be intact
+  expect(heap.size).toEqual(3);
+  expect(heap.extract()).toEqual(3);
+});
+
+tap.test('should clear the heap', async () => {
+  const heap = new BinaryHeap<TestItem>(
+    (a, b) => a.priority - b.priority,
+    (item) => item.id
+  );
+  
+  heap.insert({ id: 'a', priority: 5, value: 'five' });
+  heap.insert({ id: 'b', priority: 2, value: 'two' });
+  
+  expect(heap.size).toEqual(2);
+  expect(heap.hasKey('a')).toBeTrue();
+  
+  heap.clear();
+  
+  expect(heap.size).toEqual(0);
+  expect(heap.isEmpty()).toBeTrue();
+  expect(heap.hasKey('a')).toBeFalse();
+});
+
+tap.test('should handle complex extraction patterns', async () => {
+  const heap = new BinaryHeap<number>((a, b) => a - b);
+  
+  // Insert numbers 1-10 in random order
+  [8, 3, 5, 9, 1, 7, 4, 10, 2, 6].forEach(n => heap.insert(n));
+  
+  // Extract some in order
+  expect(heap.extract()).toEqual(1);
+  expect(heap.extract()).toEqual(2);
+  
+  // Insert more
+  heap.insert(0);
+  heap.insert(1.5);
+  
+  // Continue extracting
+  expect(heap.extract()).toEqual(0);
+  expect(heap.extract()).toEqual(1.5);
+  expect(heap.extract()).toEqual(3);
+  
+  // Verify remaining size (10 - 2 extracted + 2 inserted - 3 extracted = 7)
+  expect(heap.size).toEqual(7);
+});
+
+tap.start();

test/core/utils/test.event-system.ts

@@ -1,207 +0,0 @@
-import { expect, tap } from '@push.rocks/tapbundle';
-import {
-  EventSystem,
-  ProxyEvents,
-  ComponentType
-} from '../../../ts/core/utils/event-system.js';
-
-// Setup function for creating a new event system
-function setupEventSystem(): { eventSystem: EventSystem, receivedEvents: any[] } {
-  const eventSystem = new EventSystem(ComponentType.SMART_PROXY, 'test-id');
-  const receivedEvents: any[] = [];
-  return { eventSystem, receivedEvents };
-}
-
-tap.test('Event System - certificate events with correct structure', async () => {
-  const { eventSystem, receivedEvents } = setupEventSystem();
-  
-  // Set up listeners
-  eventSystem.on(ProxyEvents.CERTIFICATE_ISSUED, (data) => {
-    receivedEvents.push({
-      type: 'issued',
-      data
-    });
-  });
-  
-  eventSystem.on(ProxyEvents.CERTIFICATE_RENEWED, (data) => {
-    receivedEvents.push({
-      type: 'renewed',
-      data
-    });
-  });
-  
-  // Emit events
-  eventSystem.emitCertificateIssued({
-    domain: 'example.com',
-    certificate: 'cert-content',
-    privateKey: 'key-content',
-    expiryDate: new Date('2025-01-01')
-  });
-  
-  eventSystem.emitCertificateRenewed({
-    domain: 'example.com',
-    certificate: 'new-cert-content',
-    privateKey: 'new-key-content',
-    expiryDate: new Date('2026-01-01'),
-    isRenewal: true
-  });
-  
-  // Verify events
-  expect(receivedEvents.length).toEqual(2);
-  
-  // Check issuance event
-  expect(receivedEvents[0].type).toEqual('issued');
-  expect(receivedEvents[0].data.domain).toEqual('example.com');
-  expect(receivedEvents[0].data.certificate).toEqual('cert-content');
-  expect(receivedEvents[0].data.componentType).toEqual(ComponentType.SMART_PROXY);
-  expect(receivedEvents[0].data.componentId).toEqual('test-id');
-  expect(typeof receivedEvents[0].data.timestamp).toEqual('number');
-  
-  // Check renewal event
-  expect(receivedEvents[1].type).toEqual('renewed');
-  expect(receivedEvents[1].data.domain).toEqual('example.com');
-  expect(receivedEvents[1].data.isRenewal).toEqual(true);
-  expect(receivedEvents[1].data.expiryDate).toEqual(new Date('2026-01-01'));
-});
-
-tap.test('Event System - component lifecycle events', async () => {
-  const { eventSystem, receivedEvents } = setupEventSystem();
-  
-  // Set up listeners
-  eventSystem.on(ProxyEvents.COMPONENT_STARTED, (data) => {
-    receivedEvents.push({
-      type: 'started',
-      data
-    });
-  });
-  
-  eventSystem.on(ProxyEvents.COMPONENT_STOPPED, (data) => {
-    receivedEvents.push({
-      type: 'stopped',
-      data
-    });
-  });
-  
-  // Emit events
-  eventSystem.emitComponentStarted('TestComponent', '1.0.0');
-  eventSystem.emitComponentStopped('TestComponent');
-  
-  // Verify events
-  expect(receivedEvents.length).toEqual(2);
-  
-  // Check started event
-  expect(receivedEvents[0].type).toEqual('started');
-  expect(receivedEvents[0].data.name).toEqual('TestComponent');
-  expect(receivedEvents[0].data.version).toEqual('1.0.0');
-  
-  // Check stopped event
-  expect(receivedEvents[1].type).toEqual('stopped');
-  expect(receivedEvents[1].data.name).toEqual('TestComponent');
-});
-
-tap.test('Event System - connection events', async () => {
-  const { eventSystem, receivedEvents } = setupEventSystem();
-  
-  // Set up listeners
-  eventSystem.on(ProxyEvents.CONNECTION_ESTABLISHED, (data) => {
-    receivedEvents.push({
-      type: 'established',
-      data
-    });
-  });
-  
-  eventSystem.on(ProxyEvents.CONNECTION_CLOSED, (data) => {
-    receivedEvents.push({
-      type: 'closed',
-      data
-    });
-  });
-  
-  // Emit events
-  eventSystem.emitConnectionEstablished({
-    connectionId: 'conn-123',
-    clientIp: '192.168.1.1',
-    port: 443,
-    isTls: true,
-    domain: 'example.com'
-  });
-  
-  eventSystem.emitConnectionClosed({
-    connectionId: 'conn-123',
-    clientIp: '192.168.1.1',
-    port: 443
-  });
-  
-  // Verify events
-  expect(receivedEvents.length).toEqual(2);
-  
-  // Check established event
-  expect(receivedEvents[0].type).toEqual('established');
-  expect(receivedEvents[0].data.connectionId).toEqual('conn-123');
-  expect(receivedEvents[0].data.clientIp).toEqual('192.168.1.1');
-  expect(receivedEvents[0].data.port).toEqual(443);
-  expect(receivedEvents[0].data.isTls).toEqual(true);
-  
-  // Check closed event
-  expect(receivedEvents[1].type).toEqual('closed');
-  expect(receivedEvents[1].data.connectionId).toEqual('conn-123');
-});
-
-tap.test('Event System - once and off subscription methods', async () => {
-  const { eventSystem, receivedEvents } = setupEventSystem();
-  
-  // Set up a listener that should fire only once
-  eventSystem.once(ProxyEvents.CONNECTION_ESTABLISHED, (data) => {
-    receivedEvents.push({
-      type: 'once',
-      data
-    });
-  });
-  
-  // Set up a persistent listener
-  const persistentHandler = (data: any) => {
-    receivedEvents.push({
-      type: 'persistent',
-      data
-    });
-  };
-  
-  eventSystem.on(ProxyEvents.CONNECTION_ESTABLISHED, persistentHandler);
-  
-  // First event should trigger both listeners
-  eventSystem.emitConnectionEstablished({
-    connectionId: 'conn-1',
-    clientIp: '192.168.1.1',
-    port: 443
-  });
-  
-  // Second event should only trigger the persistent listener
-  eventSystem.emitConnectionEstablished({
-    connectionId: 'conn-2',
-    clientIp: '192.168.1.1',
-    port: 443
-  });
-  
-  // Unsubscribe the persistent listener
-  eventSystem.off(ProxyEvents.CONNECTION_ESTABLISHED, persistentHandler);
-  
-  // Third event should not trigger any listeners
-  eventSystem.emitConnectionEstablished({
-    connectionId: 'conn-3',
-    clientIp: '192.168.1.1',
-    port: 443
-  });
-  
-  // Verify events
-  expect(receivedEvents.length).toEqual(3);
-  expect(receivedEvents[0].type).toEqual('once');
-  expect(receivedEvents[0].data.connectionId).toEqual('conn-1');
-  
-  expect(receivedEvents[1].type).toEqual('persistent');
-  expect(receivedEvents[1].data.connectionId).toEqual('conn-1');
-  
-  expect(receivedEvents[2].type).toEqual('persistent');
-  expect(receivedEvents[2].data.connectionId).toEqual('conn-2');
-});
-
-export default tap.start();

test/core/utils/test.fs-utils.ts

@@ -0,0 +1,185 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import * as path from 'path';
+import { AsyncFileSystem } from '../../../ts/core/utils/fs-utils.js';
+
+// Use a temporary directory for tests
+const testDir = path.join(process.cwd(), '.nogit', 'test-fs-utils');
+const testFile = path.join(testDir, 'test.txt');
+const testJsonFile = path.join(testDir, 'test.json');
+
+tap.test('should create and check directory existence', async () => {
+  // Ensure directory
+  await AsyncFileSystem.ensureDir(testDir);
+  
+  // Check it exists
+  const exists = await AsyncFileSystem.exists(testDir);
+  expect(exists).toBeTrue();
+  
+  // Check it's a directory
+  const isDir = await AsyncFileSystem.isDirectory(testDir);
+  expect(isDir).toBeTrue();
+});
+
+tap.test('should write and read text files', async () => {
+  const testContent = 'Hello, async filesystem!';
+  
+  // Write file
+  await AsyncFileSystem.writeFile(testFile, testContent);
+  
+  // Check file exists
+  const exists = await AsyncFileSystem.exists(testFile);
+  expect(exists).toBeTrue();
+  
+  // Read file
+  const content = await AsyncFileSystem.readFile(testFile);
+  expect(content).toEqual(testContent);
+  
+  // Check it's a file
+  const isFile = await AsyncFileSystem.isFile(testFile);
+  expect(isFile).toBeTrue();
+});
+
+tap.test('should write and read JSON files', async () => {
+  const testData = {
+    name: 'Test',
+    value: 42,
+    nested: {
+      array: [1, 2, 3]
+    }
+  };
+  
+  // Write JSON
+  await AsyncFileSystem.writeJSON(testJsonFile, testData);
+  
+  // Read JSON
+  const readData = await AsyncFileSystem.readJSON(testJsonFile);
+  expect(readData).toEqual(testData);
+});
+
+tap.test('should copy files', async () => {
+  const copyFile = path.join(testDir, 'copy.txt');
+  
+  // Copy file
+  await AsyncFileSystem.copyFile(testFile, copyFile);
+  
+  // Check copy exists
+  const exists = await AsyncFileSystem.exists(copyFile);
+  expect(exists).toBeTrue();
+  
+  // Check content matches
+  const content = await AsyncFileSystem.readFile(copyFile);
+  const originalContent = await AsyncFileSystem.readFile(testFile);
+  expect(content).toEqual(originalContent);
+});
+
+tap.test('should move files', async () => {
+  const moveFile = path.join(testDir, 'moved.txt');
+  const copyFile = path.join(testDir, 'copy.txt');
+  
+  // Move file
+  await AsyncFileSystem.moveFile(copyFile, moveFile);
+  
+  // Check moved file exists
+  const movedExists = await AsyncFileSystem.exists(moveFile);
+  expect(movedExists).toBeTrue();
+  
+  // Check original doesn't exist
+  const originalExists = await AsyncFileSystem.exists(copyFile);
+  expect(originalExists).toBeFalse();
+});
+
+tap.test('should list files in directory', async () => {
+  const files = await AsyncFileSystem.listFiles(testDir);
+  
+  expect(files).toContain('test.txt');
+  expect(files).toContain('test.json');
+  expect(files).toContain('moved.txt');
+});
+
+tap.test('should list files with full paths', async () => {
+  const files = await AsyncFileSystem.listFilesFullPath(testDir);
+  
+  const fileNames = files.map(f => path.basename(f));
+  expect(fileNames).toContain('test.txt');
+  expect(fileNames).toContain('test.json');
+  
+  // All paths should be absolute
+  files.forEach(file => {
+    expect(path.isAbsolute(file)).toBeTrue();
+  });
+});
+
+tap.test('should get file stats', async () => {
+  const stats = await AsyncFileSystem.getStats(testFile);
+  
+  expect(stats).not.toBeNull();
+  expect(stats?.isFile()).toBeTrue();
+  expect(stats?.size).toBeGreaterThan(0);
+});
+
+tap.test('should handle non-existent files gracefully', async () => {
+  const nonExistent = path.join(testDir, 'does-not-exist.txt');
+  
+  // Check existence
+  const exists = await AsyncFileSystem.exists(nonExistent);
+  expect(exists).toBeFalse();
+  
+  // Get stats should return null
+  const stats = await AsyncFileSystem.getStats(nonExistent);
+  expect(stats).toBeNull();
+  
+  // Remove should not throw
+  await AsyncFileSystem.remove(nonExistent);
+});
+
+tap.test('should remove files', async () => {
+  // Remove a file
+  await AsyncFileSystem.remove(testFile);
+  
+  // Check it's gone
+  const exists = await AsyncFileSystem.exists(testFile);
+  expect(exists).toBeFalse();
+});
+
+tap.test('should ensure file exists', async () => {
+  const ensureFile = path.join(testDir, 'ensure.txt');
+  
+  // Ensure file
+  await AsyncFileSystem.ensureFile(ensureFile);
+  
+  // Check it exists
+  const exists = await AsyncFileSystem.exists(ensureFile);
+  expect(exists).toBeTrue();
+  
+  // Check it's empty
+  const content = await AsyncFileSystem.readFile(ensureFile);
+  expect(content).toEqual('');
+});
+
+tap.test('should recursively list files', async () => {
+  // Create subdirectory with file
+  const subDir = path.join(testDir, 'subdir');
+  const subFile = path.join(subDir, 'nested.txt');
+  
+  await AsyncFileSystem.ensureDir(subDir);
+  await AsyncFileSystem.writeFile(subFile, 'nested content');
+  
+  // List recursively
+  const files = await AsyncFileSystem.listFilesRecursive(testDir);
+  
+  // Should include files from subdirectory
+  const fileNames = files.map(f => path.relative(testDir, f));
+  expect(fileNames).toContain('test.json');
+  expect(fileNames).toContain(path.join('subdir', 'nested.txt'));
+});
+
+tap.test('should clean up test directory', async () => {
+  // Remove entire test directory
+  await AsyncFileSystem.removeDir(testDir);
+  
+  // Check it's gone
+  const exists = await AsyncFileSystem.exists(testDir);
+  expect(exists).toBeFalse();
+});
+
+tap.start();

test/core/utils/test.ip-utils.ts

@@ -1,4 +1,4 @@
-import { expect, tap } from '@push.rocks/tapbundle';
+import { expect, tap } from '@git.zone/tstest/tapbundle';
 import { IpUtils } from '../../../ts/core/utils/ip-utils.js';
 
 tap.test('ip-utils - normalizeIP', async () => {

test/core/utils/test.lifecycle-component.ts

@@ -0,0 +1,252 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import { LifecycleComponent } from '../../../ts/core/utils/lifecycle-component.js';
+import { EventEmitter } from 'events';
+
+// Test implementation of LifecycleComponent
+class TestComponent extends LifecycleComponent {
+  public timerCallCount = 0;
+  public intervalCallCount = 0;
+  public cleanupCalled = false;
+  public testEmitter = new EventEmitter();
+  public listenerCallCount = 0;
+
+  constructor() {
+    super();
+    this.setupTimers();
+    this.setupListeners();
+  }
+
+  private setupTimers() {
+    // Set up a timeout
+    this.setTimeout(() => {
+      this.timerCallCount++;
+    }, 100);
+
+    // Set up an interval
+    this.setInterval(() => {
+      this.intervalCallCount++;
+    }, 50);
+  }
+
+  private setupListeners() {
+    this.addEventListener(this.testEmitter, 'test-event', () => {
+      this.listenerCallCount++;
+    });
+  }
+
+  protected async onCleanup(): Promise<void> {
+    this.cleanupCalled = true;
+  }
+
+  // Expose protected methods for testing
+  public testSetTimeout(handler: Function, timeout: number): NodeJS.Timeout {
+    return this.setTimeout(handler, timeout);
+  }
+
+  public testSetInterval(handler: Function, interval: number): NodeJS.Timeout {
+    return this.setInterval(handler, interval);
+  }
+
+  public testClearTimeout(timer: NodeJS.Timeout): void {
+    return this.clearTimeout(timer);
+  }
+
+  public testClearInterval(timer: NodeJS.Timeout): void {
+    return this.clearInterval(timer);
+  }
+
+  public testAddEventListener(target: any, event: string, handler: Function, options?: { once?: boolean }): void {
+    return this.addEventListener(target, event, handler, options);
+  }
+
+  public testIsShuttingDown(): boolean {
+    return this.isShuttingDownState();
+  }
+}
+
+tap.test('should manage timers properly', async () => {
+  const component = new TestComponent();
+  
+  // Wait for timers to fire
+  await new Promise(resolve => setTimeout(resolve, 200));
+  
+  expect(component.timerCallCount).toEqual(1);
+  expect(component.intervalCallCount).toBeGreaterThan(2);
+  
+  await component.cleanup();
+});
+
+tap.test('should manage event listeners properly', async () => {
+  const component = new TestComponent();
+  
+  // Emit events
+  component.testEmitter.emit('test-event');
+  component.testEmitter.emit('test-event');
+  
+  expect(component.listenerCallCount).toEqual(2);
+  
+  // Cleanup and verify listeners are removed
+  await component.cleanup();
+  
+  component.testEmitter.emit('test-event');
+  expect(component.listenerCallCount).toEqual(2); // Should not increase
+});
+
+tap.test('should prevent timer execution after cleanup', async () => {
+  const component = new TestComponent();
+  
+  let laterCallCount = 0;
+  component.testSetTimeout(() => {
+    laterCallCount++;
+  }, 100);
+  
+  // Cleanup immediately
+  await component.cleanup();
+  
+  // Wait for timer that would have fired
+  await new Promise(resolve => setTimeout(resolve, 150));
+  
+  expect(laterCallCount).toEqual(0);
+});
+
+tap.test('should handle child components', async () => {
+  class ParentComponent extends LifecycleComponent {
+    public child: TestComponent;
+    
+    constructor() {
+      super();
+      this.child = new TestComponent();
+      this.registerChildComponent(this.child);
+    }
+  }
+  
+  const parent = new ParentComponent();
+  
+  // Wait for child timers
+  await new Promise(resolve => setTimeout(resolve, 100));
+  
+  expect(parent.child.timerCallCount).toEqual(1);
+  
+  // Cleanup parent should cleanup child
+  await parent.cleanup();
+  
+  expect(parent.child.cleanupCalled).toBeTrue();
+  expect(parent.child.testIsShuttingDown()).toBeTrue();
+});
+
+tap.test('should handle multiple cleanup calls gracefully', async () => {
+  const component = new TestComponent();
+  
+  // Call cleanup multiple times
+  const promises = [
+    component.cleanup(),
+    component.cleanup(),
+    component.cleanup()
+  ];
+  
+  await Promise.all(promises);
+  
+  // Should only clean up once
+  expect(component.cleanupCalled).toBeTrue();
+});
+
+tap.test('should clear specific timers', async () => {
+  const component = new TestComponent();
+  
+  let callCount = 0;
+  const timer = component.testSetTimeout(() => {
+    callCount++;
+  }, 100);
+  
+  // Clear the timer
+  component.testClearTimeout(timer);
+  
+  // Wait and verify it didn't fire
+  await new Promise(resolve => setTimeout(resolve, 150));
+  
+  expect(callCount).toEqual(0);
+  
+  await component.cleanup();
+});
+
+tap.test('should clear specific intervals', async () => {
+  const component = new TestComponent();
+  
+  let callCount = 0;
+  const interval = component.testSetInterval(() => {
+    callCount++;
+  }, 50);
+  
+  // Let it run a bit
+  await new Promise(resolve => setTimeout(resolve, 120));
+  
+  const countBeforeClear = callCount;
+  expect(countBeforeClear).toBeGreaterThan(1);
+  
+  // Clear the interval
+  component.testClearInterval(interval);
+  
+  // Wait and verify it stopped
+  await new Promise(resolve => setTimeout(resolve, 100));
+  
+  expect(callCount).toEqual(countBeforeClear);
+  
+  await component.cleanup();
+});
+
+tap.test('should handle once event listeners', async () => {
+  const component = new TestComponent();
+  const emitter = new EventEmitter();
+  
+  let callCount = 0;
+  const handler = () => {
+    callCount++;
+  };
+  
+  component.testAddEventListener(emitter, 'once-event', handler, { once: true });
+  
+  // Check listener count before emit
+  const beforeCount = emitter.listenerCount('once-event');
+  expect(beforeCount).toEqual(1);
+  
+  // Emit once - the listener should fire and auto-remove
+  emitter.emit('once-event');
+  expect(callCount).toEqual(1);
+  
+  // Check listener was auto-removed
+  const afterCount = emitter.listenerCount('once-event');
+  expect(afterCount).toEqual(0);
+  
+  // Emit again - should not increase count
+  emitter.emit('once-event');
+  expect(callCount).toEqual(1);
+  
+  await component.cleanup();
+});
+
+tap.test('should not create timers when shutting down', async () => {
+  const component = new TestComponent();
+  
+  // Start cleanup
+  const cleanupPromise = component.cleanup();
+  
+  // Try to create timers during shutdown
+  let timerFired = false;
+  let intervalFired = false;
+  
+  component.testSetTimeout(() => {
+    timerFired = true;
+  }, 10);
+  
+  component.testSetInterval(() => {
+    intervalFired = true;
+  }, 10);
+  
+  await cleanupPromise;
+  await new Promise(resolve => setTimeout(resolve, 50));
+  
+  expect(timerFired).toBeFalse();
+  expect(intervalFired).toBeFalse();
+});
+
+export default tap.start();

test/core/utils/test.route-utils.ts

@@ -1,4 +1,4 @@
-import { expect, tap } from '@push.rocks/tapbundle';
+import { expect, tap } from '@git.zone/tstest/tapbundle';
 import * as routeUtils from '../../../ts/core/utils/route-utils.js';
 
 // Test domain matching

test/core/utils/test.shared-security-manager.ts

@@ -1,22 +1,20 @@
-import { expect } from '@push.rocks/tapbundle';
+import { expect, tap } from '@git.zone/tstest/tapbundle';
 import { SharedSecurityManager } from '../../../ts/core/utils/shared-security-manager.js';
 import type { IRouteConfig, IRouteContext } from '../../../ts/proxies/smart-proxy/models/route-types.js';
 
 // Test security manager
-expect.describe('Shared Security Manager', async () => {
+tap.test('Shared Security Manager', async () => {
   let securityManager: SharedSecurityManager;
 
-  // Set up a new security manager before each test
-  expect.beforeEach(() => {
-    securityManager = new SharedSecurityManager({
-      maxConnectionsPerIP: 5,
-      connectionRateLimitPerMinute: 10
-    });
+  // Set up a new security manager for each test
+  securityManager = new SharedSecurityManager({
+    maxConnectionsPerIP: 5,
+    connectionRateLimitPerMinute: 10
   });
 
-  expect.it('should validate IPs correctly', async () => {
+  tap.test('should validate IPs correctly', async () => {
     // Should allow IPs under connection limit
-    expect(securityManager.validateIP('192.168.1.1').allowed).to.be.true;
+    expect(securityManager.validateIP('192.168.1.1').allowed).toBeTrue();
     
     // Track multiple connections
     for (let i = 0; i < 4; i++) {
@@ -24,114 +22,137 @@ expect.describe('Shared Security Manager', async () => {
     }
     
     // Should still allow IPs under connection limit
-    expect(securityManager.validateIP('192.168.1.1').allowed).to.be.true;
+    expect(securityManager.validateIP('192.168.1.1').allowed).toBeTrue();
     
     // Add one more to reach the limit
     securityManager.trackConnectionByIP('192.168.1.1', 'conn_4');
     
     // Should now block IPs over connection limit
-    expect(securityManager.validateIP('192.168.1.1').allowed).to.be.false;
+    expect(securityManager.validateIP('192.168.1.1').allowed).toBeFalse();
     
     // Remove a connection
     securityManager.removeConnectionByIP('192.168.1.1', 'conn_0');
     
     // Should allow again after connection is removed
-    expect(securityManager.validateIP('192.168.1.1').allowed).to.be.true;
+    expect(securityManager.validateIP('192.168.1.1').allowed).toBeTrue();
   });
   
-  expect.it('should authorize IPs based on allow/block lists', async () => {
+  tap.test('should authorize IPs based on allow/block lists', async () => {
     // Test with allow list only
-    expect(securityManager.isIPAuthorized('192.168.1.1', ['192.168.1.*'])).to.be.true;
-    expect(securityManager.isIPAuthorized('192.168.2.1', ['192.168.1.*'])).to.be.false;
+    expect(securityManager.isIPAuthorized('192.168.1.1', ['192.168.1.*'])).toBeTrue();
+    expect(securityManager.isIPAuthorized('192.168.2.1', ['192.168.1.*'])).toBeFalse();
     
     // Test with block list
-    expect(securityManager.isIPAuthorized('192.168.1.5', ['*'], ['192.168.1.5'])).to.be.false;
-    expect(securityManager.isIPAuthorized('192.168.1.1', ['*'], ['192.168.1.5'])).to.be.true;
+    expect(securityManager.isIPAuthorized('192.168.1.5', ['*'], ['192.168.1.5'])).toBeFalse();
+    expect(securityManager.isIPAuthorized('192.168.1.1', ['*'], ['192.168.1.5'])).toBeTrue();
     
     // Test with both allow and block lists
-    expect(securityManager.isIPAuthorized('192.168.1.1', ['192.168.1.*'], ['192.168.1.5'])).to.be.true;
-    expect(securityManager.isIPAuthorized('192.168.1.5', ['192.168.1.*'], ['192.168.1.5'])).to.be.false;
+    expect(securityManager.isIPAuthorized('192.168.1.1', ['192.168.1.*'], ['192.168.1.5'])).toBeTrue();
+    expect(securityManager.isIPAuthorized('192.168.1.5', ['192.168.1.*'], ['192.168.1.5'])).toBeFalse();
   });
-  
-  expect.it('should validate route access', async () => {
-    // Create test route with IP restrictions
+
+  tap.test('should validate route access', async () => {
     const route: IRouteConfig = {
-      match: { ports: 443 },
-      action: { type: 'forward', target: { host: 'localhost', port: 8080 } },
+      match: {
+        ports: [8080]
+      },
+      action: {
+        type: 'forward',
+        target: { host: 'target.com', port: 443 }
+      },
       security: {
-        ipAllowList: ['192.168.1.*'],
-        ipBlockList: ['192.168.1.5']
+        ipAllowList: ['10.0.0.*', '192.168.1.*'],
+        ipBlockList: ['192.168.1.100'],
+        maxConnections: 3
       }
     };
-    
-    // Create test contexts
+
     const allowedContext: IRouteContext = {
-      port: 443,
       clientIp: '192.168.1.1',
-      serverIp: 'localhost',
-      isTls: true,
+      port: 8080,
+      serverIp: '127.0.0.1',
+      isTls: false,
       timestamp: Date.now(),
       connectionId: 'test_conn_1'
     };
-    
-    const blockedContext: IRouteContext = {
-      port: 443,
-      clientIp: '192.168.1.5',
-      serverIp: 'localhost',
-      isTls: true,
-      timestamp: Date.now(),
-      connectionId: 'test_conn_2'
+
+    const blockedByIPContext: IRouteContext = {
+      ...allowedContext,
+      clientIp: '192.168.1.100'
     };
-    
-    const outsideContext: IRouteContext = {
-      port: 443,
-      clientIp: '192.168.2.1',
-      serverIp: 'localhost',
-      isTls: true,
-      timestamp: Date.now(),
-      connectionId: 'test_conn_3'
+
+    const blockedByRangeContext: IRouteContext = {
+      ...allowedContext,
+      clientIp: '172.16.0.1'
     };
+
+    const blockedByMaxConnectionsContext: IRouteContext = {
+      ...allowedContext,
+      connectionId: 'test_conn_4'
+    };
+
+    expect(securityManager.isAllowed(route, allowedContext)).toBeTrue();
+    expect(securityManager.isAllowed(route, blockedByIPContext)).toBeFalse();
+    expect(securityManager.isAllowed(route, blockedByRangeContext)).toBeFalse();
     
-    // Test route access
-    expect(securityManager.isAllowed(route, allowedContext)).to.be.true;
-    expect(securityManager.isAllowed(route, blockedContext)).to.be.false;
-    expect(securityManager.isAllowed(route, outsideContext)).to.be.false;
+    // Test max connections for route - assuming implementation has been updated
+    if ((securityManager as any).trackConnectionByRoute) {
+      (securityManager as any).trackConnectionByRoute(route, 'conn_1');
+      (securityManager as any).trackConnectionByRoute(route, 'conn_2');
+      (securityManager as any).trackConnectionByRoute(route, 'conn_3');
+      
+      // Should now block due to max connections
+      expect(securityManager.isAllowed(route, blockedByMaxConnectionsContext)).toBeFalse();
+    }
   });
-  
-  expect.it('should validate basic auth', async () => {
-    // Create test route with basic auth
+
+  tap.test('should clean up expired entries', async () => {
     const route: IRouteConfig = {
-      match: { ports: 443 },
-      action: { type: 'forward', target: { host: 'localhost', port: 8080 } },
+      match: {
+        ports: [8080]
+      },
+      action: {
+        type: 'forward',
+        target: { host: 'target.com', port: 443 }
+      },
       security: {
-        basicAuth: {
+        rateLimit: {
           enabled: true,
-          users: [
-            { username: 'user1', password: 'pass1' },
-            { username: 'user2', password: 'pass2' }
-          ],
-          realm: 'Test Realm'
+          maxRequests: 5,
+          window: 60 // 60 seconds
         }
       }
     };
-    
-    // Test valid credentials
-    const validAuth = 'Basic ' + Buffer.from('user1:pass1').toString('base64');
-    expect(securityManager.validateBasicAuth(route, validAuth)).to.be.true;
-    
-    // Test invalid credentials
-    const invalidAuth = 'Basic ' + Buffer.from('user1:wrongpass').toString('base64');
-    expect(securityManager.validateBasicAuth(route, invalidAuth)).to.be.false;
-    
-    // Test missing auth header
-    expect(securityManager.validateBasicAuth(route)).to.be.false;
-    
-    // Test malformed auth header
-    expect(securityManager.validateBasicAuth(route, 'malformed')).to.be.false;
+
+    const context: IRouteContext = {
+      clientIp: '192.168.1.1',
+      port: 8080,
+      serverIp: '127.0.0.1',
+      isTls: false,
+      timestamp: Date.now(),
+      connectionId: 'test_conn_1'
+    };
+
+    // Test rate limiting if method exists
+    if ((securityManager as any).checkRateLimit) {
+      // Add 5 attempts (max allowed)
+      for (let i = 0; i < 5; i++) {
+        expect((securityManager as any).checkRateLimit(route, context)).toBeTrue();
+      }
+
+      // Should now be blocked
+      expect((securityManager as any).checkRateLimit(route, context)).toBeFalse();
+
+      // Force cleanup (normally runs periodically)
+      if ((securityManager as any).cleanup) {
+        (securityManager as any).cleanup();
+      }
+
+      // Should still be blocked since entries are not expired yet
+      expect((securityManager as any).checkRateLimit(route, context)).toBeFalse();
+    }
   });
-  
-  // Clean up resources after tests
-  expect.afterEach(() => {
-    securityManager.clearIPTracking();
-  });
-});
+});
+
+// Export test runner
+export default tap.start();

test/core/utils/test.validation-utils.ts

@@ -1,4 +1,4 @@
-import { expect, tap } from '@push.rocks/tapbundle';
+import { expect, tap } from '@git.zone/tstest/tapbundle';
 import { ValidationUtils } from '../../../ts/core/utils/validation-utils.js';
 import type { IDomainOptions, IAcmeOptions } from '../../../ts/core/models/common-types.js';
 

test/helpers/test-cert.pem

@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDizCCAnOgAwIBAgIUAzpwtk6k5v/7LfY1KR7PreezvsswDQYJKoZIhvcNAQEL
+BQAwVTELMAkGA1UEBhMCVVMxDTALBgNVBAgMBFRlc3QxDTALBgNVBAcMBFRlc3Qx
+DTALBgNVBAoMBFRlc3QxGTAXBgNVBAMMEHRlc3QuZXhhbXBsZS5jb20wHhcNMjUw
+NTE5MTc1MDM0WhcNMjYwNTE5MTc1MDM0WjBVMQswCQYDVQQGEwJVUzENMAsGA1UE
+CAwEVGVzdDENMAsGA1UEBwwEVGVzdDENMAsGA1UECgwEVGVzdDEZMBcGA1UEAwwQ
+dGVzdC5leGFtcGxlLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB
+AK9FivUNjXz5q+snqKLCno0i3cYzJ+LTzSf+x+a/G7CA/rtigIvSYEqWC4+/MXPM
+ifpU/iIRtj7RzoPKH44uJie7mS5kKSHsMnh/qixaxxJph+tVYdNGi9hNvL12T/5n
+ihXkpMAK8MV6z3Y+ObiaKbCe4w19sLu2IIpff0U0mo6rTKOQwAfGa/N1dtzFaogP
+f/iO5kcksWUPqZowM3lwXXgy8vg5ZeU7IZk9fRTBfrEJAr9TCQ8ivdluxq59Ax86
+0AMmlbeu/dUMBcujLiTVjzqD3jz/Hr+iHq2y48NiF3j5oE/1qsD04d+QDWAygdmd
+bQOy0w/W1X0ppnuPhLILQzcCAwEAAaNTMFEwHQYDVR0OBBYEFID88wvDJXrQyTsx
+s+zl/wwx5BCMMB8GA1UdIwQYMBaAFID88wvDJXrQyTsxs+zl/wwx5BCMMA8GA1Ud
+EwEB/wQFMAMBAf8wDQYJKoZIhvcNAQELBQADggEBAIRp9bUxAip5s0dx700PPVAd
+mrS7kDCZ+KFD6UgF/F3ykshh33MfYNLghJCfhcWvUHQgiPKohWcZq1g4oMuDZPFW
+EHTr2wkX9j6A3KNjgFT5OVkLdjNPYdxMbTvmKbsJPc82C9AFN/Xz97XlZvmE4mKc
+JCKqTz9hK3JpoayEUrf9g4TJcVwNnl/UnMp2sZX3aId4wD2+jSb40H/5UPFO2stv
+SvCSdMcq0ZOQ/g/P56xOKV/5RAdIYV+0/3LWNGU/dH0nUfJO9K31e3eR+QZ1Iyn3
+iGPcaSKPDptVx+2hxcvhFuRgRjfJ0mu6/hnK5wvhrXrSm43FBgvmlo4MaX0HVss=
+-----END CERTIFICATE-----

test/helpers/test-key.pem

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQCvRYr1DY18+avr
+J6iiwp6NIt3GMyfi080n/sfmvxuwgP67YoCL0mBKlguPvzFzzIn6VP4iEbY+0c6D
+yh+OLiYnu5kuZCkh7DJ4f6osWscSaYfrVWHTRovYTby9dk/+Z4oV5KTACvDFes92
+Pjm4mimwnuMNfbC7tiCKX39FNJqOq0yjkMAHxmvzdXbcxWqID3/4juZHJLFlD6ma
+MDN5cF14MvL4OWXlOyGZPX0UwX6xCQK/UwkPIr3ZbsaufQMfOtADJpW3rv3VDAXL
+oy4k1Y86g948/x6/oh6tsuPDYhd4+aBP9arA9OHfkA1gMoHZnW0DstMP1tV9KaZ7
+j4SyC0M3AgMBAAECggEAKfW6ng74C+7TtxDAAPMZtQ0fTcdKabWt/EC1B6tBzEAd
+e6vJvW+IaOLB8tBhXOkfMSRu0KYv3Jsq1wcpBcdLkCCLu/zzkfDzZkCd809qMCC+
+jtraeBOAADEgGbV80hlkh/g8btNPr99GUnb0J5sUlvl6vuyTxmSEJsxU8jL1O2km
+YgK34fS5NS73h138P3UQAGC0dGK8Rt61EsFIKWTyH/r8tlz9nQrYcDG3LwTbFQQf
+bsRLAjolxTRV6t1CzcjsSGtrAqm/4QNypP5McCyOXAqajb3pNGaJyGg1nAEOZclK
+oagU7PPwaFmSquwo7Y1Uov72XuLJLVryBl0fOCen7QKBgQDieqvaL9gHsfaZKNoY
++0Cnul/Dw0kjuqJIKhar/mfLY7NwYmFSgH17r26g+X7mzuzaN0rnEhjh7L3j6xQJ
+qhs9zL+/OIa581Ptvb8H/42O+mxnqx7Z8s5JwH0+f5EriNkU3euoAe/W9x4DqJiE
+2VyvlM1gngxI+vFo+iewmg+vOwKBgQDGHiPKxXWD50tXvvDdRTjH+/4GQuXhEQjl
+Po59AJ/PLc/AkQkVSzr8Fspf7MHN6vufr3tS45tBuf5Qf2Y9GPBRKR3e+M1CJdoi
+1RXy0nMsnR0KujxgiIe6WQFumcT81AsIVXtDYk11Sa057tYPeeOmgtmUMJZb6lek
+wqUxrFw0NQKBgQCs/p7+jsUpO5rt6vKNWn5MoGQ+GJFppUoIbX3b6vxFs+aA1eUZ
+K+St8ZdDhtCUZUMufEXOs1gmWrvBuPMZXsJoNlnRKtBegat+Ug31ghMTP95GYcOz
+H3DLjSkd8DtnUaTf95PmRXR6c1CN4t59u7q8s6EdSByCMozsbwiaMVQBuQKBgQCY
+QxG/BYMLnPeKuHTlmg3JpSHWLhP+pdjwVuOrro8j61F/7ffNJcRvehSPJKbOW4qH
+b5aYXdU07n1F4KPy0PfhaHhMpWsbK3w6yQnVVWivIRDw7bD5f/TQgxdWqVd7+HuC
+LDBP2X0uZzF7FNPvkP4lOut9uNnWSoSRXAcZ5h33AQKBgQDWJYKGNoA8/IT9+e8n
+v1Fy0RNL/SmBfGZW9pFGFT2pcu6TrzVSugQeWY/YFO2X6FqLPbL4p72Ar4rF0Uxl
+31aYIjy3jDGzMabdIuW7mBogvtNjBG+0UgcLQzbdG6JkvTkQgqUjwIn/+Jo+0sS5
+dEylNM0zC6zx1f1U1dGGZaNcLg==
+-----END PRIVATE KEY-----

test/test.acme-http-challenge.ts

@@ -0,0 +1,127 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import * as plugins from '../ts/plugins.js';
+import { SmartProxy, SocketHandlers } from '../ts/index.js';
+
+tap.test('should handle HTTP requests on port 80 for ACME challenges', async (tools) => {
+  tools.timeout(10000);
+  
+  // Track HTTP requests that are handled
+  const handledRequests: any[] = [];
+  
+  const settings = {
+    routes: [
+      {
+        name: 'acme-test-route',
+        match: {
+          ports: [18080],  // Use high port to avoid permission issues
+          path: '/.well-known/acme-challenge/*'
+        },
+        action: {
+          type: 'socket-handler' as const,
+          socketHandler: SocketHandlers.httpServer((req, res) => {
+            handledRequests.push({
+              path: req.url,
+              method: req.method,
+              headers: req.headers
+            });
+            
+            // Simulate ACME challenge response
+            const token = req.url?.split('/').pop() || '';
+            res.header('Content-Type', 'text/plain');
+            res.send(`challenge-response-for-${token}`);
+          })
+        }
+      }
+    ]
+  };
+  
+  const proxy = new SmartProxy(settings);
+  
+  // Mock NFTables manager
+  (proxy as any).nftablesManager = {
+    ensureNFTablesSetup: async () => {},
+    stop: async () => {}
+  };
+  
+  await proxy.start();
+  
+  // Make an HTTP request to the challenge endpoint
+  const response = await fetch('http://localhost:18080/.well-known/acme-challenge/test-token', {
+    method: 'GET'
+  });
+  
+  // Verify response
+  expect(response.status).toEqual(200);
+  const body = await response.text();
+  expect(body).toEqual('challenge-response-for-test-token');
+  
+  // Verify request was handled
+  expect(handledRequests.length).toEqual(1);
+  expect(handledRequests[0].path).toEqual('/.well-known/acme-challenge/test-token');
+  expect(handledRequests[0].method).toEqual('GET');
+  
+  await proxy.stop();
+});
+
+tap.test('should parse HTTP headers correctly', async (tools) => {
+  tools.timeout(10000);
+  
+  const capturedContext: any = {};
+  
+  const settings = {
+    routes: [
+      {
+        name: 'header-test-route',
+        match: {
+          ports: [18081]
+        },
+        action: {
+          type: 'socket-handler' as const,
+          socketHandler: SocketHandlers.httpServer((req, res) => {
+            Object.assign(capturedContext, {
+              path: req.url,
+              method: req.method,
+              headers: req.headers
+            });
+            res.header('Content-Type', 'application/json');
+            res.send(JSON.stringify({
+              received: req.headers
+            }));
+          })
+        }
+      }
+    ]
+  };
+  
+  const proxy = new SmartProxy(settings);
+  
+  // Mock NFTables manager
+  (proxy as any).nftablesManager = {
+    ensureNFTablesSetup: async () => {},
+    stop: async () => {}
+  };
+  
+  await proxy.start();
+  
+  // Make request with custom headers
+  const response = await fetch('http://localhost:18081/test', {
+    method: 'POST',
+    headers: {
+      'X-Custom-Header': 'test-value',
+      'User-Agent': 'test-agent'
+    }
+  });
+  
+  expect(response.status).toEqual(200);
+  const body = await response.json();
+  
+  // Verify headers were parsed correctly
+  expect(capturedContext.headers['x-custom-header']).toEqual('test-value');
+  expect(capturedContext.headers['user-agent']).toEqual('test-agent');
+  expect(capturedContext.method).toEqual('POST');
+  expect(capturedContext.path).toEqual('/test');
+  
+  await proxy.stop();
+});
+
+tap.start();

test/test.acme-http01-challenge.ts

@@ -0,0 +1,162 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import { SmartProxy, SocketHandlers } from '../ts/index.js';
+import * as net from 'net';
+
+// Test that HTTP-01 challenges are properly processed when the initial data arrives
+tap.test('should correctly handle HTTP-01 challenge requests with initial data chunk', async (tapTest) => {
+  // Prepare test data
+  const challengeToken = 'test-acme-http01-challenge-token';
+  const challengeResponse = 'mock-response-for-challenge';
+  const challengePath = `/.well-known/acme-challenge/${challengeToken}`;
+  
+  // Create a socket handler that responds to ACME challenges using httpServer
+  const acmeHandler = SocketHandlers.httpServer((req, res) => {
+    // Log request details for debugging
+    console.log(`Received request: ${req.method} ${req.url}`);
+    
+    // Check if this is an ACME challenge request
+    if (req.url?.startsWith('/.well-known/acme-challenge/')) {
+      const token = req.url.substring('/.well-known/acme-challenge/'.length);
+      
+      // If the token matches our test token, return the response
+      if (token === challengeToken) {
+        res.header('Content-Type', 'text/plain');
+        res.send(challengeResponse);
+        return;
+      }
+    }
+    
+    // For any other requests, return 404
+    res.status(404);
+    res.header('Content-Type', 'text/plain');
+    res.send('Not found');
+  });
+  
+  // Create a proxy with the ACME challenge route
+  const proxy = new SmartProxy({
+    routes: [{
+      name: 'acme-challenge-route',
+      match: {
+        ports: 8080,
+        path: '/.well-known/acme-challenge/*'
+      },
+      action: {
+        type: 'socket-handler',
+        socketHandler: acmeHandler
+      }
+    }]
+  });
+  
+  await proxy.start();
+  
+  // Create a client to test the HTTP-01 challenge
+  const testClient = new net.Socket();
+  let responseData = '';
+  
+  // Set up client handlers
+  testClient.on('data', (data) => {
+    responseData += data.toString();
+  });
+  
+  // Connect to the proxy and send the HTTP-01 challenge request
+  await new Promise<void>((resolve, reject) => {
+    testClient.connect(8080, 'localhost', () => {
+      // Send HTTP request for the challenge token
+      testClient.write(
+        `GET ${challengePath} HTTP/1.1\r\n` +
+        'Host: test.example.com\r\n' +
+        'User-Agent: ACME Challenge Test\r\n' +
+        'Accept: */*\r\n' +
+        '\r\n'
+      );
+      resolve();
+    });
+    
+    testClient.on('error', reject);
+  });
+  
+  // Wait for the response
+  await new Promise(resolve => setTimeout(resolve, 100));
+  
+  // Verify that we received a valid HTTP response with the challenge token
+  expect(responseData).toContain('HTTP/1.1 200');
+  expect(responseData).toContain('Content-Type: text/plain');
+  expect(responseData).toContain(challengeResponse);
+  
+  // Cleanup
+  testClient.destroy();
+  await proxy.stop();
+});
+
+// Test that non-existent challenge tokens return 404
+tap.test('should return 404 for non-existent challenge tokens', async (tapTest) => {
+  // Create a socket handler that behaves like a real ACME handler
+  const acmeHandler = SocketHandlers.httpServer((req, res) => {
+    if (req.url?.startsWith('/.well-known/acme-challenge/')) {
+      const token = req.url.substring('/.well-known/acme-challenge/'.length);
+      // In this test, we only recognize one specific token
+      if (token === 'valid-token') {
+        res.header('Content-Type', 'text/plain');
+        res.send('valid-response');
+        return;
+      }
+    }
+    
+    // For all other paths or unrecognized tokens, return 404
+    res.status(404);
+    res.header('Content-Type', 'text/plain');
+    res.send('Not found');
+  });
+  
+  // Create a proxy with the ACME challenge route
+  const proxy = new SmartProxy({
+    routes: [{
+      name: 'acme-challenge-route',
+      match: {
+        ports: 8081,
+        path: '/.well-known/acme-challenge/*'
+      },
+      action: {
+        type: 'socket-handler',
+        socketHandler: acmeHandler
+      }
+    }]
+  });
+  
+  await proxy.start();
+  
+  // Create a client to test the invalid challenge request
+  const testClient = new net.Socket();
+  let responseData = '';
+  
+  testClient.on('data', (data) => {
+    responseData += data.toString();
+  });
+  
+  // Connect and send a request for a non-existent token
+  await new Promise<void>((resolve, reject) => {
+    testClient.connect(8081, 'localhost', () => {
+      testClient.write(
+        'GET /.well-known/acme-challenge/invalid-token HTTP/1.1\r\n' +
+        'Host: test.example.com\r\n' +
+        '\r\n'
+      );
+      resolve();
+    });
+    
+    testClient.on('error', reject);
+  });
+  
+  // Wait for the response
+  await new Promise(resolve => setTimeout(resolve, 100));
+  
+  // Verify we got a 404 Not Found
+  expect(responseData).toContain('HTTP/1.1 404');
+  expect(responseData).toContain('Not found');
+  
+  // Cleanup
+  testClient.destroy();
+  await proxy.stop();
+});
+
+tap.start();

test/test.acme-route-creation.ts

@@ -0,0 +1,218 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import { SmartProxy } from '../ts/index.js';
+import * as plugins from '../ts/plugins.js';
+
+/**
+ * Test that verifies ACME challenge routes are properly created
+ */
+tap.test('should create ACME challenge route', async (tools) => {
+  tools.timeout(5000);
+  
+  // Create a challenge route manually to test its structure
+  const challengeRoute = {
+    name: 'acme-challenge',
+    priority: 1000,
+    match: {
+      ports: 18080,
+      path: '/.well-known/acme-challenge/*'
+    },
+    action: {
+      type: 'socket-handler' as const,
+      socketHandler: (socket: any, context: any) => {
+        socket.once('data', (data: Buffer) => {
+          const request = data.toString();
+          const lines = request.split('\r\n');
+          const [method, path] = lines[0].split(' ');
+          const token = path?.split('/').pop() || '';
+          
+          const response = [
+            'HTTP/1.1 200 OK',
+            'Content-Type: text/plain',
+            `Content-Length: ${token.length}`,
+            'Connection: close',
+            '',
+            token
+          ].join('\r\n');
+          
+          socket.write(response);
+          socket.end();
+        });
+      }
+    }
+  };
+  
+  // Test that the challenge route has the correct structure
+  expect(challengeRoute).toBeDefined();
+  expect(challengeRoute.match.path).toEqual('/.well-known/acme-challenge/*');
+  expect(challengeRoute.match.ports).toEqual(18080);
+  expect(challengeRoute.action.type).toEqual('socket-handler');
+  expect(challengeRoute.priority).toEqual(1000);
+  
+  // Create a proxy with the challenge route
+  const settings = {
+    routes: [
+      {
+        name: 'secure-route',
+        match: {
+          ports: [18443],
+          domains: 'test.local'
+        },
+        action: {
+          type: 'forward' as const,
+          target: { host: 'localhost', port: 8080 }
+        }
+      },
+      challengeRoute
+    ]
+  };
+  
+  const proxy = new SmartProxy(settings);
+  
+  // Mock NFTables manager
+  (proxy as any).nftablesManager = {
+    ensureNFTablesSetup: async () => {},
+    stop: async () => {}
+  };
+  
+  // Mock certificate manager to prevent real ACME initialization
+  (proxy as any).createCertificateManager = async function() {
+    return {
+      setUpdateRoutesCallback: () => {},
+      setHttpProxy: () => {},
+      setGlobalAcmeDefaults: () => {},
+      setAcmeStateManager: () => {},
+      initialize: async () => {},
+      provisionAllCertificates: async () => {},
+      stop: async () => {},
+      getAcmeOptions: () => ({}),
+      getState: () => ({ challengeRouteActive: false })
+    };
+  };
+  
+  await proxy.start();
+  
+  // Verify the challenge route is in the proxy's routes
+  const proxyRoutes = proxy.routeManager.getAllRoutes();
+  const foundChallengeRoute = proxyRoutes.find((r: any) => r.name === 'acme-challenge');
+  
+  expect(foundChallengeRoute).toBeDefined();
+  expect(foundChallengeRoute?.match.path).toEqual('/.well-known/acme-challenge/*');
+  
+  await proxy.stop();
+});
+
+tap.test('should handle HTTP request parsing correctly', async (tools) => {
+  tools.timeout(5000);
+  
+  let handlerCalled = false;
+  let receivedContext: any;
+  let parsedRequest: any = {};
+  
+  const settings = {
+    routes: [
+      {
+        name: 'test-static',
+        match: {
+          ports: [18090],
+          path: '/test/*'
+        },
+        action: {
+          type: 'socket-handler' as const,
+          socketHandler: (socket, context) => {
+            handlerCalled = true;
+            receivedContext = context;
+            
+            // Parse HTTP request from socket
+            socket.once('data', (data) => {
+              const request = data.toString();
+              const lines = request.split('\r\n');
+              const [method, path, protocol] = lines[0].split(' ');
+              
+              // Parse headers
+              const headers: any = {};
+              for (let i = 1; i < lines.length; i++) {
+                if (lines[i] === '') break;
+                const [key, value] = lines[i].split(': ');
+                if (key && value) {
+                  headers[key.toLowerCase()] = value;
+                }
+              }
+              
+              // Store parsed request data
+              parsedRequest = { method, path, headers };
+              
+              // Send HTTP response
+              const response = [
+                'HTTP/1.1 200 OK',
+                'Content-Type: text/plain',
+                'Content-Length: 2',
+                'Connection: close',
+                '',
+                'OK'
+              ].join('\r\n');
+              
+              socket.write(response);
+              socket.end();
+            });
+          }
+        }
+      }
+    ]
+  };
+  
+  const proxy = new SmartProxy(settings);
+  
+  // Mock NFTables manager
+  (proxy as any).nftablesManager = {
+    ensureNFTablesSetup: async () => {},
+    stop: async () => {}
+  };
+  
+  await proxy.start();
+  
+  // Create a simple HTTP request
+  const client = new plugins.net.Socket();
+  
+  await new Promise<void>((resolve, reject) => {
+    client.connect(18090, 'localhost', () => {
+      // Send HTTP request
+      const request = [
+        'GET /test/example HTTP/1.1',
+        'Host: localhost:18090',
+        'User-Agent: test-client',
+        '',
+        ''
+      ].join('\r\n');
+      
+      client.write(request);
+      
+      // Wait for response
+      client.on('data', (data) => {
+        const response = data.toString();
+        expect(response).toContain('HTTP/1.1 200');
+        expect(response).toContain('OK');
+        client.end();
+        resolve();
+      });
+    });
+    
+    client.on('error', reject);
+  });
+  
+  // Verify handler was called
+  expect(handlerCalled).toBeTrue();
+  expect(receivedContext).toBeDefined();
+  
+  // The context passed to socket handlers is IRouteContext, not HTTP request data
+  expect(receivedContext.port).toEqual(18090);
+  expect(receivedContext.routeName).toEqual('test-static');
+  
+  // Verify the parsed HTTP request data
+  expect(parsedRequest.path).toEqual('/test/example');
+  expect(parsedRequest.method).toEqual('GET');
+  expect(parsedRequest.headers.host).toEqual('localhost:18090');
+  
+  await proxy.stop();
+});
+
+tap.start();

test/test.acme-simple.ts

@@ -0,0 +1,120 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import * as net from 'net';
+
+/**
+ * Simple test to verify HTTP parsing works for ACME challenges
+ */
+tap.test('should parse HTTP requests correctly', async (tools) => {
+  tools.timeout(15000);
+  
+  let receivedRequest = '';
+  
+  // Create a simple HTTP server to test the parsing
+  const server = net.createServer((socket) => {
+    socket.on('data', (data) => {
+      receivedRequest = data.toString();
+      
+      // Send response
+      const response = [
+        'HTTP/1.1 200 OK',
+        'Content-Type: text/plain',
+        'Content-Length: 2',
+        '',
+        'OK'
+      ].join('\r\n');
+      
+      socket.write(response);
+      socket.end();
+    });
+  });
+  
+  await new Promise<void>((resolve) => {
+    server.listen(18091, () => {
+      console.log('Test server listening on port 18091');
+      resolve();
+    });
+  });
+  
+  // Connect and send request
+  const client = net.connect(18091, 'localhost');
+  
+  await new Promise<void>((resolve, reject) => {
+    client.on('connect', () => {
+      const request = [
+        'GET /.well-known/acme-challenge/test-token HTTP/1.1',
+        'Host: localhost:18091',
+        'User-Agent: test-client',
+        '',
+        ''
+      ].join('\r\n');
+      
+      client.write(request);
+    });
+    
+    client.on('data', (data) => {
+      const response = data.toString();
+      expect(response).toContain('200 OK');
+      client.end();
+    });
+    
+    client.on('end', () => {
+      resolve();
+    });
+    
+    client.on('error', reject);
+  });
+  
+  // Verify we received the request
+  expect(receivedRequest).toContain('GET /.well-known/acme-challenge/test-token');
+  expect(receivedRequest).toContain('Host: localhost:18091');
+  
+  server.close();
+});
+
+/**
+ * Test to verify ACME route configuration
+ */
+tap.test('should configure ACME challenge route', async () => {
+  // Simple test to verify the route configuration structure
+  const challengeRoute = {
+    name: 'acme-challenge',
+    priority: 1000,
+    match: {
+      ports: 80,
+      path: '/.well-known/acme-challenge/*'
+    },
+    action: {
+      type: 'socket-handler',
+      socketHandler: (socket: any, context: any) => {
+        socket.once('data', (data: Buffer) => {
+          const request = data.toString();
+          const lines = request.split('\r\n');
+          const [method, path] = lines[0].split(' ');
+          const token = path?.split('/').pop() || '';
+          
+          const response = [
+            'HTTP/1.1 200 OK',
+            'Content-Type: text/plain',
+            `Content-Length: ${('challenge-response-' + token).length}`,
+            'Connection: close',
+            '',
+            `challenge-response-${token}`
+          ].join('\r\n');
+          
+          socket.write(response);
+          socket.end();
+        });
+      }
+    }
+  };
+  
+  expect(challengeRoute.name).toEqual('acme-challenge');
+  expect(challengeRoute.match.path).toEqual('/.well-known/acme-challenge/*');
+  expect(challengeRoute.match.ports).toEqual(80);
+  expect(challengeRoute.priority).toEqual(1000);
+  
+  // Socket handlers are tested differently - they handle raw sockets
+  expect(challengeRoute.action.socketHandler).toBeDefined();
+});
+
+tap.start();

test/test.acme-state-manager.node.ts

@@ -0,0 +1,188 @@
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import { AcmeStateManager } from '../ts/proxies/smart-proxy/acme-state-manager.js';
+import type { IRouteConfig } from '../ts/proxies/smart-proxy/models/route-types.js';
+
+tap.test('AcmeStateManager should track challenge routes correctly', async (tools) => {
+  const stateManager = new AcmeStateManager();
+  
+  const challengeRoute: IRouteConfig = {
+    name: 'acme-challenge',
+    priority: 1000,
+    match: {
+      ports: 80,
+      path: '/.well-known/acme-challenge/*'
+    },
+    action: {
+      type: 'socket-handler',
+      socketHandler: async (socket, context) => {
+        // Mock handler that would write the challenge response
+        socket.end('challenge response');
+      }
+    }
+  };
+  
+  // Initially no challenge routes
+  expect(stateManager.isChallengeRouteActive()).toBeFalse();
+  expect(stateManager.getActiveChallengeRoutes()).toEqual([]);
+  
+  // Add challenge route
+  stateManager.addChallengeRoute(challengeRoute);
+  expect(stateManager.isChallengeRouteActive()).toBeTrue();
+  expect(stateManager.getActiveChallengeRoutes()).toHaveProperty("length", 1);
+  expect(stateManager.getPrimaryChallengeRoute()).toEqual(challengeRoute);
+  
+  // Remove challenge route
+  stateManager.removeChallengeRoute('acme-challenge');
+  expect(stateManager.isChallengeRouteActive()).toBeFalse();
+  expect(stateManager.getActiveChallengeRoutes()).toEqual([]);
+  expect(stateManager.getPrimaryChallengeRoute()).toBeNull();
+});
+
+tap.test('AcmeStateManager should track port allocations', async (tools) => {
+  const stateManager = new AcmeStateManager();
+  
+  const challengeRoute1: IRouteConfig = {
+    name: 'acme-challenge-1',
+    priority: 1000,
+    match: {
+      ports: 80,
+      path: '/.well-known/acme-challenge/*'
+    },
+    action: {
+      type: 'socket-handler'
+    }
+  };
+  
+  const challengeRoute2: IRouteConfig = {
+    name: 'acme-challenge-2',
+    priority: 900,
+    match: {
+      ports: [80, 8080],
+      path: '/.well-known/acme-challenge/*'
+    },
+    action: {
+      type: 'socket-handler'
+    }
+  };
+  
+  // Add first route
+  stateManager.addChallengeRoute(challengeRoute1);
+  expect(stateManager.isPortAllocatedForAcme(80)).toBeTrue();
+  expect(stateManager.isPortAllocatedForAcme(8080)).toBeFalse();
+  expect(stateManager.getAcmePorts()).toEqual([80]);
+  
+  // Add second route
+  stateManager.addChallengeRoute(challengeRoute2);
+  expect(stateManager.isPortAllocatedForAcme(80)).toBeTrue();
+  expect(stateManager.isPortAllocatedForAcme(8080)).toBeTrue();
+  expect(stateManager.getAcmePorts()).toContain(80);
+  expect(stateManager.getAcmePorts()).toContain(8080);
+  
+  // Remove first route - port 80 should still be allocated
+  stateManager.removeChallengeRoute('acme-challenge-1');
+  expect(stateManager.isPortAllocatedForAcme(80)).toBeTrue();
+  expect(stateManager.isPortAllocatedForAcme(8080)).toBeTrue();
+  
+  // Remove second route - all ports should be deallocated
+  stateManager.removeChallengeRoute('acme-challenge-2');
+  expect(stateManager.isPortAllocatedForAcme(80)).toBeFalse();
+  expect(stateManager.isPortAllocatedForAcme(8080)).toBeFalse();
+  expect(stateManager.getAcmePorts()).toEqual([]);
+});
+
+tap.test('AcmeStateManager should select primary route by priority', async (tools) => {
+  const stateManager = new AcmeStateManager();
+  
+  const lowPriorityRoute: IRouteConfig = {
+    name: 'low-priority',
+    priority: 100,
+    match: {
+      ports: 80
+    },
+    action: {
+      type: 'socket-handler'
+    }
+  };
+  
+  const highPriorityRoute: IRouteConfig = {
+    name: 'high-priority',
+    priority: 2000,
+    match: {
+      ports: 80
+    },
+    action: {
+      type: 'socket-handler'
+    }
+  };
+  
+  const defaultPriorityRoute: IRouteConfig = {
+    name: 'default-priority',
+    // No priority specified - should default to 0
+    match: {
+      ports: 80
+    },
+    action: {
+      type: 'socket-handler'
+    }
+  };
+  
+  // Add low priority first
+  stateManager.addChallengeRoute(lowPriorityRoute);
+  expect(stateManager.getPrimaryChallengeRoute()?.name).toEqual('low-priority');
+  
+  // Add high priority - should become primary
+  stateManager.addChallengeRoute(highPriorityRoute);
+  expect(stateManager.getPrimaryChallengeRoute()?.name).toEqual('high-priority');
+  
+  // Add default priority - primary should remain high priority
+  stateManager.addChallengeRoute(defaultPriorityRoute);
+  expect(stateManager.getPrimaryChallengeRoute()?.name).toEqual('high-priority');
+  
+  // Remove high priority - primary should fall back to low priority
+  stateManager.removeChallengeRoute('high-priority');
+  expect(stateManager.getPrimaryChallengeRoute()?.name).toEqual('low-priority');
+});
+
+tap.test('AcmeStateManager should handle clear operation', async (tools) => {
+  const stateManager = new AcmeStateManager();
+  
+  const challengeRoute1: IRouteConfig = {
+    name: 'route-1',
+    match: {
+      ports: [80, 443]
+    },
+    action: {
+      type: 'socket-handler'
+    }
+  };
+  
+  const challengeRoute2: IRouteConfig = {
+    name: 'route-2',
+    match: {
+      ports: 8080
+    },
+    action: {
+      type: 'socket-handler'
+    }
+  };
+  
+  // Add routes
+  stateManager.addChallengeRoute(challengeRoute1);
+  stateManager.addChallengeRoute(challengeRoute2);
+  
+  // Verify state before clear
+  expect(stateManager.isChallengeRouteActive()).toBeTrue();
+  expect(stateManager.getActiveChallengeRoutes()).toHaveProperty("length", 2);
+  expect(stateManager.getAcmePorts()).toHaveProperty("length", 3);
+  
+  // Clear all state
+  stateManager.clear();
+  
+  // Verify state after clear
+  expect(stateManager.isChallengeRouteActive()).toBeFalse();
+  expect(stateManager.getActiveChallengeRoutes()).toEqual([]);
+  expect(stateManager.getAcmePorts()).toEqual([]);
+  expect(stateManager.getPrimaryChallengeRoute()).toBeNull();
+});
+
+export default tap.start();

test/test.acme-timing-simple.ts

@@ -0,0 +1,122 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import { SmartProxy } from '../ts/index.js';
+
+// Test that certificate provisioning is deferred until after ports are listening
+tap.test('should defer certificate provisioning until ports are ready', async (tapTest) => {
+  // Track when operations happen
+  let portsListening = false;
+  let certProvisioningStarted = false;
+  let operationOrder: string[] = [];
+  
+  // Create proxy with certificate route but without real ACME
+  const proxy = new SmartProxy({
+    routes: [{
+      name: 'test-route',
+      match: {
+        ports: 8443,
+        domains: ['test.local']
+      },
+      action: {
+        type: 'forward',
+        target: { host: 'localhost', port: 8181 },
+        tls: {
+          mode: 'terminate',
+          certificate: 'auto',
+          acme: {
+            email: 'test@local.dev',
+            useProduction: false
+          }
+        }
+      }
+    }]
+  });
+  
+  // Override the certificate manager creation to avoid real ACME
+  const originalCreateCertManager = proxy['createCertificateManager'];
+  proxy['createCertificateManager'] = async function(...args: any[]) {
+    console.log('Creating mock cert manager');
+    operationOrder.push('create-cert-manager');
+    const mockCertManager = {
+      certStore: null,
+      smartAcme: null,
+      httpProxy: null,
+      renewalTimer: null,
+      pendingChallenges: new Map(),
+      challengeRoute: null,
+      certStatus: new Map(),
+      globalAcmeDefaults: null,
+      updateRoutesCallback: undefined,
+      challengeRouteActive: false,
+      isProvisioning: false,
+      acmeStateManager: null,
+      initialize: async () => {
+        operationOrder.push('cert-manager-init');
+        console.log('Mock cert manager initialized');
+      },
+      provisionAllCertificates: async () => {
+        operationOrder.push('cert-provisioning');
+        certProvisioningStarted = true;
+        // Check that ports are listening when provisioning starts
+        if (!portsListening) {
+          throw new Error('Certificate provisioning started before ports ready!');
+        }
+        console.log('Mock certificate provisioning (ports are ready)');
+      },
+      stop: async () => {},
+      setHttpProxy: () => {},
+      setGlobalAcmeDefaults: () => {},
+      setAcmeStateManager: () => {},
+      setUpdateRoutesCallback: () => {},
+      getAcmeOptions: () => ({}),
+      getState: () => ({ challengeRouteActive: false }),
+      getCertStatus: () => new Map(),
+      checkAndRenewCertificates: async () => {},
+      addChallengeRoute: async () => {},
+      removeChallengeRoute: async () => {},
+      getCertificate: async () => null,
+      isValidCertificate: () => false,
+      waitForProvisioning: async () => {}
+    } as any;
+    
+    // Call initialize immediately as the real createCertificateManager does
+    await mockCertManager.initialize();
+    
+    return mockCertManager;
+  };
+  
+  // Track port manager operations
+  const originalAddPorts = proxy['portManager'].addPorts;
+  proxy['portManager'].addPorts = async function(ports: number[]) {
+    operationOrder.push('ports-starting');
+    const result = await originalAddPorts.call(this, ports);
+    operationOrder.push('ports-ready');
+    portsListening = true;
+    console.log('Ports are now listening');
+    return result;
+  };
+  
+  // Start the proxy
+  await proxy.start();
+  
+  // Log the operation order for debugging
+  console.log('Operation order:', operationOrder);
+  
+  // Verify operations happened in the correct order
+  expect(operationOrder).toContain('create-cert-manager');
+  expect(operationOrder).toContain('cert-manager-init');
+  expect(operationOrder).toContain('ports-starting');
+  expect(operationOrder).toContain('ports-ready');
+  expect(operationOrder).toContain('cert-provisioning');
+  
+  // Verify ports were ready before certificate provisioning
+  const portsReadyIndex = operationOrder.indexOf('ports-ready');
+  const certProvisioningIndex = operationOrder.indexOf('cert-provisioning');
+  
+  expect(portsReadyIndex).toBeLessThan(certProvisioningIndex);
+  expect(certProvisioningStarted).toEqual(true);
+  expect(portsListening).toEqual(true);
+  
+  await proxy.stop();
+});
+
+tap.start();

test/test.acme-timing.ts

@@ -0,0 +1,204 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import { SmartProxy } from '../ts/index.js';
+import * as net from 'net';
+
+// Test that certificate provisioning waits for ports to be ready
+tap.test('should defer certificate provisioning until after ports are listening', async (tapTest) => {
+  // Track the order of operations
+  const operationLog: string[] = [];
+  
+  // Create a mock server to verify ports are listening
+  let port80Listening = false;
+  
+  // Try to use port 8080 instead of 80 to avoid permission issues in testing
+  const acmePort = 8080;
+  
+  // Create proxy with ACME certificate requirement
+  const proxy = new SmartProxy({
+    useHttpProxy: [acmePort],
+    httpProxyPort: 8845, // Use different port to avoid conflicts
+    acme: {
+      email: 'test@test.local',
+      useProduction: false,
+      port: acmePort
+    },
+    routes: [{
+      name: 'test-acme-route',
+      match: {
+        ports: 8443,
+        domains: ['test.local']
+      },
+      action: {
+        type: 'forward',
+        target: { host: 'localhost', port: 8181 },
+        tls: {
+          mode: 'terminate',
+          certificate: 'auto',
+          acme: {
+            email: 'test@test.local',
+            useProduction: false
+          }
+        }
+      }
+    }]
+  });
+  
+  // Mock some internal methods to track operation order
+  const originalAddPorts = proxy['portManager'].addPorts;
+  proxy['portManager'].addPorts = async function(ports: number[]) {
+    operationLog.push('Starting port listeners');
+    const result = await originalAddPorts.call(this, ports);
+    operationLog.push('Port listeners started');
+    port80Listening = true;
+    return result;
+  };
+  
+  // Track that we created a certificate manager and SmartProxy will call provisionAllCertificates
+  let certManagerCreated = false;
+  
+  // Override createCertificateManager to set up our tracking
+  const originalCreateCertManager = (proxy as any).createCertificateManager;
+  (proxy as any).certManagerCreated = false;
+  
+  // Mock certificate manager to avoid real ACME initialization
+  (proxy as any).createCertificateManager = async function() {
+    operationLog.push('Creating certificate manager');
+    const mockCertManager = {
+      setUpdateRoutesCallback: () => {},
+      setHttpProxy: () => {},
+      setGlobalAcmeDefaults: () => {},
+      setAcmeStateManager: () => {},
+      initialize: async () => {
+        operationLog.push('Certificate manager initialized');
+      },
+      provisionAllCertificates: async () => {
+        operationLog.push('Starting certificate provisioning');
+        if (!port80Listening) {
+          operationLog.push('ERROR: Certificate provisioning started before ports ready');
+        }
+        operationLog.push('Certificate provisioning completed');
+      },
+      stop: async () => {},
+      getAcmeOptions: () => ({ email: 'test@test.local', useProduction: false }),
+      getState: () => ({ challengeRouteActive: false })
+    };
+    certManagerCreated = true;
+    (proxy as any).certManager = mockCertManager;
+    return mockCertManager;
+  };
+  
+  // Start the proxy
+  await proxy.start();
+  
+  // Verify the order of operations
+  expect(operationLog).toContain('Starting port listeners');
+  expect(operationLog).toContain('Port listeners started');
+  expect(operationLog).toContain('Starting certificate provisioning');
+  
+  // Ensure port listeners started before certificate provisioning
+  const portStartIndex = operationLog.indexOf('Port listeners started');
+  const certStartIndex = operationLog.indexOf('Starting certificate provisioning');
+  
+  expect(portStartIndex).toBeLessThan(certStartIndex);
+  expect(operationLog).not.toContain('ERROR: Certificate provisioning started before ports ready');
+  
+  await proxy.stop();
+});
+
+// Test that ACME challenge route is available when certificate is requested
+tap.test('should have ACME challenge route ready before certificate provisioning', async (tapTest) => {
+  let challengeRouteActive = false;
+  let certificateProvisioningStarted = false;
+  
+  const proxy = new SmartProxy({
+    useHttpProxy: [8080],
+    httpProxyPort: 8846, // Use different port to avoid conflicts
+    acme: {
+      email: 'test@test.local',
+      useProduction: false,
+      port: 8080
+    },
+    routes: [{
+      name: 'test-route',
+      match: {
+        ports: 8443,
+        domains: ['test.example.com']
+      },
+      action: {
+        type: 'forward',
+        target: { host: 'localhost', port: 8181 },
+        tls: {
+          mode: 'terminate',
+          certificate: 'auto'
+        }
+      }
+    }]
+  });
+  
+  // Mock the certificate manager to track operations
+  const originalInitialize = proxy['certManager'] ? 
+    proxy['certManager'].initialize : null;
+    
+  if (proxy['certManager']) {
+    const certManager = proxy['certManager'];
+    
+    // Track when challenge route is added
+    const originalAddChallenge = certManager['addChallengeRoute'];
+    certManager['addChallengeRoute'] = async function() {
+      await originalAddChallenge.call(this);
+      challengeRouteActive = true;
+    };
+    
+    // Track when certificate provisioning starts
+    const originalProvisionAcme = certManager['provisionAcmeCertificate'];
+    certManager['provisionAcmeCertificate'] = async function(...args: any[]) {
+      certificateProvisioningStarted = true;
+      // Verify challenge route is active
+      expect(challengeRouteActive).toEqual(true);
+      // Don't actually provision in test
+      return;
+    };
+  }
+  
+  // Mock certificate manager to avoid real ACME initialization
+  (proxy as any).createCertificateManager = async function() {
+    const mockCertManager = {
+      setUpdateRoutesCallback: () => {},
+      setHttpProxy: () => {},
+      setGlobalAcmeDefaults: () => {},
+      setAcmeStateManager: () => {},
+      initialize: async () => {
+        challengeRouteActive = true;
+      },
+      provisionAllCertificates: async () => {
+        certificateProvisioningStarted = true;
+        expect(challengeRouteActive).toEqual(true);
+      },
+      stop: async () => {},
+      getAcmeOptions: () => ({ email: 'test@test.local', useProduction: false }),
+      getState: () => ({ challengeRouteActive: false }),
+      addChallengeRoute: async () => {
+        challengeRouteActive = true;
+      },
+      provisionAcmeCertificate: async () => {
+        certificateProvisioningStarted = true;
+        expect(challengeRouteActive).toEqual(true);
+      }
+    };
+    // Call initialize like the real createCertificateManager does
+    await mockCertManager.initialize();
+    return mockCertManager;
+  };
+  
+  await proxy.start();
+  
+  // Give it a moment to complete initialization
+  await new Promise(resolve => setTimeout(resolve, 100));
+  
+  // Verify challenge route was added before any certificate provisioning
+  expect(challengeRouteActive).toEqual(true);
+  
+  await proxy.stop();
+});
+
+export default tap.start();

test/test.certificate-acme-update.ts

@@ -0,0 +1,77 @@
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import * as plugins from '../ts/plugins.js';
+import * as smartproxy from '../ts/index.js';
+
+// This test verifies that SmartProxy correctly uses the updated SmartAcme v8.0.0 API
+// with the optional wildcard parameter
+
+tap.test('SmartCertManager should call getCertificateForDomain with wildcard option', async () => {
+  console.log('Testing SmartCertManager with SmartAcme v8.0.0 API...');
+  
+  // Create a mock route with ACME certificate configuration
+  const mockRoute: smartproxy.IRouteConfig = {
+    match: {
+      domains: ['test.example.com'],
+      ports: 443
+    },
+    action: {
+      type: 'forward',
+      target: {
+        host: 'localhost',
+        port: 8080
+      },
+      tls: {
+        mode: 'terminate',
+        certificate: 'auto',
+        acme: {
+          email: 'test@example.com',
+          useProduction: false
+        }
+      }
+    },
+    name: 'test-route'
+  };
+  
+  // Create a certificate manager
+  const certManager = new smartproxy.SmartCertManager(
+    [mockRoute],
+    './test-certs',
+    {
+      email: 'test@example.com',
+      useProduction: false
+    }
+  );
+  
+  // Since we can't actually test ACME in a unit test, we'll just verify the logic
+  // The actual test would be that it builds and runs without errors
+  
+  // Test the wildcard logic for different domain types and challenge handlers
+  const testCases = [
+    { domain: 'example.com', hasDnsChallenge: true, shouldIncludeWildcard: true },
+    { domain: 'example.com', hasDnsChallenge: false, shouldIncludeWildcard: false },
+    { domain: 'sub.example.com', hasDnsChallenge: true, shouldIncludeWildcard: true },
+    { domain: 'sub.example.com', hasDnsChallenge: false, shouldIncludeWildcard: false },
+    { domain: '*.example.com', hasDnsChallenge: true, shouldIncludeWildcard: false },
+    { domain: '*.example.com', hasDnsChallenge: false, shouldIncludeWildcard: false },
+    { domain: 'test', hasDnsChallenge: true, shouldIncludeWildcard: false }, // single label domain
+    { domain: 'test', hasDnsChallenge: false, shouldIncludeWildcard: false },
+    { domain: 'my.sub.example.com', hasDnsChallenge: true, shouldIncludeWildcard: true },
+    { domain: 'my.sub.example.com', hasDnsChallenge: false, shouldIncludeWildcard: false }
+  ];
+  
+  for (const testCase of testCases) {
+    const shouldIncludeWildcard = !testCase.domain.startsWith('*.') && 
+                                  testCase.domain.includes('.') && 
+                                  testCase.domain.split('.').length >= 2 &&
+                                  testCase.hasDnsChallenge;
+    
+    console.log(`Domain: ${testCase.domain}, DNS-01: ${testCase.hasDnsChallenge}, Should include wildcard: ${shouldIncludeWildcard}`);
+    expect(shouldIncludeWildcard).toEqual(testCase.shouldIncludeWildcard);
+  }
+  
+  console.log('All wildcard logic tests passed!');
+});
+
+tap.start({
+  throwOnError: true
+});

test/test.certificate-provisioning.ts

@@ -1,396 +1,241 @@
-/**
- * Tests for certificate provisioning with route-based configuration
- */
-import { expect, tap } from '@push.rocks/tapbundle';
-import * as path from 'path';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as plugins from '../ts/plugins.js';
-
-// Import from core modules
-import { CertProvisioner } from '../ts/certificate/providers/cert-provisioner.js';
 import { SmartProxy } from '../ts/proxies/smart-proxy/index.js';
-import { createCertificateProvisioner } from '../ts/certificate/index.js';
-import type { ISmartProxyOptions } from '../ts/proxies/smart-proxy/models/interfaces.js';
+import { expect, tap } from '@git.zone/tstest/tapbundle';
 
-// Extended options interface for testing - allows us to map ports for testing
-interface TestSmartProxyOptions extends ISmartProxyOptions {
-  portMap?: Record<number, number>; // Map standard ports to non-privileged ones for testing
-}
-
-// Import route helpers
-import {
-  createHttpsTerminateRoute,
-  createCompleteHttpsServer,
-  createHttpRoute
-} from '../ts/proxies/smart-proxy/utils/route-helpers.js';
-
-// Import test helpers
-import { loadTestCertificates } from './helpers/certificates.js';
-
-// Create temporary directory for certificates
-const tempDir = path.join(os.tmpdir(), `smartproxy-test-${Date.now()}`);
-fs.mkdirSync(tempDir, { recursive: true });
-
-// Mock Port80Handler class that extends EventEmitter
-class MockPort80Handler extends plugins.EventEmitter {
-  public domainsAdded: string[] = [];
-  
-  addDomain(opts: { domainName: string; sslRedirect: boolean; acmeMaintenance: boolean }) {
-    this.domainsAdded.push(opts.domainName);
-    return true;
-  }
-  
-  async renewCertificate(domain: string): Promise<void> {
-    // In a real implementation, this would trigger certificate renewal
-    console.log(`Mock certificate renewal for ${domain}`);
-  }
-}
-
-// Mock NetworkProxyBridge
-class MockNetworkProxyBridge {
-  public appliedCerts: any[] = [];
-  
-  applyExternalCertificate(cert: any) {
-    this.appliedCerts.push(cert);
-  }
-}
-
-tap.test('CertProvisioner: Should extract certificate domains from routes', async () => {
-  // Create routes with domains requiring certificates
-  const routes = [
-    createHttpsTerminateRoute('example.com', { host: 'localhost', port: 8080 }, {
-      certificate: 'auto'
-    }),
-    createHttpsTerminateRoute('secure.example.com', { host: 'localhost', port: 8081 }, {
-      certificate: 'auto'
-    }),
-    createHttpsTerminateRoute('api.example.com', { host: 'localhost', port: 8082 }, {
-      certificate: 'auto'
-    }),
-    // This route shouldn't require a certificate (passthrough)
-    createHttpsTerminateRoute('passthrough.example.com', { host: 'localhost', port: 8083 }, {
-      certificate: 'auto', // Will be ignored for passthrough
-      httpsPort: 4443,
+const testProxy = new SmartProxy({
+  routes: [{
+    name: 'test-route',
+    match: { ports: 9443, domains: 'test.local' },
+    action: {
+      type: 'forward',
+      target: { host: 'localhost', port: 8080 },
       tls: {
-        mode: 'passthrough'
+        mode: 'terminate',
+        certificate: 'auto',
+        acme: {
+          email: 'test@test.local',
+          useProduction: false
+        }
       }
-    }),
-    // This route shouldn't require a certificate (static certificate provided)
-    createHttpsTerminateRoute('static-cert.example.com', { host: 'localhost', port: 8084 }, {
-      certificate: {
-        key: 'test-key',
-        cert: 'test-cert'
-      }
-    })
-  ];
-
-  // Create mocks
-  const mockPort80 = new MockPort80Handler();
-  const mockBridge = new MockNetworkProxyBridge();
-  
-  // Create certificate provisioner
-  const certProvisioner = new CertProvisioner(
-    routes,
-    mockPort80 as any,
-    mockBridge as any
-  );
-  
-  // Get routes that require certificate provisioning
-  const extractedDomains = (certProvisioner as any).extractCertificateRoutesFromRoutes(routes);
-
-  // Validate extraction
-  expect(extractedDomains).toBeInstanceOf(Array);
-  expect(extractedDomains.length).toBeGreaterThan(0); // Should extract at least some domains
-
-  // Check that the correct domains were extracted
-  const domains = extractedDomains.map(item => item.domain);
-  expect(domains).toInclude('example.com');
-  expect(domains).toInclude('secure.example.com');
-  expect(domains).toInclude('api.example.com');
-
-  // NOTE: Since we're now using createHttpsTerminateRoute for the passthrough domain
-  // and we've set certificate: 'auto', the domain will be included
-  // but will use passthrough mode for TLS
-  expect(domains).toInclude('passthrough.example.com');
-
-  // NOTE: The current implementation extracts all domains with terminate mode,
-  // including those with static certificates. This is different from our expectation,
-  // but we'll update the test to match the actual implementation.
-  expect(domains).toInclude('static-cert.example.com');
-});
-
-tap.test('CertProvisioner: Should handle wildcard domains in routes', async () => {
-  // Create routes with wildcard domains
-  const routes = [
-    createHttpsTerminateRoute('*.example.com', { host: 'localhost', port: 8080 }, {
-      certificate: 'auto'
-    }),
-    createHttpsTerminateRoute('example.org', { host: 'localhost', port: 8081 }, {
-      certificate: 'auto'
-    }),
-    createHttpsTerminateRoute(['api.example.net', 'app.example.net'], { host: 'localhost', port: 8082 }, {
-      certificate: 'auto'
-    })
-  ];
-
-  // Create mocks
-  const mockPort80 = new MockPort80Handler();
-  const mockBridge = new MockNetworkProxyBridge();
-  
-  // Create custom certificate provisioner function
-  const customCertFunc = async (domain: string) => {
-    // Always return a static certificate for testing
-    return {
-      domainName: domain,
-      publicKey: 'TEST-CERT',
-      privateKey: 'TEST-KEY',
-      validUntil: Date.now() + 90 * 24 * 60 * 60 * 1000,
-      created: Date.now(),
-      csr: 'TEST-CSR',
-      id: 'TEST-ID',
-    };
-  };
-
-  // Create certificate provisioner with custom cert function
-  const certProvisioner = new CertProvisioner(
-    routes, 
-    mockPort80 as any,
-    mockBridge as any,
-    customCertFunc
-  );
-
-  // Get routes that require certificate provisioning
-  const extractedDomains = (certProvisioner as any).extractCertificateRoutesFromRoutes(routes);
-  
-  // Validate extraction
-  expect(extractedDomains).toBeInstanceOf(Array);
-  
-  // Check that the correct domains were extracted
-  const domains = extractedDomains.map(item => item.domain);
-  expect(domains).toInclude('*.example.com');
-  expect(domains).toInclude('example.org');
-  expect(domains).toInclude('api.example.net');
-  expect(domains).toInclude('app.example.net');
-});
-
-tap.test('CertProvisioner: Should provision certificates for routes', async () => {
-  const testCerts = loadTestCertificates();
-  
-  // Create the custom provisioner function
-  const mockProvisionFunction = async (domain: string) => {
-    return {
-      domainName: domain,
-      publicKey: testCerts.publicKey,
-      privateKey: testCerts.privateKey,
-      validUntil: Date.now() + 90 * 24 * 60 * 60 * 1000,
-      created: Date.now(),
-      csr: 'TEST-CSR',
-      id: 'TEST-ID',
-    };
-  };
-
-  // Create routes with domains requiring certificates
-  const routes = [
-    createHttpsTerminateRoute('example.com', { host: 'localhost', port: 8080 }, {
-      certificate: 'auto'
-    }),
-    createHttpsTerminateRoute('secure.example.com', { host: 'localhost', port: 8081 }, {
-      certificate: 'auto'
-    })
-  ];
-
-  // Create mocks
-  const mockPort80 = new MockPort80Handler();
-  const mockBridge = new MockNetworkProxyBridge();
-
-  // Create certificate provisioner with mock provider
-  const certProvisioner = new CertProvisioner(
-    routes,
-    mockPort80 as any,
-    mockBridge as any,
-    mockProvisionFunction
-  );
-
-  // Create an events array to catch certificate events
-  const events: any[] = [];
-  certProvisioner.on('certificate', (event) => {
-    events.push(event);
-  });
-
-  // Start the provisioner (which will trigger initial provisioning)
-  await certProvisioner.start();
-  
-  // Verify certificates were provisioned (static provision flow)
-  expect(mockBridge.appliedCerts.length).toBeGreaterThanOrEqual(2);
-  expect(events.length).toBeGreaterThanOrEqual(2);
-  
-  // Check that each domain received a certificate
-  const certifiedDomains = events.map(e => e.domain);
-  expect(certifiedDomains).toInclude('example.com');
-  expect(certifiedDomains).toInclude('secure.example.com');
-
-  // Important: stop the provisioner to clean up any timers or listeners
-  await certProvisioner.stop();
-});
-
-tap.test('SmartProxy: Should handle certificate provisioning through routes', async () => {
-  // Skip this test in CI environments where we can't bind to the needed ports
-  if (process.env.CI) {
-    console.log('Skipping SmartProxy certificate test in CI environment');
-    return;
-  }
-  
-  // Create test certificates
-  const testCerts = loadTestCertificates();
-  
-  // Create mock cert provision function
-  const mockProvisionFunction = async (domain: string) => {
-    return {
-      domainName: domain,
-      publicKey: testCerts.publicKey,
-      privateKey: testCerts.privateKey,
-      validUntil: Date.now() + 90 * 24 * 60 * 60 * 1000,
-      created: Date.now(),
-      csr: 'TEST-CSR',
-      id: 'TEST-ID',
-    };
-  };
-  
-  // Create routes for testing
-  const routes = [
-    // HTTPS with auto certificate
-    createHttpsTerminateRoute('auto.example.com', { host: 'localhost', port: 8080 }, {
-      certificate: 'auto'
-    }),
-    
-    // HTTPS with static certificate
-    createHttpsTerminateRoute('static.example.com', { host: 'localhost', port: 8081 }, {
-      certificate: {
-        key: testCerts.privateKey,
-        cert: testCerts.publicKey
-      }
-    }),
-    
-    // Complete HTTPS server with auto certificate
-    ...createCompleteHttpsServer('auto-complete.example.com', { host: 'localhost', port: 8082 }, {
-      certificate: 'auto'
-    }),
-    
-    // API route with auto certificate - using createHttpRoute with HTTPS options
-    createHttpsTerminateRoute('auto-api.example.com', { host: 'localhost', port: 8083 }, {
-      certificate: 'auto',
-      match: { path: '/api/*' }
-    })
-  ];
-  
-  try {
-    // Create a minimal server to act as a target for testing
-    // This will be used in unit testing only, not in production
-    const mockTarget = new class {
-      server = plugins.http.createServer((req, res) => {
-        res.writeHead(200, { 'Content-Type': 'text/plain' });
-        res.end('Mock target server');
-      });
-      
-      start() {
-        return new Promise<void>((resolve) => {
-          this.server.listen(8080, () => resolve());
-        });
-      }
-      
-      stop() {
-        return new Promise<void>((resolve) => {
-          this.server.close(() => resolve());
-        });
-      }
-    };
-    
-    // Start the mock target
-    await mockTarget.start();
-    
-    // Create a SmartProxy instance that can avoid binding to privileged ports
-    // and using a mock certificate provisioner for testing
-    const proxy = new SmartProxy({
-      // Use TestSmartProxyOptions with portMap for testing
-      routes,
-      // Use high port numbers for testing to avoid need for root privileges
-      portMap: {
-        80: 8080,  // Map HTTP port 80 to 8080
-        443: 4443  // Map HTTPS port 443 to 4443
-      },
-      tlsSetupTimeoutMs: 500, // Lower timeout for testing
-      // Certificate provisioning settings
-      certProvisionFunction: mockProvisionFunction,
-      acme: {
-        enabled: true,
-        accountEmail: 'test@bleu.de',
-        useProduction: false,  // Use staging
-        certificateStore: tempDir
-      }
-    });
-    
-    // Track certificate events
-    const events: any[] = [];
-    proxy.on('certificate', (event) => {
-      events.push(event);
-    });
-    
-    // Instead of starting the actual proxy which tries to bind to ports,
-    // just test the initialization part that handles the certificate configuration
-
-    // We can't access private certProvisioner directly,
-    // so just use dummy events for testing
-    console.log(`Test would provision certificates if actually started`);
-
-    // Add some dummy events for testing
-    proxy.emit('certificate', {
-      domain: 'auto.example.com',
-      certificate: 'test-cert',
-      privateKey: 'test-key',
-      expiryDate: new Date(Date.now() + 90 * 24 * 60 * 60 * 1000),
-      source: 'test'
-    });
-
-    proxy.emit('certificate', {
-      domain: 'auto-complete.example.com',
-      certificate: 'test-cert',
-      privateKey: 'test-key',
-      expiryDate: new Date(Date.now() + 90 * 24 * 60 * 60 * 1000),
-      source: 'test'
-    });
-    
-    // Give time for events to finalize
-    await new Promise(resolve => setTimeout(resolve, 100));
-    
-    // Verify certificates were set up - this test might be skipped due to permissions
-    // For unit testing, we're only testing the routes are set up properly
-    // The errors in the log are expected in non-root environments and can be ignored
-
-    // Stop the mock target server
-    await mockTarget.stop();
-
-    // Instead of directly accessing the private certProvisioner property,
-    // we'll call the public stop method which will clean up internal resources
-    await proxy.stop();
-    
-  } catch (err) {
-    if (err.code === 'EACCES') {
-      console.log('Skipping test: EACCES error (needs privileged ports)');
-    } else {
-      console.error('Error in SmartProxy test:', err);
-      throw err;
     }
+  }],
+  acme: {
+    port: 9080 // Use high port for ACME challenges
   }
 });
 
-tap.test('cleanup', async () => {
-  try {
-    fs.rmSync(tempDir, { recursive: true, force: true });
-    console.log('Temporary directory cleaned up:', tempDir);
-  } catch (err) {
-    console.error('Error cleaning up:', err);
-  }
+tap.test('should provision certificate automatically', async () => {
+  // Mock certificate manager to avoid real ACME initialization
+  const mockCertStatus = {
+    domain: 'test-route',
+    status: 'valid' as const,
+    source: 'acme' as const,
+    expiryDate: new Date(Date.now() + 90 * 24 * 60 * 60 * 1000),
+    issueDate: new Date()
+  };
+  
+  (testProxy as any).createCertificateManager = async function() {
+    return {
+      setUpdateRoutesCallback: () => {},
+      setHttpProxy: () => {},
+      setGlobalAcmeDefaults: () => {},
+      setAcmeStateManager: () => {},
+      initialize: async () => {},
+      provisionAllCertificates: async () => {},
+      stop: async () => {},
+      getAcmeOptions: () => ({ email: 'test@test.local', useProduction: false }),
+      getState: () => ({ challengeRouteActive: false }),
+      getCertificateStatus: () => mockCertStatus
+    };
+  };
+  
+  (testProxy as any).getCertificateStatus = () => mockCertStatus;
+  
+  await testProxy.start();
+  
+  const status = testProxy.getCertificateStatus('test-route');
+  expect(status).toBeDefined();
+  expect(status.status).toEqual('valid');
+  expect(status.source).toEqual('acme');
+  
+  await testProxy.stop();
 });
 
-export default tap.start();
+tap.test('should handle static certificates', async () => {
+  const proxy = new SmartProxy({
+    routes: [{
+      name: 'static-route',
+      match: { ports: 9444, domains: 'static.example.com' },
+      action: {
+        type: 'forward',
+        target: { host: 'localhost', port: 8080 },
+        tls: {
+          mode: 'terminate',
+          certificate: {
+            cert: '-----BEGIN CERTIFICATE-----\nMIIC...\n-----END CERTIFICATE-----',
+            key: '-----BEGIN PRIVATE KEY-----\nMIIE...\n-----END PRIVATE KEY-----'
+          }
+        }
+      }
+    }]
+  });
+  
+  await proxy.start();
+  
+  const status = proxy.getCertificateStatus('static-route');
+  expect(status).toBeDefined();
+  expect(status.status).toEqual('valid');
+  expect(status.source).toEqual('static');
+  
+  await proxy.stop();
+});
+
+tap.test('should handle ACME challenge routes', async () => {
+  const proxy = new SmartProxy({
+    routes: [{
+      name: 'auto-cert-route',
+      match: { ports: 9445, domains: 'acme.local' },
+      action: {
+        type: 'forward',
+        target: { host: 'localhost', port: 8080 },
+        tls: {
+          mode: 'terminate',
+          certificate: 'auto',
+          acme: {
+            email: 'acme@test.local',
+            useProduction: false,
+            challengePort: 9081
+          }
+        }
+      }
+    }, {
+      name: 'port-9081-route',
+      match: { ports: 9081, domains: 'acme.local' },
+      action: {
+        type: 'forward',
+        target: { host: 'localhost', port: 8080 }
+      }
+    }],
+    acme: {
+      port: 9081 // Use high port for ACME challenges
+    }
+  });
+  
+  // Mock certificate manager to avoid real ACME initialization
+  (proxy as any).createCertificateManager = async function() {
+    return {
+      setUpdateRoutesCallback: () => {},
+      setHttpProxy: () => {},
+      setGlobalAcmeDefaults: () => {},
+      setAcmeStateManager: () => {},
+      initialize: async () => {},
+      provisionAllCertificates: async () => {},
+      stop: async () => {},
+      getAcmeOptions: () => ({ email: 'acme@test.local', useProduction: false }),
+      getState: () => ({ challengeRouteActive: false })
+    };
+  };
+  
+  await proxy.start();
+  
+  // Verify the proxy is configured with routes including the necessary port
+  const routes = proxy.settings.routes;
+  
+  // Check that we have a route listening on the ACME challenge port
+  const acmeChallengePort = 9081;
+  const routesOnChallengePort = routes.filter((r: any) => {
+    const ports = Array.isArray(r.match.ports) ? r.match.ports : [r.match.ports];
+    return ports.includes(acmeChallengePort);
+  });
+  
+  expect(routesOnChallengePort.length).toBeGreaterThan(0);
+  expect(routesOnChallengePort[0].name).toEqual('port-9081-route');
+  
+  // Verify the main route has ACME configuration
+  const mainRoute = routes.find((r: any) => r.name === 'auto-cert-route');
+  expect(mainRoute).toBeDefined();
+  expect(mainRoute?.action.tls?.certificate).toEqual('auto');
+  expect(mainRoute?.action.tls?.acme?.email).toEqual('acme@test.local');
+  expect(mainRoute?.action.tls?.acme?.challengePort).toEqual(9081);
+  
+  await proxy.stop();
+});
+
+tap.test('should renew certificates', async () => {
+  const proxy = new SmartProxy({
+    routes: [{
+      name: 'renew-route',
+      match: { ports: 9446, domains: 'renew.local' },
+      action: {
+        type: 'forward',
+        target: { host: 'localhost', port: 8080 },
+        tls: {
+          mode: 'terminate',
+          certificate: 'auto',
+          acme: {
+            email: 'renew@test.local',
+            useProduction: false,
+            renewBeforeDays: 30
+          }
+        }
+      }
+    }],
+    acme: {
+      port: 9082 // Use high port for ACME challenges
+    }
+  });
+  
+  // Mock certificate manager with renewal capability
+  let renewCalled = false;
+  const mockCertStatus = {
+    domain: 'renew-route',
+    status: 'valid' as const,
+    source: 'acme' as const,
+    expiryDate: new Date(Date.now() + 90 * 24 * 60 * 60 * 1000),
+    issueDate: new Date()
+  };
+  
+  (proxy as any).certManager = {
+    renewCertificate: async (routeName: string) => {
+      renewCalled = true;
+      expect(routeName).toEqual('renew-route');
+    },
+    getCertificateStatus: () => mockCertStatus,
+    setUpdateRoutesCallback: () => {},
+    setHttpProxy: () => {},
+    setGlobalAcmeDefaults: () => {},
+    setAcmeStateManager: () => {},
+    initialize: async () => {},
+    provisionAllCertificates: async () => {},
+    stop: async () => {},
+    getAcmeOptions: () => ({ email: 'renew@test.local', useProduction: false }),
+    getState: () => ({ challengeRouteActive: false })
+  };
+  
+  (proxy as any).createCertificateManager = async function() {
+    return this.certManager;
+  };
+  
+  (proxy as any).getCertificateStatus = function(routeName: string) {
+    return this.certManager.getCertificateStatus(routeName);
+  };
+  
+  (proxy as any).renewCertificate = async function(routeName: string) {
+    if (this.certManager) {
+      await this.certManager.renewCertificate(routeName);
+    }
+  };
+  
+  await proxy.start();
+  
+  // Force renewal
+  await proxy.renewCertificate('renew-route');
+  expect(renewCalled).toBeTrue();
+  
+  const status = proxy.getCertificateStatus('renew-route');
+  expect(status).toBeDefined();
+  expect(status.status).toEqual('valid');
+  
+  await proxy.stop();
+});
+
+tap.start();

test/test.certificate-simple.ts

@@ -0,0 +1,60 @@
+import { SmartProxy } from '../ts/proxies/smart-proxy/index.js';
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+
+tap.test('should create SmartProxy with certificate routes', async () => {
+  const proxy = new SmartProxy({
+    routes: [{
+      name: 'test-route',
+      match: { ports: 8443, domains: 'test.example.com' },
+      action: {
+        type: 'forward',
+        target: { host: 'localhost', port: 8080 },
+        tls: {
+          mode: 'terminate',
+          certificate: 'auto',
+          acme: {
+            email: 'test@example.com',
+            useProduction: false
+          }
+        }
+      }
+    }]
+  });
+  
+  expect(proxy).toBeDefined();
+  expect(proxy.settings.routes.length).toEqual(1);
+});
+
+tap.test('should handle socket handler route type', async () => {
+  // Create a test route with socket handler
+  const proxy = new SmartProxy({
+    routes: [{
+      name: 'socket-handler-test',
+      match: { ports: 8080, path: '/test' },
+      action: {
+        type: 'socket-handler',
+        socketHandler: (socket, context) => {
+          socket.once('data', (data) => {
+            const response = [
+              'HTTP/1.1 200 OK',
+              'Content-Type: text/plain',
+              'Content-Length: 23',
+              'Connection: close',
+              '',
+              'Hello from socket handler'
+            ].join('\r\n');
+            
+            socket.write(response);
+            socket.end();
+          });
+        }
+      }
+    }]
+  });
+  
+  const route = proxy.settings.routes[0];
+  expect(route.action.type).toEqual('socket-handler');
+  expect(route.action.socketHandler).toBeDefined();
+});
+
+tap.start();

test/test.certprovisioner.unit.ts

@@ -1,211 +0,0 @@
-import { tap, expect } from '@push.rocks/tapbundle';
-import * as plugins from '../ts/plugins.js';
-import { CertProvisioner } from '../ts/certificate/providers/cert-provisioner.js';
-import type { IRouteConfig } from '../ts/proxies/smart-proxy/models/route-types.js';
-import type { ICertificateData } from '../ts/certificate/models/certificate-types.js';
-import type { TCertProvisionObject } from '../ts/certificate/providers/cert-provisioner.js';
-
-// Fake Port80Handler stub
-class FakePort80Handler extends plugins.EventEmitter {
-  public domainsAdded: string[] = [];
-  public renewCalled: string[] = [];
-  addDomain(opts: { domainName: string; sslRedirect: boolean; acmeMaintenance: boolean }) {
-    this.domainsAdded.push(opts.domainName);
-  }
-  async renewCertificate(domain: string): Promise<void> {
-    this.renewCalled.push(domain);
-  }
-}
-
-// Fake NetworkProxyBridge stub
-class FakeNetworkProxyBridge {
-  public appliedCerts: ICertificateData[] = [];
-  applyExternalCertificate(cert: ICertificateData) {
-    this.appliedCerts.push(cert);
-  }
-}
-
-tap.test('CertProvisioner handles static provisioning', async () => {
-  const domain = 'static.com';
-  // Create route-based configuration for testing
-  const routeConfigs: IRouteConfig[] = [{
-    name: 'Static Route',
-    match: {
-      ports: 443,
-      domains: [domain]
-    },
-    action: {
-      type: 'forward',
-      target: { host: 'localhost', port: 443 },
-      tls: {
-        mode: 'terminate-and-reencrypt',
-        certificate: 'auto'
-      }
-    }
-  }];
-  const fakePort80 = new FakePort80Handler();
-  const fakeBridge = new FakeNetworkProxyBridge();
-  // certProvider returns static certificate
-  const certProvider = async (d: string): Promise<TCertProvisionObject> => {
-    expect(d).toEqual(domain);
-    return {
-      domainName: domain,
-      publicKey: 'CERT',
-      privateKey: 'KEY',
-      validUntil: Date.now() + 3600 * 1000,
-      created: Date.now(),
-      csr: 'CSR',
-      id: 'ID',
-    };
-  };
-  const prov = new CertProvisioner(
-    routeConfigs,
-    fakePort80 as any,
-    fakeBridge as any,
-    certProvider,
-    1, // low renew threshold
-    1, // short interval
-    false // disable auto renew for unit test
-  );
-  const events: any[] = [];
-  prov.on('certificate', (data) => events.push(data));
-  await prov.start();
-  // Static flow: no addDomain, certificate applied via bridge
-  expect(fakePort80.domainsAdded.length).toEqual(0);
-  expect(fakeBridge.appliedCerts.length).toEqual(1);
-  expect(events.length).toEqual(1);
-  const evt = events[0];
-  expect(evt.domain).toEqual(domain);
-  expect(evt.certificate).toEqual('CERT');
-  expect(evt.privateKey).toEqual('KEY');
-  expect(evt.isRenewal).toEqual(false);
-  expect(evt.source).toEqual('static');
-  expect(evt.routeReference).toBeTruthy();
-  expect(evt.routeReference.routeName).toEqual('Static Route');
-});
-
-tap.test('CertProvisioner handles http01 provisioning', async () => {
-  const domain = 'http01.com';
-  // Create route-based configuration for testing
-  const routeConfigs: IRouteConfig[] = [{
-    name: 'HTTP01 Route',
-    match: {
-      ports: 443,
-      domains: [domain]
-    },
-    action: {
-      type: 'forward',
-      target: { host: 'localhost', port: 80 },
-      tls: {
-        mode: 'terminate',
-        certificate: 'auto'
-      }
-    }
-  }];
-  const fakePort80 = new FakePort80Handler();
-  const fakeBridge = new FakeNetworkProxyBridge();
-  // certProvider returns http01 directive
-  const certProvider = async (): Promise<TCertProvisionObject> => 'http01';
-  const prov = new CertProvisioner(
-    routeConfigs,
-    fakePort80 as any,
-    fakeBridge as any,
-    certProvider,
-    1,
-    1,
-    false
-  );
-  const events: any[] = [];
-  prov.on('certificate', (data) => events.push(data));
-  await prov.start();
-  // HTTP-01 flow: addDomain called, no static cert applied
-  expect(fakePort80.domainsAdded).toEqual([domain]);
-  expect(fakeBridge.appliedCerts.length).toEqual(0);
-  expect(events.length).toEqual(0);
-});
-
-tap.test('CertProvisioner on-demand http01 renewal', async () => {
-  const domain = 'renew.com';
-  // Create route-based configuration for testing
-  const routeConfigs: IRouteConfig[] = [{
-    name: 'Renewal Route',
-    match: {
-      ports: 443,
-      domains: [domain]
-    },
-    action: {
-      type: 'forward',
-      target: { host: 'localhost', port: 80 },
-      tls: {
-        mode: 'terminate',
-        certificate: 'auto'
-      }
-    }
-  }];
-  const fakePort80 = new FakePort80Handler();
-  const fakeBridge = new FakeNetworkProxyBridge();
-  const certProvider = async (): Promise<TCertProvisionObject> => 'http01';
-  const prov = new CertProvisioner(
-    routeConfigs,
-    fakePort80 as any,
-    fakeBridge as any,
-    certProvider,
-    1,
-    1,
-    false
-  );
-  // requestCertificate should call renewCertificate
-  await prov.requestCertificate(domain);
-  expect(fakePort80.renewCalled).toEqual([domain]);
-});
-
-tap.test('CertProvisioner on-demand static provisioning', async () => {
-  const domain = 'ondemand.com';
-  // Create route-based configuration for testing
-  const routeConfigs: IRouteConfig[] = [{
-    name: 'On-Demand Route',
-    match: {
-      ports: 443,
-      domains: [domain]
-    },
-    action: {
-      type: 'forward',
-      target: { host: 'localhost', port: 443 },
-      tls: {
-        mode: 'terminate-and-reencrypt',
-        certificate: 'auto'
-      }
-    }
-  }];
-  const fakePort80 = new FakePort80Handler();
-  const fakeBridge = new FakeNetworkProxyBridge();
-  const certProvider = async (): Promise<TCertProvisionObject> => ({
-    domainName: domain,
-    publicKey: 'PKEY',
-    privateKey: 'PRIV',
-    validUntil: Date.now() + 1000,
-    created: Date.now(),
-    csr: 'CSR',
-    id: 'ID',
-  });
-  const prov = new CertProvisioner(
-    routeConfigs,
-    fakePort80 as any,
-    fakeBridge as any,
-    certProvider,
-    1,
-    1,
-    false
-  );
-  const events: any[] = [];
-  prov.on('certificate', (data) => events.push(data));
-  await prov.requestCertificate(domain);
-  expect(fakeBridge.appliedCerts.length).toEqual(1);
-  expect(events.length).toEqual(1);
-  expect(events[0].domain).toEqual(domain);
-  expect(events[0].source).toEqual('static');
-  expect(events[0].routeReference).toBeTruthy();
-  expect(events[0].routeReference.routeName).toEqual('On-Demand Route');
-});
-
-export default tap.start();

test/test.connection-forwarding.ts

@@ -0,0 +1,278 @@
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import * as net from 'net';
+import * as tls from 'tls';
+import * as fs from 'fs';
+import * as path from 'path';
+import { SmartProxy } from '../ts/proxies/smart-proxy/smart-proxy.js';
+import type { IRouteConfig } from '../ts/proxies/smart-proxy/models/route-types.js';
+
+// Setup test infrastructure
+const testCertPath = path.join(process.cwd(), 'test', 'helpers', 'test-cert.pem');
+const testKeyPath = path.join(process.cwd(), 'test', 'helpers', 'test-key.pem');
+
+let testServer: net.Server;
+let tlsTestServer: tls.Server;
+let smartProxy: SmartProxy;
+
+tap.test('setup test servers', async () => {
+  // Create TCP test server
+  testServer = net.createServer((socket) => {
+    socket.write('Connected to TCP test server\n');
+    socket.on('data', (data) => {
+      socket.write(`TCP Echo: ${data}`);
+    });
+  });
+
+  await new Promise<void>((resolve) => {
+    testServer.listen(7001, '127.0.0.1', () => {
+      console.log('TCP test server listening on port 7001');
+      resolve();
+    });
+  });
+
+  // Create TLS test server for SNI testing
+  tlsTestServer = tls.createServer(
+    {
+      cert: fs.readFileSync(testCertPath),
+      key: fs.readFileSync(testKeyPath),
+    },
+    (socket) => {
+      socket.write('Connected to TLS test server\n');
+      socket.on('data', (data) => {
+        socket.write(`TLS Echo: ${data}`);
+      });
+    }
+  );
+
+  await new Promise<void>((resolve) => {
+    tlsTestServer.listen(7002, '127.0.0.1', () => {
+      console.log('TLS test server listening on port 7002');
+      resolve();
+    });
+  });
+});
+
+tap.test('should forward TCP connections correctly', async () => {
+  // Create SmartProxy with forward route
+  smartProxy = new SmartProxy({
+    enableDetailedLogging: true,
+    routes: [
+      {
+        id: 'tcp-forward',
+        name: 'TCP Forward Route',
+        match: {
+          ports: 8080,
+        },
+        action: {
+          type: 'forward',
+          target: {
+            host: '127.0.0.1',
+            port: 7001,
+          },
+        },
+      },
+    ],
+  });
+
+  await smartProxy.start();
+
+  // Test TCP forwarding
+  const client = await new Promise<net.Socket>((resolve, reject) => {
+    const socket = net.connect(8080, '127.0.0.1', () => {
+      console.log('Connected to proxy');
+      resolve(socket);
+    });
+    socket.on('error', reject);
+  });
+
+  // Test data transmission
+  await new Promise<void>((resolve) => {
+    client.on('data', (data) => {
+      const response = data.toString();
+      console.log('Received:', response);
+      expect(response).toContain('Connected to TCP test server');
+      client.end();
+      resolve();
+    });
+
+    client.write('Hello from client');
+  });
+
+  await smartProxy.stop();
+});
+
+tap.test('should handle TLS passthrough correctly', async () => {
+  // Create SmartProxy with TLS passthrough route
+  smartProxy = new SmartProxy({
+    enableDetailedLogging: true,
+    routes: [
+      {
+        id: 'tls-passthrough',
+        name: 'TLS Passthrough Route',
+        match: {
+          ports: 8443,
+          domains: 'test.example.com',
+        },
+        action: {
+          type: 'forward',
+          tls: {
+            mode: 'passthrough',
+          },
+          target: {
+            host: '127.0.0.1',
+            port: 7002,
+          },
+        },
+      },
+    ],
+  });
+
+  await smartProxy.start();
+
+  // Test TLS passthrough
+  const client = await new Promise<tls.TLSSocket>((resolve, reject) => {
+    const socket = tls.connect(
+      {
+        port: 8443,
+        host: '127.0.0.1',
+        servername: 'test.example.com',
+        rejectUnauthorized: false,
+      },
+      () => {
+        console.log('Connected via TLS');
+        resolve(socket);
+      }
+    );
+    socket.on('error', reject);
+  });
+
+  // Test data transmission over TLS
+  await new Promise<void>((resolve) => {
+    client.on('data', (data) => {
+      const response = data.toString();
+      console.log('TLS Received:', response);
+      expect(response).toContain('Connected to TLS test server');
+      client.end();
+      resolve();
+    });
+
+    client.write('Hello from TLS client');
+  });
+
+  await smartProxy.stop();
+});
+
+tap.test('should handle SNI-based forwarding', async () => {
+  // Create SmartProxy with multiple domain routes
+  smartProxy = new SmartProxy({
+    enableDetailedLogging: true,
+    routes: [
+      {
+        id: 'domain-a',
+        name: 'Domain A Route',
+        match: {
+          ports: 8443,
+          domains: 'a.example.com',
+        },
+        action: {
+          type: 'forward',
+          tls: {
+            mode: 'passthrough',
+          },
+          target: {
+            host: '127.0.0.1',
+            port: 7002,
+          },
+        },
+      },
+      {
+        id: 'domain-b',
+        name: 'Domain B Route',
+        match: {
+          ports: 8443,
+          domains: 'b.example.com',
+        },
+        action: {
+          type: 'forward',
+          tls: {
+            mode: 'passthrough',
+          },
+          target: {
+            host: '127.0.0.1',
+            port: 7002,
+          },
+        },
+      },
+    ],
+  });
+
+  await smartProxy.start();
+
+  // Test domain A (TLS passthrough)
+  const clientA = await new Promise<tls.TLSSocket>((resolve, reject) => {
+    const socket = tls.connect(
+      {
+        port: 8443,
+        host: '127.0.0.1',
+        servername: 'a.example.com',
+        rejectUnauthorized: false,
+      },
+      () => {
+        console.log('Connected to domain A');
+        resolve(socket);
+      }
+    );
+    socket.on('error', reject);
+  });
+
+  await new Promise<void>((resolve) => {
+    clientA.on('data', (data) => {
+      const response = data.toString();
+      console.log('Domain A response:', response);
+      expect(response).toContain('Connected to TLS test server');
+      clientA.end();
+      resolve();
+    });
+
+    clientA.write('Hello from domain A');
+  });
+
+  // Test domain B should also use TLS since it's on port 8443
+  const clientB = await new Promise<tls.TLSSocket>((resolve, reject) => {
+    const socket = tls.connect(
+      {
+        port: 8443,
+        host: '127.0.0.1',
+        servername: 'b.example.com',
+        rejectUnauthorized: false,
+      },
+      () => {
+        console.log('Connected to domain B');
+        resolve(socket);
+      }
+    );
+    socket.on('error', reject);
+  });
+
+  await new Promise<void>((resolve) => {
+    clientB.on('data', (data) => {
+      const response = data.toString();
+      console.log('Domain B response:', response);
+      // Should be forwarded to TLS server
+      expect(response).toContain('Connected to TLS test server');
+      clientB.end();
+      resolve();
+    });
+
+    clientB.write('Hello from domain B');
+  });
+
+  await smartProxy.stop();
+});
+
+tap.test('cleanup', async () => {
+  testServer.close();
+  tlsTestServer.close();
+});
+
+export default tap.start();

test/test.fix-verification.ts

@@ -0,0 +1,82 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import { SmartProxy } from '../ts/index.js';
+
+tap.test('should verify certificate manager callback is preserved on updateRoutes', async () => {
+  // Create proxy with initial cert routes
+  const proxy = new SmartProxy({
+    routes: [{
+      name: 'cert-route',
+      match: { ports: [18443], domains: ['test.local'] },
+      action: {
+        type: 'forward',
+        target: { host: 'localhost', port: 3000 },
+        tls: {
+          mode: 'terminate',
+          certificate: 'auto',
+          acme: { email: 'test@local.test' }
+        }
+      }
+    }],
+    acme: { email: 'test@local.test', port: 18080 }
+  });
+  
+  // Track callback preservation
+  let initialCallbackSet = false;
+  let updateCallbackSet = false;
+  
+  // Mock certificate manager creation
+  (proxy as any).createCertificateManager = async function(...args: any[]) {
+    const certManager = {
+      updateRoutesCallback: null as any,
+      setUpdateRoutesCallback: function(callback: any) {
+        this.updateRoutesCallback = callback;
+        if (!initialCallbackSet) {
+          initialCallbackSet = true;
+        } else {
+          updateCallbackSet = true;
+        }
+      },
+      setHttpProxy: () => {},
+      setGlobalAcmeDefaults: () => {},
+      setAcmeStateManager: () => {},
+      initialize: async () => {},
+      provisionAllCertificates: async () => {},
+      stop: async () => {},
+      getAcmeOptions: () => ({ email: 'test@local.test' }),
+      getState: () => ({ challengeRouteActive: false })
+    };
+    
+    // Set callback as in real implementation
+    certManager.setUpdateRoutesCallback(async (routes) => {
+      await this.updateRoutes(routes);
+    });
+    
+    return certManager;
+  };
+  
+  await proxy.start();
+  expect(initialCallbackSet).toEqual(true);
+  
+  // Update routes - this should preserve the callback
+  await proxy.updateRoutes([{
+    name: 'updated-route',
+    match: { ports: [18444], domains: ['test2.local'] },
+    action: {
+      type: 'forward',
+      target: { host: 'localhost', port: 3001 },
+      tls: {
+        mode: 'terminate',
+        certificate: 'auto',
+        acme: { email: 'test@local.test' }
+      }
+    }
+  }]);
+  
+  expect(updateCallbackSet).toEqual(true);
+  
+  await proxy.stop();
+  
+  console.log('Fix verified: Certificate manager callback is preserved on updateRoutes');
+});
+
+tap.start();

test/test.forwarding-fix-verification.ts

@@ -0,0 +1,151 @@
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import * as net from 'net';
+import { SmartProxy } from '../ts/proxies/smart-proxy/smart-proxy.js';
+
+let testServer: net.Server;
+let smartProxy: SmartProxy;
+
+tap.test('setup test server', async () => {
+  // Create a test server that handles connections
+  testServer = await new Promise<net.Server>((resolve) => {
+    const server = net.createServer((socket) => {
+      console.log('Test server: Client connected');
+      socket.write('Welcome from test server\n');
+      
+      socket.on('data', (data) => {
+        console.log(`Test server received: ${data.toString().trim()}`);
+        socket.write(`Echo: ${data}`);
+      });
+      
+      socket.on('close', () => {
+        console.log('Test server: Client disconnected');
+      });
+    });
+    
+    server.listen(6789, () => {
+      console.log('Test server listening on port 6789');
+      resolve(server);
+    });
+  });
+});
+
+tap.test('regular forward route should work correctly', async () => {
+  smartProxy = new SmartProxy({
+    routes: [{
+      id: 'test-forward',
+      name: 'Test Forward Route',
+      match: { ports: 7890 },
+      action: {
+        type: 'forward',
+        target: { host: 'localhost', port: 6789 }
+      }
+    }]
+  });
+
+  await smartProxy.start();
+
+  // Create a client connection
+  const client = await new Promise<net.Socket>((resolve, reject) => {
+    const socket = net.connect(7890, 'localhost', () => {
+      console.log('Client connected to proxy');
+      resolve(socket);
+    });
+    socket.on('error', reject);
+  });
+
+  // Test data exchange with timeout
+  const response = await new Promise<string>((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error('Timeout waiting for initial response'));
+    }, 5000);
+    
+    client.on('data', (data) => {
+      clearTimeout(timeout);
+      resolve(data.toString());
+    });
+    
+    client.on('error', (err) => {
+      clearTimeout(timeout);
+      reject(err);
+    });
+  });
+
+  expect(response).toContain('Welcome from test server');
+  
+  // Send data through proxy
+  client.write('Test message');
+  
+  const echo = await new Promise<string>((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      reject(new Error('Timeout waiting for echo response'));
+    }, 5000);
+    
+    client.once('data', (data) => {
+      clearTimeout(timeout);
+      resolve(data.toString());
+    });
+    
+    client.on('error', (err) => {
+      clearTimeout(timeout);
+      reject(err);
+    });
+  });
+  
+  expect(echo).toContain('Echo: Test message');
+  
+  client.end();
+  await smartProxy.stop();
+});
+
+tap.skip.test('NFTables forward route should not terminate connections (requires root)', async () => {
+  smartProxy = new SmartProxy({
+    routes: [{
+      id: 'nftables-test',
+      name: 'NFTables Test Route',
+      match: { ports: 7891 },
+      action: {
+        type: 'forward',
+        forwardingEngine: 'nftables',
+        target: { host: 'localhost', port: 6789 }
+      }
+    }]
+  });
+
+  await smartProxy.start();
+
+  // Create a client connection
+  const client = await new Promise<net.Socket>((resolve, reject) => {
+    const socket = net.connect(7891, 'localhost', () => {
+      console.log('Client connected to NFTables proxy');
+      resolve(socket);
+    });
+    socket.on('error', reject);
+  });
+
+  // With NFTables, the connection should stay open at the application level
+  // even though forwarding happens at kernel level
+  let connectionClosed = false;
+  client.on('close', () => {
+    connectionClosed = true;
+  });
+
+  // Wait a bit to ensure connection isn't immediately closed
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  
+  expect(connectionClosed).toEqual(false);
+  console.log('NFTables connection stayed open as expected');
+  
+  client.end();
+  await smartProxy.stop();
+});
+
+tap.test('cleanup', async () => {
+  if (testServer) {
+    testServer.close();
+  }
+  if (smartProxy) {
+    await smartProxy.stop();
+  }
+});
+
+export default tap.start();

test/test.forwarding-regression.ts

@@ -0,0 +1,111 @@
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import * as net from 'net';
+import { SmartProxy } from '../ts/proxies/smart-proxy/smart-proxy.js';
+
+// Test to verify port forwarding works correctly
+tap.test('forward connections should not be immediately closed', async (t) => {
+  // Create a backend server that accepts connections
+  const testServer = net.createServer((socket) => {
+    console.log('Client connected to test server');
+    socket.write('Welcome from test server\n');
+    
+    socket.on('data', (data) => {
+      console.log('Test server received:', data.toString());
+      socket.write(`Echo: ${data}`);
+    });
+    
+    socket.on('error', (err) => {
+      console.error('Test server socket error:', err);
+    });
+  });
+
+  // Listen on a non-privileged port
+  await new Promise<void>((resolve) => {
+    testServer.listen(9090, '127.0.0.1', () => {
+      console.log('Test server listening on port 9090');
+      resolve();
+    });
+  });
+
+  // Create SmartProxy with a forward route
+  const smartProxy = new SmartProxy({
+    enableDetailedLogging: true,
+    routes: [
+      {
+        id: 'forward-test',
+        name: 'Forward Test Route',
+        match: {
+          ports: 8080,
+        },
+        action: {
+          type: 'forward',
+          target: {
+            host: '127.0.0.1',
+            port: 9090,
+          },
+        },
+      },
+    ],
+  });
+
+  await smartProxy.start();
+
+  // Create a client connection through the proxy
+  const client = net.createConnection({
+    port: 8080,
+    host: '127.0.0.1',
+  });
+
+  let connectionClosed = false;
+  let dataReceived = false;
+  let welcomeMessage = '';
+
+  client.on('connect', () => {
+    console.log('Client connected to proxy');
+  });
+
+  client.on('data', (data) => {
+    console.log('Client received:', data.toString());
+    dataReceived = true;
+    welcomeMessage = data.toString();
+  });
+
+  client.on('close', () => {
+    console.log('Client connection closed');
+    connectionClosed = true;
+  });
+
+  client.on('error', (err) => {
+    console.error('Client error:', err);
+  });
+
+  // Wait for the welcome message
+  let waitTime = 0;
+  while (!dataReceived && waitTime < 2000) {
+    await new Promise(resolve => setTimeout(resolve, 100));
+    waitTime += 100;
+  }
+  
+  if (!dataReceived) {
+    throw new Error('Data should be received from the server');
+  }
+
+  // Verify we got the welcome message
+  expect(welcomeMessage).toContain('Welcome from test server');
+  
+  // Send some data
+  client.write('Hello from client');
+  
+  // Wait a bit to make sure connection isn't immediately closed
+  await new Promise(resolve => setTimeout(resolve, 100));
+  
+  // Connection should still be open
+  expect(connectionClosed).toEqual(false);
+  
+  // Clean up
+  client.end();
+  await smartProxy.stop();
+  testServer.close();
+});
+
+export default tap.start();

test/test.forwarding.examples.ts

@@ -1,168 +1,145 @@
 import * as path from 'path';
-import { tap, expect } from '@push.rocks/tapbundle';
+import { tap, expect } from '@git.zone/tstest/tapbundle';
 
 import { SmartProxy } from '../ts/proxies/smart-proxy/index.js';
 import {
   createHttpRoute,
-  createHttpsRoute,
-  createPassthroughRoute,
-  createRedirectRoute,
+  createHttpsTerminateRoute,
+  createHttpsPassthroughRoute,
   createHttpToHttpsRedirect,
-  createBlockRoute,
+  createCompleteHttpsServer,
   createLoadBalancerRoute,
-  createHttpsServer,
-  createPortRange,
-  createSecurityConfig,
-  createStaticFileRoute,
-  createTestRoute
-} from '../ts/proxies/smart-proxy/route-helpers/index.js';
+  createApiRoute,
+  createWebSocketRoute
+} from '../ts/proxies/smart-proxy/utils/route-helpers.js';
 import type { IRouteConfig } from '../ts/proxies/smart-proxy/models/route-types.js';
 
 // Test to demonstrate various route configurations using the new helpers
 tap.test('Route-based configuration examples', async (tools) => {
   // Example 1: HTTP-only configuration
-  const httpOnlyRoute = createHttpRoute({
-    domains: 'http.example.com',
-    target: {
+  const httpOnlyRoute = createHttpRoute(
+    'http.example.com',
+    {
       host: 'localhost',
       port: 3000
     },
-    security: {
-      allowedIps: ['*'] // Allow all
-    },
-    name: 'Basic HTTP Route'
-  });
+    {
+      name: 'Basic HTTP Route'
+    }
+  );
 
   console.log('HTTP-only route created successfully:', httpOnlyRoute.name);
   expect(httpOnlyRoute.action.type).toEqual('forward');
   expect(httpOnlyRoute.match.domains).toEqual('http.example.com');
 
   // Example 2: HTTPS Passthrough (SNI) configuration
-  const httpsPassthroughRoute = createPassthroughRoute({
-    domains: 'pass.example.com',
-    target: {
+  const httpsPassthroughRoute = createHttpsPassthroughRoute(
+    'pass.example.com',
+    {
       host: ['10.0.0.1', '10.0.0.2'], // Round-robin target IPs
       port: 443
     },
-    security: {
-      allowedIps: ['*'] // Allow all
-    },
-    name: 'HTTPS Passthrough Route'
-  });
+    {
+      name: 'HTTPS Passthrough Route'
+    }
+  );
 
   expect(httpsPassthroughRoute).toBeTruthy();
   expect(httpsPassthroughRoute.action.tls?.mode).toEqual('passthrough');
   expect(Array.isArray(httpsPassthroughRoute.action.target?.host)).toBeTrue();
 
   // Example 3: HTTPS Termination to HTTP Backend
-  const terminateToHttpRoute = createHttpsRoute({
-    domains: 'secure.example.com',
-    target: {
+  const terminateToHttpRoute = createHttpsTerminateRoute(
+    'secure.example.com',
+    {
       host: 'localhost',
       port: 8080
     },
-    tlsMode: 'terminate',
-    certificate: 'auto',
-    headers: {
-      'X-Forwarded-Proto': 'https'
-    },
-    security: {
-      allowedIps: ['*'] // Allow all
-    },
-    name: 'HTTPS Termination to HTTP Backend'
-  });
+    {
+      certificate: 'auto',
+      name: 'HTTPS Termination to HTTP Backend'
+    }
+  );
 
   // Create the HTTP to HTTPS redirect for this domain
-  const httpToHttpsRedirect = createHttpToHttpsRedirect({
-    domains: 'secure.example.com',
-    name: 'HTTP to HTTPS Redirect for secure.example.com'
-  });
+  const httpToHttpsRedirect = createHttpToHttpsRedirect(
+    'secure.example.com',
+    443,
+    {
+      name: 'HTTP to HTTPS Redirect for secure.example.com'
+    }
+  );
 
   expect(terminateToHttpRoute).toBeTruthy();
   expect(terminateToHttpRoute.action.tls?.mode).toEqual('terminate');
-  expect(terminateToHttpRoute.action.advanced?.headers?.['X-Forwarded-Proto']).toEqual('https');
-  expect(httpToHttpsRedirect.action.type).toEqual('redirect');
+  expect(httpToHttpsRedirect.action.type).toEqual('socket-handler');
 
   // Example 4: Load Balancer with HTTPS
-  const loadBalancerRoute = createLoadBalancerRoute({
-    domains: 'proxy.example.com',
-    targets: ['internal-api-1.local', 'internal-api-2.local'],
-    targetPort: 8443,
-    tlsMode: 'terminate-and-reencrypt',
-    certificate: 'auto',
-    headers: {
-      'X-Original-Host': '{domain}'
-    },
-    security: {
-      allowedIps: ['10.0.0.0/24', '192.168.1.0/24'],
-      maxConnections: 1000
-    },
-    name: 'Load Balanced HTTPS Route'
-  });
+  const loadBalancerRoute = createLoadBalancerRoute(
+    'proxy.example.com',
+    ['internal-api-1.local', 'internal-api-2.local'],
+    8443,
+    {
+      tls: {
+        mode: 'terminate-and-reencrypt',
+        certificate: 'auto'
+      },
+      name: 'Load Balanced HTTPS Route'
+    }
+  );
 
   expect(loadBalancerRoute).toBeTruthy();
   expect(loadBalancerRoute.action.tls?.mode).toEqual('terminate-and-reencrypt');
   expect(Array.isArray(loadBalancerRoute.action.target?.host)).toBeTrue();
-  expect(loadBalancerRoute.action.security?.allowedIps?.length).toEqual(2);
 
-  // Example 5: Block specific IPs
-  const blockRoute = createBlockRoute({
-    ports: [80, 443],
-    clientIp: ['192.168.5.0/24'],
-    name: 'Block Suspicious IPs',
-    priority: 1000 // High priority to ensure it's evaluated first
-  });
+  // Example 5: API Route
+  const apiRoute = createApiRoute(
+    'api.example.com',
+    '/api',
+    { host: 'localhost', port: 8081 },
+    {
+      name: 'API Route',
+      useTls: true,
+      addCorsHeaders: true
+    }
+  );
 
-  expect(blockRoute.action.type).toEqual('block');
-  expect(blockRoute.match.clientIp?.length).toEqual(1);
-  expect(blockRoute.priority).toEqual(1000);
+  expect(apiRoute.action.type).toEqual('forward');
+  expect(apiRoute.match.path).toBeTruthy();
 
   // Example 6: Complete HTTPS Server with HTTP Redirect
-  const httpsServerRoutes = createHttpsServer({
-    domains: 'complete.example.com',
-    target: {
+  const httpsServerRoutes = createCompleteHttpsServer(
+    'complete.example.com',
+    {
       host: 'localhost',
       port: 8080
     },
-    certificate: 'auto',
-    name: 'Complete HTTPS Server'
-  });
+    {
+      certificate: 'auto',
+      name: 'Complete HTTPS Server'
+    }
+  );
 
   expect(Array.isArray(httpsServerRoutes)).toBeTrue();
   expect(httpsServerRoutes.length).toEqual(2); // HTTPS route and HTTP redirect
   expect(httpsServerRoutes[0].action.tls?.mode).toEqual('terminate');
-  expect(httpsServerRoutes[1].action.type).toEqual('redirect');
+  expect(httpsServerRoutes[1].action.type).toEqual('socket-handler');
 
-  // Example 7: Static File Server
-  const staticFileRoute = createStaticFileRoute({
-    domains: 'static.example.com',
-    targetDirectory: '/var/www/static',
-    tlsMode: 'terminate',
-    certificate: 'auto',
-    headers: {
-      'Cache-Control': 'public, max-age=86400'
-    },
-    name: 'Static File Server'
-  });
+  // Example 7: Static File Server - removed (use nginx/apache behind proxy)
 
-  expect(staticFileRoute.action.advanced?.staticFiles?.directory).toEqual('/var/www/static');
-  expect(staticFileRoute.action.advanced?.headers?.['Cache-Control']).toEqual('public, max-age=86400');
-
-  // Example 8: Test Route for Debugging
-  const testRoute = createTestRoute({
-    ports: 8000,
-    domains: 'test.example.com',
-    response: {
-      status: 200,
-      headers: {
-        'Content-Type': 'application/json'
-      },
-      body: JSON.stringify({ status: 'ok', message: 'API is working!' })
+  // Example 8: WebSocket Route
+  const webSocketRoute = createWebSocketRoute(
+    'ws.example.com',
+    '/ws',
+    { host: 'localhost', port: 8082 },
+    {
+      useTls: true,
+      name: 'WebSocket Route'
     }
-  });
+  );
 
-  expect(testRoute.match.ports).toEqual(8000);
-  expect(testRoute.action.advanced?.testResponse?.status).toEqual(200);
+  expect(webSocketRoute.action.type).toEqual('forward');
+  expect(webSocketRoute.action.websocket?.enabled).toBeTrue();
 
   // Create a SmartProxy instance with all routes
   const allRoutes: IRouteConfig[] = [
@@ -171,27 +148,20 @@ tap.test('Route-based configuration examples', async (tools) => {
     terminateToHttpRoute,
     httpToHttpsRedirect,
     loadBalancerRoute,
-    blockRoute,
+    apiRoute,
     ...httpsServerRoutes,
-    staticFileRoute,
-    testRoute
+    webSocketRoute
   ];
 
   // We're not actually starting the SmartProxy in this test,
   // just verifying that the configuration is valid
   const smartProxy = new SmartProxy({
-    routes: allRoutes,
-    acme: {
-      email: 'admin@example.com',
-      termsOfServiceAgreed: true,
-      directoryUrl: 'https://acme-staging-v02.api.letsencrypt.org/directory'
-    }
+    routes: allRoutes
   });
 
-  console.log(`Smart Proxy configured with ${allRoutes.length} routes`);
-
-  // Verify our example proxy was created correctly
-  expect(smartProxy).toBeTruthy();
+  // Just verify that all routes are configured correctly
+  console.log(`Created ${allRoutes.length} example routes`);
+  expect(allRoutes.length).toEqual(9); // One less without static file route
 });
 
 export default tap.start();

test/test.forwarding.ts

@@ -1,10 +1,9 @@
-import { tap, expect } from '@push.rocks/tapbundle';
+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 { httpOnly, tlsTerminateToHttp, tlsTerminateToHttps, httpsPassthrough } from '../ts/forwarding/config/forwarding-types.js';
 // Import route-based helpers
 import {
   createHttpRoute,
@@ -14,11 +13,15 @@ import {
   createCompleteHttpsServer
 } from '../ts/proxies/smart-proxy/utils/route-helpers.js';
 
+// Create helper functions for backward compatibility
 const helpers = {
-  httpOnly,
-  tlsTerminateToHttp,
-  tlsTerminateToHttps,
-  httpsPassthrough
+  httpOnly: (domains: string | string[], target: any) => createHttpRoute(domains, target),
+  tlsTerminateToHttp: (domains: string | string[], target: any) => 
+    createHttpsTerminateRoute(domains, target),
+  tlsTerminateToHttps: (domains: string | string[], target: any) => 
+    createHttpsTerminateRoute(domains, target, { reencrypt: true }),
+  httpsPassthrough: (domains: string | string[], target: any) => 
+    createHttpsPassthroughRoute(domains, target)
 };
 
 // Route-based utility functions for testing
@@ -27,207 +30,59 @@ function findRouteForDomain(routes: any[], domain: string): any {
     const domains = Array.isArray(route.match.domains)
       ? route.match.domains
       : [route.match.domains];
-
-    return domains.some(d => {
-      // Handle wildcard domains
-      if (d.startsWith('*.')) {
-        const suffix = d.substring(2);
-        return domain.endsWith(suffix) && domain.split('.').length > suffix.split('.').length;
-      }
-      return d === domain;
-    });
+    return domains.includes(domain);
   });
 }
 
-tap.test('ForwardingHandlerFactory - apply defaults based on type', async () => {
-      // HTTP-only defaults
-      const httpConfig: IForwardConfig = {
-        type: 'http-only',
-        target: { host: 'localhost', port: 3000 }
-      };
-      
-      const expandedHttpConfig = ForwardingHandlerFactory.applyDefaults(httpConfig);
-      expect(expandedHttpConfig.http?.enabled).toEqual(true);
-      
-      // HTTPS-passthrough defaults
-      const passthroughConfig: IForwardConfig = {
-        type: 'https-passthrough',
-        target: { host: 'localhost', port: 443 }
-      };
-      
-      const expandedPassthroughConfig = ForwardingHandlerFactory.applyDefaults(passthroughConfig);
-      expect(expandedPassthroughConfig.https?.forwardSni).toEqual(true);
-      expect(expandedPassthroughConfig.http?.enabled).toEqual(false);
-      
-      // HTTPS-terminate-to-http defaults
-      const terminateToHttpConfig: IForwardConfig = {
-        type: 'https-terminate-to-http',
-        target: { host: 'localhost', port: 3000 }
-      };
-      
-      const expandedTerminateToHttpConfig = ForwardingHandlerFactory.applyDefaults(terminateToHttpConfig);
-      expect(expandedTerminateToHttpConfig.http?.enabled).toEqual(true);
-      expect(expandedTerminateToHttpConfig.http?.redirectToHttps).toEqual(true);
-      expect(expandedTerminateToHttpConfig.acme?.enabled).toEqual(true);
-      expect(expandedTerminateToHttpConfig.acme?.maintenance).toEqual(true);
-      
-      // HTTPS-terminate-to-https defaults
-      const terminateToHttpsConfig: IForwardConfig = {
-        type: 'https-terminate-to-https',
-        target: { host: 'localhost', port: 8443 }
-      };
-      
-      const expandedTerminateToHttpsConfig = ForwardingHandlerFactory.applyDefaults(terminateToHttpsConfig);
-      expect(expandedTerminateToHttpsConfig.http?.enabled).toEqual(true);
-      expect(expandedTerminateToHttpsConfig.http?.redirectToHttps).toEqual(true);
-      expect(expandedTerminateToHttpsConfig.acme?.enabled).toEqual(true);
-      expect(expandedTerminateToHttpsConfig.acme?.maintenance).toEqual(true);
-    });
-    
-tap.test('ForwardingHandlerFactory - validate configuration', async () => {
-      // Valid configuration
-      const validConfig: IForwardConfig = {
-        type: 'http-only',
-        target: { host: 'localhost', port: 3000 }
-      };
-      
-      expect(() => ForwardingHandlerFactory.validateConfig(validConfig)).not.toThrow();
-      
-      // Invalid configuration - missing target
-      const invalidConfig1: any = {
-        type: 'http-only'
-      };
-      
-      expect(() => ForwardingHandlerFactory.validateConfig(invalidConfig1)).toThrow();
-      
-      // Invalid configuration - invalid port
-      const invalidConfig2: IForwardConfig = {
-        type: 'http-only',
-        target: { host: 'localhost', port: 0 }
-      };
-      
-      expect(() => ForwardingHandlerFactory.validateConfig(invalidConfig2)).toThrow();
-      
-      // Invalid configuration - HTTP disabled for HTTP-only
-      const invalidConfig3: IForwardConfig = {
-        type: 'http-only',
-        target: { host: 'localhost', port: 3000 },
-        http: { enabled: false }
-      };
-      
-      expect(() => ForwardingHandlerFactory.validateConfig(invalidConfig3)).toThrow();
-      
-      // Invalid configuration - HTTP enabled for HTTPS passthrough
-      const invalidConfig4: IForwardConfig = {
-        type: 'https-passthrough',
-        target: { host: 'localhost', port: 443 },
-        http: { enabled: true }
-      };
-      
-      expect(() => ForwardingHandlerFactory.validateConfig(invalidConfig4)).toThrow();
-    });
-tap.test('Route Management - manage route configurations', async () => {
-      // Create an array to store routes
-      const routes: any[] = [];
+// Replace the old test with route-based tests
+tap.test('Route Helpers - Create HTTP routes', async () => {
+  const route = helpers.httpOnly('example.com', { host: 'localhost', port: 3000 });
+  expect(route.action.type).toEqual('forward');
+  expect(route.match.domains).toEqual('example.com');
+  expect(route.action.target).toEqual({ host: 'localhost', port: 3000 });
+});
 
-      // Add a route configuration
-      const httpRoute = createHttpRoute('example.com', { host: 'localhost', port: 3000 });
-      routes.push(httpRoute);
+tap.test('Route Helpers - Create HTTPS terminate to HTTP routes', async () => {
+  const route = helpers.tlsTerminateToHttp('secure.example.com', { host: 'localhost', port: 3000 });
+  expect(route.action.type).toEqual('forward');
+  expect(route.match.domains).toEqual('secure.example.com');
+  expect(route.action.tls?.mode).toEqual('terminate');
+});
 
-      // Check that the configuration was added
-      expect(routes.length).toEqual(1);
-      expect(routes[0].match.domains).toEqual('example.com');
-      expect(routes[0].action.type).toEqual('forward');
-      expect(routes[0].action.target.host).toEqual('localhost');
-      expect(routes[0].action.target.port).toEqual(3000);
+tap.test('Route Helpers - Create HTTPS passthrough routes', async () => {
+  const route = helpers.httpsPassthrough('passthrough.example.com', { host: 'backend', port: 443 });
+  expect(route.action.type).toEqual('forward');
+  expect(route.match.domains).toEqual('passthrough.example.com');
+  expect(route.action.tls?.mode).toEqual('passthrough');
+});
 
-      // Find a route for a domain
-      const foundRoute = findRouteForDomain(routes, 'example.com');
-      expect(foundRoute).toBeDefined();
+tap.test('Route Helpers - Create HTTPS to HTTPS routes', async () => {
+  const route = helpers.tlsTerminateToHttps('reencrypt.example.com', { host: 'backend', port: 443 });
+  expect(route.action.type).toEqual('forward');
+  expect(route.match.domains).toEqual('reencrypt.example.com');
+  expect(route.action.tls?.mode).toEqual('terminate-and-reencrypt');
+});
 
-      // Remove a route configuration
-      const initialLength = routes.length;
-      const domainToRemove = 'example.com';
-      const indexToRemove = routes.findIndex(route => {
-        const domains = Array.isArray(route.match.domains) ? route.match.domains : [route.match.domains];
-        return domains.includes(domainToRemove);
-      });
+tap.test('Route Helpers - Create complete HTTPS server with redirect', async () => {
+  const routes = createCompleteHttpsServer(
+    'full.example.com',
+    { host: 'localhost', port: 3000 },
+    { certificate: 'auto' }
+  );
+  
+  expect(routes.length).toEqual(2);
+  
+  // Check HTTP to HTTPS redirect - find route by port
+  const redirectRoute = routes.find(r => r.match.ports === 80);
+  expect(redirectRoute.action.type).toEqual('socket-handler');
+  expect(redirectRoute.action.socketHandler).toBeDefined();
+  expect(redirectRoute.match.ports).toEqual(80);
+  
+  // Check HTTPS route
+  const httpsRoute = routes.find(r => r.action.type === 'forward');
+  expect(httpsRoute.match.ports).toEqual(443);
+  expect(httpsRoute.action.tls?.mode).toEqual('terminate');
+});
 
-      if (indexToRemove !== -1) {
-        routes.splice(indexToRemove, 1);
-      }
-
-      expect(routes.length).toEqual(initialLength - 1);
-
-      // Check that the configuration was removed
-      expect(routes.length).toEqual(0);
-
-      // Check that no route exists anymore
-      const notFoundRoute = findRouteForDomain(routes, 'example.com');
-      expect(notFoundRoute).toBeUndefined();
-    });
-
-tap.test('Route Management - support wildcard domains', async () => {
-      // Create an array to store routes
-      const routes: any[] = [];
-
-      // Add a wildcard domain route
-      const wildcardRoute = createHttpRoute('*.example.com', { host: 'localhost', port: 3000 });
-      routes.push(wildcardRoute);
-
-      // Find a route for a subdomain
-      const foundRoute = findRouteForDomain(routes, 'test.example.com');
-      expect(foundRoute).toBeDefined();
-
-      // Find a route for a different domain (should not match)
-      const notFoundRoute = findRouteForDomain(routes, 'example.org');
-      expect(notFoundRoute).toBeUndefined();
-    });
-tap.test('Route Helper Functions - create HTTP route', async () => {
-      const route = createHttpRoute('example.com', { host: 'localhost', port: 3000 });
-      expect(route.match.domains).toEqual('example.com');
-      expect(route.match.ports).toEqual(80);
-      expect(route.action.type).toEqual('forward');
-      expect(route.action.target.host).toEqual('localhost');
-      expect(route.action.target.port).toEqual(3000);
-    });
-
-tap.test('Route Helper Functions - create HTTPS terminate route', async () => {
-      const route = createHttpsTerminateRoute('example.com', { host: 'localhost', port: 3000 });
-      expect(route.match.domains).toEqual('example.com');
-      expect(route.match.ports).toEqual(443);
-      expect(route.action.type).toEqual('forward');
-      expect(route.action.target.host).toEqual('localhost');
-      expect(route.action.target.port).toEqual(3000);
-      expect(route.action.tls?.mode).toEqual('terminate');
-      expect(route.action.tls?.certificate).toEqual('auto');
-    });
-
-tap.test('Route Helper Functions - create complete HTTPS server', async () => {
-      const routes = createCompleteHttpsServer('example.com', { host: 'localhost', port: 8443 });
-      expect(routes.length).toEqual(2);
-
-      // HTTPS route
-      expect(routes[0].match.domains).toEqual('example.com');
-      expect(routes[0].match.ports).toEqual(443);
-      expect(routes[0].action.type).toEqual('forward');
-      expect(routes[0].action.target.host).toEqual('localhost');
-      expect(routes[0].action.target.port).toEqual(8443);
-      expect(routes[0].action.tls?.mode).toEqual('terminate');
-
-      // HTTP redirect route
-      expect(routes[1].match.domains).toEqual('example.com');
-      expect(routes[1].match.ports).toEqual(80);
-      expect(routes[1].action.type).toEqual('redirect');
-    });
-
-tap.test('Route Helper Functions - create HTTPS passthrough route', async () => {
-      const route = createHttpsPassthroughRoute('example.com', { host: 'localhost', port: 443 });
-      expect(route.match.domains).toEqual('example.com');
-      expect(route.match.ports).toEqual(443);
-      expect(route.action.type).toEqual('forward');
-      expect(route.action.target.host).toEqual('localhost');
-      expect(route.action.target.port).toEqual(443);
-      expect(route.action.tls?.mode).toEqual('passthrough');
-    });
+// Export test runner
 export default tap.start();

test/test.forwarding.unit.ts

@@ -1,168 +1,53 @@
-import { tap, expect } from '@push.rocks/tapbundle';
+import { tap, expect } from '@git.zone/tstest/tapbundle';
 import * as plugins from '../ts/plugins.js';
-import type { IForwardConfig } 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 { httpOnly, tlsTerminateToHttp, tlsTerminateToHttps, httpsPassthrough } from '../ts/forwarding/config/forwarding-types.js';
-// Import route-based helpers
+// Import route-based helpers from the correct location
 import {
   createHttpRoute,
   createHttpsTerminateRoute,
   createHttpsPassthroughRoute,
   createHttpToHttpsRedirect,
-  createCompleteHttpsServer
-} from '../ts/proxies/smart-proxy/utils/route-helpers.js';
+  createCompleteHttpsServer,
+  createLoadBalancerRoute
+} from '../ts/proxies/smart-proxy/utils/route-patterns.js';
 
+// Create helper functions for building forwarding configs
 const helpers = {
-  httpOnly,
-  tlsTerminateToHttp,
-  tlsTerminateToHttps,
-  httpsPassthrough
+  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: IForwardConfig = {
-        type: 'http-only',
-        target: { host: 'localhost', port: 3000 }
-      };
-      
-      const expandedHttpConfig = ForwardingHandlerFactory.applyDefaults(httpConfig);
-      expect(expandedHttpConfig.http?.enabled).toEqual(true);
+  // 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');
+});
 
-      // HTTPS-passthrough defaults
-      const passthroughConfig: IForwardConfig = {
-        type: 'https-passthrough',
-        target: { host: 'localhost', port: 443 }
-      };
+tap.test('ForwardingHandlerFactory - factory function for handlers', async () => {
+  // @todo Implement unit tests for ForwardingHandlerFactory
+  // These tests would need proper mocking of the handlers
+});
 
-      const expandedPassthroughConfig = ForwardingHandlerFactory.applyDefaults(passthroughConfig);
-      expect(expandedPassthroughConfig.https?.forwardSni).toEqual(true);
-      expect(expandedPassthroughConfig.http?.enabled).toEqual(false);
-
-      // HTTPS-terminate-to-http defaults
-      const terminateToHttpConfig: IForwardConfig = {
-        type: 'https-terminate-to-http',
-        target: { host: 'localhost', port: 3000 }
-      };
-
-      const expandedTerminateToHttpConfig = ForwardingHandlerFactory.applyDefaults(terminateToHttpConfig);
-      expect(expandedTerminateToHttpConfig.http?.enabled).toEqual(true);
-      expect(expandedTerminateToHttpConfig.http?.redirectToHttps).toEqual(true);
-      expect(expandedTerminateToHttpConfig.acme?.enabled).toEqual(true);
-      expect(expandedTerminateToHttpConfig.acme?.maintenance).toEqual(true);
-
-      // HTTPS-terminate-to-https defaults
-      const terminateToHttpsConfig: IForwardConfig = {
-        type: 'https-terminate-to-https',
-        target: { host: 'localhost', port: 8443 }
-      };
-
-      const expandedTerminateToHttpsConfig = ForwardingHandlerFactory.applyDefaults(terminateToHttpsConfig);
-      expect(expandedTerminateToHttpsConfig.http?.enabled).toEqual(true);
-      expect(expandedTerminateToHttpsConfig.http?.redirectToHttps).toEqual(true);
-      expect(expandedTerminateToHttpsConfig.acme?.enabled).toEqual(true);
-      expect(expandedTerminateToHttpsConfig.acme?.maintenance).toEqual(true);
-    });
-    
-tap.test('ForwardingHandlerFactory - validate configuration', async () => {
-      // Valid configuration
-      const validConfig: IForwardConfig = {
-        type: 'http-only',
-        target: { host: 'localhost', port: 3000 }
-      };
-      
-      expect(() => ForwardingHandlerFactory.validateConfig(validConfig)).not.toThrow();
-      
-      // Invalid configuration - missing target
-      const invalidConfig1: any = {
-        type: 'http-only'
-      };
-      
-      expect(() => ForwardingHandlerFactory.validateConfig(invalidConfig1)).toThrow();
-      
-      // Invalid configuration - invalid port
-      const invalidConfig2: IForwardConfig = {
-        type: 'http-only',
-        target: { host: 'localhost', port: 0 }
-      };
-      
-      expect(() => ForwardingHandlerFactory.validateConfig(invalidConfig2)).toThrow();
-      
-      // Invalid configuration - HTTP disabled for HTTP-only
-      const invalidConfig3: IForwardConfig = {
-        type: 'http-only',
-        target: { host: 'localhost', port: 3000 },
-        http: { enabled: false }
-      };
-      
-      expect(() => ForwardingHandlerFactory.validateConfig(invalidConfig3)).toThrow();
-      
-      // Invalid configuration - HTTP enabled for HTTPS passthrough
-      const invalidConfig4: IForwardConfig = {
-        type: 'https-passthrough',
-        target: { host: 'localhost', port: 443 },
-        http: { enabled: true }
-      };
-      
-      expect(() => ForwardingHandlerFactory.validateConfig(invalidConfig4)).toThrow();
-    });
-tap.test('Route Helper - create HTTP route configuration', async () => {
-      // Create a route-based configuration
-      const route = createHttpRoute('example.com', { host: 'localhost', port: 3000 });
-
-      // Verify route properties
-      expect(route.match.domains).toEqual('example.com');
-      expect(route.action.type).toEqual('forward');
-      expect(route.action.target?.host).toEqual('localhost');
-      expect(route.action.target?.port).toEqual(3000);
-    });
-tap.test('Route Helper Functions - create HTTP route', async () => {
-      const route = createHttpRoute('example.com', { host: 'localhost', port: 3000 });
-      expect(route.match.domains).toEqual('example.com');
-      expect(route.match.ports).toEqual(80);
-      expect(route.action.type).toEqual('forward');
-      expect(route.action.target.host).toEqual('localhost');
-      expect(route.action.target.port).toEqual(3000);
-    });
-
-tap.test('Route Helper Functions - create HTTPS terminate route', async () => {
-      const route = createHttpsTerminateRoute('example.com', { host: 'localhost', port: 3000 });
-      expect(route.match.domains).toEqual('example.com');
-      expect(route.match.ports).toEqual(443);
-      expect(route.action.type).toEqual('forward');
-      expect(route.action.target.host).toEqual('localhost');
-      expect(route.action.target.port).toEqual(3000);
-      expect(route.action.tls?.mode).toEqual('terminate');
-      expect(route.action.tls?.certificate).toEqual('auto');
-    });
-
-tap.test('Route Helper Functions - create complete HTTPS server', async () => {
-      const routes = createCompleteHttpsServer('example.com', { host: 'localhost', port: 8443 });
-      expect(routes.length).toEqual(2);
-
-      // HTTPS route
-      expect(routes[0].match.domains).toEqual('example.com');
-      expect(routes[0].match.ports).toEqual(443);
-      expect(routes[0].action.type).toEqual('forward');
-      expect(routes[0].action.target.host).toEqual('localhost');
-      expect(routes[0].action.target.port).toEqual(8443);
-      expect(routes[0].action.tls?.mode).toEqual('terminate');
-
-      // HTTP redirect route
-      expect(routes[1].match.domains).toEqual('example.com');
-      expect(routes[1].match.ports).toEqual(80);
-      expect(routes[1].action.type).toEqual('redirect');
-    });
-
-tap.test('Route Helper Functions - create HTTPS passthrough route', async () => {
-      const route = createHttpsPassthroughRoute('example.com', { host: 'localhost', port: 443 });
-      expect(route.match.domains).toEqual('example.com');
-      expect(route.match.ports).toEqual(443);
-      expect(route.action.type).toEqual('forward');
-      expect(route.action.target.host).toEqual('localhost');
-      expect(route.action.target.port).toEqual(443);
-      expect(route.action.tls?.mode).toEqual('passthrough');
-    });
 export default tap.start();

test/test.http-fix-unit.ts

@@ -0,0 +1,183 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import * as net from 'net';
+
+// Unit test for the HTTP forwarding fix
+tap.test('should forward non-TLS connections on HttpProxy ports', async (tapTest) => {
+  // Test configuration
+  const testPort = 8080;
+  const httpProxyPort = 8844;
+  
+  // Track forwarding logic
+  let forwardedToHttpProxy = false;
+  let setupDirectConnection = false;
+  
+  // Create mock settings
+  const mockSettings = {
+    useHttpProxy: [testPort],
+    httpProxyPort: httpProxyPort,
+    routes: [{
+      name: 'test-route',
+      match: { ports: testPort },
+      action: {
+        type: 'forward',
+        target: { host: 'localhost', port: 8181 }
+      }
+    }]
+  };
+  
+  // Create mock connection record
+  const mockRecord = {
+    id: 'test-connection',
+    localPort: testPort,
+    remoteIP: '127.0.0.1',
+    isTLS: false
+  };
+  
+  // Mock HttpProxyBridge
+  const mockHttpProxyBridge = {
+    getHttpProxy: () => ({ available: true }),
+    forwardToHttpProxy: async () => {
+      forwardedToHttpProxy = true;
+    }
+  };
+  
+  // Test the logic from handleForwardAction
+  const route = mockSettings.routes[0];
+  const action = route.action as any;
+  
+  // Simulate the fixed logic
+  if (!action.tls) {
+    // No TLS settings - check if this port should use HttpProxy
+    const isHttpProxyPort = mockSettings.useHttpProxy?.includes(mockRecord.localPort);
+    
+    if (isHttpProxyPort && mockHttpProxyBridge.getHttpProxy()) {
+      // Forward non-TLS connections to HttpProxy if configured
+      console.log(`Using HttpProxy for non-TLS connection on port ${mockRecord.localPort}`);
+      await mockHttpProxyBridge.forwardToHttpProxy();
+    } else {
+      // Basic forwarding
+      console.log(`Using basic forwarding`);
+      setupDirectConnection = true;
+    }
+  }
+  
+  // Verify the fix works correctly
+  expect(forwardedToHttpProxy).toEqual(true);
+  expect(setupDirectConnection).toEqual(false);
+  
+  console.log('Test passed: Non-TLS connections on HttpProxy ports are forwarded correctly');
+});
+
+// Test that non-HttpProxy ports still use direct connection
+tap.test('should use direct connection for non-HttpProxy ports', async (tapTest) => {
+  let forwardedToHttpProxy = false;
+  let setupDirectConnection = false;
+  
+  const mockSettings = {
+    useHttpProxy: [80, 443], // Different ports
+    httpProxyPort: 8844,
+    routes: [{
+      name: 'test-route',
+      match: { ports: 8080 }, // Not in useHttpProxy
+      action: {
+        type: 'forward',
+        target: { host: 'localhost', port: 8181 }
+      }
+    }]
+  };
+  
+  const mockRecord = {
+    id: 'test-connection-2',
+    localPort: 8080, // Not in useHttpProxy
+    remoteIP: '127.0.0.1',
+    isTLS: false
+  };
+  
+  const mockHttpProxyBridge = {
+    getHttpProxy: () => ({ available: true }),
+    forwardToHttpProxy: async () => {
+      forwardedToHttpProxy = true;
+    }
+  };
+  
+  const route = mockSettings.routes[0];
+  const action = route.action as any;
+  
+  // Test the logic
+  if (!action.tls) {
+    const isHttpProxyPort = mockSettings.useHttpProxy?.includes(mockRecord.localPort);
+    
+    if (isHttpProxyPort && mockHttpProxyBridge.getHttpProxy()) {
+      console.log(`Using HttpProxy for non-TLS connection on port ${mockRecord.localPort}`);
+      await mockHttpProxyBridge.forwardToHttpProxy();
+    } else {
+      console.log(`Using basic forwarding for port ${mockRecord.localPort}`);
+      setupDirectConnection = true;
+    }
+  }
+  
+  // Verify port 8080 uses direct connection when not in useHttpProxy
+  expect(forwardedToHttpProxy).toEqual(false);
+  expect(setupDirectConnection).toEqual(true);
+  
+  console.log('Test passed: Non-HttpProxy ports use direct connection');
+});
+
+// Test HTTP-01 ACME challenge scenario
+tap.test('should handle ACME HTTP-01 challenges on port 80 with HttpProxy', async (tapTest) => {
+  let forwardedToHttpProxy = false;
+  
+  const mockSettings = {
+    useHttpProxy: [80], // Port 80 configured for HttpProxy
+    httpProxyPort: 8844,
+    acme: {
+      port: 80,
+      email: 'test@example.com'
+    },
+    routes: [{
+      name: 'acme-challenge',
+      match: { 
+        ports: 80,
+        paths: ['/.well-known/acme-challenge/*']
+      },
+      action: {
+        type: 'forward',
+        target: { host: 'localhost', port: 8080 }
+      }
+    }]
+  };
+  
+  const mockRecord = {
+    id: 'acme-connection',
+    localPort: 80,
+    remoteIP: '127.0.0.1',
+    isTLS: false
+  };
+  
+  const mockHttpProxyBridge = {
+    getHttpProxy: () => ({ available: true }),
+    forwardToHttpProxy: async () => {
+      forwardedToHttpProxy = true;
+    }
+  };
+  
+  const route = mockSettings.routes[0];
+  const action = route.action as any;
+  
+  // Test the fix for ACME HTTP-01 challenges
+  if (!action.tls) {
+    const isHttpProxyPort = mockSettings.useHttpProxy?.includes(mockRecord.localPort);
+    
+    if (isHttpProxyPort && mockHttpProxyBridge.getHttpProxy()) {
+      console.log(`Using HttpProxy for ACME challenge on port ${mockRecord.localPort}`);
+      await mockHttpProxyBridge.forwardToHttpProxy();
+    }
+  }
+  
+  // Verify HTTP-01 challenges on port 80 go through HttpProxy
+  expect(forwardedToHttpProxy).toEqual(true);
+  
+  console.log('Test passed: ACME HTTP-01 challenges on port 80 use HttpProxy');
+});
+
+tap.start();

test/test.http-fix-verification.ts

@@ -0,0 +1,249 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import { RouteConnectionHandler } from '../ts/proxies/smart-proxy/route-connection-handler.js';
+import type { ISmartProxyOptions } from '../ts/proxies/smart-proxy/models/interfaces.js';
+import * as net from 'net';
+
+// Direct test of the fix in RouteConnectionHandler
+tap.test('should detect and forward non-TLS connections on useHttpProxy ports', async (tapTest) => {
+  // Create mock objects
+  const mockSettings: ISmartProxyOptions = {
+    useHttpProxy: [8080],
+    httpProxyPort: 8844,
+    routes: [{
+      name: 'test-route',
+      match: { ports: 8080 },
+      action: {
+        type: 'forward',
+        target: { host: 'localhost', port: 8181 }
+      }
+    }]
+  };
+  
+  let httpProxyForwardCalled = false;
+  let directConnectionCalled = false;
+  
+  // Create mocks for dependencies
+  const mockHttpProxyBridge = {
+    getHttpProxy: () => ({ available: true }),
+    forwardToHttpProxy: async (...args: any[]) => {
+      console.log('Mock: forwardToHttpProxy called');
+      httpProxyForwardCalled = true;
+    }
+  };
+  
+  // Mock connection manager
+  const mockConnectionManager = {
+    createConnection: (socket: any) => ({
+      id: 'test-connection',
+      localPort: 8080,
+      remoteIP: '127.0.0.1',
+      isTLS: false
+    }),
+    initiateCleanupOnce: () => {},
+    cleanupConnection: () => {},
+    getConnectionCount: () => 1,
+    handleError: (type: string, record: any) => {
+      return (error: Error) => {
+        console.log(`Mock: Error handled for ${type}: ${error.message}`);
+      };
+    }
+  };
+  
+  // Mock route manager that returns a matching route
+  const mockRouteManager = {
+    findMatchingRoute: (criteria: any) => ({
+      route: mockSettings.routes[0]
+    }),
+    getAllRoutes: () => mockSettings.routes,
+    getRoutesForPort: (port: number) => mockSettings.routes.filter(r => {
+      const ports = Array.isArray(r.match.ports) ? r.match.ports : [r.match.ports];
+      return ports.some(p => {
+        if (typeof p === 'number') {
+          return p === port;
+        } else if (p && typeof p === 'object' && 'from' in p && 'to' in p) {
+          return port >= p.from && port <= p.to;
+        }
+        return false;
+      });
+    })
+  };
+  
+  // Mock security manager
+  const mockSecurityManager = {
+    validateIP: () => ({ allowed: true })
+  };
+  
+  // Create route connection handler instance
+  const handler = new RouteConnectionHandler(
+    mockSettings,
+    mockConnectionManager as any,
+    mockSecurityManager as any, // security manager
+    {} as any, // tls manager
+    mockHttpProxyBridge as any,
+    {} as any, // timeout manager
+    mockRouteManager as any
+  );
+  
+  // Override setupDirectConnection to track if it's called
+  handler['setupDirectConnection'] = (...args: any[]) => {
+    console.log('Mock: setupDirectConnection called');
+    directConnectionCalled = true;
+  };
+  
+  // Test: Create a mock socket representing non-TLS connection on port 8080
+  const mockSocket = {
+    localPort: 8080,
+    remoteAddress: '127.0.0.1',
+    on: function(event: string, handler: Function) { return this; },
+    once: function(event: string, handler: Function) {
+      // Capture the data handler
+      if (event === 'data') {
+        this._dataHandler = handler;
+      }
+      return this;
+    },
+    end: () => {},
+    destroy: () => {},
+    pause: () => {},
+    resume: () => {},
+    removeListener: function() { return this; },
+    emit: () => {},
+    setNoDelay: () => {},
+    setKeepAlive: () => {},
+    _dataHandler: null as any
+  } as any;
+  
+  // Simulate the handler processing the connection
+  handler.handleConnection(mockSocket);
+  
+  // Simulate receiving non-TLS data
+  if (mockSocket._dataHandler) {
+    mockSocket._dataHandler(Buffer.from('GET / HTTP/1.1\r\nHost: test.local\r\n\r\n'));
+  }
+  
+  // Give it a moment to process
+  await new Promise(resolve => setTimeout(resolve, 100));
+  
+  // Verify that the connection was forwarded to HttpProxy, not direct connection
+  expect(httpProxyForwardCalled).toEqual(true);
+  expect(directConnectionCalled).toEqual(false);
+});
+
+// Test that verifies TLS connections still work normally
+tap.test('should handle TLS connections normally', async (tapTest) => {
+  const mockSettings: ISmartProxyOptions = {
+    useHttpProxy: [443],
+    httpProxyPort: 8844,
+    routes: [{
+      name: 'tls-route',
+      match: { ports: 443 },
+      action: {
+        type: 'forward',
+        target: { host: 'localhost', port: 8443 },
+        tls: { mode: 'terminate' }
+      }
+    }]
+  };
+  
+  let httpProxyForwardCalled = false;
+  
+  const mockHttpProxyBridge = {
+    getHttpProxy: () => ({ available: true }),
+    forwardToHttpProxy: async (...args: any[]) => {
+      httpProxyForwardCalled = true;
+    }
+  };
+  
+  const mockConnectionManager = {
+    createConnection: (socket: any) => ({
+      id: 'test-tls-connection',
+      localPort: 443,
+      remoteIP: '127.0.0.1',
+      isTLS: true,
+      tlsHandshakeComplete: false
+    }),
+    initiateCleanupOnce: () => {},
+    cleanupConnection: () => {},
+    getConnectionCount: () => 1,
+    handleError: (type: string, record: any) => {
+      return (error: Error) => {
+        console.log(`Mock: Error handled for ${type}: ${error.message}`);
+      };
+    }
+  };
+  
+  const mockTlsManager = {
+    isTlsHandshake: (chunk: Buffer) => true,
+    isClientHello: (chunk: Buffer) => true,
+    extractSNI: (chunk: Buffer) => 'test.local'
+  };
+  
+  const mockRouteManager = {
+    findMatchingRoute: (criteria: any) => ({
+      route: mockSettings.routes[0]
+    }),
+    getAllRoutes: () => mockSettings.routes,
+    getRoutesForPort: (port: number) => mockSettings.routes.filter(r => {
+      const ports = Array.isArray(r.match.ports) ? r.match.ports : [r.match.ports];
+      return ports.some(p => {
+        if (typeof p === 'number') {
+          return p === port;
+        } else if (p && typeof p === 'object' && 'from' in p && 'to' in p) {
+          return port >= p.from && port <= p.to;
+        }
+        return false;
+      });
+    })
+  };
+  
+  const mockSecurityManager = {
+    validateIP: () => ({ allowed: true })
+  };
+  
+  const handler = new RouteConnectionHandler(
+    mockSettings,
+    mockConnectionManager as any,
+    mockSecurityManager as any,
+    mockTlsManager as any,
+    mockHttpProxyBridge as any,
+    {} as any,
+    mockRouteManager as any
+  );
+  
+  const mockSocket = {
+    localPort: 443,
+    remoteAddress: '127.0.0.1',
+    on: function(event: string, handler: Function) { return this; },
+    once: function(event: string, handler: Function) {
+      // Capture the data handler
+      if (event === 'data') {
+        this._dataHandler = handler;
+      }
+      return this;
+    },
+    end: () => {},
+    destroy: () => {},
+    pause: () => {},
+    resume: () => {},
+    removeListener: function() { return this; },
+    emit: () => {},
+    setNoDelay: () => {},
+    setKeepAlive: () => {},
+    _dataHandler: null as any
+  } as any;
+  
+  handler.handleConnection(mockSocket);
+  
+  // Simulate TLS handshake
+  if (mockSocket._dataHandler) {
+    const tlsHandshake = Buffer.from([0x16, 0x03, 0x01, 0x00, 0x05]);
+    mockSocket._dataHandler(tlsHandshake);
+  }
+  
+  await new Promise(resolve => setTimeout(resolve, 100));
+  
+  // TLS connections with 'terminate' mode should go to HttpProxy
+  expect(httpProxyForwardCalled).toEqual(true);
+});
+
+export default tap.start();

test/test.http-forwarding-fix.ts

@@ -0,0 +1,179 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import { SmartProxy } from '../ts/index.js';
+import * as net from 'net';
+
+// Test that verifies HTTP connections on ports configured in useHttpProxy are properly forwarded
+tap.test('should detect and forward non-TLS connections on HttpProxy ports', async (tapTest) => {
+  // Track whether the connection was forwarded to HttpProxy
+  let forwardedToHttpProxy = false;
+  let connectionPath = '';
+  
+  // Create a SmartProxy instance first
+  const proxy = new SmartProxy({
+    useHttpProxy: [8081], // Use different port to avoid conflicts
+    httpProxyPort: 8847, // Use different port to avoid conflicts
+    routes: [{
+      name: 'test-http-forward',
+      match: { ports: 8081 },
+      action: {
+        type: 'forward',
+        target: { host: 'localhost', port: 8181 }
+      }
+    }]
+  });
+  
+  // Add detailed logging to the existing proxy instance
+  proxy.settings.enableDetailedLogging = true;
+  
+  // Override the HttpProxy initialization to avoid actual HttpProxy setup
+  proxy['httpProxyBridge'].initialize = async () => {
+    console.log('Mock: HttpProxyBridge initialized');
+  };
+  proxy['httpProxyBridge'].start = async () => {
+    console.log('Mock: HttpProxyBridge started');
+  };
+  proxy['httpProxyBridge'].stop = async () => {
+    console.log('Mock: HttpProxyBridge stopped');
+  };
+  
+  await proxy.start();
+  
+  // Mock the HttpProxy forwarding AFTER start to ensure it's not overridden
+  const originalForward = (proxy as any).httpProxyBridge.forwardToHttpProxy;
+  (proxy as any).httpProxyBridge.forwardToHttpProxy = async function(...args: any[]) {
+    forwardedToHttpProxy = true;
+    connectionPath = 'httpproxy';
+    console.log('Mock: Connection forwarded to HttpProxy with args:', args[0], 'on port:', args[2]?.localPort);
+    // Just close the connection for the test
+    args[1].end(); // socket.end()
+  };
+  
+  // No need to mock getHttpProxy - the bridge already handles HttpProxy availability
+  
+  // Make a connection to port 8080
+  const client = new net.Socket();
+  
+  await new Promise<void>((resolve, reject) => {
+    client.connect(8081, 'localhost', () => {
+      console.log('Client connected to proxy on port 8081');
+      // Send a non-TLS HTTP request
+      client.write('GET / HTTP/1.1\r\nHost: test.local\r\n\r\n');
+      // Add a small delay to ensure data is sent
+      setTimeout(() => resolve(), 50);
+    });
+    
+    client.on('error', reject);
+  });
+  
+  // Give it a moment to process
+  await new Promise(resolve => setTimeout(resolve, 100));
+  
+  // Verify the connection was forwarded to HttpProxy
+  expect(forwardedToHttpProxy).toEqual(true);
+  expect(connectionPath).toEqual('httpproxy');
+  
+  client.destroy();
+  await proxy.stop();
+  
+  // Wait a bit to ensure port is released
+  await new Promise(resolve => setTimeout(resolve, 100));
+  
+  // Restore original method
+  (proxy as any).httpProxyBridge.forwardToHttpProxy = originalForward;
+});
+
+// Test that verifies the fix detects non-TLS connections
+tap.test('should properly detect non-TLS connections on HttpProxy ports', async (tapTest) => {
+  const targetPort = 8182;
+  let receivedConnection = false;
+  
+  // Create a target server that never receives the connection (because it goes to HttpProxy)
+  const targetServer = net.createServer((socket) => {
+    receivedConnection = true;
+    socket.end();
+  });
+  
+  await new Promise<void>((resolve) => {
+    targetServer.listen(targetPort, () => {
+      console.log(`Target server listening on port ${targetPort}`);
+      resolve();
+    });
+  });
+  
+  // Mock HttpProxyBridge to track forwarding
+  let httpProxyForwardCalled = false;
+  
+  const proxy = new SmartProxy({
+    useHttpProxy: [8082], // Use different port to avoid conflicts
+    httpProxyPort: 8848, // Use different port to avoid conflicts
+    routes: [{
+      name: 'test-route',
+      match: {
+        ports: 8082
+      },
+      action: {
+        type: 'forward',
+        target: { host: 'localhost', port: targetPort }
+      }
+    }]
+  });
+  
+  // Override the forwardToHttpProxy method to track calls
+  const originalForward = proxy['httpProxyBridge'].forwardToHttpProxy;
+  proxy['httpProxyBridge'].forwardToHttpProxy = async function(...args: any[]) {
+    httpProxyForwardCalled = true;
+    console.log('HttpProxy forward called with connectionId:', args[0]);
+    // Just end the connection
+    args[1].end();
+  };
+  
+  // Mock HttpProxyBridge methods
+  proxy['httpProxyBridge'].initialize = async () => {
+    console.log('Mock: HttpProxyBridge initialized');
+  };
+  proxy['httpProxyBridge'].start = async () => {
+    console.log('Mock: HttpProxyBridge started');
+  };
+  proxy['httpProxyBridge'].stop = async () => {
+    console.log('Mock: HttpProxyBridge stopped');
+  };
+  
+  // Mock getHttpProxy to return a truthy value
+  proxy['httpProxyBridge'].getHttpProxy = () => ({} as any);
+  
+  await proxy.start();
+  
+  // Make a non-TLS connection
+  const client = new net.Socket();
+  
+  await new Promise<void>((resolve, reject) => {
+    client.connect(8082, 'localhost', () => {
+      console.log('Connected to proxy');
+      client.write('GET / HTTP/1.1\r\nHost: test.local\r\n\r\n');
+      // Add a small delay to ensure data is sent
+      setTimeout(() => resolve(), 50);
+    });
+    
+    client.on('error', () => resolve()); // Ignore errors since we're ending the connection
+  });
+  
+  await new Promise(resolve => setTimeout(resolve, 100));
+  
+  // Verify that HttpProxy was called, not direct connection
+  expect(httpProxyForwardCalled).toEqual(true);
+  expect(receivedConnection).toEqual(false); // Target should not receive direct connection
+  
+  client.destroy();
+  await proxy.stop();
+  await new Promise<void>((resolve) => {
+    targetServer.close(() => resolve());
+  });
+  
+  // Wait a bit to ensure port is released
+  await new Promise(resolve => setTimeout(resolve, 100));
+  
+  // Restore original method
+  proxy['httpProxyBridge'].forwardToHttpProxy = originalForward;
+});
+
+export default tap.start();

test/test.http-port8080-forwarding.ts

@@ -0,0 +1,159 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import { SmartProxy } from '../ts/index.js';
+import * as http from 'http';
+
+tap.test('should forward HTTP connections on port 8080', async (tapTest) => {
+  // Create a mock HTTP server to act as our target
+  const targetPort = 8181;
+  let receivedRequest = false;
+  let receivedPath = '';
+  
+  const targetServer = http.createServer((req, res) => {
+    // Log request details for debugging
+    console.log(`Target server received: ${req.method} ${req.url}`);
+    receivedPath = req.url || '';
+    
+    if (req.url === '/.well-known/acme-challenge/test-token') {
+      receivedRequest = true;
+      res.writeHead(200, { 'Content-Type': 'text/plain' });
+      res.end('test-challenge-response');
+    } else {
+      res.writeHead(200);
+      res.end('OK');
+    }
+  });
+  
+  await new Promise<void>((resolve) => {
+    targetServer.listen(targetPort, () => {
+      console.log(`Target server listening on port ${targetPort}`);
+      resolve();
+    });
+  });
+  
+  // Create SmartProxy without HttpProxy for plain HTTP
+  const proxy = new SmartProxy({
+    enableDetailedLogging: true,
+    routes: [{
+      name: 'test-route',
+      match: {
+        ports: 8080
+        // Remove domain restriction for HTTP connections
+        // Domain matching happens after HTTP headers are received
+      },
+      action: {
+        type: 'forward',
+        target: { host: 'localhost', port: targetPort }
+      }
+    }]
+  });
+  
+  await proxy.start();
+  
+  // Give the proxy a moment to fully initialize
+  await new Promise(resolve => setTimeout(resolve, 500));
+  
+  // Make an HTTP request to port 8080
+  const options = {
+    hostname: 'localhost',
+    port: 8080,
+    path: '/.well-known/acme-challenge/test-token',
+    method: 'GET',
+    headers: {
+      'Host': 'test.local'
+    }
+  };
+  
+  const response = await new Promise<http.IncomingMessage>((resolve, reject) => {
+    const req = http.request(options, (res) => resolve(res));
+    req.on('error', reject);
+    req.end();
+  });
+  
+  // Collect response data
+  let responseData = '';
+  response.setEncoding('utf8');
+  response.on('data', chunk => responseData += chunk);
+  await new Promise(resolve => response.on('end', resolve));
+  
+  // Verify the request was properly forwarded
+  expect(response.statusCode).toEqual(200);
+  expect(receivedPath).toEqual('/.well-known/acme-challenge/test-token');
+  expect(responseData).toEqual('test-challenge-response');
+  expect(receivedRequest).toEqual(true);
+  
+  await proxy.stop();
+  await new Promise<void>((resolve) => {
+    targetServer.close(() => resolve());
+  });
+});
+
+tap.test('should handle basic HTTP request forwarding', async (tapTest) => {
+  // Create a simple target server
+  const targetPort = 8182;
+  let receivedRequest = false;
+  
+  const targetServer = http.createServer((req, res) => {
+    console.log(`Target received: ${req.method} ${req.url} from ${req.headers.host}`);
+    receivedRequest = true;
+    res.writeHead(200, { 'Content-Type': 'text/plain' });
+    res.end('Hello from target');
+  });
+  
+  await new Promise<void>((resolve) => {
+    targetServer.listen(targetPort, () => {
+      console.log(`Target server listening on port ${targetPort}`);
+      resolve();
+    });
+  });
+  
+  // Create a simple proxy without HttpProxy
+  const proxy = new SmartProxy({
+    routes: [{
+      name: 'simple-forward',
+      match: {
+        ports: 8081
+        // Remove domain restriction for HTTP connections
+      },
+      action: {
+        type: 'forward',
+        target: { host: 'localhost', port: targetPort }
+      }
+    }]
+  });
+  
+  await proxy.start();
+  await new Promise(resolve => setTimeout(resolve, 500));
+  
+  // Make request
+  const options = {
+    hostname: 'localhost',
+    port: 8081,
+    path: '/test',
+    method: 'GET',
+    headers: {
+      'Host': 'test.local'
+    }
+  };
+  
+  const response = await new Promise<http.IncomingMessage>((resolve, reject) => {
+    const req = http.request(options, (res) => resolve(res));
+    req.on('error', reject);
+    req.end();
+  });
+  
+  let responseData = '';
+  response.setEncoding('utf8');
+  response.on('data', chunk => responseData += chunk);
+  await new Promise(resolve => response.on('end', resolve));
+  
+  expect(response.statusCode).toEqual(200);
+  expect(responseData).toEqual('Hello from target');
+  expect(receivedRequest).toEqual(true);
+  
+  await proxy.stop();
+  await new Promise<void>((resolve) => {
+    targetServer.close(() => resolve());
+  });
+});
+
+tap.start();

test/test.http-port8080-simple.ts

@@ -0,0 +1,245 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import { SmartProxy } from '../ts/index.js';
+import * as plugins from '../ts/plugins.js';
+import * as net from 'net';
+import * as http from 'http';
+
+/**
+ * This test verifies our improved port binding intelligence for ACME challenges.
+ * It specifically tests:
+ * 1. Using port 8080 instead of 80 for ACME HTTP challenges
+ * 2. Correctly handling shared port bindings between regular routes and challenge routes
+ * 3. Avoiding port conflicts when updating routes
+ */
+
+tap.test('should handle ACME challenges on port 8080 with improved port binding intelligence', async (tapTest) => {
+  // Create a simple echo server to act as our target
+  const targetPort = 9001;
+  let receivedData = '';
+  
+  const targetServer = net.createServer((socket) => {
+    console.log('Target server received connection');
+    
+    socket.on('data', (data) => {
+      receivedData += data.toString();
+      console.log('Target server received data:', data.toString().split('\n')[0]);
+      
+      // Send a simple HTTP response
+      const response = 'HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 13\r\n\r\nHello, World!';
+      socket.write(response);
+    });
+  });
+  
+  await new Promise<void>((resolve) => {
+    targetServer.listen(targetPort, () => {
+      console.log(`Target server listening on port ${targetPort}`);
+      resolve();
+    });
+  });
+  
+  // In this test we will NOT create a mock ACME server on the same port
+  // as SmartProxy will use, instead we'll let SmartProxy handle it
+  const acmeServerPort = 9009;
+  const acmeRequests: string[] = [];
+  let acmeServer: http.Server | null = null;
+  
+  // We'll assume the ACME port is available for SmartProxy
+  let acmePortAvailable = true;
+  
+  // Create SmartProxy with ACME configured to use port 8080
+  console.log('Creating SmartProxy with ACME port 8080...');
+  const tempCertDir = './temp-certs';
+  
+  try {
+    await plugins.smartfile.fs.ensureDir(tempCertDir);
+  } catch (error) {
+    // Directory may already exist, that's ok
+  }
+  
+  const proxy = new SmartProxy({
+    enableDetailedLogging: true,
+    routes: [
+      {
+        name: 'test-route',
+        match: {
+          ports: [9003],
+          domains: ['test.example.com']
+        },
+        action: {
+          type: 'forward',
+          target: { host: 'localhost', port: targetPort },
+          tls: {
+            mode: 'terminate',
+            certificate: 'auto'  // Use ACME for certificate
+          }
+        }
+      },
+      // Also add a route for port 8080 to test port sharing
+      {
+        name: 'http-route',
+        match: {
+          ports: [9009],
+          domains: ['test.example.com']
+        },
+        action: {
+          type: 'forward',
+          target: { host: 'localhost', port: targetPort }
+        }
+      }
+    ],
+    acme: {
+      email: 'test@example.com',
+      useProduction: false,
+      port: 9009,  // Use 9009 instead of default 80
+      certificateStore: tempCertDir
+    }
+  });
+  
+  // Mock the certificate manager to avoid actual ACME operations
+  console.log('Mocking certificate manager...');
+  const createCertManager = (proxy as any).createCertificateManager;
+  (proxy as any).createCertificateManager = async function(...args: any[]) {
+    // Create a completely mocked certificate manager that doesn't use ACME at all
+    return {
+      initialize: async () => {},
+      getCertPair: async () => {
+        return {
+          publicKey: 'MOCK CERTIFICATE',
+          privateKey: 'MOCK PRIVATE KEY'
+        };
+      },
+      getAcmeOptions: () => {
+        return {
+          port: 9009
+        };
+      },
+      getState: () => {
+        return {
+          initializing: false,
+          ready: true,
+          port: 9009
+        };
+      },
+      provisionAllCertificates: async () => {
+        console.log('Mock: Provisioning certificates');
+        return [];
+      },
+      stop: async () => {},
+      smartAcme: {
+        getCertificateForDomain: async () => {
+          // Return a mock certificate
+          return {
+            publicKey: 'MOCK CERTIFICATE',
+            privateKey: 'MOCK PRIVATE KEY',
+            validUntil: Date.now() + 90 * 24 * 60 * 60 * 1000,
+            created: Date.now()
+          };
+        },
+        start: async () => {},
+        stop: async () => {}
+      }
+    };
+  };
+  
+  // Track port binding attempts to verify intelligence
+  const portBindAttempts: number[] = [];
+  const originalAddPort = (proxy as any).portManager.addPort;
+  (proxy as any).portManager.addPort = async function(port: number) {
+    portBindAttempts.push(port);
+    return originalAddPort.call(this, port);
+  };
+  
+  try {
+    console.log('Starting SmartProxy...');
+    await proxy.start();
+    
+    console.log('Port binding attempts:', portBindAttempts);
+    
+    // Check that we tried to bind to port 9009
+    // Should attempt to bind to port 9009
+    expect(portBindAttempts.includes(9009)).toEqual(true);
+    // Should attempt to bind to port 9003
+    expect(portBindAttempts.includes(9003)).toEqual(true);
+    
+    // Get actual bound ports
+    const boundPorts = proxy.getListeningPorts();
+    console.log('Actually bound ports:', boundPorts);
+    
+    // If port 9009 was available, we should be bound to it
+    if (acmePortAvailable) {
+      // Should be bound to port 9009 if available
+      expect(boundPorts.includes(9009)).toEqual(true);
+    }
+    
+    // Should be bound to port 9003
+    expect(boundPorts.includes(9003)).toEqual(true);
+    
+    // Test adding a new route on port 8080
+    console.log('Testing route update with port reuse...');
+    
+    // Reset tracking
+    portBindAttempts.length = 0;
+    
+    // Add a new route on port 8080
+    const newRoutes = [
+      ...proxy.settings.routes,
+      {
+        name: 'additional-route',
+        match: {
+          ports: [9009],
+          path: '/additional'
+        },
+        action: {
+          type: 'forward' as const,
+          target: { host: 'localhost', port: targetPort }
+        }
+      }
+    ];
+    
+    // Update routes - this should NOT try to rebind port 8080
+    await proxy.updateRoutes(newRoutes);
+    
+    console.log('Port binding attempts after update:', portBindAttempts);
+    
+    // We should not try to rebind port 9009 since it's already bound
+    // Should not attempt to rebind port 9009
+    expect(portBindAttempts.includes(9009)).toEqual(false);
+    
+    // We should still be listening on both ports
+    const portsAfterUpdate = proxy.getListeningPorts();
+    console.log('Bound ports after update:', portsAfterUpdate);
+    
+    if (acmePortAvailable) {
+      // Should still be bound to port 9009
+      expect(portsAfterUpdate.includes(9009)).toEqual(true);
+    }
+    // Should still be bound to port 9003
+    expect(portsAfterUpdate.includes(9003)).toEqual(true);
+    
+    // The test is successful at this point - we've verified the port binding intelligence
+    console.log('Port binding intelligence verified successfully!');
+    // We'll skip the actual connection test to avoid timeouts
+  } finally {
+    // Clean up
+    console.log('Cleaning up...');
+    await proxy.stop();
+    
+    if (targetServer) {
+      await new Promise<void>((resolve) => {
+        targetServer.close(() => resolve());
+      });
+    }
+    
+    // No acmeServer to close in this test
+    
+    // Clean up temp directory
+    try {
+      // Remove temp directory
+      await plugins.smartfile.fs.remove(tempCertDir);
+    } catch (error) {
+      console.error('Failed to remove temp directory:', error);
+    }
+  }
+});
+
+tap.start();

test/test.httpproxy.function-targets.ts

@@ -1,20 +1,20 @@
-import { expect, tap } from '@push.rocks/tapbundle';
+import { expect, tap } from '@git.zone/tstest/tapbundle';
 import * as plugins from '../ts/plugins.js';
-import { NetworkProxy } from '../ts/proxies/network-proxy/index.js';
+import { HttpProxy } from '../ts/proxies/http-proxy/index.js';
 import type { IRouteConfig } from '../ts/proxies/smart-proxy/models/route-types.js';
 import type { IRouteContext } from '../ts/core/models/route-context.js';
 
-const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
-
 // Declare variables for tests
-let networkProxy: NetworkProxy;
+let httpProxy: HttpProxy;
 let testServer: plugins.http.Server;
 let testServerHttp2: plugins.http2.Http2Server;
 let serverPort: number;
 let serverPortHttp2: number;
 
 // Setup test environment
-tap.test('setup NetworkProxy function-based targets test environment', async () => {
+tap.test('setup HttpProxy function-based targets test environment', async (tools) => {
+  // Set a reasonable timeout for the test
+  tools.timeout(30000); // 30 seconds
   // Create simple HTTP server to respond to requests
   testServer = plugins.http.createServer((req, res) => {
     res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -41,6 +41,11 @@ tap.test('setup NetworkProxy function-based targets test environment', async ()
     }));
   });
   
+  // Handle HTTP/2 errors
+  testServerHttp2.on('error', (err) => {
+    console.error('HTTP/2 server error:', err);
+  });
+  
   // Start the servers
   await new Promise<void>(resolve => {
     testServer.listen(0, () => {
@@ -58,8 +63,8 @@ tap.test('setup NetworkProxy function-based targets test environment', async ()
     });
   });
   
-  // Create NetworkProxy instance
-  networkProxy = new NetworkProxy({
+  // Create HttpProxy instance
+  httpProxy = new HttpProxy({
     port: 0, // Use dynamic port
     logLevel: 'info', // Use info level to see more logs
     // Disable ACME to avoid trying to bind to port 80
@@ -68,11 +73,11 @@ tap.test('setup NetworkProxy function-based targets test environment', async ()
     }
   });
   
-  await networkProxy.start();
+  await httpProxy.start();
   
   // Log the actual port being used
-  const actualPort = networkProxy.getListeningPort();
-  console.log(`NetworkProxy actual listening port: ${actualPort}`);
+  const actualPort = httpProxy.getListeningPort();
+  console.log(`HttpProxy actual listening port: ${actualPort}`);
 });
 
 // Test static host/port routes
@@ -95,10 +100,10 @@ tap.test('should support static host/port routes', async () => {
     }
   ];
   
-  await networkProxy.updateRouteConfigs(routes);
+  await httpProxy.updateRouteConfigs(routes);
   
   // Get proxy port using the improved getListeningPort() method 
-  const proxyPort = networkProxy.getListeningPort();
+  const proxyPort = httpProxy.getListeningPort();
   
   // Make request to proxy
   const response = await makeRequest({
@@ -140,10 +145,10 @@ tap.test('should support function-based host', async () => {
     }
   ];
   
-  await networkProxy.updateRouteConfigs(routes);
+  await httpProxy.updateRouteConfigs(routes);
   
   // Get proxy port using the improved getListeningPort() method 
-  const proxyPort = networkProxy.getListeningPort();
+  const proxyPort = httpProxy.getListeningPort();
   
   // Make request to proxy
   const response = await makeRequest({
@@ -185,10 +190,10 @@ tap.test('should support function-based port', async () => {
     }
   ];
   
-  await networkProxy.updateRouteConfigs(routes);
+  await httpProxy.updateRouteConfigs(routes);
   
   // Get proxy port using the improved getListeningPort() method 
-  const proxyPort = networkProxy.getListeningPort();
+  const proxyPort = httpProxy.getListeningPort();
   
   // Make request to proxy
   const response = await makeRequest({
@@ -231,10 +236,10 @@ tap.test('should support function-based host AND port', async () => {
     }
   ];
   
-  await networkProxy.updateRouteConfigs(routes);
+  await httpProxy.updateRouteConfigs(routes);
   
   // Get proxy port using the improved getListeningPort() method 
-  const proxyPort = networkProxy.getListeningPort();
+  const proxyPort = httpProxy.getListeningPort();
   
   // Make request to proxy
   const response = await makeRequest({
@@ -280,10 +285,10 @@ tap.test('should support context-based routing with path', async () => {
     }
   ];
   
-  await networkProxy.updateRouteConfigs(routes);
+  await httpProxy.updateRouteConfigs(routes);
   
   // Get proxy port using the improved getListeningPort() method 
-  const proxyPort = networkProxy.getListeningPort();
+  const proxyPort = httpProxy.getListeningPort();
   
   // Make request to proxy with /api path
   const apiResponse = await makeRequest({
@@ -317,22 +322,58 @@ tap.test('should support context-based routing with path', async () => {
 });
 
 // Cleanup test environment
-tap.test('cleanup NetworkProxy function-based targets test environment', async () => {
-  if (networkProxy) {
-    await networkProxy.stop();
+tap.test('cleanup HttpProxy function-based targets test environment', async () => {
+  // Skip cleanup if setup failed
+  if (!httpProxy && !testServer && !testServerHttp2) {
+    console.log('Skipping cleanup - setup failed');
+    return;
   }
   
+  // Stop test servers first
   if (testServer) {
-    await new Promise<void>(resolve => {
-      testServer.close(() => resolve());
+    await new Promise<void>((resolve, reject) => {
+      testServer.close((err) => {
+        if (err) {
+          console.error('Error closing test server:', err);
+          reject(err);
+        } else {
+          console.log('Test server closed successfully');
+          resolve();
+        }
+      });
     });
   }
   
   if (testServerHttp2) {
-    await new Promise<void>(resolve => {
-      testServerHttp2.close(() => resolve());
+    await new Promise<void>((resolve, reject) => {
+      testServerHttp2.close((err) => {
+        if (err) {
+          console.error('Error closing HTTP/2 test server:', err);
+          reject(err);
+        } else {
+          console.log('HTTP/2 test server closed successfully');
+          resolve();
+        }
+      });
     });
   }
+  
+  // Stop HttpProxy last
+  if (httpProxy) {
+    console.log('Stopping HttpProxy...');
+    await httpProxy.stop();
+    console.log('HttpProxy stopped successfully');
+  }
+  
+  // Force exit after a short delay to ensure cleanup
+  const cleanupTimeout = setTimeout(() => {
+    console.log('Cleanup completed, exiting');
+  }, 100);
+  
+  // Don't keep the process alive just for this timeout
+  if (cleanupTimeout.unref) {
+    cleanupTimeout.unref();
+  }
 });
 
 // Helper function to make HTTPS requests with self-signed certificate support
@@ -365,5 +406,8 @@ async function makeRequest(options: plugins.http.RequestOptions): Promise<{ stat
   });
 }
 
-// Export the test runner to start tests
-export default tap.start();
+// Start the tests
+tap.start().then(() => {
+  // Ensure process exits after tests complete
+  process.exit(0);
+});

test/test.httpproxy.ts

@@ -0,0 +1,596 @@
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import * as smartproxy from '../ts/index.js';
+import { loadTestCertificates } from './helpers/certificates.js';
+import * as https from 'https';
+import * as http from 'http';
+import { WebSocket, WebSocketServer } from 'ws';
+
+let testProxy: smartproxy.HttpProxy;
+let testServer: http.Server;
+let wsServer: WebSocketServer;
+let testCertificates: { privateKey: string; publicKey: string };
+
+// Helper function to make HTTPS requests
+async function makeHttpsRequest(
+  options: https.RequestOptions,
+): Promise<{ statusCode: number; headers: http.IncomingHttpHeaders; body: string }> {
+  console.log('[TEST] Making HTTPS request:', {
+    hostname: options.hostname,
+    port: options.port,
+    path: options.path,
+    method: options.method,
+    headers: options.headers,
+  });
+  return new Promise((resolve, reject) => {
+    const req = https.request(options, (res) => {
+      console.log('[TEST] Received HTTPS response:', {
+        statusCode: res.statusCode,
+        headers: res.headers,
+      });
+      let data = '';
+      res.on('data', (chunk) => (data += chunk));
+      res.on('end', () => {
+        console.log('[TEST] Response completed:', { data });
+        // Ensure the socket is destroyed to prevent hanging connections
+        res.socket?.destroy();
+        resolve({
+          statusCode: res.statusCode!,
+          headers: res.headers,
+          body: data,
+        });
+      });
+    });
+    req.on('error', (error) => {
+      console.error('[TEST] Request error:', error);
+      reject(error);
+    });
+    req.end();
+  });
+}
+
+// Setup test environment
+tap.test('setup test environment', async () => {
+  // Load and validate certificates
+  console.log('[TEST] Loading and validating certificates');
+  testCertificates = loadTestCertificates();
+  console.log('[TEST] Certificates loaded and validated');
+
+  // Create a test HTTP server
+  testServer = http.createServer((req, res) => {
+    console.log('[TEST SERVER] Received HTTP request:', {
+      url: req.url,
+      method: req.method,
+      headers: req.headers,
+    });
+    res.writeHead(200, { 'Content-Type': 'text/plain' });
+    res.end('Hello from test server!');
+  });
+
+  // Handle WebSocket upgrade requests
+  testServer.on('upgrade', (request, socket, head) => {
+    console.log('[TEST SERVER] Received WebSocket upgrade request:', {
+      url: request.url,
+      method: request.method,
+      headers: {
+        host: request.headers.host,
+        upgrade: request.headers.upgrade,
+        connection: request.headers.connection,
+        'sec-websocket-key': request.headers['sec-websocket-key'],
+        'sec-websocket-version': request.headers['sec-websocket-version'],
+        'sec-websocket-protocol': request.headers['sec-websocket-protocol'],
+      },
+    });
+
+    if (request.headers.upgrade?.toLowerCase() !== 'websocket') {
+      console.log('[TEST SERVER] Not a WebSocket upgrade request');
+      socket.destroy();
+      return;
+    }
+
+    console.log('[TEST SERVER] Handling WebSocket upgrade');
+    wsServer.handleUpgrade(request, socket, head, (ws) => {
+      console.log('[TEST SERVER] WebSocket connection upgraded');
+      wsServer.emit('connection', ws, request);
+    });
+  });
+
+  // Create a WebSocket server (for the test HTTP server)
+  console.log('[TEST SERVER] Creating WebSocket server');
+  wsServer = new WebSocketServer({
+    noServer: true,
+    perMessageDeflate: false,
+    clientTracking: true,
+    handleProtocols: () => 'echo-protocol',
+  });
+
+  wsServer.on('connection', (ws, request) => {
+    console.log('[TEST SERVER] WebSocket connection established:', {
+      url: request.url,
+      headers: {
+        host: request.headers.host,
+        upgrade: request.headers.upgrade,
+        connection: request.headers.connection,
+        'sec-websocket-key': request.headers['sec-websocket-key'],
+        'sec-websocket-version': request.headers['sec-websocket-version'],
+        'sec-websocket-protocol': request.headers['sec-websocket-protocol'],
+      },
+    });
+
+    // Set up connection timeout
+    const connectionTimeout = setTimeout(() => {
+      console.error('[TEST SERVER] WebSocket connection timed out');
+      ws.terminate();
+    }, 5000);
+
+    // Clear timeout when connection is properly closed
+    const clearConnectionTimeout = () => {
+      clearTimeout(connectionTimeout);
+    };
+
+    ws.on('message', (message) => {
+      const msg = message.toString();
+      console.log('[TEST SERVER] Received WebSocket message:', msg);
+      try {
+        const response = `Echo: ${msg}`;
+        console.log('[TEST SERVER] Sending WebSocket response:', response);
+        ws.send(response);
+        // Clear timeout on successful message exchange
+        clearConnectionTimeout();
+      } catch (error) {
+        console.error('[TEST SERVER] Error sending WebSocket message:', error);
+      }
+    });
+
+    ws.on('error', (error) => {
+      console.error('[TEST SERVER] WebSocket error:', error);
+      clearConnectionTimeout();
+    });
+
+    ws.on('close', (code, reason) => {
+      console.log('[TEST SERVER] WebSocket connection closed:', {
+        code,
+        reason: reason.toString(),
+        wasClean: code === 1000 || code === 1001,
+      });
+      clearConnectionTimeout();
+    });
+
+    ws.on('ping', (data) => {
+      try {
+        console.log('[TEST SERVER] Received ping, sending pong');
+        ws.pong(data);
+      } catch (error) {
+        console.error('[TEST SERVER] Error sending pong:', error);
+      }
+    });
+
+    ws.on('pong', (data) => {
+      console.log('[TEST SERVER] Received pong');
+    });
+  });
+
+  wsServer.on('error', (error) => {
+    console.error('Test server: WebSocket server error:', error);
+  });
+
+  wsServer.on('headers', (headers) => {
+    console.log('Test server: WebSocket headers:', headers);
+  });
+
+  wsServer.on('close', () => {
+    console.log('Test server: WebSocket server closed');
+  });
+
+  await new Promise<void>((resolve) => testServer.listen(3100, resolve));
+  console.log('Test server listening on port 3100');
+});
+
+tap.test('should create proxy instance', async () => {
+  // Test with the original minimal options (only port)
+  testProxy = new smartproxy.HttpProxy({
+    port: 3001,
+  });
+  expect(testProxy).toEqual(testProxy); // Instance equality check
+});
+
+tap.test('should create proxy instance with extended options', async () => {
+  // Test with extended options to verify backward compatibility
+  testProxy = new smartproxy.HttpProxy({
+    port: 3001,
+    maxConnections: 5000,
+    keepAliveTimeout: 120000,
+    headersTimeout: 60000,
+    logLevel: 'info',
+    cors: {
+      allowOrigin: '*',
+      allowMethods: 'GET, POST, OPTIONS',
+      allowHeaders: 'Content-Type',
+      maxAge: 3600
+    }
+  });
+  expect(testProxy).toEqual(testProxy); // Instance equality check
+  expect(testProxy.options.port).toEqual(3001);
+});
+
+tap.test('should start the proxy server', async () => {
+  // Create a new proxy instance
+  testProxy = new smartproxy.HttpProxy({
+    port: 3001,
+    maxConnections: 5000,
+    backendProtocol: 'http1',
+    acme: {
+      enabled: false // Disable ACME for testing
+    }
+  });
+
+  // Configure routes for the proxy
+  await testProxy.updateRouteConfigs([
+    {
+      match: {
+        ports: [3001],
+        domains: ['push.rocks', 'localhost']
+      },
+      action: {
+        type: 'forward',
+        target: {
+          host: 'localhost',
+          port: 3100
+        },
+        tls: {
+          mode: 'terminate'
+        },
+        websocket: {
+          enabled: true,
+          subprotocols: ['echo-protocol']
+        }
+      }
+    }
+  ]);
+
+  // Start the proxy
+  await testProxy.start();
+  
+  // Verify the proxy is listening on the correct port
+  expect(testProxy.getListeningPort()).toEqual(3001);
+});
+
+tap.test('should route HTTPS requests based on host header', async () => {
+  // IMPORTANT: Connect to localhost (where the proxy is listening) but use the Host header "push.rocks"
+  const response = await makeHttpsRequest({
+    hostname: 'localhost', // changed from 'push.rocks' to 'localhost'
+    port: 3001,
+    path: '/',
+    method: 'GET',
+    headers: {
+      host: 'push.rocks', // virtual host for routing
+    },
+    rejectUnauthorized: false,
+  });
+
+  expect(response.statusCode).toEqual(200);
+  expect(response.body).toEqual('Hello from test server!');
+});
+
+tap.test('should handle unknown host headers', async () => {
+  // Connect to localhost but use an unknown host header.
+  const response = await makeHttpsRequest({
+    hostname: 'localhost', // connecting to localhost
+    port: 3001,
+    path: '/',
+    method: 'GET',
+    headers: {
+      host: 'unknown.host', // this should not match any proxy config
+    },
+    rejectUnauthorized: false,
+  });
+
+  // Expect a 404 response with the appropriate error message.
+  expect(response.statusCode).toEqual(404);
+});
+
+tap.test('should support WebSocket connections', async () => {
+  // Create a WebSocket client
+  console.log('[TEST] Testing WebSocket connection');
+  
+  console.log('[TEST] Creating WebSocket to wss://localhost:3001/ with host header: push.rocks');
+  const ws = new WebSocket('wss://localhost:3001/', {
+    protocol: 'echo-protocol',
+    rejectUnauthorized: false,
+    headers: {
+      host: 'push.rocks'
+    }
+  });
+
+  const connectionTimeout = setTimeout(() => {
+    console.error('[TEST] WebSocket connection timeout');
+    ws.terminate();
+  }, 5000);
+
+  const timeouts: NodeJS.Timeout[] = [connectionTimeout];
+
+  try {
+    // Wait for connection with timeout
+    await Promise.race([
+      new Promise<void>((resolve, reject) => {
+        ws.on('open', () => {
+          console.log('[TEST] WebSocket connected');
+          clearTimeout(connectionTimeout);
+          resolve();
+        });
+        ws.on('error', (err) => {
+          console.error('[TEST] WebSocket connection error:', err);
+          clearTimeout(connectionTimeout);
+          reject(err);
+        });
+      }),
+      new Promise<void>((_, reject) => {
+        const timeout = setTimeout(() => reject(new Error('Connection timeout')), 3000);
+        timeouts.push(timeout);
+      })
+    ]);
+
+    // Send a message and receive echo with timeout
+    await Promise.race([
+      new Promise<void>((resolve, reject) => {
+        const testMessage = 'Hello WebSocket!';
+        let messageReceived = false;
+        
+        ws.on('message', (data) => {
+          messageReceived = true;
+          const message = data.toString();
+          console.log('[TEST] Received WebSocket message:', message);
+          expect(message).toEqual(`Echo: ${testMessage}`);
+          resolve();
+        });
+
+        ws.on('error', (err) => {
+          console.error('[TEST] WebSocket message error:', err);
+          reject(err);
+        });
+
+        console.log('[TEST] Sending WebSocket message:', testMessage);
+        ws.send(testMessage);
+        
+        // Add additional debug logging
+        const debugTimeout = setTimeout(() => {
+          if (!messageReceived) {
+            console.log('[TEST] No message received after 2 seconds');
+          }
+        }, 2000);
+        timeouts.push(debugTimeout);
+      }),
+      new Promise<void>((_, reject) => {
+        const timeout = setTimeout(() => reject(new Error('Message timeout')), 3000);
+        timeouts.push(timeout);
+      })
+    ]);
+
+    // Close the connection properly  
+    await Promise.race([
+      new Promise<void>((resolve) => {
+        ws.on('close', () => {
+          console.log('[TEST] WebSocket closed');
+          resolve();
+        });
+        ws.close();
+      }),
+      new Promise<void>((resolve) => {
+        const timeout = setTimeout(() => {
+          console.log('[TEST] Force closing WebSocket');
+          ws.terminate();
+          resolve();
+        }, 2000);
+        timeouts.push(timeout);
+      })
+    ]);
+  } catch (error) {
+    console.error('[TEST] WebSocket test error:', error);
+    try {
+      ws.terminate();
+    } catch (terminateError) {
+      console.error('[TEST] Error during terminate:', terminateError);
+    }
+    // Skip if WebSocket fails for now
+    console.log('[TEST] WebSocket test failed, continuing with other tests');
+  } finally {
+    // Clean up all timeouts
+    timeouts.forEach(timeout => clearTimeout(timeout));
+  }
+});
+
+tap.test('should handle custom headers', async () => {
+  await testProxy.addDefaultHeaders({
+    'X-Proxy-Header': 'test-value',
+  });
+
+  const response = await makeHttpsRequest({
+    hostname: 'localhost', // changed to 'localhost'
+    port: 3001,
+    path: '/',
+    method: 'GET',
+    headers: {
+      host: 'push.rocks', // still routing to push.rocks
+    },
+    rejectUnauthorized: false,
+  });
+
+  expect(response.headers['x-proxy-header']).toEqual('test-value');
+});
+
+tap.test('should handle CORS preflight requests', async () => {
+  // Test OPTIONS request (CORS preflight)
+  const response = await makeHttpsRequest({
+    hostname: 'localhost',
+    port: 3001,
+    path: '/',
+    method: 'OPTIONS',
+    headers: {
+      host: 'push.rocks',
+      origin: 'https://example.com',
+      'access-control-request-method': 'POST',
+      'access-control-request-headers': 'content-type'
+    },
+    rejectUnauthorized: false,
+  });
+
+  // Should get appropriate CORS headers
+  expect(response.statusCode).toBeLessThan(300); // 200 or 204
+  expect(response.headers['access-control-allow-origin']).toEqual('*');
+  expect(response.headers['access-control-allow-methods']).toContain('GET');
+  expect(response.headers['access-control-allow-methods']).toContain('POST');
+});
+
+tap.test('should track connections and metrics', async () => {
+  // Get metrics from the proxy
+  const metrics = testProxy.getMetrics();
+  
+  // Verify metrics structure and some values
+  expect(metrics).toHaveProperty('activeConnections');
+  expect(metrics).toHaveProperty('totalRequests');
+  expect(metrics).toHaveProperty('failedRequests');
+  expect(metrics).toHaveProperty('uptime');
+  expect(metrics).toHaveProperty('memoryUsage');
+  expect(metrics).toHaveProperty('activeWebSockets');
+  
+  // Should have served at least some requests from previous tests
+  expect(metrics.totalRequests).toBeGreaterThan(0);
+  expect(metrics.uptime).toBeGreaterThan(0);
+});
+
+tap.test('should update capacity settings', async () => {
+  // Update proxy capacity settings
+  testProxy.updateCapacity(2000, 60000, 25);
+  
+  // Verify settings were updated
+  expect(testProxy.options.maxConnections).toEqual(2000);
+  expect(testProxy.options.keepAliveTimeout).toEqual(60000);
+  expect(testProxy.options.connectionPoolSize).toEqual(25);
+});
+
+tap.test('should handle certificate requests', async () => {
+  // Test certificate request (this won't actually issue a cert in test mode)
+  const result = await testProxy.requestCertificate('test.example.com');
+  
+  // In test mode with ACME disabled, this should return false
+  expect(result).toEqual(false);
+});
+
+tap.test('should update certificates directly', async () => {
+  // Test certificate update
+  const testCert = '-----BEGIN CERTIFICATE-----\nMIIB...test...';
+  const testKey = '-----BEGIN PRIVATE KEY-----\nMIIE...test...';
+  
+  // This should not throw
+  expect(() => {
+    testProxy.updateCertificate('test.example.com', testCert, testKey);
+  }).not.toThrow();
+});
+
+tap.test('cleanup', async () => {
+  console.log('[TEST] Starting cleanup');
+  
+  try {
+    // 1. Close WebSocket clients if server exists
+    if (wsServer && wsServer.clients) {
+      console.log(`[TEST] Terminating ${wsServer.clients.size} WebSocket clients`);
+      wsServer.clients.forEach((client) => {
+        try {
+          client.terminate();
+        } catch (err) {
+          console.error('[TEST] Error terminating client:', err);
+        }
+      });
+    }
+
+    // 2. Close WebSocket server with timeout
+    if (wsServer) {
+      console.log('[TEST] Closing WebSocket server');
+      await Promise.race([
+        new Promise<void>((resolve, reject) => {
+          wsServer.close((err) => {
+            if (err) {
+              console.error('[TEST] Error closing WebSocket server:', err);
+              reject(err);
+            } else {
+              console.log('[TEST] WebSocket server closed');
+              resolve();
+            }
+          });
+        }).catch((err) => {
+          console.error('[TEST] Caught error closing WebSocket server:', err);
+        }),
+        new Promise<void>((resolve) => {
+          setTimeout(() => {
+            console.log('[TEST] WebSocket server close timeout');
+            resolve();
+          }, 1000);
+        })
+      ]);
+    }
+
+    // 3. Close test server with timeout
+    if (testServer) {
+      console.log('[TEST] Closing test server');
+      // First close all connections
+      testServer.closeAllConnections();
+      
+      await Promise.race([
+        new Promise<void>((resolve, reject) => {
+          testServer.close((err) => {
+            if (err) {
+              console.error('[TEST] Error closing test server:', err);
+              reject(err);
+            } else {
+              console.log('[TEST] Test server closed');
+              resolve();
+            }
+          });
+        }).catch((err) => {
+          console.error('[TEST] Caught error closing test server:', err);
+        }),
+        new Promise<void>((resolve) => {
+          setTimeout(() => {
+            console.log('[TEST] Test server close timeout');
+            resolve();
+          }, 1000);
+        })
+      ]);
+    }
+
+    // 4. Stop the proxy with timeout
+    if (testProxy) {
+      console.log('[TEST] Stopping proxy');
+      await Promise.race([
+        testProxy.stop()
+          .then(() => {
+            console.log('[TEST] Proxy stopped successfully');
+          })
+          .catch((error) => {
+            console.error('[TEST] Error stopping proxy:', error);
+          }),
+        new Promise<void>((resolve) => {
+          setTimeout(() => {
+            console.log('[TEST] Proxy stop timeout');
+            resolve();
+          }, 2000);
+        })
+      ]);
+    }
+  } catch (error) {
+    console.error('[TEST] Error during cleanup:', error);
+  }
+  
+  console.log('[TEST] Cleanup complete');
+  
+  // Add debugging to see what might be keeping the process alive
+  if (process.env.DEBUG_HANDLES) {
+    console.log('[TEST] Active handles:', (process as any)._getActiveHandles?.().length);
+    console.log('[TEST] Active requests:', (process as any)._getActiveRequests?.().length);
+  }
+});
+
+// Exit handler removed to prevent interference with test cleanup
+
+// Teardown test removed - let tap handle proper cleanup
+
+export default tap.start();

test/test.long-lived-connections.ts

@@ -0,0 +1,192 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import * as net from 'net';
+import * as tls from 'tls';
+import { SmartProxy } from '../ts/index.js';
+
+let testProxy: SmartProxy;
+let targetServer: net.Server;
+
+// Create a simple echo server as target
+tap.test('setup test environment', async () => {
+  // Create target server that echoes data back
+  targetServer = net.createServer((socket) => {
+    console.log('Target server: client connected');
+    
+    // Echo data back
+    socket.on('data', (data) => {
+      console.log(`Target server received: ${data.toString().trim()}`);
+      socket.write(data);
+    });
+    
+    socket.on('close', () => {
+      console.log('Target server: client disconnected');
+    });
+  });
+  
+  await new Promise<void>((resolve) => {
+    targetServer.listen(9876, () => {
+      console.log('Target server listening on port 9876');
+      resolve();
+    });
+  });
+  
+  // Create proxy with simple TCP forwarding (no TLS)
+  testProxy = new SmartProxy({
+    routes: [{
+      name: 'tcp-forward-test',
+      match: {
+        ports: 8888  // Plain TCP port
+      },
+      action: {
+        type: 'forward',
+        target: {
+          host: 'localhost',
+          port: 9876
+        }
+        // No TLS configuration - just plain TCP forwarding
+      }
+    }],
+    defaults: {
+      target: {
+        host: 'localhost',
+        port: 9876
+      }
+    },
+    enableDetailedLogging: true,
+    keepAliveTreatment: 'extended',  // Allow long-lived connections
+    inactivityTimeout: 3600000,      // 1 hour
+    socketTimeout: 3600000,          // 1 hour
+    keepAlive: true,
+    keepAliveInitialDelay: 1000
+  });
+  
+  await testProxy.start();
+});
+
+tap.test('should keep WebSocket-like connection open for extended period', async (tools) => {
+  tools.timeout(65000); // 65 second test timeout
+  
+  const client = new net.Socket();
+  let messagesReceived = 0;
+  let connectionClosed = false;
+  
+  // Connect to proxy
+  await new Promise<void>((resolve, reject) => {
+    client.connect(8888, 'localhost', () => {
+      console.log('Client connected to proxy');
+      resolve();
+    });
+    
+    client.on('error', reject);
+  });
+  
+  // Set up data handler
+  client.on('data', (data) => {
+    console.log(`Client received: ${data.toString().trim()}`);
+    messagesReceived++;
+  });
+  
+  client.on('close', () => {
+    console.log('Client connection closed');
+    connectionClosed = true;
+  });
+  
+  // Send initial handshake-like data
+  client.write('HELLO\n');
+  
+  // Wait for response
+  await new Promise(resolve => setTimeout(resolve, 100));
+  expect(messagesReceived).toEqual(1);
+  
+  // Simulate WebSocket-like keep-alive pattern
+  // Send periodic messages over 60 seconds
+  const startTime = Date.now();
+  const pingInterval = setInterval(() => {
+    if (!connectionClosed && Date.now() - startTime < 60000) {
+      console.log('Sending ping...');
+      client.write('PING\n');
+    } else {
+      clearInterval(pingInterval);
+    }
+  }, 10000); // Every 10 seconds
+  
+  // Wait for 61 seconds
+  await new Promise(resolve => setTimeout(resolve, 61000));
+  
+  // Clean up interval
+  clearInterval(pingInterval);
+  
+  // Connection should still be open
+  expect(connectionClosed).toEqual(false);
+  
+  // Should have received responses (1 hello + 6 pings)
+  expect(messagesReceived).toBeGreaterThan(5);
+  
+  // Close connection gracefully
+  client.end();
+  
+  // Wait for close
+  await new Promise(resolve => setTimeout(resolve, 100));
+  expect(connectionClosed).toEqual(true);
+});
+
+tap.test('should support half-open connections', async () => {
+  const client = new net.Socket();
+  const serverSocket = await new Promise<net.Socket>((resolve) => {
+    targetServer.once('connection', resolve);
+    client.connect(8888, 'localhost');
+  });
+  
+  let clientClosed = false;
+  let serverClosed = false;
+  let serverReceivedData = false;
+  
+  client.on('close', () => {
+    clientClosed = true;
+  });
+  
+  serverSocket.on('close', () => {
+    serverClosed = true;
+  });
+  
+  serverSocket.on('data', () => {
+    serverReceivedData = true;
+  });
+  
+  // Client sends data then closes write side
+  client.write('HALF-OPEN TEST\n');
+  client.end(); // Close write side only
+  
+  // Wait a bit
+  await new Promise(resolve => setTimeout(resolve, 500));
+  
+  // Server should still be able to send data
+  expect(serverClosed).toEqual(false);
+  serverSocket.write('RESPONSE\n');
+  
+  // Wait for data
+  await new Promise(resolve => setTimeout(resolve, 100));
+  
+  // Now close server side
+  serverSocket.end();
+  
+  // Wait for full close
+  await new Promise(resolve => setTimeout(resolve, 500));
+  
+  expect(clientClosed).toEqual(true);
+  expect(serverClosed).toEqual(true);
+  expect(serverReceivedData).toEqual(true);
+});
+
+tap.test('cleanup', async () => {
+  await testProxy.stop();
+  
+  await new Promise<void>((resolve) => {
+    targetServer.close(() => {
+      console.log('Target server closed');
+      resolve();
+    });
+  });
+});
+
+export default tap.start();

test/test.networkproxy.ts

@@ -1,629 +0,0 @@
-import { expect, tap } from '@push.rocks/tapbundle';
-import * as smartproxy from '../ts/index.js';
-import { loadTestCertificates } from './helpers/certificates.js';
-import * as https from 'https';
-import * as http from 'http';
-import { WebSocket, WebSocketServer } from 'ws';
-
-let testProxy: smartproxy.NetworkProxy;
-let testServer: http.Server;
-let wsServer: WebSocketServer;
-let testCertificates: { privateKey: string; publicKey: string };
-
-// Helper function to make HTTPS requests
-async function makeHttpsRequest(
-  options: https.RequestOptions,
-): Promise<{ statusCode: number; headers: http.IncomingHttpHeaders; body: string }> {
-  console.log('[TEST] Making HTTPS request:', {
-    hostname: options.hostname,
-    port: options.port,
-    path: options.path,
-    method: options.method,
-    headers: options.headers,
-  });
-  return new Promise((resolve, reject) => {
-    const req = https.request(options, (res) => {
-      console.log('[TEST] Received HTTPS response:', {
-        statusCode: res.statusCode,
-        headers: res.headers,
-      });
-      let data = '';
-      res.on('data', (chunk) => (data += chunk));
-      res.on('end', () => {
-        console.log('[TEST] Response completed:', { data });
-        resolve({
-          statusCode: res.statusCode!,
-          headers: res.headers,
-          body: data,
-        });
-      });
-    });
-    req.on('error', (error) => {
-      console.error('[TEST] Request error:', error);
-      reject(error);
-    });
-    req.end();
-  });
-}
-
-// Setup test environment
-tap.test('setup test environment', async () => {
-  // Load and validate certificates
-  console.log('[TEST] Loading and validating certificates');
-  testCertificates = loadTestCertificates();
-  console.log('[TEST] Certificates loaded and validated');
-
-  // Create a test HTTP server
-  testServer = http.createServer((req, res) => {
-    console.log('[TEST SERVER] Received HTTP request:', {
-      url: req.url,
-      method: req.method,
-      headers: req.headers,
-    });
-    res.writeHead(200, { 'Content-Type': 'text/plain' });
-    res.end('Hello from test server!');
-  });
-
-  // Handle WebSocket upgrade requests
-  testServer.on('upgrade', (request, socket, head) => {
-    console.log('[TEST SERVER] Received WebSocket upgrade request:', {
-      url: request.url,
-      method: request.method,
-      headers: {
-        host: request.headers.host,
-        upgrade: request.headers.upgrade,
-        connection: request.headers.connection,
-        'sec-websocket-key': request.headers['sec-websocket-key'],
-        'sec-websocket-version': request.headers['sec-websocket-version'],
-        'sec-websocket-protocol': request.headers['sec-websocket-protocol'],
-      },
-    });
-
-    if (request.headers.upgrade?.toLowerCase() !== 'websocket') {
-      console.log('[TEST SERVER] Not a WebSocket upgrade request');
-      socket.destroy();
-      return;
-    }
-
-    console.log('[TEST SERVER] Handling WebSocket upgrade');
-    wsServer.handleUpgrade(request, socket, head, (ws) => {
-      console.log('[TEST SERVER] WebSocket connection upgraded');
-      wsServer.emit('connection', ws, request);
-    });
-  });
-
-  // Create a WebSocket server (for the test HTTP server)
-  console.log('[TEST SERVER] Creating WebSocket server');
-  wsServer = new WebSocketServer({
-    noServer: true,
-    perMessageDeflate: false,
-    clientTracking: true,
-    handleProtocols: () => 'echo-protocol',
-  });
-
-  wsServer.on('connection', (ws, request) => {
-    console.log('[TEST SERVER] WebSocket connection established:', {
-      url: request.url,
-      headers: {
-        host: request.headers.host,
-        upgrade: request.headers.upgrade,
-        connection: request.headers.connection,
-        'sec-websocket-key': request.headers['sec-websocket-key'],
-        'sec-websocket-version': request.headers['sec-websocket-version'],
-        'sec-websocket-protocol': request.headers['sec-websocket-protocol'],
-      },
-    });
-
-    // Set up connection timeout
-    const connectionTimeout = setTimeout(() => {
-      console.error('[TEST SERVER] WebSocket connection timed out');
-      ws.terminate();
-    }, 5000);
-
-    // Clear timeout when connection is properly closed
-    const clearConnectionTimeout = () => {
-      clearTimeout(connectionTimeout);
-    };
-
-    ws.on('message', (message) => {
-      const msg = message.toString();
-      console.log('[TEST SERVER] Received message:', msg);
-      try {
-        const response = `Echo: ${msg}`;
-        console.log('[TEST SERVER] Sending response:', response);
-        ws.send(response);
-        // Clear timeout on successful message exchange
-        clearConnectionTimeout();
-      } catch (error) {
-        console.error('[TEST SERVER] Error sending message:', error);
-      }
-    });
-
-    ws.on('error', (error) => {
-      console.error('[TEST SERVER] WebSocket error:', error);
-      clearConnectionTimeout();
-    });
-
-    ws.on('close', (code, reason) => {
-      console.log('[TEST SERVER] WebSocket connection closed:', {
-        code,
-        reason: reason.toString(),
-        wasClean: code === 1000 || code === 1001,
-      });
-      clearConnectionTimeout();
-    });
-
-    ws.on('ping', (data) => {
-      try {
-        console.log('[TEST SERVER] Received ping, sending pong');
-        ws.pong(data);
-      } catch (error) {
-        console.error('[TEST SERVER] Error sending pong:', error);
-      }
-    });
-
-    ws.on('pong', (data) => {
-      console.log('[TEST SERVER] Received pong');
-    });
-  });
-
-  wsServer.on('error', (error) => {
-    console.error('Test server: WebSocket server error:', error);
-  });
-
-  wsServer.on('headers', (headers) => {
-    console.log('Test server: WebSocket headers:', headers);
-  });
-
-  wsServer.on('close', () => {
-    console.log('Test server: WebSocket server closed');
-  });
-
-  await new Promise<void>((resolve) => testServer.listen(3000, resolve));
-  console.log('Test server listening on port 3000');
-});
-
-tap.test('should create proxy instance', async () => {
-  // Test with the original minimal options (only port)
-  testProxy = new smartproxy.NetworkProxy({
-    port: 3001,
-  });
-  expect(testProxy).toEqual(testProxy); // Instance equality check
-});
-
-tap.test('should create proxy instance with extended options', async () => {
-  // Test with extended options to verify backward compatibility
-  testProxy = new smartproxy.NetworkProxy({
-    port: 3001,
-    maxConnections: 5000,
-    keepAliveTimeout: 120000,
-    headersTimeout: 60000,
-    logLevel: 'info',
-    cors: {
-      allowOrigin: '*',
-      allowMethods: 'GET, POST, OPTIONS',
-      allowHeaders: 'Content-Type',
-      maxAge: 3600
-    }
-  });
-  expect(testProxy).toEqual(testProxy); // Instance equality check
-  expect(testProxy.options.port).toEqual(3001);
-});
-
-tap.test('should start the proxy server', async () => {
-  // Ensure any previous server is closed
-  if (testProxy && testProxy.httpsServer) {
-    await new Promise<void>((resolve) =>
-      testProxy.httpsServer.close(() => resolve())
-    );
-  }
-
-  console.log('[TEST] Starting the proxy server');
-  await testProxy.start();
-  console.log('[TEST] Proxy server started');
-
-  // Configure proxy with test certificates
-  // Awaiting the update ensures that the SNI context is added before any requests come in.
-  await testProxy.updateProxyConfigs([
-    {
-      destinationIps: ['127.0.0.1'],
-      destinationPorts: [3000],
-      hostName: 'push.rocks',
-      publicKey: testCertificates.publicKey,
-      privateKey: testCertificates.privateKey,
-    },
-  ]);
-
-  console.log('[TEST] Proxy configuration updated');
-});
-
-tap.test('should route HTTPS requests based on host header', async () => {
-  // IMPORTANT: Connect to localhost (where the proxy is listening) but use the Host header "push.rocks"
-  const response = await makeHttpsRequest({
-    hostname: 'localhost', // changed from 'push.rocks' to 'localhost'
-    port: 3001,
-    path: '/',
-    method: 'GET',
-    headers: {
-      host: 'push.rocks', // virtual host for routing
-    },
-    rejectUnauthorized: false,
-  });
-
-  expect(response.statusCode).toEqual(200);
-  expect(response.body).toEqual('Hello from test server!');
-});
-
-tap.test('should handle unknown host headers', async () => {
-  // Connect to localhost but use an unknown host header.
-  const response = await makeHttpsRequest({
-    hostname: 'localhost', // connecting to localhost
-    port: 3001,
-    path: '/',
-    method: 'GET',
-    headers: {
-      host: 'unknown.host', // this should not match any proxy config
-    },
-    rejectUnauthorized: false,
-  });
-
-  // Expect a 404 response with the appropriate error message.
-  expect(response.statusCode).toEqual(404);
-});
-
-tap.test('should support WebSocket connections', async () => {
-  console.log('\n[TEST] ====== WebSocket Test Started ======');
-  console.log('[TEST] Test server port:', 3000);
-  console.log('[TEST] Proxy server port:', 3001);
-  console.log('\n[TEST] Starting WebSocket test');
-
-  // Reconfigure proxy with test certificates if necessary
-  await testProxy.updateProxyConfigs([
-    {
-      destinationIps: ['127.0.0.1'],
-      destinationPorts: [3000],
-      hostName: 'push.rocks',
-      publicKey: testCertificates.publicKey,
-      privateKey: testCertificates.privateKey,
-    },
-  ]);
-
-  try {
-    await new Promise<void>((resolve, reject) => {
-      console.log('[TEST] Creating WebSocket client');
-
-      // IMPORTANT: Connect to localhost but specify the SNI servername and Host header as "push.rocks"
-      const wsUrl = 'wss://localhost:3001'; // changed from 'wss://push.rocks:3001'
-      console.log('[TEST] Creating WebSocket connection to:', wsUrl);
-
-      let ws: WebSocket | null = null;
-      
-      try {
-        ws = new WebSocket(wsUrl, {
-          rejectUnauthorized: false, // Accept self-signed certificates
-          handshakeTimeout: 3000,
-          perMessageDeflate: false,
-          headers: {
-            Host: 'push.rocks', // required for SNI and routing on the proxy
-            Connection: 'Upgrade',
-            Upgrade: 'websocket',
-            'Sec-WebSocket-Version': '13',
-          },
-          protocol: 'echo-protocol',
-          agent: new https.Agent({
-            rejectUnauthorized: false, // Also needed for the underlying HTTPS connection
-          }),
-        });
-        console.log('[TEST] WebSocket client created');
-      } catch (error) {
-        console.error('[TEST] Error creating WebSocket client:', error);
-        reject(new Error('Failed to create WebSocket client'));
-        return;
-      }
-
-      let resolved = false;
-      const cleanup = () => {
-        if (!resolved) {
-          resolved = true;
-          try {
-            console.log('[TEST] Cleaning up WebSocket connection');
-            if (ws && ws.readyState < WebSocket.CLOSING) {
-              ws.close();
-            }
-            resolve();
-          } catch (error) {
-            console.error('[TEST] Error during cleanup:', error);
-            // Just resolve even if cleanup fails
-            resolve();
-          }
-        }
-      };
-
-      // Set a shorter timeout to prevent test from hanging
-      const timeout = setTimeout(() => {
-        console.log('[TEST] WebSocket test timed out - resolving test anyway');
-        cleanup();
-      }, 3000);
-
-      // Connection establishment events
-      ws.on('upgrade', (response) => {
-        console.log('[TEST] WebSocket upgrade response received:', {
-          headers: response.headers,
-          statusCode: response.statusCode,
-        });
-      });
-
-      ws.on('open', () => {
-        console.log('[TEST] WebSocket connection opened');
-        try {
-          console.log('[TEST] Sending test message');
-          ws.send('Hello WebSocket');
-        } catch (error) {
-          console.error('[TEST] Error sending message:', error);
-          cleanup();
-        }
-      });
-
-      ws.on('message', (message) => {
-        console.log('[TEST] Received message:', message.toString());
-        if (
-          message.toString() === 'Hello WebSocket' ||
-          message.toString() === 'Echo: Hello WebSocket'
-        ) {
-          console.log('[TEST] Message received correctly');
-          clearTimeout(timeout);
-          cleanup();
-        }
-      });
-
-      ws.on('error', (error) => {
-        console.error('[TEST] WebSocket error:', error);
-        cleanup();
-      });
-
-      ws.on('close', (code, reason) => {
-        console.log('[TEST] WebSocket connection closed:', {
-          code,
-          reason: reason.toString(),
-        });
-        cleanup();
-      });
-    });
-
-    // Add an additional timeout to ensure the test always completes
-    console.log('[TEST] WebSocket test completed');
-  } catch (error) {
-    console.error('[TEST] WebSocket test error:', error);
-    console.log('[TEST] WebSocket test failed but continuing');
-  }
-});
-
-tap.test('should handle custom headers', async () => {
-  await testProxy.addDefaultHeaders({
-    'X-Proxy-Header': 'test-value',
-  });
-
-  const response = await makeHttpsRequest({
-    hostname: 'localhost', // changed to 'localhost'
-    port: 3001,
-    path: '/',
-    method: 'GET',
-    headers: {
-      host: 'push.rocks', // still routing to push.rocks
-    },
-    rejectUnauthorized: false,
-  });
-
-  expect(response.headers['x-proxy-header']).toEqual('test-value');
-});
-
-tap.test('should handle CORS preflight requests', async () => {
-  try {
-    console.log('[TEST] Testing CORS preflight handling...');
-    
-    // First ensure the existing proxy is working correctly
-    console.log('[TEST] Making initial GET request to verify server');
-    const initialResponse = await makeHttpsRequest({
-      hostname: 'localhost',
-      port: 3001,
-      path: '/',
-      method: 'GET',
-      headers: { host: 'push.rocks' },
-      rejectUnauthorized: false,
-    });
-    
-    console.log('[TEST] Initial response status:', initialResponse.statusCode);
-    expect(initialResponse.statusCode).toEqual(200);
-    
-    // Add CORS headers to the existing proxy
-    console.log('[TEST] Adding CORS headers');
-    await testProxy.addDefaultHeaders({
-      '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'
-    });
-    
-    // Allow server to process the header changes
-    console.log('[TEST] Waiting for headers to be processed');
-    await new Promise(resolve => setTimeout(resolve, 500)); // Increased timeout
-    
-    // Send OPTIONS request to simulate CORS preflight
-    console.log('[TEST] Sending OPTIONS request for CORS preflight');
-    const response = await makeHttpsRequest({
-      hostname: 'localhost',
-      port: 3001,
-      path: '/',
-      method: 'OPTIONS',
-      headers: {
-        host: 'push.rocks',
-        'Access-Control-Request-Method': 'POST',
-        'Access-Control-Request-Headers': 'Content-Type',
-        'Origin': 'https://example.com'
-      },
-      rejectUnauthorized: false,
-    });
-
-    console.log('[TEST] CORS preflight response status:', response.statusCode);
-    console.log('[TEST] CORS preflight response headers:', response.headers);
-    
-    // For now, accept either 204 or 200 as success
-    expect([200, 204]).toContain(response.statusCode);
-    console.log('[TEST] CORS test completed successfully');
-  } catch (error) {
-    console.error('[TEST] Error in CORS test:', error);
-    throw error; // Rethrow to fail the test
-  }
-});
-
-tap.test('should track connections and metrics', async () => {
-  try {
-    console.log('[TEST] Testing metrics tracking...');
-    
-    // Get initial metrics counts
-    const initialRequestsServed = testProxy.requestsServed || 0;
-    console.log('[TEST] Initial requests served:', initialRequestsServed);
-    
-    // Make a few requests to ensure we have metrics to check
-    console.log('[TEST] Making test requests to increment metrics');
-    for (let i = 0; i < 3; i++) {
-      console.log(`[TEST] Making request ${i+1}/3`);
-      await makeHttpsRequest({
-        hostname: 'localhost',
-        port: 3001,
-        path: '/metrics-test-' + i,
-        method: 'GET',
-        headers: { host: 'push.rocks' },
-        rejectUnauthorized: false,
-      });
-    }
-    
-    // Wait a bit to let metrics update
-    console.log('[TEST] Waiting for metrics to update');
-    await new Promise(resolve => setTimeout(resolve, 500)); // Increased timeout
-    
-    // Verify metrics tracking is working
-    console.log('[TEST] Current requests served:', testProxy.requestsServed);
-    console.log('[TEST] Connected clients:', testProxy.connectedClients);
-    
-    expect(testProxy.connectedClients).toBeDefined();
-    expect(typeof testProxy.requestsServed).toEqual('number');
-    
-    // Use ">=" instead of ">" to be more forgiving with edge cases
-    expect(testProxy.requestsServed).toBeGreaterThanOrEqual(initialRequestsServed + 2);
-    console.log('[TEST] Metrics test completed successfully');
-  } catch (error) {
-    console.error('[TEST] Error in metrics test:', error);
-    throw error; // Rethrow to fail the test
-  }
-});
-
-tap.test('cleanup', async () => {
-  console.log('[TEST] Starting cleanup');
-
-  // Close all components with shorter timeouts to avoid hanging
-
-  // 1. Close WebSocket clients first
-  console.log('[TEST] Terminating WebSocket clients');
-  try {
-    wsServer.clients.forEach((client) => {
-      try {
-        client.terminate();
-      } catch (err) {
-        console.error('[TEST] Error terminating client:', err);
-      }
-    });
-  } catch (err) {
-    console.error('[TEST] Error accessing WebSocket clients:', err);
-  }
-
-  // 2. Close WebSocket server with short timeout
-  console.log('[TEST] Closing WebSocket server');
-  await Promise.race([
-    new Promise<void>((resolve) => {
-      wsServer.close(() => {
-        console.log('[TEST] WebSocket server closed');
-        resolve();
-      });
-    }),
-    new Promise<void>((resolve) => {
-      setTimeout(() => {
-        console.log('[TEST] WebSocket server close timed out, continuing');
-        resolve();
-      }, 500);
-    })
-  ]);
-
-  // 3. Close test server with short timeout
-  console.log('[TEST] Closing test server');
-  await Promise.race([
-    new Promise<void>((resolve) => {
-      testServer.close(() => {
-        console.log('[TEST] Test server closed');
-        resolve();
-      });
-    }),
-    new Promise<void>((resolve) => {
-      setTimeout(() => {
-        console.log('[TEST] Test server close timed out, continuing');
-        resolve();
-      }, 500);
-    })
-  ]);
-
-  // 4. Stop the proxy with short timeout
-  console.log('[TEST] Stopping proxy');
-  await Promise.race([
-    testProxy.stop().catch(err => {
-      console.error('[TEST] Error stopping proxy:', err);
-    }),
-    new Promise<void>((resolve) => {
-      setTimeout(() => {
-        console.log('[TEST] Proxy stop timed out, continuing');
-        if (testProxy.httpsServer) {
-          try {
-            testProxy.httpsServer.close();
-          } catch (e) {}
-        }
-        resolve();
-      }, 500);
-    })
-  ]);
-  
-  console.log('[TEST] Cleanup complete');
-});
-
-// Set up a more reliable exit handler
-process.on('exit', () => {
-  console.log('[TEST] Process exit - force shutdown of all components');
-  
-  // At this point, it's too late for async operations, just try to close things
-  try {
-    if (wsServer) {
-      console.log('[TEST] Force closing WebSocket server');
-      wsServer.close();
-    }
-  } catch (e) {}
-  
-  try {
-    if (testServer) {
-      console.log('[TEST] Force closing test server');
-      testServer.close();
-    }
-  } catch (e) {}
-  
-  try {
-    if (testProxy && testProxy.httpsServer) {
-      console.log('[TEST] Force closing proxy server');
-      testProxy.httpsServer.close();
-    }
-  } catch (e) {}
-});
-
-export default tap.start().then(() => {
-  // Force exit to prevent hanging
-  setTimeout(() => {
-    console.log("[TEST] Forcing process exit");
-    process.exit(0);
-  }, 500);
-});

test/test.nftables-forwarding.ts

@@ -0,0 +1,116 @@
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import * as net from 'net';
+import { SmartProxy } from '../ts/proxies/smart-proxy/smart-proxy.js';
+import type { IRouteConfig } from '../ts/proxies/smart-proxy/models/route-types.js';
+
+// Test to verify NFTables forwarding doesn't terminate connections
+tap.skip.test('NFTables forwarding should not terminate connections (requires root)', async () => {
+  // Create a test server that receives connections
+  const testServer = net.createServer((socket) => {
+    socket.write('Connected to test server\n');
+    socket.on('data', (data) => {
+      socket.write(`Echo: ${data}`);
+    });
+  });
+
+  // Start test server
+  await new Promise<void>((resolve) => {
+    testServer.listen(8001, '127.0.0.1', () => {
+      console.log('Test server listening on port 8001');
+      resolve();
+    });
+  });
+
+  // Create SmartProxy with NFTables route
+  const smartProxy = new SmartProxy({
+    enableDetailedLogging: true,
+    routes: [
+      {
+        id: 'nftables-test',
+        name: 'NFTables Test Route',
+        match: {
+          ports: 8080,
+        },
+        action: {
+          type: 'forward',
+          forwardingEngine: 'nftables',
+          target: {
+            host: '127.0.0.1',
+            port: 8001,
+          },
+        },
+      },
+      // Also add regular forwarding route for comparison
+      {
+        id: 'regular-test',
+        name: 'Regular Forward Route',
+        match: {
+          ports: 8081,
+        },
+        action: {
+          type: 'forward',
+          target: {
+            host: '127.0.0.1',
+            port: 8001,
+          },
+        },
+      },
+    ],
+  });
+
+  await smartProxy.start();
+
+  // Test NFTables route
+  const nftablesConnection = await new Promise<net.Socket>((resolve, reject) => {
+    const client = net.connect(8080, '127.0.0.1', () => {
+      console.log('Connected to NFTables route');
+      resolve(client);
+    });
+    client.on('error', reject);
+  });
+
+  // Add timeout to check if connection stays alive
+  await new Promise<void>((resolve) => {
+    let dataReceived = false;
+    nftablesConnection.on('data', (data) => {
+      console.log('NFTables route data:', data.toString());
+      dataReceived = true;
+    });
+
+    // Send test data
+    nftablesConnection.write('Test NFTables');
+
+    // Check connection after 100ms
+    setTimeout(() => {
+      // Connection should still be alive even if app doesn't handle it
+      expect(nftablesConnection.destroyed).toEqual(false);
+      nftablesConnection.end();
+      resolve();
+    }, 100);
+  });
+
+  // Test regular forwarding route for comparison
+  const regularConnection = await new Promise<net.Socket>((resolve, reject) => {
+    const client = net.connect(8081, '127.0.0.1', () => {
+      console.log('Connected to regular route');
+      resolve(client);
+    });
+    client.on('error', reject);
+  });
+
+  // Test regular connection works
+  await new Promise<void>((resolve) => {
+    regularConnection.on('data', (data) => {
+      console.log('Regular route data:', data.toString());
+      expect(data.toString()).toContain('Connected to test server');
+      regularConnection.end();
+      resolve();
+    });
+  });
+
+  // Cleanup
+  await smartProxy.stop();
+  testServer.close();
+});
+
+export default tap.start();

test/test.nftables-integration.simple.ts

@@ -0,0 +1,96 @@
+import { SmartProxy } from '../ts/proxies/smart-proxy/index.js';
+import { createNfTablesRoute, createNfTablesTerminateRoute } from '../ts/proxies/smart-proxy/utils/route-helpers.js';
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import * as child_process from 'child_process';
+import { promisify } from 'util';
+
+const exec = promisify(child_process.exec);
+
+// Check if we have root privileges to run NFTables tests
+async function checkRootPrivileges(): Promise<boolean> {
+  try {
+    // Check if we're running as root
+    const { stdout } = await exec('id -u');
+    return stdout.trim() === '0';
+  } catch (err) {
+    return false;
+  }
+}
+
+// Check if tests should run
+const isRoot = await checkRootPrivileges();
+
+if (!isRoot) {
+  console.log('');
+  console.log('========================================');
+  console.log('NFTables tests require root privileges');
+  console.log('Skipping NFTables integration tests');
+  console.log('========================================');
+  console.log('');
+}
+
+// Define the test with proper skip condition
+const testFn = isRoot ? tap.test : tap.skip.test;
+
+testFn('NFTables integration tests', async () => {
+  
+  console.log('Running NFTables tests with root privileges');
+  
+  // Create test routes
+  const routes = [
+    createNfTablesRoute('tcp-forward', {
+      host: 'localhost',
+      port: 8080
+    }, {
+      ports: 9080,
+      protocol: 'tcp'
+    }),
+    
+    createNfTablesRoute('udp-forward', {
+      host: 'localhost',
+      port: 5353
+    }, {
+      ports: 5354,
+      protocol: 'udp'
+    }),
+    
+    createNfTablesRoute('port-range', {
+      host: 'localhost',
+      port: 8080
+    }, {
+      ports: [{ from: 9000, to: 9100 }],
+      protocol: 'tcp'
+    })
+  ];
+  
+  const smartProxy = new SmartProxy({
+    enableDetailedLogging: true,
+    routes
+  });
+  
+  // Start the proxy
+  await smartProxy.start();
+  console.log('SmartProxy started with NFTables routes');
+  
+  // Get NFTables status
+  const status = await smartProxy.getNfTablesStatus();
+  console.log('NFTables status:', JSON.stringify(status, null, 2));
+  
+  // Verify all routes are provisioned
+  expect(Object.keys(status).length).toEqual(routes.length);
+  
+  for (const routeStatus of Object.values(status)) {
+    expect(routeStatus.active).toBeTrue();
+    expect(routeStatus.ruleCount.total).toBeGreaterThan(0);
+  }
+  
+  // Stop the proxy
+  await smartProxy.stop();
+  console.log('SmartProxy stopped');
+  
+  // Verify all rules are cleaned up
+  const finalStatus = await smartProxy.getNfTablesStatus();
+  expect(Object.keys(finalStatus).length).toEqual(0);
+});
+
+export default tap.start();

test/test.nftables-integration.ts

@@ -0,0 +1,349 @@
+import { SmartProxy } from '../ts/proxies/smart-proxy/index.js';
+import { createNfTablesRoute, createNfTablesTerminateRoute } from '../ts/proxies/smart-proxy/utils/route-helpers.js';
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import * as net from 'net';
+import * as http from 'http';
+import * as https from 'https';
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import * as child_process from 'child_process';
+import { promisify } from 'util';
+
+const exec = promisify(child_process.exec);
+
+// Get __dirname equivalent for ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Check if we have root privileges
+async function checkRootPrivileges(): Promise<boolean> {
+  try {
+    const { stdout } = await exec('id -u');
+    return stdout.trim() === '0';
+  } catch (err) {
+    return false;
+  }
+}
+
+// Check if tests should run
+const runTests = await checkRootPrivileges();
+
+if (!runTests) {
+  console.log('');
+  console.log('========================================');
+  console.log('NFTables tests require root privileges');
+  console.log('Skipping NFTables integration tests');
+  console.log('========================================');
+  console.log('');
+  // Skip tests when not running as root - tests are marked with tap.skip.test
+}
+
+// Test server and client utilities
+let testTcpServer: net.Server;
+let testHttpServer: http.Server;
+let testHttpsServer: https.Server;
+let smartProxy: SmartProxy;
+
+const TEST_TCP_PORT = 4000;
+const TEST_HTTP_PORT = 4001;
+const TEST_HTTPS_PORT = 4002;
+const PROXY_TCP_PORT = 5000;
+const PROXY_HTTP_PORT = 5001;
+const PROXY_HTTPS_PORT = 5002;
+const TEST_DATA = 'Hello through NFTables!';
+
+// Helper to create test certificates
+async function createTestCertificates() {
+  try {
+    // Import the certificate helper
+    const certsModule = await import('./helpers/certificates.js');
+    const certificates = certsModule.loadTestCertificates();
+    return {
+      cert: certificates.publicKey,
+      key: certificates.privateKey
+    };
+  } catch (err) {
+    console.error('Failed to load test certificates:', err);
+    // Use dummy certificates for testing
+    return {
+      cert: fs.readFileSync(path.join(__dirname, '..', 'assets', 'certs', 'cert.pem'), 'utf8'),
+      key: fs.readFileSync(path.join(__dirname, '..', 'assets', 'certs', 'key.pem'), 'utf8')
+    };
+  }
+}
+
+tap.skip.test('setup NFTables integration test environment', async () => {
+  console.log('Running NFTables integration tests with root privileges');
+  
+  // Create a basic TCP test server
+  testTcpServer = net.createServer((socket) => {
+    socket.on('data', (data) => {
+      socket.write(`Server says: ${data.toString()}`);
+    });
+  });
+  
+  await new Promise<void>((resolve) => {
+    testTcpServer.listen(TEST_TCP_PORT, () => {
+      console.log(`TCP test server listening on port ${TEST_TCP_PORT}`);
+      resolve();
+    });
+  });
+  
+  // Create an HTTP test server
+  testHttpServer = http.createServer((req, res) => {
+    res.writeHead(200, { 'Content-Type': 'text/plain' });
+    res.end(`HTTP Server says: ${TEST_DATA}`);
+  });
+  
+  await new Promise<void>((resolve) => {
+    testHttpServer.listen(TEST_HTTP_PORT, () => {
+      console.log(`HTTP test server listening on port ${TEST_HTTP_PORT}`);
+      resolve();
+    });
+  });
+  
+  // Create an HTTPS test server
+  const certs = await createTestCertificates();
+  testHttpsServer = https.createServer({ key: certs.key, cert: certs.cert }, (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'text/plain' });
+    res.end(`HTTPS Server says: ${TEST_DATA}`);
+  });
+  
+  await new Promise<void>((resolve) => {
+    testHttpsServer.listen(TEST_HTTPS_PORT, () => {
+      console.log(`HTTPS test server listening on port ${TEST_HTTPS_PORT}`);
+      resolve();
+    });
+  });
+  
+  // Create SmartProxy with various NFTables routes
+  smartProxy = new SmartProxy({
+    enableDetailedLogging: true,
+    routes: [
+      // TCP forwarding route
+      createNfTablesRoute('tcp-nftables', {
+        host: 'localhost',
+        port: TEST_TCP_PORT
+      }, {
+        ports: PROXY_TCP_PORT,
+        protocol: 'tcp'
+      }),
+      
+      // HTTP forwarding route
+      createNfTablesRoute('http-nftables', {
+        host: 'localhost',
+        port: TEST_HTTP_PORT
+      }, {
+        ports: PROXY_HTTP_PORT,
+        protocol: 'tcp'
+      }),
+      
+      // HTTPS termination route
+      createNfTablesTerminateRoute('https-nftables.example.com', {
+        host: 'localhost',
+        port: TEST_HTTPS_PORT
+      }, {
+        ports: PROXY_HTTPS_PORT,
+        protocol: 'tcp',
+        certificate: certs
+      }),
+      
+      // Route with IP allow list
+      createNfTablesRoute('secure-tcp', {
+        host: 'localhost',
+        port: TEST_TCP_PORT
+      }, {
+        ports: 5003,
+        protocol: 'tcp',
+        ipAllowList: ['127.0.0.1', '::1']
+      }),
+      
+      // Route with QoS settings
+      createNfTablesRoute('qos-tcp', {
+        host: 'localhost',
+        port: TEST_TCP_PORT
+      }, {
+        ports: 5004,
+        protocol: 'tcp',
+        maxRate: '10mbps',
+        priority: 1
+      })
+    ]
+  });
+  
+  console.log('SmartProxy created, now starting...');
+  
+  // Start the proxy
+  try {
+    await smartProxy.start();
+    console.log('SmartProxy started successfully');
+    
+    // Verify proxy is listening on expected ports
+    const listeningPorts = smartProxy.getListeningPorts();
+    console.log(`SmartProxy is listening on ports: ${listeningPorts.join(', ')}`);
+  } catch (err) {
+    console.error('Failed to start SmartProxy:', err);
+    throw err;
+  }
+});
+
+tap.skip.test('should forward TCP connections through NFTables', async () => {
+  console.log(`Attempting to connect to proxy TCP port ${PROXY_TCP_PORT}...`);
+  
+  // First verify our test server is running
+  try {
+    const testClient = new net.Socket();
+    await new Promise<void>((resolve, reject) => {
+      testClient.connect(TEST_TCP_PORT, 'localhost', () => {
+        console.log(`Test server on port ${TEST_TCP_PORT} is accessible`);
+        testClient.end();
+        resolve();
+      });
+      testClient.on('error', reject);
+    });
+  } catch (err) {
+    console.error(`Test server on port ${TEST_TCP_PORT} is not accessible: ${err}`);
+  }
+  
+  // Connect to the proxy port
+  const client = new net.Socket();
+  
+  const response = await new Promise<string>((resolve, reject) => {
+    let responseData = '';
+    const timeout = setTimeout(() => {
+      client.destroy();
+      reject(new Error(`Connection timeout after 5 seconds to proxy port ${PROXY_TCP_PORT}`));
+    }, 5000);
+    
+    client.connect(PROXY_TCP_PORT, 'localhost', () => {
+      console.log(`Connected to proxy port ${PROXY_TCP_PORT}, sending data...`);
+      client.write(TEST_DATA);
+    });
+    
+    client.on('data', (data) => {
+      console.log(`Received data from proxy: ${data.toString()}`);
+      responseData += data.toString();
+      client.end();
+    });
+    
+    client.on('end', () => {
+      clearTimeout(timeout);
+      resolve(responseData);
+    });
+    
+    client.on('error', (err) => {
+      clearTimeout(timeout);
+      console.error(`Connection error on proxy port ${PROXY_TCP_PORT}: ${err.message}`);
+      reject(err);
+    });
+  });
+  
+  expect(response).toEqual(`Server says: ${TEST_DATA}`);
+});
+
+tap.skip.test('should forward HTTP connections through NFTables', async () => {
+  const response = await new Promise<string>((resolve, reject) => {
+    http.get(`http://localhost:${PROXY_HTTP_PORT}`, (res) => {
+      let data = '';
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+      res.on('end', () => {
+        resolve(data);
+      });
+    }).on('error', reject);
+  });
+  
+  expect(response).toEqual(`HTTP Server says: ${TEST_DATA}`);
+});
+
+tap.skip.test('should handle HTTPS termination with NFTables', async () => {
+  // Skip this test if running without proper certificates
+  const response = await new Promise<string>((resolve, reject) => {
+    const options = {
+      hostname: 'localhost',
+      port: PROXY_HTTPS_PORT,
+      path: '/',
+      method: 'GET',
+      rejectUnauthorized: false // For self-signed cert
+    };
+    
+    https.get(options, (res) => {
+      let data = '';
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+      res.on('end', () => {
+        resolve(data);
+      });
+    }).on('error', reject);
+  });
+  
+  expect(response).toEqual(`HTTPS Server says: ${TEST_DATA}`);
+});
+
+tap.skip.test('should respect IP allow lists in NFTables', async () => {
+  // This test should pass since we're connecting from localhost
+  const client = new net.Socket();
+  
+  const connected = await new Promise<boolean>((resolve) => {
+    const timeout = setTimeout(() => {
+      client.destroy();
+      resolve(false);
+    }, 2000);
+    
+    client.connect(5003, 'localhost', () => {
+      clearTimeout(timeout);
+      client.end();
+      resolve(true);
+    });
+    
+    client.on('error', () => {
+      clearTimeout(timeout);
+      resolve(false);
+    });
+  });
+  
+  expect(connected).toBeTrue();
+});
+
+tap.skip.test('should get NFTables status', async () => {
+  const status = await smartProxy.getNfTablesStatus();
+  
+  // Check that we have status for our routes
+  const statusKeys = Object.keys(status);
+  expect(statusKeys.length).toBeGreaterThan(0);
+  
+  // Check status structure for one of the routes
+  const firstStatus = status[statusKeys[0]];
+  expect(firstStatus).toHaveProperty('active');
+  expect(firstStatus).toHaveProperty('ruleCount');
+  expect(firstStatus.ruleCount).toHaveProperty('total');
+  expect(firstStatus.ruleCount).toHaveProperty('added');
+});
+
+tap.skip.test('cleanup NFTables integration test environment', async () => {
+  // Stop the proxy and test servers
+  await smartProxy.stop();
+  
+  await new Promise<void>((resolve) => {
+    testTcpServer.close(() => {
+      resolve();
+    });
+  });
+  
+  await new Promise<void>((resolve) => {
+    testHttpServer.close(() => {
+      resolve();
+    });
+  });
+  
+  await new Promise<void>((resolve) => {
+    testHttpsServer.close(() => {
+      resolve();
+    });
+  });
+});
+
+export default tap.start();

test/test.nftables-manager.ts

@@ -0,0 +1,184 @@
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import { NFTablesManager } from '../ts/proxies/smart-proxy/nftables-manager.js';
+import type { IRouteConfig } from '../ts/proxies/smart-proxy/models/route-types.js';
+import type { ISmartProxyOptions } from '../ts/proxies/smart-proxy/models/interfaces.js';
+import * as child_process from 'child_process';
+import { promisify } from 'util';
+
+const exec = promisify(child_process.exec);
+
+// Check if we have root privileges
+async function checkRootPrivileges(): Promise<boolean> {
+  try {
+    const { stdout } = await exec('id -u');
+    return stdout.trim() === '0';
+  } catch (err) {
+    return false;
+  }
+}
+
+// Skip tests if not root
+const isRoot = await checkRootPrivileges();
+if (!isRoot) {
+  console.log('');
+  console.log('========================================');
+  console.log('NFTablesManager tests require root privileges');
+  console.log('Skipping NFTablesManager tests');
+  console.log('========================================');
+  console.log('');
+  // Skip tests when not running as root - tests are marked with tap.skip.test
+}
+
+/**
+ * Tests for the NFTablesManager class
+ */
+
+// Sample route configurations for testing
+const sampleRoute: IRouteConfig = {
+  name: 'test-nftables-route',
+  match: {
+    ports: 8080,
+    domains: 'test.example.com'
+  },
+  action: {
+    type: 'forward',
+    target: {
+      host: 'localhost',
+      port: 8000
+    },
+    forwardingEngine: 'nftables',
+    nftables: {
+      protocol: 'tcp',
+      preserveSourceIP: true,
+      useIPSets: true
+    }
+  }
+};
+
+// Sample SmartProxy options
+const sampleOptions: ISmartProxyOptions = {
+  routes: [sampleRoute],
+  enableDetailedLogging: true
+};
+
+// Instance of NFTablesManager for testing
+let manager: NFTablesManager;
+
+// Skip these tests by default since they require root privileges to run NFTables commands
+// When running as root, change this to false
+const SKIP_TESTS = true;
+
+tap.skip.test('NFTablesManager setup test', async () => {
+  // Test will be skipped if not running as root due to tap.skip.test
+  
+  // Create a new instance of NFTablesManager
+  manager = new NFTablesManager(sampleOptions);
+  
+  // Verify the instance was created successfully
+  expect(manager).toBeTruthy();
+});
+
+tap.skip.test('NFTablesManager route provisioning test', async () => {
+  // Test will be skipped if not running as root due to tap.skip.test
+  
+  // Provision the sample route
+  const result = await manager.provisionRoute(sampleRoute);
+  
+  // Verify the route was provisioned successfully
+  expect(result).toEqual(true);
+  
+  // Verify the route is listed as provisioned
+  expect(manager.isRouteProvisioned(sampleRoute)).toEqual(true);
+});
+
+tap.skip.test('NFTablesManager status test', async () => {
+  // Test will be skipped if not running as root due to tap.skip.test
+  
+  // Get the status of the managed rules
+  const status = await manager.getStatus();
+  
+  // Verify status includes our route
+  const keys = Object.keys(status);
+  expect(keys.length).toBeGreaterThan(0);
+  
+  // Check the status of the first rule
+  const firstStatus = status[keys[0]];
+  expect(firstStatus.active).toEqual(true);
+  expect(firstStatus.ruleCount.added).toBeGreaterThan(0);
+});
+
+tap.skip.test('NFTablesManager route updating test', async () => {
+  // Test will be skipped if not running as root due to tap.skip.test
+  
+  // Create an updated version of the sample route
+  const updatedRoute: IRouteConfig = {
+    ...sampleRoute,
+    action: {
+      ...sampleRoute.action,
+      target: {
+        host: 'localhost',
+        port: 9000 // Different port
+      },
+      nftables: {
+        ...sampleRoute.action.nftables,
+        protocol: 'all' // Different protocol
+      }
+    }
+  };
+  
+  // Update the route
+  const result = await manager.updateRoute(sampleRoute, updatedRoute);
+  
+  // Verify the route was updated successfully
+  expect(result).toEqual(true);
+  
+  // Verify the old route is no longer provisioned
+  expect(manager.isRouteProvisioned(sampleRoute)).toEqual(false);
+  
+  // Verify the new route is provisioned
+  expect(manager.isRouteProvisioned(updatedRoute)).toEqual(true);
+});
+
+tap.skip.test('NFTablesManager route deprovisioning test', async () => {
+  // Test will be skipped if not running as root due to tap.skip.test
+  
+  // Create an updated version of the sample route from the previous test
+  const updatedRoute: IRouteConfig = {
+    ...sampleRoute,
+    action: {
+      ...sampleRoute.action,
+      target: {
+        host: 'localhost',
+        port: 9000 // Different port from original test
+      },
+      nftables: {
+        ...sampleRoute.action.nftables,
+        protocol: 'all' // Different protocol from original test
+      }
+    }
+  };
+  
+  // Deprovision the route
+  const result = await manager.deprovisionRoute(updatedRoute);
+  
+  // Verify the route was deprovisioned successfully
+  expect(result).toEqual(true);
+  
+  // Verify the route is no longer provisioned
+  expect(manager.isRouteProvisioned(updatedRoute)).toEqual(false);
+});
+
+tap.skip.test('NFTablesManager cleanup test', async () => {
+  // Test will be skipped if not running as root due to tap.skip.test
+  
+  // Stop all NFTables rules
+  await manager.stop();
+  
+  // Get the status of the managed rules
+  const status = await manager.getStatus();
+  
+  // Verify there are no active rules
+  expect(Object.keys(status).length).toEqual(0);
+});
+
+export default tap.start();

test/test.nftables-status.ts

@@ -0,0 +1,164 @@
+import { SmartProxy } from '../ts/proxies/smart-proxy/index.js';
+import { NFTablesManager } from '../ts/proxies/smart-proxy/nftables-manager.js';
+import { createNfTablesRoute } from '../ts/proxies/smart-proxy/utils/route-helpers.js';
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import * as child_process from 'child_process';
+import { promisify } from 'util';
+
+const exec = promisify(child_process.exec);
+
+// Check if we have root privileges
+async function checkRootPrivileges(): Promise<boolean> {
+  try {
+    const { stdout } = await exec('id -u');
+    return stdout.trim() === '0';
+  } catch (err) {
+    return false;
+  }
+}
+
+// Skip tests if not root
+const isRoot = await checkRootPrivileges();
+if (!isRoot) {
+  console.log('');
+  console.log('========================================');
+  console.log('NFTables status tests require root privileges');
+  console.log('Skipping NFTables status tests');
+  console.log('========================================');
+  console.log('');
+}
+
+// Define the test function based on root privileges
+const testFn = isRoot ? tap.test : tap.skip.test;
+
+testFn('NFTablesManager status functionality', async () => {
+  const nftablesManager = new NFTablesManager({ routes: [] });
+  
+  // Create test routes
+  const testRoutes = [
+    createNfTablesRoute('test-route-1', { host: 'localhost', port: 8080 }, { ports: 9080 }),
+    createNfTablesRoute('test-route-2', { host: 'localhost', port: 8081 }, { ports: 9081 }),
+    createNfTablesRoute('test-route-3', { host: 'localhost', port: 8082 }, { 
+      ports: 9082,
+      ipAllowList: ['127.0.0.1', '192.168.1.0/24']
+    })
+  ];
+  
+  // Get initial status (should be empty)
+  let status = await nftablesManager.getStatus();
+  expect(Object.keys(status).length).toEqual(0);
+  
+  // Provision routes
+  for (const route of testRoutes) {
+    await nftablesManager.provisionRoute(route);
+  }
+  
+  // Get status after provisioning
+  status = await nftablesManager.getStatus();
+  expect(Object.keys(status).length).toEqual(3);
+  
+  // Check status structure
+  for (const routeStatus of Object.values(status)) {
+    expect(routeStatus).toHaveProperty('active');
+    expect(routeStatus).toHaveProperty('ruleCount');
+    expect(routeStatus).toHaveProperty('lastUpdate');
+    expect(routeStatus.active).toBeTrue();
+  }
+  
+  // Deprovision one route
+  await nftablesManager.deprovisionRoute(testRoutes[0]);
+  
+  // Check status after deprovisioning
+  status = await nftablesManager.getStatus();
+  expect(Object.keys(status).length).toEqual(2);
+  
+  // Cleanup remaining routes
+  await nftablesManager.stop();
+  
+  // Final status should be empty
+  status = await nftablesManager.getStatus();
+  expect(Object.keys(status).length).toEqual(0);
+});
+
+testFn('SmartProxy getNfTablesStatus functionality', async () => {
+  const smartProxy = new SmartProxy({
+    routes: [
+      createNfTablesRoute('proxy-test-1', { host: 'localhost', port: 3000 }, { ports: 3001 }),
+      createNfTablesRoute('proxy-test-2', { host: 'localhost', port: 3002 }, { ports: 3003 }),
+      // Include a non-NFTables route to ensure it's not included in the status
+      {
+        name: 'non-nftables-route',
+        match: { ports: 3004 },
+        action: {
+          type: 'forward',
+          target: { host: 'localhost', port: 3005 }
+        }
+      }
+    ]
+  });
+  
+  // Start the proxy
+  await smartProxy.start();
+  
+  // Get NFTables status
+  const status = await smartProxy.getNfTablesStatus();
+  
+  // Should only have 2 NFTables routes
+  const statusKeys = Object.keys(status);
+  expect(statusKeys.length).toEqual(2);
+  
+  // Check that both NFTables routes are in the status
+  const routeIds = statusKeys.sort();
+  expect(routeIds).toContain('proxy-test-1:3001');
+  expect(routeIds).toContain('proxy-test-2:3003');
+  
+  // Verify status structure
+  for (const [routeId, routeStatus] of Object.entries(status)) {
+    expect(routeStatus).toHaveProperty('active', true);
+    expect(routeStatus).toHaveProperty('ruleCount');
+    expect(routeStatus.ruleCount).toHaveProperty('total');
+    expect(routeStatus.ruleCount.total).toBeGreaterThan(0);
+  }
+  
+  // Stop the proxy
+  await smartProxy.stop();
+  
+  // After stopping, status should be empty
+  const finalStatus = await smartProxy.getNfTablesStatus();
+  expect(Object.keys(finalStatus).length).toEqual(0);
+});
+
+testFn('NFTables route update status tracking', async () => {
+  const smartProxy = new SmartProxy({
+    routes: [
+      createNfTablesRoute('update-test', { host: 'localhost', port: 4000 }, { ports: 4001 })
+    ]
+  });
+  
+  await smartProxy.start();
+  
+  // Get initial status
+  let status = await smartProxy.getNfTablesStatus();
+  expect(Object.keys(status).length).toEqual(1);
+  const initialUpdate = status['update-test:4001'].lastUpdate;
+  
+  // Wait a moment
+  await new Promise(resolve => setTimeout(resolve, 10));
+  
+  // Update the route
+  await smartProxy.updateRoutes([
+    createNfTablesRoute('update-test', { host: 'localhost', port: 4002 }, { ports: 4001 })
+  ]);
+  
+  // Get status after update
+  status = await smartProxy.getNfTablesStatus();
+  expect(Object.keys(status).length).toEqual(1);
+  const updatedTime = status['update-test:4001'].lastUpdate;
+  
+  // The update time should be different
+  expect(updatedTime.getTime()).toBeGreaterThan(initialUpdate.getTime());
+  
+  await smartProxy.stop();
+});
+
+export default tap.start();

test/test.port-forwarding-fix.ts

@@ -0,0 +1,100 @@
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import * as net from 'net';
+import { SmartProxy } from '../ts/proxies/smart-proxy/smart-proxy.js';
+
+let echoServer: net.Server;
+let proxy: SmartProxy;
+
+tap.test('port forwarding should not immediately close connections', async (tools) => {
+  // Set a timeout for this test
+  tools.timeout(10000); // 10 seconds
+  // Create an echo server
+  echoServer = await new Promise<net.Server>((resolve) => {
+    const server = net.createServer((socket) => {
+      socket.on('data', (data) => {
+        socket.write(`ECHO: ${data}`);
+      });
+    });
+    
+    server.listen(8888, () => {
+      console.log('Echo server listening on port 8888');
+      resolve(server);
+    });
+  });
+
+  // Create proxy with forwarding route
+  proxy = new SmartProxy({
+    routes: [{
+      id: 'test',
+      match: { ports: 9999 },
+      action: {
+        type: 'forward',
+        target: { host: 'localhost', port: 8888 }
+      }
+    }]
+  });
+
+  await proxy.start();
+
+  // Test connection through proxy
+  const client = net.createConnection(9999, 'localhost');
+  
+  const result = await new Promise<string>((resolve, reject) => {
+    client.on('data', (data) => {
+      const response = data.toString();
+      client.end(); // Close the connection after receiving data
+      resolve(response);
+    });
+    
+    client.on('error', reject);
+    
+    client.write('Hello');
+  });
+
+  expect(result).toEqual('ECHO: Hello');
+});
+
+tap.test('TLS passthrough should work correctly', async () => {
+  // Create proxy with TLS passthrough
+  proxy = new SmartProxy({
+    routes: [{
+      id: 'tls-test', 
+      match: { ports: 8443, domains: 'test.example.com' },
+      action: {
+        type: 'forward',
+        tls: { mode: 'passthrough' },
+        target: { host: 'localhost', port: 443 }
+      }
+    }]
+  });
+
+  await proxy.start();
+
+  // For now just verify the proxy starts correctly with TLS passthrough route
+  expect(proxy).toBeDefined();
+
+  await proxy.stop();
+});
+
+tap.test('cleanup', async () => {
+  if (echoServer) {
+    await new Promise<void>((resolve) => {
+      echoServer.close(() => {
+        console.log('Echo server closed');
+        resolve();
+      });
+    });
+  }
+  if (proxy) {
+    await proxy.stop();
+    console.log('Proxy stopped');
+  }
+});
+
+export default tap.start().then(() => {
+  // Force exit after tests complete
+  setTimeout(() => {
+    console.log('Forcing process exit');
+    process.exit(0);
+  }, 1000);
+});

test/test.port-mapping.ts

@@ -1,4 +1,4 @@
-import { expect, tap } from '@push.rocks/tapbundle';
+import { expect, tap } from '@git.zone/tstest/tapbundle';
 import * as net from 'net';
 import { SmartProxy } from '../ts/proxies/smart-proxy/index.js';
 import {
@@ -20,12 +20,29 @@ const TEST_DATA = 'Hello through dynamic port mapper!';
 
 // Cleanup function to close all servers and proxies
 function cleanup() {
-  return Promise.all([
-    ...testServers.map(({ server }) => new Promise<void>(resolve => {
-      server.close(() => resolve());
-    })),
-    smartProxy ? smartProxy.stop() : Promise.resolve()
-  ]);
+  console.log('Starting cleanup...');
+  const promises = [];
+  
+  // Close test servers
+  for (const { server, port } of testServers) {
+    promises.push(new Promise<void>(resolve => {
+      console.log(`Closing test server on port ${port}`);
+      server.close(() => {
+        console.log(`Test server on port ${port} closed`);
+        resolve();
+      });
+    }));
+  }
+  
+  // Stop SmartProxy
+  if (smartProxy) {
+    console.log('Stopping SmartProxy...');
+    promises.push(smartProxy.stop().then(() => {
+      console.log('SmartProxy stopped');
+    }));
+  }
+  
+  return Promise.all(promises);
 }
 
 // Helper: Creates a test TCP server that listens on a given port
@@ -213,15 +230,30 @@ tap.test('should handle errors in port mapping functions', async () => {
   // The connection should fail or timeout
   try {
     await createTestClient(PROXY_PORT_START + 5, TEST_DATA);
-    expect(false).toBeTrue('Connection should have failed but succeeded');
+    // Connection should not succeed
+    expect(false).toBeTrue();
   } catch (error) {
-    expect(true).toBeTrue('Connection failed as expected');
+    // Connection failed as expected
+    expect(true).toBeTrue();
   }
 });
 
 // Cleanup
 tap.test('cleanup port mapping test environment', async () => {
-  await cleanup();
+  // Add timeout to prevent hanging if SmartProxy shutdown has issues
+  const cleanupPromise = cleanup();
+  const timeoutPromise = new Promise((_, reject) => 
+    setTimeout(() => reject(new Error('Cleanup timeout after 5 seconds')), 5000)
+  );
+  
+  try {
+    await Promise.race([cleanupPromise, timeoutPromise]);
+  } catch (error) {
+    console.error('Cleanup error:', error);
+    // Force cleanup even if there's an error
+    testServers = [];
+    smartProxy = null as any;
+  }
 });
 
 export default tap.start();

test/test.port80-management.node.ts

@@ -0,0 +1,281 @@
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import { SmartProxy } from '../ts/index.js';
+
+/**
+ * Test that verifies port 80 is not double-registered when both
+ * user routes and ACME challenges use the same port
+ */
+tap.test('should not double-register port 80 when user route and ACME use same port', async (tools) => {
+  tools.timeout(5000);
+  
+  let port80AddCount = 0;
+  const activePorts = new Set<number>();
+  
+  const settings = {
+    port: 9901,
+    routes: [
+      {
+        name: 'user-route',
+        match: {
+          ports: [80]
+        },
+        action: {
+          type: 'forward' as const,
+          target: { host: 'localhost', port: 3000 }
+        }
+      },
+      {
+        name: 'secure-route',
+        match: {
+          ports: [443]
+        },
+        action: {
+          type: 'forward' as const,
+          target: { host: 'localhost', port: 3001 },
+          tls: {
+            mode: 'terminate' as const,
+            certificate: 'auto' as const
+          }
+        }
+      }
+    ],
+    acme: {
+      email: 'test@test.com',
+      port: 80  // ACME on same port as user route
+    }
+  };
+  
+  const proxy = new SmartProxy(settings);
+  
+  // Mock the port manager to track port additions
+  const mockPortManager = {
+    addPort: async (port: number) => {
+      if (activePorts.has(port)) {
+        return; // Simulate deduplication
+      }
+      activePorts.add(port);
+      if (port === 80) {
+        port80AddCount++;
+      }
+    },
+    addPorts: async (ports: number[]) => {
+      for (const port of ports) {
+        await mockPortManager.addPort(port);
+      }
+    },
+    updatePorts: async (requiredPorts: Set<number>) => {
+      for (const port of requiredPorts) {
+        await mockPortManager.addPort(port);
+      }
+    },
+    setShuttingDown: () => {},
+    closeAll: async () => { activePorts.clear(); },
+    stop: async () => { await mockPortManager.closeAll(); }
+  };
+  
+  // Inject mock
+  (proxy as any).portManager = mockPortManager;
+  
+  // Mock certificate manager to prevent ACME calls
+  (proxy as any).createCertificateManager = async function(routes: any[], certDir: string, acmeOptions: any, initialState?: any) {
+    const mockCertManager = {
+      setUpdateRoutesCallback: function(callback: any) { /* noop */ },
+      setHttpProxy: function() {},
+      setGlobalAcmeDefaults: function() {},
+      setAcmeStateManager: function() {},
+      initialize: async function() {
+        // Simulate ACME route addition
+        const challengeRoute = {
+          name: 'acme-challenge',
+          priority: 1000,
+          match: {
+            ports: acmeOptions?.port || 80,
+            path: '/.well-known/acme-challenge/*'
+          },
+          action: {
+            type: 'static'
+          }
+        };
+        // This would trigger route update in real implementation
+      },
+      provisionAllCertificates: async function() {
+        // Mock implementation to satisfy the call in SmartProxy.start()
+        // Add the ACME challenge port here too in case initialize was skipped
+        const challengePort = acmeOptions?.port || 80;
+        await mockPortManager.addPort(challengePort);
+        console.log(`Added ACME challenge port from provisionAllCertificates: ${challengePort}`);
+      },
+      getAcmeOptions: () => acmeOptions,
+      getState: () => ({ challengeRouteActive: false }),
+      stop: async () => {}
+    };
+    return mockCertManager;
+  };
+  
+  // Mock NFTables
+  (proxy as any).nftablesManager = {
+    ensureNFTablesSetup: async () => {},
+    stop: async () => {}
+  };
+  
+  // Mock admin server
+  (proxy as any).startAdminServer = async function() {
+    (this as any).servers.set(this.settings.port, { 
+      port: this.settings.port,
+      close: async () => {}
+    });
+  };
+  
+  await proxy.start();
+  
+  // Verify that port 80 was added only once
+  expect(port80AddCount).toEqual(1);
+  
+  await proxy.stop();
+});
+
+/**
+ * Test that verifies ACME can use a different port than user routes
+ */
+tap.test('should handle ACME on different port than user routes', async (tools) => {
+  tools.timeout(5000);
+  
+  const portAddHistory: number[] = [];
+  const activePorts = new Set<number>();
+  
+  const settings = {
+    port: 9902,
+    routes: [
+      {
+        name: 'user-route',
+        match: {
+          ports: [80]
+        },
+        action: {
+          type: 'forward' as const,
+          target: { host: 'localhost', port: 3000 }
+        }
+      },
+      {
+        name: 'secure-route',
+        match: {
+          ports: [443]
+        },
+        action: {
+          type: 'forward' as const,
+          target: { host: 'localhost', port: 3001 },
+          tls: {
+            mode: 'terminate' as const,
+            certificate: 'auto' as const
+          }
+        }
+      }
+    ],
+    acme: {
+      email: 'test@test.com',
+      port: 8080  // ACME on different port than user routes
+    }
+  };
+  
+  const proxy = new SmartProxy(settings);
+  
+  // Mock the port manager
+  const mockPortManager = {
+    addPort: async (port: number) => {
+      console.log(`Attempting to add port: ${port}`);
+      if (!activePorts.has(port)) {
+        activePorts.add(port);
+        portAddHistory.push(port);
+        console.log(`Port ${port} added to history`);
+      } else {
+        console.log(`Port ${port} already active, not adding to history`);
+      }
+    },
+    addPorts: async (ports: number[]) => {
+      for (const port of ports) {
+        await mockPortManager.addPort(port);
+      }
+    },
+    updatePorts: async (requiredPorts: Set<number>) => {
+      for (const port of requiredPorts) {
+        await mockPortManager.addPort(port);
+      }
+    },
+    setShuttingDown: () => {},
+    closeAll: async () => { activePorts.clear(); },
+    stop: async () => { await mockPortManager.closeAll(); }
+  };
+  
+  // Inject mocks
+  (proxy as any).portManager = mockPortManager;
+  
+  // Mock certificate manager
+  (proxy as any).createCertificateManager = async function(routes: any[], certDir: string, acmeOptions: any, initialState?: any) {
+    const mockCertManager = {
+      setUpdateRoutesCallback: function(callback: any) { /* noop */ },
+      setHttpProxy: function() {},
+      setGlobalAcmeDefaults: function() {},
+      setAcmeStateManager: function() {},
+      initialize: async function() {
+        // Simulate ACME route addition on different port
+        const challengePort = acmeOptions?.port || 80;
+        const challengeRoute = {
+          name: 'acme-challenge',
+          priority: 1000,
+          match: {
+            ports: challengePort,
+            path: '/.well-known/acme-challenge/*'
+          },
+          action: {
+            type: 'static'
+          }
+        };
+        
+        // Add the ACME port to our port tracking
+        await mockPortManager.addPort(challengePort);
+        
+        // For debugging
+        console.log(`Added ACME challenge port: ${challengePort}`);
+      },
+      provisionAllCertificates: async function() {
+        // Mock implementation to satisfy the call in SmartProxy.start()
+        // Add the ACME challenge port here too in case initialize was skipped
+        const challengePort = acmeOptions?.port || 80;
+        await mockPortManager.addPort(challengePort);
+        console.log(`Added ACME challenge port from provisionAllCertificates: ${challengePort}`);
+      },
+      getAcmeOptions: () => acmeOptions,
+      getState: () => ({ challengeRouteActive: false }),
+      stop: async () => {}
+    };
+    return mockCertManager;
+  };
+  
+  // Mock NFTables
+  (proxy as any).nftablesManager = {
+    ensureNFTablesSetup: async () => {},
+    stop: async () => {}
+  };
+  
+  // Mock admin server
+  (proxy as any).startAdminServer = async function() {
+    (this as any).servers.set(this.settings.port, { 
+      port: this.settings.port,
+      close: async () => {}
+    });
+  };
+  
+  await proxy.start();
+  
+  // Log the port history for debugging
+  console.log('Port add history:', portAddHistory);
+  
+  // Verify that all expected ports were added
+  expect(portAddHistory.includes(80)).toBeTrue();    // User route
+  expect(portAddHistory.includes(443)).toBeTrue();   // TLS route  
+  expect(portAddHistory.includes(8080)).toBeTrue();  // ACME challenge on different port
+  
+  await proxy.stop();
+});
+
+export default tap.start();

test/test.race-conditions.node.ts

@@ -0,0 +1,185 @@
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import { SmartProxy, type IRouteConfig } from '../ts/index.js';
+
+/**
+ * Test that concurrent route updates complete successfully and maintain consistency
+ * This replaces the previous implementation-specific mutex tests with behavior-based tests
+ */
+tap.test('should handle concurrent route updates correctly', async (tools) => {
+  tools.timeout(15000);
+  
+  const initialRoute: IRouteConfig = {
+    name: 'base-route',
+    match: { ports: 8080 },
+    action: {
+      type: 'forward',
+      target: { host: 'localhost', port: 3000 }
+    }
+  };
+  
+  const proxy = new SmartProxy({
+    routes: [initialRoute]
+  });
+  
+  await proxy.start();
+  
+  // Create many concurrent updates to stress test the system
+  const updatePromises: Promise<void>[] = [];
+  const routeNames: string[] = [];
+  
+  // Launch 20 concurrent updates
+  for (let i = 0; i < 20; i++) {
+    const routeName = `concurrent-route-${i}`;
+    routeNames.push(routeName);
+    
+    const updatePromise = proxy.updateRoutes([
+      initialRoute,
+      {
+        name: routeName,
+        match: { ports: 9000 + i },
+        action: {
+          type: 'forward',
+          target: { host: 'localhost', port: 4000 + i }
+        }
+      }
+    ]);
+    
+    updatePromises.push(updatePromise);
+  }
+  
+  // All updates should complete without errors
+  await Promise.all(updatePromises);
+  
+  // Verify the final state is consistent
+  const finalRoutes = proxy.routeManager.getAllRoutes();
+  
+  // Should have base route plus one of the concurrent routes
+  expect(finalRoutes.length).toEqual(2);
+  expect(finalRoutes.some(r => r.name === 'base-route')).toBeTrue();
+  
+  // One of the concurrent routes should have won
+  const concurrentRoute = finalRoutes.find(r => r.name?.startsWith('concurrent-route-'));
+  expect(concurrentRoute).toBeTruthy();
+  expect(routeNames).toContain(concurrentRoute!.name);
+  
+  await proxy.stop();
+});
+
+/**
+ * Test rapid sequential route updates
+ */
+tap.test('should handle rapid sequential route updates', async (tools) => {
+  tools.timeout(10000);
+  
+  const proxy = new SmartProxy({
+    routes: [{
+      name: 'initial',
+      match: { ports: 8081 },
+      action: {
+        type: 'forward',
+        target: { host: 'localhost', port: 3000 }
+      }
+    }]
+  });
+  
+  await proxy.start();
+  
+  // Perform rapid sequential updates
+  for (let i = 0; i < 10; i++) {
+    await proxy.updateRoutes([{
+      name: 'changing-route',
+      match: { ports: 8081 },
+      action: {
+        type: 'forward',
+        target: { host: 'localhost', port: 3000 + i }
+      }
+    }]);
+  }
+  
+  // Verify final state
+  const finalRoutes = proxy.routeManager.getAllRoutes();
+  expect(finalRoutes.length).toEqual(1);
+  expect(finalRoutes[0].name).toEqual('changing-route');
+  expect((finalRoutes[0].action as any).target.port).toEqual(3009);
+  
+  await proxy.stop();
+});
+
+/**
+ * Test that port management remains consistent during concurrent updates
+ */
+tap.test('should maintain port consistency during concurrent updates', async (tools) => {
+  tools.timeout(10000);
+  
+  const proxy = new SmartProxy({
+    routes: [{
+      name: 'port-test',
+      match: { ports: 8082 },
+      action: {
+        type: 'forward',
+        target: { host: 'localhost', port: 3000 }
+      }
+    }]
+  });
+  
+  await proxy.start();
+  
+  // Create updates that add and remove ports
+  const updates: Promise<void>[] = [];
+  
+  // Some updates add new ports
+  for (let i = 0; i < 5; i++) {
+    updates.push(proxy.updateRoutes([
+      {
+        name: 'port-test',
+        match: { ports: 8082 },
+        action: {
+          type: 'forward',
+          target: { host: 'localhost', port: 3000 }
+        }
+      },
+      {
+        name: `new-port-${i}`,
+        match: { ports: 9100 + i },
+        action: {
+          type: 'forward',
+          target: { host: 'localhost', port: 4000 + i }
+        }
+      }
+    ]));
+  }
+  
+  // Some updates remove ports
+  for (let i = 0; i < 5; i++) {
+    updates.push(proxy.updateRoutes([
+      {
+        name: 'port-test',
+        match: { ports: 8082 },
+        action: {
+          type: 'forward',
+          target: { host: 'localhost', port: 3000 }
+        }
+      }
+    ]));
+  }
+  
+  // Wait for all updates
+  await Promise.all(updates);
+  
+  // Give time for port cleanup
+  await new Promise(resolve => setTimeout(resolve, 100));
+  
+  // Verify final state
+  const finalRoutes = proxy.routeManager.getAllRoutes();
+  const listeningPorts = proxy['portManager'].getListeningPorts();
+  
+  // Should only have the base port listening
+  expect(listeningPorts).toContain(8082);
+  
+  // Routes should be consistent
+  expect(finalRoutes.some(r => r.name === 'port-test')).toBeTrue();
+  
+  await proxy.stop();
+});
+
+export default tap.start();

test/test.route-callback-simple.ts

@@ -0,0 +1,116 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import { SmartProxy } from '../ts/index.js';
+
+tap.test('should set update routes callback on certificate manager', async () => {
+  // Create a simple proxy with a route requiring certificates
+  const proxy = new SmartProxy({
+    acme: {
+      email: 'test@local.dev',
+      useProduction: false,
+      port: 8080  // Use non-privileged port for ACME challenges globally
+    },
+    routes: [{
+      name: 'test-route',
+      match: {
+        ports: [8443],
+        domains: ['test.local']
+      },
+      action: {
+        type: 'forward',
+        target: { host: 'localhost', port: 3000 },
+        tls: {
+          mode: 'terminate',
+          certificate: 'auto',
+          acme: {
+            email: 'test@local.dev',
+            useProduction: false
+          }
+        }
+      }
+    }]
+  });
+  
+  // Track callback setting
+  let callbackSet = false;
+  
+  // Override createCertificateManager to track callback setting
+  (proxy as any).createCertificateManager = async function(
+    routes: any,
+    certStore: string,
+    acmeOptions?: any,
+    initialState?: any
+  ) {
+    // Create a mock certificate manager
+    const mockCertManager = {
+      setUpdateRoutesCallback: function(callback: any) {
+        callbackSet = true;
+      },
+      setHttpProxy: function(proxy: any) {},
+      setGlobalAcmeDefaults: function(defaults: any) {},
+      setAcmeStateManager: function(manager: any) {},
+      initialize: async function() {},
+      provisionAllCertificates: async function() {},
+      stop: async function() {},
+      getAcmeOptions: function() { return acmeOptions || {}; },
+      getState: function() { return initialState || { challengeRouteActive: false }; }
+    };
+    
+    // Mimic the real createCertificateManager behavior
+    // Always set up the route update callback for ACME challenges
+    mockCertManager.setUpdateRoutesCallback(async (routes) => {
+      await this.updateRoutes(routes);
+    });
+    
+    // Connect with HttpProxy if available (mimic real behavior)
+    if ((this as any).httpProxyBridge.getHttpProxy()) {
+      mockCertManager.setHttpProxy((this as any).httpProxyBridge.getHttpProxy());
+    }
+    
+    // Set the ACME state manager
+    mockCertManager.setAcmeStateManager((this as any).acmeStateManager);
+    
+    // Pass down the global ACME config if available
+    if ((this as any).settings.acme) {
+      mockCertManager.setGlobalAcmeDefaults((this as any).settings.acme);
+    }
+    
+    await mockCertManager.initialize();
+    return mockCertManager;
+  };
+  
+  await proxy.start();
+  
+  // The callback should have been set during initialization
+  expect(callbackSet).toEqual(true);
+  
+  // Reset tracking
+  callbackSet = false;
+  
+  // Update routes - this should recreate the certificate manager
+  await proxy.updateRoutes([{
+    name: 'new-route',
+    match: {
+      ports: [8444],
+      domains: ['new.local']
+    },
+    action: {
+      type: 'forward',
+      target: { host: 'localhost', port: 3001 },
+      tls: {
+        mode: 'terminate',
+        certificate: 'auto',
+        acme: {
+          email: 'test@local.dev',
+          useProduction: false
+        }
+      }
+    }
+  }]);
+  
+  // The callback should have been set again after update
+  expect(callbackSet).toEqual(true);
+  
+  await proxy.stop();
+});
+
+tap.start();

test/test.route-config.ts

@@ -1,7 +1,7 @@
 /**
  * Tests for the unified route-based configuration system
  */
-import { expect, tap } from '@push.rocks/tapbundle';
+import { expect, tap } from '@git.zone/tstest/tapbundle';
 
 // Import from core modules
 import { SmartProxy } from '../ts/proxies/smart-proxy/index.js';
@@ -35,7 +35,6 @@ import {
   createHttpToHttpsRedirect,
   createCompleteHttpsServer,
   createLoadBalancerRoute,
-  createStaticFileRoute,
   createApiRoute,
   createWebSocketRoute
 } from '../ts/proxies/smart-proxy/utils/route-helpers.js';
@@ -82,16 +81,13 @@ tap.test('Routes: Should create HTTPS route with TLS termination', async () => {
 
 tap.test('Routes: Should create HTTP to HTTPS redirect', async () => {
   // Create an HTTP to HTTPS redirect
-  const redirectRoute = createHttpToHttpsRedirect('example.com', 443, {
-    status: 301
-  });
+  const redirectRoute = createHttpToHttpsRedirect('example.com', 443);
 
   // Validate the route configuration
   expect(redirectRoute.match.ports).toEqual(80);
   expect(redirectRoute.match.domains).toEqual('example.com');
-  expect(redirectRoute.action.type).toEqual('redirect');
-  expect(redirectRoute.action.redirect?.to).toEqual('https://{domain}:443{path}');
-  expect(redirectRoute.action.redirect?.status).toEqual(301);
+  expect(redirectRoute.action.type).toEqual('socket-handler');
+  expect(redirectRoute.action.socketHandler).toBeDefined();
 });
 
 tap.test('Routes: Should create complete HTTPS server with redirects', async () => {
@@ -113,8 +109,8 @@ tap.test('Routes: Should create complete HTTPS server with redirects', async ()
   // Validate HTTP redirect route
   const redirectRoute = routes[1];
   expect(redirectRoute.match.ports).toEqual(80);
-  expect(redirectRoute.action.type).toEqual('redirect');
-  expect(redirectRoute.action.redirect?.to).toEqual('https://{domain}:443{path}');
+  expect(redirectRoute.action.type).toEqual('socket-handler');
+  expect(redirectRoute.action.socketHandler).toBeDefined();
 });
 
 tap.test('Routes: Should create load balancer route', async () => {
@@ -192,24 +188,7 @@ tap.test('Routes: Should create WebSocket route', async () => {
   }
 });
 
-tap.test('Routes: Should create static file route', async () => {
-  // Create a static file route
-  const staticRoute = createStaticFileRoute('static.example.com', '/var/www/html', {
-    serveOnHttps: true,
-    certificate: 'auto',
-    indexFiles: ['index.html', 'index.htm', 'default.html'],
-    name: 'Static File Route'
-  });
-
-  // Validate the route configuration
-  expect(staticRoute.match.domains).toEqual('static.example.com');
-  expect(staticRoute.action.type).toEqual('static');
-  expect(staticRoute.action.static?.root).toEqual('/var/www/html');
-  expect(staticRoute.action.static?.index).toBeInstanceOf(Array);
-  expect(staticRoute.action.static?.index).toInclude('index.html');
-  expect(staticRoute.action.static?.index).toInclude('default.html');
-  expect(staticRoute.action.tls?.mode).toEqual('terminate');
-});
+// Static file serving has been removed - should be handled by external servers
 
 tap.test('SmartProxy: Should create instance with route-based config', async () => {
   // Create TLS certificates for testing
@@ -517,11 +496,6 @@ tap.test('Route Integration - Combining Multiple Route Types', async () => {
       certificate: 'auto'
     }),
     
-    // Static assets
-    createStaticFileRoute('static.example.com', '/var/www/assets', {
-      serveOnHttps: true,
-      certificate: 'auto'
-    }),
     
     // Legacy system with passthrough
     createHttpsPassthroughRoute('legacy.example.com', { host: 'legacy-server', port: 443 })
@@ -542,11 +516,11 @@ tap.test('Route Integration - Combining Multiple Route Types', async () => {
     expect(webServerMatch.action.target.host).toEqual('web-server');
   }
   
-  // Web server (HTTP redirect)
+  // Web server (HTTP redirect via socket handler)
   const webRedirectMatch = findBestMatchingRoute(routes, { domain: 'example.com', port: 80 });
   expect(webRedirectMatch).not.toBeUndefined();
   if (webRedirectMatch) {
-    expect(webRedirectMatch.action.type).toEqual('redirect');
+    expect(webRedirectMatch.action.type).toEqual('socket-handler');
   }
   
   // API server
@@ -574,16 +548,7 @@ tap.test('Route Integration - Combining Multiple Route Types', async () => {
     expect(wsMatch.action.websocket?.enabled).toBeTrue();
   }
   
-  // Static assets
-  const staticMatch = findBestMatchingRoute(routes, { 
-    domain: 'static.example.com', 
-    port: 443
-  });
-  expect(staticMatch).not.toBeUndefined();
-  if (staticMatch) {
-    expect(staticMatch.action.type).toEqual('static');
-    expect(staticMatch.action.static.root).toEqual('/var/www/assets');
-  }
+  // Static assets route was removed - static file serving should be handled externally
   
   // Legacy system
   const legacyMatch = findBestMatchingRoute(routes, { 

test/test.route-security-integration.ts

@@ -0,0 +1,279 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import * as smartproxy from '../ts/index.js';
+import type { IRouteConfig } from '../ts/proxies/smart-proxy/models/route-types.js';
+import * as net from 'net';
+
+tap.test('route security should block connections from unauthorized IPs', async () => {
+  // Create a target server that should never receive connections
+  let targetServerConnections = 0;
+  const targetServer = net.createServer((socket) => {
+    targetServerConnections++;
+    console.log('Target server received connection - this should not happen!');
+    socket.write('ERROR: This connection should have been blocked');
+    socket.end();
+  });
+  
+  await new Promise<void>((resolve) => {
+    targetServer.listen(9990, '127.0.0.1', () => {
+      console.log('Target server listening on port 9990');
+      resolve();
+    });
+  });
+  
+  // Create proxy with restrictive security at route level
+  const routes: IRouteConfig[] = [{
+    name: 'secure-route',
+    match: {
+      ports: 9991
+    },
+    action: {
+      type: 'forward',
+      target: {
+        host: '127.0.0.1',
+        port: 9990
+      }
+    },
+    security: {
+      // Only allow a non-existent IP
+      ipAllowList: ['192.168.99.99']
+    }
+  }];
+  
+  const proxy = new smartproxy.SmartProxy({
+    enableDetailedLogging: true,
+    routes: routes
+  });
+  
+  
+  await proxy.start();
+  console.log('Proxy started on port 9991');
+  
+  // Wait a moment to ensure server is fully ready
+  await new Promise(resolve => setTimeout(resolve, 100));
+  
+  // Try to connect from localhost (should be blocked)
+  const client = new net.Socket();
+  const events: string[] = [];
+  
+  const result = await new Promise<string>((resolve) => {
+    let resolved = false;
+    
+    client.on('connect', () => {
+      console.log('Client connected (TCP handshake succeeded)');
+      events.push('connected');
+      // Send initial data to trigger routing
+      client.write('test');
+    });
+    
+    client.on('data', (data) => {
+      console.log('Client received data:', data.toString());
+      events.push('data');
+      if (!resolved) {
+        resolved = true;
+        resolve('data');
+      }
+    });
+    
+    client.on('error', (err: any) => {
+      console.log('Client error:', err.code);
+      events.push('error');
+      if (!resolved) {
+        resolved = true;
+        resolve('error');
+      }
+    });
+    
+    client.on('close', () => {
+      console.log('Client connection closed by server');
+      events.push('closed');
+      if (!resolved) {
+        resolved = true;
+        resolve('closed');
+      }
+    });
+    
+    setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        resolve('timeout');
+      }
+    }, 2000);
+    
+    console.log('Attempting connection from 127.0.0.1...');
+    client.connect(9991, '127.0.0.1');
+  });
+  
+  console.log('Connection result:', result);
+  console.log('Events:', events);
+  
+  // The connection might be closed before or after TCP handshake
+  // What matters is that the target server never receives a connection
+  console.log('Test passed: Connection was properly blocked by security');
+  
+  // Target server should not have received any connections
+  expect(targetServerConnections).toEqual(0);
+  
+  // Clean up
+  client.destroy();
+  await proxy.stop();
+  await new Promise<void>((resolve) => {
+    targetServer.close(() => resolve());
+  });
+});
+
+tap.test('route security with block list should work', async () => {
+  // Create a target server
+  let targetServerConnections = 0;
+  const targetServer = net.createServer((socket) => {
+    targetServerConnections++;
+    socket.write('Hello from target');
+    socket.end();
+  });
+  
+  await new Promise<void>((resolve) => {
+    targetServer.listen(9992, '127.0.0.1', () => resolve());
+  });
+  
+  // Create proxy with security at route level (not action level)
+  const routes: IRouteConfig[] = [{
+    name: 'secure-route-level',
+    match: {
+      ports: 9993
+    },
+    action: {
+      type: 'forward',
+      target: {
+        host: '127.0.0.1',
+        port: 9992
+      }
+    },
+    security: {  // Security at route level, not action level
+      ipBlockList: ['127.0.0.1', '::1', '::ffff:127.0.0.1']
+    }
+  }];
+  
+  const proxy = new smartproxy.SmartProxy({
+    enableDetailedLogging: true,
+    routes: routes
+  });
+  
+  await proxy.start();
+  
+  // Try to connect (should be blocked)
+  const client = new net.Socket();
+  const events: string[] = [];
+  
+  const result = await new Promise<string>((resolve) => {
+    let resolved = false;
+    const timeout = setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        resolve('timeout');
+      }
+    }, 2000);
+    
+    client.on('connect', () => {
+      console.log('Client connected to block list test');
+      events.push('connected');
+      // Send initial data to trigger routing
+      client.write('test');
+    });
+    
+    client.on('error', () => {
+      events.push('error');
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timeout);
+        resolve('error');
+      }
+    });
+    
+    client.on('close', () => {
+      events.push('closed');
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timeout);
+        resolve('closed');
+      }
+    });
+    
+    client.connect(9993, '127.0.0.1');
+  });
+  
+  // Should connect then be immediately closed by security
+  expect(events).toContain('connected');
+  expect(events).toContain('closed');
+  expect(result).toEqual('closed');
+  expect(targetServerConnections).toEqual(0);
+  
+  // Clean up
+  client.destroy();
+  await proxy.stop();
+  await new Promise<void>((resolve) => {
+    targetServer.close(() => resolve());
+  });
+});
+
+tap.test('route without security should allow all connections', async () => {
+  // Create echo server
+  const echoServer = net.createServer((socket) => {
+    socket.on('data', (data) => {
+      socket.write(data);
+    });
+  });
+  
+  await new Promise<void>((resolve) => {
+    echoServer.listen(9994, '127.0.0.1', () => resolve());
+  });
+  
+  // Create proxy without security
+  const routes: IRouteConfig[] = [{
+    name: 'open-route',
+    match: {
+      ports: 9995
+    },
+    action: {
+      type: 'forward',
+      target: {
+        host: '127.0.0.1',
+        port: 9994
+      }
+    }
+    // No security defined
+  }];
+  
+  const proxy = new smartproxy.SmartProxy({
+    enableDetailedLogging: false,
+    routes: routes
+  });
+  
+  await proxy.start();
+  
+  // Connect and test echo
+  const client = new net.Socket();
+  await new Promise<void>((resolve) => {
+    client.connect(9995, '127.0.0.1', () => resolve());
+  });
+  
+  // Send data and verify echo
+  const testData = 'Hello World';
+  client.write(testData);
+  
+  const response = await new Promise<string>((resolve) => {
+    client.once('data', (data) => {
+      resolve(data.toString());
+    });
+    setTimeout(() => resolve(''), 2000);
+  });
+  
+  expect(response).toEqual(testData);
+  
+  // Clean up
+  client.destroy();
+  await proxy.stop();
+  await new Promise<void>((resolve) => {
+    echoServer.close(() => resolve());
+  });
+});
+
+export default tap.start();

test/test.route-security-unit.ts

@@ -0,0 +1,61 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import * as smartproxy from '../ts/index.js';
+
+tap.test('route security should be correctly configured', async () => {
+  // Test that we can create a proxy with route-specific security
+  const routes = [{
+    name: 'secure-route',
+    match: {
+      ports: 8990
+    },
+    action: {
+      type: 'forward' as const,
+      target: {
+        host: '127.0.0.1',
+        port: 8991
+      },
+      security: {
+        ipAllowList: ['192.168.1.1'],
+        ipBlockList: ['10.0.0.1']
+      }
+    }
+  }];
+  
+  // This should not throw an error
+  const proxy = new smartproxy.SmartProxy({
+    enableDetailedLogging: false,
+    routes: routes
+  });
+  
+  // The proxy should be created successfully
+  expect(proxy).toBeInstanceOf(smartproxy.SmartProxy);
+  
+  // Test that security manager exists and has the isIPAuthorized method
+  const securityManager = (proxy as any).securityManager;
+  expect(securityManager).toBeDefined();
+  expect(typeof securityManager.isIPAuthorized).toEqual('function');
+  
+  // Test IP authorization logic directly
+  const isLocalhostAllowed = securityManager.isIPAuthorized(
+    '127.0.0.1',
+    ['192.168.1.1'],  // Allow list
+    []  // Block list
+  );
+  expect(isLocalhostAllowed).toBeFalse();
+  
+  const isAllowedIPAllowed = securityManager.isIPAuthorized(
+    '192.168.1.1',
+    ['192.168.1.1'],  // Allow list
+    []  // Block list
+  );
+  expect(isAllowedIPAllowed).toBeTrue();
+  
+  const isBlockedIPAllowed = securityManager.isIPAuthorized(
+    '10.0.0.1',
+    ['0.0.0.0/0'],  // Allow all
+    ['10.0.0.1']    // But block this specific IP
+  );
+  expect(isBlockedIPAllowed).toBeFalse();
+});
+
+tap.start();

test/test.route-security.ts

@@ -0,0 +1,275 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import * as smartproxy from '../ts/index.js';
+import type { IRouteConfig } from '../ts/proxies/smart-proxy/models/route-types.js';
+import * as net from 'net';
+
+tap.test('route-specific security should be enforced', async () => {
+  // Create a simple echo server for testing
+  const echoServer = net.createServer((socket) => {
+    socket.on('data', (data) => {
+      socket.write(data);
+    });
+  });
+  
+  await new Promise<void>((resolve) => {
+    echoServer.listen(8877, '127.0.0.1', () => {
+      console.log('Echo server listening on port 8877');
+      resolve();
+    });
+  });
+  
+  // Create proxy with route-specific security
+  const routes: IRouteConfig[] = [{
+    name: 'secure-route',
+    match: {
+      ports: 8878
+    },
+    action: {
+      type: 'forward',
+      target: {
+        host: '127.0.0.1',
+        port: 8877
+      }
+    },
+    security: {
+      ipAllowList: ['127.0.0.1', '::1', '::ffff:127.0.0.1']
+    }
+  }];
+  
+  const proxy = new smartproxy.SmartProxy({
+    enableDetailedLogging: true,
+    routes: routes
+  });
+  
+  await proxy.start();
+  
+  // Test 1: Connection from allowed IP should work
+  const client1 = new net.Socket();
+  const connected = await new Promise<boolean>((resolve) => {
+    client1.connect(8878, '127.0.0.1', () => {
+      console.log('Client connected from allowed IP');
+      resolve(true);
+    });
+    
+    client1.on('error', (err) => {
+      console.log('Connection error:', err.message);
+      resolve(false);
+    });
+    
+    // Set timeout to prevent hanging
+    setTimeout(() => resolve(false), 2000);
+  });
+  
+  if (connected) {
+    // Test echo
+    const testData = 'Hello from allowed IP';
+    client1.write(testData);
+    
+    const response = await new Promise<string>((resolve) => {
+      client1.once('data', (data) => {
+        resolve(data.toString());
+      });
+      setTimeout(() => resolve(''), 2000);
+    });
+    
+    expect(response).toEqual(testData);
+    client1.destroy();
+  } else {
+    expect(connected).toBeTrue();
+  }
+  
+  // Clean up
+  await proxy.stop();
+  await new Promise<void>((resolve) => {
+    echoServer.close(() => resolve());
+  });
+});
+
+tap.test('route-specific IP block list should be enforced', async () => {
+  // Create a simple echo server for testing
+  const echoServer = net.createServer((socket) => {
+    socket.on('data', (data) => {
+      socket.write(data);
+    });
+  });
+  
+  await new Promise<void>((resolve) => {
+    echoServer.listen(8879, '127.0.0.1', () => {
+      console.log('Echo server listening on port 8879');
+      resolve();
+    });
+  });
+  
+  // Create proxy with route-specific block list
+  const routes: IRouteConfig[] = [{
+    name: 'blocked-route',
+    match: {
+      ports: 8880
+    },
+    action: {
+      type: 'forward',
+      target: {
+        host: '127.0.0.1',
+        port: 8879
+      }
+    },
+    security: {
+      ipAllowList: ['0.0.0.0/0', '::/0'],  // Allow all IPs
+      ipBlockList: ['127.0.0.1', '::1', '::ffff:127.0.0.1']  // But block localhost
+    }
+  }];
+  
+  const proxy = new smartproxy.SmartProxy({
+    enableDetailedLogging: true,
+    routes: routes
+  });
+  
+  await proxy.start();
+  
+  // Test: Connection from blocked IP should fail or be immediately closed
+  const client = new net.Socket();
+  let connectionSuccessful = false;
+  
+  const result = await new Promise<{ connected: boolean; dataReceived: boolean }>((resolve) => {
+    let resolved = false;
+    let dataReceived = false;
+    
+    const doResolve = (connected: boolean) => {
+      if (!resolved) {
+        resolved = true;
+        resolve({ connected, dataReceived });
+      }
+    };
+    
+    client.connect(8880, '127.0.0.1', () => {
+      console.log('Client connect event fired');
+      connectionSuccessful = true;
+      // Try to send data to test if the connection is really established
+      try {
+        client.write('test data');
+      } catch (e) {
+        console.log('Write failed:', e.message);
+      }
+    });
+    
+    client.on('data', () => {
+      dataReceived = true;
+    });
+    
+    client.on('error', (err) => {
+      console.log('Connection error:', err.message);
+      doResolve(false);
+    });
+    
+    client.on('close', () => {
+      console.log('Connection closed, connectionSuccessful:', connectionSuccessful, 'dataReceived:', dataReceived);
+      doResolve(connectionSuccessful);
+    });
+    
+    // Set timeout
+    setTimeout(() => doResolve(connectionSuccessful), 1000);
+  });
+  
+  // The connection should either fail to connect OR connect but immediately close without data exchange
+  if (result.connected) {
+    // If connected, it should have been immediately closed without data exchange
+    expect(result.dataReceived).toBeFalse();
+    console.log('Connection was established but immediately closed (acceptable behavior)');
+  } else {
+    // Connection failed entirely (also acceptable)
+    expect(result.connected).toBeFalse();
+    console.log('Connection was blocked entirely (preferred behavior)');
+  }
+  
+  if (client.readyState !== 'closed') {
+    client.destroy();
+  }
+  
+  // Clean up
+  await proxy.stop();
+  await new Promise<void>((resolve) => {
+    echoServer.close(() => resolve());
+  });
+});
+
+tap.test('routes without security should allow all connections', async () => {
+  // Create a simple echo server for testing
+  const echoServer = net.createServer((socket) => {
+    socket.on('data', (data) => {
+      socket.write(data);
+    });
+  });
+  
+  await new Promise<void>((resolve) => {
+    echoServer.listen(8881, '127.0.0.1', () => {
+      console.log('Echo server listening on port 8881');
+      resolve();
+    });
+  });
+  
+  // Create proxy without route-specific security
+  const routes: IRouteConfig[] = [{
+    name: 'open-route',
+    match: {
+      ports: 8882
+    },
+    action: {
+      type: 'forward',
+      target: {
+        host: '127.0.0.1',
+        port: 8881
+      }
+      // No security section - should allow all
+    }
+  }];
+  
+  const proxy = new smartproxy.SmartProxy({
+    enableDetailedLogging: true,
+    routes: routes
+  });
+  
+  await proxy.start();
+  
+  // Test: Connection should work without security restrictions
+  const client = new net.Socket();
+  const connected = await new Promise<boolean>((resolve) => {
+    client.connect(8882, '127.0.0.1', () => {
+      console.log('Client connected to open route');
+      resolve(true);
+    });
+    
+    client.on('error', (err) => {
+      console.log('Connection error:', err.message);
+      resolve(false);
+    });
+    
+    // Set timeout
+    setTimeout(() => resolve(false), 2000);
+  });
+  
+  expect(connected).toBeTrue();
+  
+  if (connected) {
+    // Test echo
+    const testData = 'Hello from open route';
+    client.write(testData);
+    
+    const response = await new Promise<string>((resolve) => {
+      client.once('data', (data) => {
+        resolve(data.toString());
+      });
+      setTimeout(() => resolve(''), 2000);
+    });
+    
+    expect(response).toEqual(testData);
+    client.destroy();
+  }
+  
+  // Clean up
+  await proxy.stop();
+  await new Promise<void>((resolve) => {
+    echoServer.close(() => resolve());
+  });
+});
+
+export default tap.start();

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

@@ -0,0 +1,339 @@
+import * as plugins from '../ts/plugins.js';
+import { SmartProxy } from '../ts/index.js';
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+
+let testProxy: SmartProxy;
+
+// Create test routes using high ports to avoid permission issues
+const createRoute = (id: number, domain: string, port: number = 8443) => ({
+  name: `test-route-${id}`,
+  match: {
+    ports: [port],
+    domains: [domain]
+  },
+  action: {
+    type: 'forward' as const,
+    target: {
+      host: 'localhost',
+      port: 3000 + id
+    },
+    tls: {
+      mode: 'terminate' as const,
+      certificate: 'auto' as const,
+      acme: {
+        email: 'test@testdomain.test',
+        useProduction: false
+      }
+    }
+  }
+});
+
+tap.test('should create SmartProxy instance', async () => {
+  testProxy = new SmartProxy({
+    routes: [createRoute(1, 'test1.testdomain.test', 8443)],
+    acme: {
+      email: 'test@testdomain.test',
+      useProduction: false,
+      port: 8080
+    }
+  });
+  expect(testProxy).toBeInstanceOf(SmartProxy);
+});
+
+tap.test('should preserve route update callback after updateRoutes', async () => {
+  // Mock the certificate manager to avoid actual ACME initialization
+  const originalInitializeCertManager = (testProxy as any).initializeCertificateManager;
+  let certManagerInitialized = false;
+  
+  (testProxy as any).initializeCertificateManager = async function() {
+    certManagerInitialized = true;
+    // Create a minimal mock certificate manager
+    const mockCertManager = {
+      setUpdateRoutesCallback: function(callback: any) {
+        this.updateRoutesCallback = callback;
+      },
+      updateRoutesCallback: null,
+      setHttpProxy: function() {},
+      setGlobalAcmeDefaults: function() {},
+      setAcmeStateManager: function() {},
+      initialize: async function() {
+        // This is where the callback is actually set in the real implementation
+        return Promise.resolve();
+      },
+      provisionAllCertificates: async function() {
+        return Promise.resolve();
+      },
+      stop: async function() {},
+      getAcmeOptions: function() {
+        return { email: 'test@testdomain.test' };
+      },
+      getState: function() {
+        return { challengeRouteActive: false };
+      }
+    };
+    
+    (this as any).certManager = mockCertManager;
+    
+    // Simulate the real behavior where setUpdateRoutesCallback is called
+    mockCertManager.setUpdateRoutesCallback(async (routes: any) => {
+      await this.updateRoutes(routes);
+    });
+  };
+  
+  // Start the proxy (with mocked cert manager)
+  await testProxy.start();
+  expect(certManagerInitialized).toEqual(true);
+  
+  // Get initial certificate manager reference
+  const initialCertManager = (testProxy as any).certManager;
+  expect(initialCertManager).toBeTruthy();
+  expect(initialCertManager.updateRoutesCallback).toBeTruthy();
+  
+  // Store the initial callback reference
+  const initialCallback = initialCertManager.updateRoutesCallback;
+  
+  // Update routes - this should recreate the cert manager with callback
+  const newRoutes = [
+    createRoute(1, 'test1.testdomain.test', 8443),
+    createRoute(2, 'test2.testdomain.test', 8444)
+  ];
+  
+  // Mock the updateRoutes to simulate the real implementation
+  testProxy.updateRoutes = async function(routes) {
+    // Update settings
+    this.settings.routes = routes;
+    
+    // Simulate what happens in the real code - recreate cert manager via createCertificateManager
+    if ((this as any).certManager) {
+      await (this as any).certManager.stop();
+      
+      // Simulate createCertificateManager which creates a new cert manager
+      const newMockCertManager = {
+        setUpdateRoutesCallback: function(callback: any) {
+          this.updateRoutesCallback = callback;
+        },
+        updateRoutesCallback: null,
+        setHttpProxy: function() {},
+        setGlobalAcmeDefaults: function() {},
+        setAcmeStateManager: function() {},
+        initialize: async function() {},
+        provisionAllCertificates: async function() {},
+        stop: async function() {},
+        getAcmeOptions: function() {
+          return { email: 'test@testdomain.test' };
+        },
+        getState: function() {
+          return { challengeRouteActive: false };
+        }
+      };
+      
+      // Set the callback as done in createCertificateManager
+      newMockCertManager.setUpdateRoutesCallback(async (routes: any) => {
+        await this.updateRoutes(routes);
+      });
+      
+      (this as any).certManager = newMockCertManager;
+      await (this as any).certManager.initialize();
+    }
+  };
+  
+  await testProxy.updateRoutes(newRoutes);
+  
+  // Get new certificate manager reference
+  const newCertManager = (testProxy as any).certManager;
+  expect(newCertManager).toBeTruthy();
+  expect(newCertManager).not.toEqual(initialCertManager); // Should be a new instance
+  expect(newCertManager.updateRoutesCallback).toBeTruthy(); // Callback should be set
+  
+  // Test that the callback works
+  const testChallengeRoute = {
+    name: 'acme-challenge',
+    match: {
+      ports: [8080],
+      path: '/.well-known/acme-challenge/*'
+    },
+    action: {
+      type: 'static' as const,
+      content: 'challenge-token'
+    }
+  };
+  
+  // This should not throw "No route update callback set" error
+  let callbackWorked = false;
+  try {
+    // If callback is set, this should work
+    if (newCertManager.updateRoutesCallback) {
+      await newCertManager.updateRoutesCallback([...newRoutes, testChallengeRoute]);
+      callbackWorked = true;
+    }
+  } catch (error) {
+    throw new Error(`Route update callback failed: ${error.message}`);
+  }
+  
+  expect(callbackWorked).toEqual(true);
+  console.log('Route update callback successfully preserved and invoked');
+});
+
+tap.test('should handle multiple sequential route updates', async () => {
+  // Continue with the mocked proxy from previous test
+  let updateCount = 0;
+  
+  // Perform multiple route updates
+  for (let i = 1; i <= 3; i++) {
+    const routes = [];
+    for (let j = 1; j <= i; j++) {
+      routes.push(createRoute(j, `test${j}.testdomain.test`, 8440 + j));
+    }
+    
+    await testProxy.updateRoutes(routes);
+    updateCount++;
+    
+    // Verify cert manager is properly set up each time
+    const certManager = (testProxy as any).certManager;
+    expect(certManager).toBeTruthy();
+    expect(certManager.updateRoutesCallback).toBeTruthy();
+    
+    console.log(`Route update ${i} callback is properly set`);
+  }
+  
+  expect(updateCount).toEqual(3);
+});
+
+tap.test('should handle route updates when cert manager is not initialized', async () => {
+  // Create proxy without routes that need certificates
+  const proxyWithoutCerts = new SmartProxy({
+    routes: [{
+      name: 'no-cert-route',
+      match: {
+        ports: [9080]
+      },
+      action: {
+        type: 'forward' as const,
+        target: {
+          host: 'localhost',
+          port: 3000
+        }
+      }
+    }]
+  });
+  
+  // Mock initializeCertificateManager to avoid ACME issues
+  (proxyWithoutCerts as any).initializeCertificateManager = async function() {
+    // Only create cert manager if routes need it
+    const autoRoutes = this.settings.routes.filter((r: any) => 
+      r.action.tls?.certificate === 'auto'
+    );
+    
+    if (autoRoutes.length === 0) {
+      console.log('No routes require certificate management');
+      return;
+    }
+    
+    // Create mock cert manager
+    const mockCertManager = {
+      setUpdateRoutesCallback: function(callback: any) {
+        this.updateRoutesCallback = callback;
+      },
+      updateRoutesCallback: null,
+      setHttpProxy: function() {},
+      initialize: async function() {},
+      provisionAllCertificates: async function() {},
+      stop: async function() {},
+      getAcmeOptions: function() {
+        return { email: 'test@testdomain.test' };
+      },
+      getState: function() {
+        return { challengeRouteActive: false };
+      }
+    };
+    
+    (this as any).certManager = mockCertManager;
+    
+    // Set the callback
+    mockCertManager.setUpdateRoutesCallback(async (routes: any) => {
+      await this.updateRoutes(routes);
+    });
+  };
+  
+  await proxyWithoutCerts.start();
+  
+  // This should not have a cert manager
+  const certManager = (proxyWithoutCerts as any).certManager;
+  expect(certManager).toBeFalsy();
+  
+  // Update with routes that need certificates
+  await proxyWithoutCerts.updateRoutes([createRoute(1, 'cert-needed.testdomain.test', 9443)]);
+  
+  // In the real implementation, cert manager is not created by updateRoutes if it doesn't exist
+  // This is the expected behavior - cert manager is only created during start() or re-created if already exists
+  const newCertManager = (proxyWithoutCerts as any).certManager;
+  expect(newCertManager).toBeFalsy(); // Should still be null
+  
+  await proxyWithoutCerts.stop();
+});
+
+tap.test('should clean up properly', async () => {
+  await testProxy.stop();
+});
+
+tap.test('real code integration test - verify fix is applied', async () => {
+  // This test will start with routes that need certificates to test the fix
+  const realProxy = new SmartProxy({
+    routes: [createRoute(1, 'test.example.com', 9999)],
+    acme: {
+      email: 'test@example.com',
+      useProduction: false,
+      port: 18080
+    }
+  });
+  
+  // Mock the certificate manager creation to track callback setting
+  let callbackSet = false;
+  (realProxy as any).createCertificateManager = async function(routes: any[], certDir: string, acmeOptions: any, initialState?: any) {
+    const mockCertManager = {
+      setUpdateRoutesCallback: function(callback: any) {
+        callbackSet = true;
+        this.updateRoutesCallback = callback;
+      },
+      updateRoutesCallback: null as any,
+      setHttpProxy: function() {},
+      setGlobalAcmeDefaults: function() {},
+      setAcmeStateManager: function() {},
+      initialize: async function() {},
+      provisionAllCertificates: async function() {},
+      stop: async function() {},
+      getAcmeOptions: function() {
+        return acmeOptions || { email: 'test@example.com', useProduction: false };
+      },
+      getState: function() {
+        return initialState || { challengeRouteActive: false };
+      }
+    };
+    
+    // Always set up the route update callback for ACME challenges
+    mockCertManager.setUpdateRoutesCallback(async (routes) => {
+      await this.updateRoutes(routes);
+    });
+    
+    return mockCertManager;
+  };
+  
+  await realProxy.start();
+  
+  // The callback should have been set during initialization
+  expect(callbackSet).toEqual(true);
+  callbackSet = false; // Reset for update test
+  
+  // Update routes - this should recreate cert manager with callback preserved
+  const newRoute = createRoute(2, 'test2.example.com', 9999);
+  await realProxy.updateRoutes([createRoute(1, 'test.example.com', 9999), newRoute]);
+  
+  // The callback should have been set again during update
+  expect(callbackSet).toEqual(true);
+  
+  await realProxy.stop();
+  
+  console.log('Real code integration test passed - fix is correctly applied!');
+});
+
+tap.start();

test/test.route-utils.ts

@@ -1,4 +1,4 @@
-import { tap, expect } from '@push.rocks/tapbundle';
+import { tap, expect } from '@git.zone/tstest/tapbundle';
 import * as plugins from '../ts/plugins.js';
 
 // Import from individual modules to avoid naming conflicts
@@ -6,7 +6,6 @@ import {
   // Route helpers
   createHttpRoute,
   createHttpsTerminateRoute,
-  createStaticFileRoute,
   createApiRoute,
   createWebSocketRoute,
   createHttpToHttpsRedirect,
@@ -43,7 +42,6 @@ import {
 import {
   // Route patterns
   createApiGatewayRoute,
-  createStaticFileServerRoute,
   createWebSocketRoute as createWebSocketPattern,
   createLoadBalancerRoute as createLbPattern,
   addRateLimiting,
@@ -145,28 +143,16 @@ tap.test('Route Validation - validateRouteAction', async () => {
   expect(validForwardResult.valid).toBeTrue();
   expect(validForwardResult.errors.length).toEqual(0);
   
-  // Valid redirect action
-  const validRedirectAction: IRouteAction = {
-    type: 'redirect',
-    redirect: {
-      to: 'https://example.com',
-      status: 301
+  // Valid socket-handler action
+  const validSocketAction: IRouteAction = {
+    type: 'socket-handler',
+    socketHandler: (socket, context) => {
+      socket.end();
     }
   };
-  const validRedirectResult = validateRouteAction(validRedirectAction);
-  expect(validRedirectResult.valid).toBeTrue();
-  expect(validRedirectResult.errors.length).toEqual(0);
-  
-  // Valid static action
-  const validStaticAction: IRouteAction = {
-    type: 'static',
-    static: {
-      root: '/var/www/html'
-    }
-  };
-  const validStaticResult = validateRouteAction(validStaticAction);
-  expect(validStaticResult.valid).toBeTrue();
-  expect(validStaticResult.errors.length).toEqual(0);
+  const validSocketResult = validateRouteAction(validSocketAction);
+  expect(validSocketResult.valid).toBeTrue();
+  expect(validSocketResult.errors.length).toEqual(0);
   
   // Invalid action (missing target)
   const invalidAction: IRouteAction = {
@@ -177,24 +163,14 @@ tap.test('Route Validation - validateRouteAction', async () => {
   expect(invalidResult.errors.length).toBeGreaterThan(0);
   expect(invalidResult.errors[0]).toInclude('Target is required');
   
-  // Invalid action (missing redirect configuration)
-  const invalidRedirectAction: IRouteAction = {
-    type: 'redirect'
+  // Invalid action (missing socket handler)
+  const invalidSocketAction: IRouteAction = {
+    type: 'socket-handler'
   };
-  const invalidRedirectResult = validateRouteAction(invalidRedirectAction);
-  expect(invalidRedirectResult.valid).toBeFalse();
-  expect(invalidRedirectResult.errors.length).toBeGreaterThan(0);
-  expect(invalidRedirectResult.errors[0]).toInclude('Redirect configuration is required');
-  
-  // Invalid action (missing static root)
-  const invalidStaticAction: IRouteAction = {
-    type: 'static',
-    static: {}
-  };
-  const invalidStaticResult = validateRouteAction(invalidStaticAction);
-  expect(invalidStaticResult.valid).toBeFalse();
-  expect(invalidStaticResult.errors.length).toBeGreaterThan(0);
-  expect(invalidStaticResult.errors[0]).toInclude('Static file root directory is required');
+  const invalidSocketResult = validateRouteAction(invalidSocketAction);
+  expect(invalidSocketResult.valid).toBeFalse();
+  expect(invalidSocketResult.errors.length).toBeGreaterThan(0);
+  expect(invalidSocketResult.errors[0]).toInclude('Socket handler function is required');
 });
 
 tap.test('Route Validation - validateRouteConfig', async () => {
@@ -253,26 +229,25 @@ tap.test('Route Validation - hasRequiredPropertiesForAction', async () => {
   const forwardRoute = createHttpRoute('example.com', { host: 'localhost', port: 3000 });
   expect(hasRequiredPropertiesForAction(forwardRoute, 'forward')).toBeTrue();
   
-  // Redirect action
+  // Socket handler action (redirect functionality)
   const redirectRoute = createHttpToHttpsRedirect('example.com');
-  expect(hasRequiredPropertiesForAction(redirectRoute, 'redirect')).toBeTrue();
+  expect(hasRequiredPropertiesForAction(redirectRoute, 'socket-handler')).toBeTrue();
   
-  // Static action
-  const staticRoute = createStaticFileRoute('example.com', '/var/www/html');
-  expect(hasRequiredPropertiesForAction(staticRoute, 'static')).toBeTrue();
-  
-  // Block action
-  const blockRoute: IRouteConfig = {
+  // Socket handler action
+  const socketRoute: IRouteConfig = {
     match: {
-      domains: 'blocked.example.com',
+      domains: 'socket.example.com',
       ports: 80
     },
     action: {
-      type: 'block'
+      type: 'socket-handler',
+      socketHandler: (socket, context) => {
+        socket.end();
+      }
     },
-    name: 'Block Route'
+    name: 'Socket Handler Route'
   };
-  expect(hasRequiredPropertiesForAction(blockRoute, 'block')).toBeTrue();
+  expect(hasRequiredPropertiesForAction(socketRoute, 'socket-handler')).toBeTrue();
   
   // Missing required properties
   const invalidForwardRoute: IRouteConfig = {
@@ -345,20 +320,22 @@ tap.test('Route Utilities - mergeRouteConfigs', async () => {
   expect(actionMergedRoute.action.target.host).toEqual('new-host.local');
   expect(actionMergedRoute.action.target.port).toEqual(5000);
   
-  // Test replacing action with different type
+  // Test replacing action with socket handler
   const typeChangeOverride: Partial<IRouteConfig> = {
     action: {
-      type: 'redirect',
-      redirect: {
-        to: 'https://example.com',
-        status: 301
+      type: 'socket-handler',
+      socketHandler: (socket, context) => {
+        socket.write('HTTP/1.1 301 Moved Permanently\r\n');
+        socket.write('Location: https://example.com\r\n');
+        socket.write('\r\n');
+        socket.end();
       }
     }
   };
   
   const typeChangedRoute = mergeRouteConfigs(baseRoute, typeChangeOverride);
-  expect(typeChangedRoute.action.type).toEqual('redirect');
-  expect(typeChangedRoute.action.redirect.to).toEqual('https://example.com');
+  expect(typeChangedRoute.action.type).toEqual('socket-handler');
+  expect(typeChangedRoute.action.socketHandler).toBeDefined();
   expect(typeChangedRoute.action.target).toBeUndefined();
 });
 
@@ -705,9 +682,8 @@ tap.test('Route Helpers - createHttpToHttpsRedirect', async () => {
   
   expect(route.match.domains).toEqual('example.com');
   expect(route.match.ports).toEqual(80);
-  expect(route.action.type).toEqual('redirect');
-  expect(route.action.redirect.to).toEqual('https://{domain}:443{path}');
-  expect(route.action.redirect.status).toEqual(301);
+  expect(route.action.type).toEqual('socket-handler');
+  expect(route.action.socketHandler).toBeDefined();
   
   const validationResult = validateRouteConfig(route);
   expect(validationResult.valid).toBeTrue();
@@ -741,7 +717,7 @@ tap.test('Route Helpers - createCompleteHttpsServer', async () => {
   // HTTP redirect route
   expect(routes[1].match.domains).toEqual('example.com');
   expect(routes[1].match.ports).toEqual(80);
-  expect(routes[1].action.type).toEqual('redirect');
+  expect(routes[1].action.type).toEqual('socket-handler');
   
   const validation1 = validateRouteConfig(routes[0]);
   const validation2 = validateRouteConfig(routes[1]);
@@ -749,24 +725,8 @@ tap.test('Route Helpers - createCompleteHttpsServer', async () => {
   expect(validation2.valid).toBeTrue();
 });
 
-tap.test('Route Helpers - createStaticFileRoute', async () => {
-  const route = createStaticFileRoute('example.com', '/var/www/html', {
-    serveOnHttps: true,
-    certificate: 'auto',
-    indexFiles: ['index.html', 'index.htm', 'default.html']
-  });
-  
-  expect(route.match.domains).toEqual('example.com');
-  expect(route.match.ports).toEqual(443);
-  expect(route.action.type).toEqual('static');
-  expect(route.action.static.root).toEqual('/var/www/html');
-  expect(route.action.static.index).toInclude('index.html');
-  expect(route.action.static.index).toInclude('default.html');
-  expect(route.action.tls.mode).toEqual('terminate');
-  
-  const validationResult = validateRouteConfig(route);
-  expect(validationResult.valid).toBeTrue();
-});
+// createStaticFileRoute has been removed - static file serving should be handled by
+// external servers (nginx/apache) behind the proxy
 
 tap.test('Route Helpers - createApiRoute', async () => {
   const route = createApiRoute('api.example.com', '/v1', { host: 'localhost', port: 3000 }, {
@@ -874,34 +834,8 @@ tap.test('Route Patterns - createApiGatewayRoute', async () => {
   expect(result.valid).toBeTrue();
 });
 
-tap.test('Route Patterns - createStaticFileServerRoute', async () => {
-  // Create static file server route
-  const staticRoute = createStaticFileServerRoute(
-    'static.example.com',
-    '/var/www/html',
-    {
-      useTls: true,
-      cacheControl: 'public, max-age=7200'
-    }
-  );
-  
-  // Validate route configuration
-  expect(staticRoute.match.domains).toEqual('static.example.com');
-  expect(staticRoute.action.type).toEqual('static');
-  
-  // Check static configuration
-  if (staticRoute.action.static) {
-    expect(staticRoute.action.static.root).toEqual('/var/www/html');
-    
-    // Check cache control headers if they exist
-    if (staticRoute.action.static.headers) {
-      expect(staticRoute.action.static.headers['Cache-Control']).toEqual('public, max-age=7200');
-    }
-  }
-  
-  const result = validateRouteConfig(staticRoute);
-  expect(result.valid).toBeTrue();
-});
+// createStaticFileServerRoute has been removed - static file serving should be handled by
+// external servers (nginx/apache) behind the proxy
 
 tap.test('Route Patterns - createWebSocketPattern', async () => {
   // Create WebSocket route pattern

test/test.router.ts

@@ -1,7 +1,7 @@
-import { expect, tap } from '@push.rocks/tapbundle';
+import { expect, tap } from '@git.zone/tstest/tapbundle';
 import * as tsclass from '@tsclass/tsclass';
 import * as http from 'http';
-import { ProxyRouter, type RouterResult } from '../ts/http/router/proxy-router.js';
+import { ProxyRouter, type RouterResult } from '../ts/routing/router/proxy-router.js';
 
 // Test proxies and configurations
 let router: ProxyRouter;

test/test.simple-acme-mock.ts

@@ -0,0 +1,88 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import { SmartProxy } from '../ts/index.js';
+
+/**
+ * Simple test to check route manager initialization with ACME
+ */
+tap.test('should properly initialize with ACME configuration', async (tools) => {
+  const settings = {
+    routes: [
+      {
+        name: 'secure-route', 
+        match: {
+          ports: [8443],
+          domains: 'test.example.com'
+        },
+        action: {
+          type: 'forward' as const,
+          target: { host: 'localhost', port: 8080 },
+          tls: {
+            mode: 'terminate' as const,
+            certificate: 'auto' as const,
+            acme: {
+              email: 'ssl@bleu.de',
+              challengePort: 8080
+            }
+          }
+        }
+      }
+    ],
+    acme: {
+      email: 'ssl@bleu.de',
+      port: 8080,
+      useProduction: false,
+      enabled: true
+    }
+  };
+  
+  const proxy = new SmartProxy(settings);
+  
+  // Replace the certificate manager creation to avoid real ACME requests
+  (proxy as any).createCertificateManager = async () => {
+    return {
+      setUpdateRoutesCallback: () => {},
+      setHttpProxy: () => {},
+      setGlobalAcmeDefaults: () => {},
+      setAcmeStateManager: () => {},
+      initialize: async () => {
+        // Using logger would be better but in test we'll keep console.log
+        console.log('Mock certificate manager initialized');
+      },
+      provisionAllCertificates: async () => {
+        console.log('Mock certificate provisioning');
+      },
+      stop: async () => {
+        console.log('Mock certificate manager stopped');
+      }
+    };
+  };
+  
+  // Mock NFTables
+  (proxy as any).nftablesManager = {
+    provisionRoute: async () => {},
+    deprovisionRoute: async () => {},
+    updateRoute: async () => {},
+    getStatus: async () => ({}),
+    stop: async () => {}
+  };
+  
+  await proxy.start();
+  
+  // Verify proxy started successfully
+  expect(proxy).toBeDefined();
+  
+  // Verify route manager has routes
+  const routeManager = (proxy as any).routeManager;
+  expect(routeManager).toBeDefined();
+  expect(routeManager.getAllRoutes().length).toBeGreaterThan(0);
+  
+  // Verify the route exists with correct domain
+  const routes = routeManager.getAllRoutes();
+  const secureRoute = routes.find((r: any) => r.name === 'secure-route');
+  expect(secureRoute).toBeDefined();
+  expect(secureRoute.match.domains).toEqual('test.example.com');
+  
+  await proxy.stop();
+});
+
+tap.start();

test/test.smartacme-integration.ts

@@ -0,0 +1,54 @@
+import * as plugins from '../ts/plugins.js';
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+import { SmartCertManager } from '../ts/proxies/smart-proxy/certificate-manager.js';
+import type { IRouteConfig } from '../ts/proxies/smart-proxy/models/route-types.js';
+
+let certManager: SmartCertManager;
+
+tap.test('should create a SmartCertManager instance', async () => {
+  const routes: IRouteConfig[] = [
+    {
+      name: 'test-acme-route',
+      match: {
+        domains: ['test.example.com'],
+        ports: []
+      },
+      action: {
+        type: 'forward',
+        target: { 
+          host: 'localhost', 
+          port: 3000 
+        },
+        tls: {
+          mode: 'terminate',
+          certificate: 'auto',
+          acme: {
+            email: 'test@example.com'
+          }
+        }
+      }
+    }
+  ];
+
+  certManager = new SmartCertManager(routes, './test-certs', {
+    email: 'test@example.com',
+    useProduction: false
+  });
+
+  // Just verify it creates without error
+  expect(certManager).toBeInstanceOf(SmartCertManager);
+});
+
+tap.test('should verify SmartAcme handlers are accessible', async () => {
+  // Test that we can access SmartAcme handlers
+  const http01Handler = new plugins.smartacme.handlers.Http01MemoryHandler();
+  expect(http01Handler).toBeDefined();
+});
+
+tap.test('should verify SmartAcme cert managers are accessible', async () => {
+  // Test that we can access SmartAcme cert managers
+  const memoryCertManager = new plugins.smartacme.certmanagers.MemoryCertManager();
+  expect(memoryCertManager).toBeDefined();
+});
+
+tap.start();

test/test.smartproxy.ts

@@ -1,4 +1,4 @@
-import { expect, tap } from '@push.rocks/tapbundle';
+import { expect, tap } from '@git.zone/tstest/tapbundle';
 import * as net from 'net';
 import { SmartProxy } from '../ts/proxies/smart-proxy/index.js';
 
@@ -82,7 +82,7 @@ tap.test('setup port proxy test environment', async () => {
     ],
     defaults: {
       security: {
-        allowedIps: ['127.0.0.1']
+        ipAllowList: ['127.0.0.1']
       }
     }
   });
@@ -121,7 +121,7 @@ tap.test('should forward TCP connections to custom host', async () => {
     ],
     defaults: {
       security: {
-        allowedIps: ['127.0.0.1']
+        ipAllowList: ['127.0.0.1']
       }
     }
   });
@@ -166,7 +166,7 @@ tap.test('should forward connections to custom IP', async () => {
     ],
     defaults: {
       security: {
-        allowedIps: ['127.0.0.1', '::ffff:127.0.0.1']
+        ipAllowList: ['127.0.0.1', '::ffff:127.0.0.1']
       }
     }
   });
@@ -261,7 +261,7 @@ tap.test('should support optional source IP preservation in chained proxies', as
     ],
     defaults: {
       security: {
-        allowedIps: ['127.0.0.1', '::ffff:127.0.0.1']
+        ipAllowList: ['127.0.0.1', '::ffff:127.0.0.1']
       }
     }
   });
@@ -282,7 +282,7 @@ tap.test('should support optional source IP preservation in chained proxies', as
     ],
     defaults: {
       security: {
-        allowedIps: ['127.0.0.1', '::ffff:127.0.0.1']
+        ipAllowList: ['127.0.0.1', '::ffff:127.0.0.1']
       }
     }
   });
@@ -320,7 +320,7 @@ tap.test('should support optional source IP preservation in chained proxies', as
     ],
     defaults: {
       security: {
-        allowedIps: ['127.0.0.1']
+        ipAllowList: ['127.0.0.1']
       },
       preserveSourceIP: true
     },
@@ -343,7 +343,7 @@ tap.test('should support optional source IP preservation in chained proxies', as
     ],
     defaults: {
       security: {
-        allowedIps: ['127.0.0.1']
+        ipAllowList: ['127.0.0.1']
       },
       preserveSourceIP: true
     },

test/test.socket-handler-race.ts

@@ -0,0 +1,83 @@
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import * as net from 'net';
+import { SmartProxy } from '../ts/index.js';
+
+tap.test('should handle async handler that sets up listeners after delay', async () => {
+  const proxy = new SmartProxy({
+    routes: [{
+      name: 'delayed-setup-handler',
+      match: { ports: 7777 },
+      action: {
+        type: 'socket-handler',
+        socketHandler: async (socket, context) => {
+          // Simulate async work BEFORE setting up listeners
+          await new Promise(resolve => setTimeout(resolve, 50));
+          
+          // Now set up the listener - with the race condition, this would miss initial data
+          socket.on('data', (data) => {
+            const message = data.toString().trim();
+            socket.write(`RECEIVED: ${message}\n`);
+            if (message === 'close') {
+              socket.end();
+            }
+          });
+          
+          // Send ready message
+          socket.write('HANDLER READY\n');
+        }
+      }
+    }],
+    enableDetailedLogging: false
+  });
+  
+  await proxy.start();
+  
+  // Test connection
+  const client = new net.Socket();
+  let response = '';
+  
+  client.on('data', (data) => {
+    response += data.toString();
+  });
+  
+  await new Promise<void>((resolve, reject) => {
+    client.connect(7777, 'localhost', () => {
+      // Send initial data immediately - this tests the race condition
+      client.write('initial-message\n');
+      resolve();
+    });
+    client.on('error', reject);
+  });
+  
+  // Wait for handler setup and initial data processing
+  await new Promise(resolve => setTimeout(resolve, 150));
+  
+  // Send another message to verify handler is working
+  client.write('test-message\n');
+  
+  // Wait for response
+  await new Promise(resolve => setTimeout(resolve, 50));
+  
+  // Send close command
+  client.write('close\n');
+  
+  // Wait for connection to close
+  await new Promise(resolve => {
+    client.on('close', () => resolve(undefined));
+  });
+  
+  console.log('Response:', response);
+  
+  // Should have received the ready message
+  expect(response).toContain('HANDLER READY');
+  
+  // Should have received the initial message (this would fail with race condition)
+  expect(response).toContain('RECEIVED: initial-message');
+  
+  // Should have received the test message
+  expect(response).toContain('RECEIVED: test-message');
+  
+  await proxy.stop();
+});
+
+export default tap.start();

test/test.socket-handler.ts

@@ -0,0 +1,173 @@
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import * as net from 'net';
+import { SmartProxy } from '../ts/index.js';
+import type { IRouteConfig } from '../ts/index.js';
+
+let proxy: SmartProxy;
+
+tap.test('setup socket handler test', async () => {
+  // Create a simple socket handler route
+  const routes: IRouteConfig[] = [{
+    name: 'echo-handler',
+    match: { 
+      ports: 9999
+      // No domains restriction - matches all connections
+    },
+    action: {
+      type: 'socket-handler',
+      socketHandler: (socket, context) => {
+        console.log('Socket handler called');
+        // Simple echo server
+        socket.write('ECHO SERVER\n');
+        socket.on('data', (data) => {
+          console.log('Socket handler received data:', data.toString());
+          socket.write(`ECHO: ${data}`);
+        });
+        socket.on('error', (err) => {
+          console.error('Socket error:', err);
+        });
+      }
+    }
+  }];
+  
+  proxy = new SmartProxy({
+    routes,
+    enableDetailedLogging: false
+  });
+  
+  await proxy.start();
+});
+
+tap.test('should handle socket with custom function', async () => {
+  const client = new net.Socket();
+  let response = '';
+  
+  await new Promise<void>((resolve, reject) => {
+    client.connect(9999, 'localhost', () => {
+      console.log('Client connected to proxy');
+      resolve();
+    });
+    
+    client.on('error', reject);
+  });
+  
+  // Collect data
+  client.on('data', (data) => {
+    console.log('Client received:', data.toString());
+    response += data.toString();
+  });
+  
+  // Wait a bit for connection to stabilize
+  await new Promise(resolve => setTimeout(resolve, 50));
+  
+  // Send test data
+  console.log('Sending test data...');
+  client.write('Hello World\n');
+  
+  // Wait for response
+  await new Promise(resolve => setTimeout(resolve, 200));
+  
+  console.log('Total response:', response);
+  expect(response).toContain('ECHO SERVER');
+  expect(response).toContain('ECHO: Hello World');
+  
+  client.destroy();
+});
+
+tap.test('should handle async socket handler', async () => {
+  // Update route with async handler
+  await proxy.updateRoutes([{
+    name: 'async-handler',
+    match: { ports: 9999 },
+    action: {
+      type: 'socket-handler',
+      socketHandler: async (socket, context) => {
+        // Set up data handler first
+        socket.on('data', async (data) => {
+          console.log('Async handler received:', data.toString());
+          // Simulate async processing
+          await new Promise(resolve => setTimeout(resolve, 10));
+          const processed = `PROCESSED: ${data.toString().trim().toUpperCase()}\n`;
+          console.log('Sending:', processed);
+          socket.write(processed);
+        });
+        
+        // Then simulate async operation
+        await new Promise(resolve => setTimeout(resolve, 10));
+        socket.write('ASYNC READY\n');
+      }
+    }
+  }]);
+  
+  const client = new net.Socket();
+  let response = '';
+  
+  // Collect data
+  client.on('data', (data) => {
+    response += data.toString();
+  });
+  
+  await new Promise<void>((resolve, reject) => {
+    client.connect(9999, 'localhost', () => {
+      // Send initial data to trigger the handler
+      client.write('test data\n');
+      resolve();
+    });
+    
+    client.on('error', reject);
+  });
+  
+  // Wait for async processing
+  await new Promise(resolve => setTimeout(resolve, 200));
+  
+  console.log('Final response:', response);
+  expect(response).toContain('ASYNC READY');
+  expect(response).toContain('PROCESSED: TEST DATA');
+  
+  client.destroy();
+});
+
+tap.test('should handle errors in socket handler', async () => {
+  // Update route with error-throwing handler
+  await proxy.updateRoutes([{
+    name: 'error-handler',
+    match: { ports: 9999 },
+    action: {
+      type: 'socket-handler',
+      socketHandler: (socket, context) => {
+        throw new Error('Handler error');
+      }
+    }
+  }]);
+  
+  const client = new net.Socket();
+  let connectionClosed = false;
+  
+  client.on('close', () => {
+    connectionClosed = true;
+  });
+  
+  await new Promise<void>((resolve, reject) => {
+    client.connect(9999, 'localhost', () => {
+      // Connection established - send data to trigger handler
+      client.write('trigger\n');
+      resolve();
+    });
+    
+    client.on('error', () => {
+      // Ignore client errors - we expect the connection to be closed
+    });
+  });
+  
+  // Wait a bit
+  await new Promise(resolve => setTimeout(resolve, 100));
+  
+  // Socket should be closed due to handler error
+  expect(connectionClosed).toEqual(true);
+});
+
+tap.test('cleanup', async () => {
+  await proxy.stop();
+});
+
+export default tap.start();

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartproxy',
-  version: '18.0.0',
+  version: '19.5.3',
   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.'
 }

ts/certificate/acme/acme-factory.ts

@@ -1,48 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import type { IAcmeOptions } from '../models/certificate-types.js';
-import { ensureCertificateDirectory } from '../utils/certificate-helpers.js';
-// We'll need to update this import when we move the Port80Handler
-import { Port80Handler } from '../../http/port80/port80-handler.js';
-
-/**
- * Factory to create a Port80Handler with common setup.
- * Ensures the certificate store directory exists and instantiates the handler.
- * @param options Port80Handler configuration options
- * @returns A new Port80Handler instance
- */
-export function buildPort80Handler(
-  options: IAcmeOptions
-): Port80Handler {
-  if (options.certificateStore) {
-    ensureCertificateDirectory(options.certificateStore);
-    console.log(`Ensured certificate store directory: ${options.certificateStore}`);
-  }
-  return new Port80Handler(options);
-}
-
-/**
- * Creates default ACME options with sensible defaults
- * @param email Account email for ACME provider
- * @param certificateStore Path to store certificates
- * @param useProduction Whether to use production ACME servers
- * @returns Configured ACME options
- */
-export function createDefaultAcmeOptions(
-  email: string,
-  certificateStore: string,
-  useProduction: boolean = false
-): IAcmeOptions {
-  return {
-    accountEmail: email,
-    enabled: true,
-    port: 80,
-    useProduction,
-    httpsRedirectPort: 443,
-    renewThresholdDays: 30,
-    renewCheckIntervalHours: 24,
-    autoRenew: true,
-    certificateStore,
-    skipConfiguredCerts: false
-  };
-}

ts/certificate/acme/challenge-handler.ts

@@ -1,110 +0,0 @@
-import * as plugins from '../../plugins.js';
-import type { IAcmeOptions, ICertificateData } from '../models/certificate-types.js';
-import { CertificateEvents } from '../events/certificate-events.js';
-
-/**
- * Manages ACME challenges and certificate validation
- */
-export class AcmeChallengeHandler extends plugins.EventEmitter {
-  private options: IAcmeOptions;
-  private client: any; // ACME client from plugins
-  private pendingChallenges: Map<string, any>;
-
-  /**
-   * Creates a new ACME challenge handler
-   * @param options ACME configuration options
-   */
-  constructor(options: IAcmeOptions) {
-    super();
-    this.options = options;
-    this.pendingChallenges = new Map();
-
-    // Initialize ACME client if needed
-    // This is just a placeholder implementation since we don't use the actual
-    // client directly in this implementation - it's handled by Port80Handler
-    this.client = null;
-    console.log('Created challenge handler with options:',
-      options.accountEmail,
-      options.useProduction ? 'production' : 'staging'
-    );
-  }
-
-  /**
-   * Gets or creates the ACME account key
-   */
-  private getAccountKey(): Buffer {
-    // Implementation details would depend on plugin requirements
-    // This is a simplified version
-    if (!this.options.certificateStore) {
-      throw new Error('Certificate store is required for ACME challenges');
-    }
-    
-    // This is just a placeholder - actual implementation would check for
-    // existing account key and create one if needed
-    return Buffer.from('account-key-placeholder');
-  }
-
-  /**
-   * Validates a domain using HTTP-01 challenge
-   * @param domain Domain to validate
-   * @param challengeToken ACME challenge token
-   * @param keyAuthorization Key authorization for the challenge
-   */
-  public async handleHttpChallenge(
-    domain: string,
-    challengeToken: string,
-    keyAuthorization: string
-  ): Promise<void> {
-    // Store challenge for response
-    this.pendingChallenges.set(challengeToken, keyAuthorization);
-    
-    try {
-      // Wait for challenge validation - this would normally be handled by the ACME client
-      await new Promise(resolve => setTimeout(resolve, 1000));
-      this.emit(CertificateEvents.CERTIFICATE_ISSUED, {
-        domain,
-        success: true
-      });
-    } catch (error) {
-      this.emit(CertificateEvents.CERTIFICATE_FAILED, {
-        domain,
-        error: error instanceof Error ? error.message : String(error),
-        isRenewal: false
-      });
-      throw error;
-    } finally {
-      // Clean up the challenge
-      this.pendingChallenges.delete(challengeToken);
-    }
-  }
-
-  /**
-   * Responds to an HTTP-01 challenge request
-   * @param token Challenge token from the request path
-   * @returns The key authorization if found
-   */
-  public getChallengeResponse(token: string): string | null {
-    return this.pendingChallenges.get(token) || null;
-  }
-
-  /**
-   * Checks if a request path is an ACME challenge
-   * @param path Request path
-   * @returns True if this is an ACME challenge request
-   */
-  public isAcmeChallenge(path: string): boolean {
-    return path.startsWith('/.well-known/acme-challenge/');
-  }
-
-  /**
-   * Extracts the challenge token from an ACME challenge path
-   * @param path Request path
-   * @returns The challenge token if valid
-   */
-  public extractChallengeToken(path: string): string | null {
-    if (!this.isAcmeChallenge(path)) return null;
-    
-    const parts = path.split('/');
-    return parts[parts.length - 1] || null;
-  }
-}

ts/certificate/acme/index.ts

@@ -1,3 +0,0 @@
-/**
- * ACME certificate provisioning
- */

ts/certificate/events/certificate-events.ts

@@ -1,36 +0,0 @@
-/**
- * Certificate-related events emitted by certificate management components
- */
-export enum CertificateEvents {
-  CERTIFICATE_ISSUED = 'certificate-issued',
-  CERTIFICATE_RENEWED = 'certificate-renewed',
-  CERTIFICATE_FAILED = 'certificate-failed',
-  CERTIFICATE_EXPIRING = 'certificate-expiring',
-  CERTIFICATE_APPLIED = 'certificate-applied',
-  // Events moved from Port80Handler for compatibility
-  MANAGER_STARTED = 'manager-started',
-  MANAGER_STOPPED = 'manager-stopped',
-}
-
-/**
- * Port80Handler-specific events including certificate-related ones
- * @deprecated Use CertificateEvents and HttpEvents instead
- */
-export enum Port80HandlerEvents {
-  CERTIFICATE_ISSUED = 'certificate-issued',
-  CERTIFICATE_RENEWED = 'certificate-renewed',
-  CERTIFICATE_FAILED = 'certificate-failed',
-  CERTIFICATE_EXPIRING = 'certificate-expiring',
-  MANAGER_STARTED = 'manager-started',
-  MANAGER_STOPPED = 'manager-stopped',
-  REQUEST_FORWARDED = 'request-forwarded',
-}
-
-/**
- * Certificate provider events
- */
-export enum CertProvisionerEvents {
-  CERTIFICATE_ISSUED = 'certificate',
-  CERTIFICATE_RENEWED = 'certificate',
-  CERTIFICATE_FAILED = 'certificate-failed'
-}

ts/certificate/index.ts

@@ -1,75 +0,0 @@
-/**
- * Certificate management module for SmartProxy
- * Provides certificate provisioning, storage, and management capabilities
- */
-
-// Certificate types and models
-export * from './models/certificate-types.js';
-
-// Certificate events
-export * from './events/certificate-events.js';
-
-// Certificate providers
-export * from './providers/cert-provisioner.js';
-
-// ACME related exports
-export * from './acme/acme-factory.js';
-export * from './acme/challenge-handler.js';
-
-// Certificate utilities
-export * from './utils/certificate-helpers.js';
-
-// Certificate storage
-export * from './storage/file-storage.js';
-
-// Convenience function to create a certificate provisioner with common settings
-import { CertProvisioner } from './providers/cert-provisioner.js';
-import type { TCertProvisionObject } from './providers/cert-provisioner.js';
-import { buildPort80Handler } from './acme/acme-factory.js';
-import type { IAcmeOptions, IRouteForwardConfig } from './models/certificate-types.js';
-import type { IRouteConfig } from '../proxies/smart-proxy/models/route-types.js';
-
-/**
- * Interface for NetworkProxyBridge used by CertProvisioner
- */
-interface ICertNetworkProxyBridge {
-  applyExternalCertificate(certData: any): void;
-}
-
-/**
- * Creates a complete certificate provisioning system with default settings
- * @param routeConfigs Route configurations that may need certificates
- * @param acmeOptions ACME options for certificate provisioning
- * @param networkProxyBridge Bridge to apply certificates to network proxy
- * @param certProvider Optional custom certificate provider
- * @returns Configured CertProvisioner
- */
-export function createCertificateProvisioner(
-  routeConfigs: IRouteConfig[],
-  acmeOptions: IAcmeOptions,
-  networkProxyBridge: ICertNetworkProxyBridge,
-  certProvider?: (domain: string) => Promise<TCertProvisionObject>
-): CertProvisioner {
-  // Build the Port80Handler for ACME challenges
-  const port80Handler = buildPort80Handler(acmeOptions);
-
-  // Extract ACME-specific configuration
-  const {
-    renewThresholdDays = 30,
-    renewCheckIntervalHours = 24,
-    autoRenew = true,
-    routeForwards = []
-  } = acmeOptions;
-
-  // Create and return the certificate provisioner
-  return new CertProvisioner(
-    routeConfigs,
-    port80Handler,
-    networkProxyBridge,
-    certProvider,
-    renewThresholdDays,
-    renewCheckIntervalHours,
-    autoRenew,
-    routeForwards
-  );
-}

ts/certificate/models/certificate-types.ts

@@ -1,109 +0,0 @@
-import * as plugins from '../../plugins.js';
-import type { IRouteConfig } from '../../proxies/smart-proxy/models/route-types.js';
-
-/**
- * Certificate data structure containing all necessary information
- * about a certificate
- */
-export interface ICertificateData {
-  domain: string;
-  certificate: string;
-  privateKey: string;
-  expiryDate: Date;
-  // Optional source and renewal information for event emissions
-  source?: 'static' | 'http01' | 'dns01';
-  isRenewal?: boolean;
-  // Reference to the route that requested this certificate (if available)
-  routeReference?: {
-    routeId?: string;
-    routeName?: string;
-  };
-}
-
-/**
- * Certificates pair (private and public keys)
- */
-export interface ICertificates {
-  privateKey: string;
-  publicKey: string;
-}
-
-/**
- * Certificate failure payload type
- */
-export interface ICertificateFailure {
-  domain: string;
-  error: string;
-  isRenewal: boolean;
-  routeReference?: {
-    routeId?: string;
-    routeName?: string;
-  };
-}
-
-/**
- * Certificate expiry payload type
- */
-export interface ICertificateExpiring {
-  domain: string;
-  expiryDate: Date;
-  daysRemaining: number;
-  routeReference?: {
-    routeId?: string;
-    routeName?: string;
-  };
-}
-
-/**
- * Route-specific forwarding configuration for ACME challenges
- */
-export interface IRouteForwardConfig {
-  domain: string;
-  target: {
-    host: string;
-    port: number;
-  };
-  sslRedirect?: boolean;
-}
-
-/**
- * Domain configuration options for Port80Handler
- *
- * This is used internally by the Port80Handler to manage domains
- * but will eventually be replaced with route-based options.
- */
-export interface IDomainOptions {
-  domainName: string;
-  sslRedirect: boolean;   // if true redirects the request to port 443
-  acmeMaintenance: boolean; // tries to always have a valid cert for this domain
-  forward?: {
-    ip: string;
-    port: number;
-  }; // forwards all http requests to that target
-  acmeForward?: {
-    ip: string;
-    port: number;
-  }; // forwards letsencrypt requests to this config
-  routeReference?: {
-    routeId?: string;
-    routeName?: string;
-  };
-}
-
-/**
- * Unified ACME configuration options used across proxies and handlers
- */
-export interface IAcmeOptions {
-  accountEmail?: string;          // Email for Let's Encrypt account
-  enabled?: boolean;              // Whether ACME is enabled
-  port?: number;                  // Port to listen on for ACME challenges (default: 80)
-  useProduction?: boolean;        // Use production environment (default: staging)
-  httpsRedirectPort?: number;     // Port to redirect HTTP requests to HTTPS (default: 443)
-  renewThresholdDays?: number;    // Days before expiry to renew certificates
-  renewCheckIntervalHours?: number; // How often to check for renewals (in hours)
-  autoRenew?: boolean;            // Whether to automatically renew certificates
-  certificateStore?: string;      // Directory to store certificates
-  skipConfiguredCerts?: boolean;  // Skip domains with existing certificates
-  routeForwards?: IRouteForwardConfig[]; // Route-specific forwarding configs
-}
-

ts/certificate/providers/cert-provisioner.ts

@@ -1,519 +0,0 @@
-import * as plugins from '../../plugins.js';
-import type { IRouteConfig } from '../../proxies/smart-proxy/models/route-types.js';
-import type { ICertificateData, IRouteForwardConfig, IDomainOptions } from '../models/certificate-types.js';
-import { Port80HandlerEvents, CertProvisionerEvents } from '../events/certificate-events.js';
-import { Port80Handler } from '../../http/port80/port80-handler.js';
-
-// Interface for NetworkProxyBridge
-interface INetworkProxyBridge {
-  applyExternalCertificate(certData: ICertificateData): void;
-}
-
-/**
- * Type for static certificate provisioning
- */
-export type TCertProvisionObject = plugins.tsclass.network.ICert | 'http01' | 'dns01';
-
-/**
- * Interface for routes that need certificates
- */
-interface ICertRoute {
-  domain: string;
-  route: IRouteConfig;
-  tlsMode: 'terminate' | 'terminate-and-reencrypt';
-}
-
-/**
- * CertProvisioner manages certificate provisioning and renewal workflows,
- * unifying static certificates and HTTP-01 challenges via Port80Handler.
- *
- * This class directly works with route configurations instead of converting to domain configs.
- */
-export class CertProvisioner extends plugins.EventEmitter {
-  private routeConfigs: IRouteConfig[];
-  private certRoutes: ICertRoute[] = [];
-  private port80Handler: Port80Handler;
-  private networkProxyBridge: INetworkProxyBridge;
-  private certProvisionFunction?: (domain: string) => Promise<TCertProvisionObject>;
-  private routeForwards: IRouteForwardConfig[];
-  private renewThresholdDays: number;
-  private renewCheckIntervalHours: number;
-  private autoRenew: boolean;
-  private renewManager?: plugins.taskbuffer.TaskManager;
-  // Track provisioning type per domain
-  private provisionMap: Map<string, { type: 'http01' | 'dns01' | 'static', routeRef?: ICertRoute }>;
-
-  /**
-   * Extract routes that need certificates
-   * @param routes Route configurations
-   */
-  private extractCertificateRoutesFromRoutes(routes: IRouteConfig[]): ICertRoute[] {
-    const certRoutes: ICertRoute[] = [];
-
-    // Process all HTTPS routes that need certificates
-    for (const route of routes) {
-      // Only process routes with TLS termination that need certificates
-      if (route.action.type === 'forward' &&
-          route.action.tls &&
-          (route.action.tls.mode === 'terminate' || route.action.tls.mode === 'terminate-and-reencrypt') &&
-          route.match.domains) {
-
-        // Extract domains from the route
-        const domains = Array.isArray(route.match.domains)
-          ? route.match.domains
-          : [route.match.domains];
-
-        // For each domain in the route, create a certRoute entry
-        for (const domain of domains) {
-          // Skip wildcard domains that can't use ACME unless we have a certProvider
-          if (domain.includes('*') && (!this.certProvisionFunction || this.certProvisionFunction.length === 0)) {
-            console.warn(`Skipping wildcard domain that requires a certProvisionFunction: ${domain}`);
-            continue;
-          }
-
-          certRoutes.push({
-            domain,
-            route,
-            tlsMode: route.action.tls.mode
-          });
-        }
-      }
-    }
-
-    return certRoutes;
-  }
-
-  /**
-   * Constructor for CertProvisioner
-   *
-   * @param routeConfigs Array of route configurations
-   * @param port80Handler HTTP-01 challenge handler instance
-   * @param networkProxyBridge Bridge for applying external certificates
-   * @param certProvider Optional callback returning a static cert or 'http01'
-   * @param renewThresholdDays Days before expiry to trigger renewals
-   * @param renewCheckIntervalHours Interval in hours to check for renewals
-   * @param autoRenew Whether to automatically schedule renewals
-   * @param routeForwards Route-specific forwarding configs for ACME challenges
-   */
-  constructor(
-    routeConfigs: IRouteConfig[],
-    port80Handler: Port80Handler,
-    networkProxyBridge: INetworkProxyBridge,
-    certProvider?: (domain: string) => Promise<TCertProvisionObject>,
-    renewThresholdDays: number = 30,
-    renewCheckIntervalHours: number = 24,
-    autoRenew: boolean = true,
-    routeForwards: IRouteForwardConfig[] = []
-  ) {
-    super();
-    this.routeConfigs = routeConfigs;
-    this.port80Handler = port80Handler;
-    this.networkProxyBridge = networkProxyBridge;
-    this.certProvisionFunction = certProvider;
-    this.renewThresholdDays = renewThresholdDays;
-    this.renewCheckIntervalHours = renewCheckIntervalHours;
-    this.autoRenew = autoRenew;
-    this.provisionMap = new Map();
-    this.routeForwards = routeForwards;
-
-    // Extract certificate routes during instantiation
-    this.certRoutes = this.extractCertificateRoutesFromRoutes(routeConfigs);
-  }
-
-  /**
-   * Start initial provisioning and schedule renewals.
-   */
-  public async start(): Promise<void> {
-    // Subscribe to Port80Handler certificate events
-    this.setupEventSubscriptions();
-
-    // Apply route forwarding for ACME challenges
-    this.setupForwardingConfigs();
-
-    // Initial provisioning for all domains in routes
-    await this.provisionAllCertificates();
-
-    // Schedule renewals if enabled
-    if (this.autoRenew) {
-      this.scheduleRenewals();
-    }
-  }
-
-  /**
-   * Set up event subscriptions for certificate events
-   */
-  private setupEventSubscriptions(): void {
-    this.port80Handler.on(Port80HandlerEvents.CERTIFICATE_ISSUED, (data: ICertificateData) => {
-      // Add route reference if we have it
-      const routeRef = this.findRouteForDomain(data.domain);
-      const enhancedData: ICertificateData = {
-        ...data,
-        source: 'http01',
-        isRenewal: false,
-        routeReference: routeRef ? {
-          routeId: routeRef.route.name,
-          routeName: routeRef.route.name
-        } : undefined
-      };
-
-      this.emit(CertProvisionerEvents.CERTIFICATE_ISSUED, enhancedData);
-    });
-
-    this.port80Handler.on(Port80HandlerEvents.CERTIFICATE_RENEWED, (data: ICertificateData) => {
-      // Add route reference if we have it
-      const routeRef = this.findRouteForDomain(data.domain);
-      const enhancedData: ICertificateData = {
-        ...data,
-        source: 'http01',
-        isRenewal: true,
-        routeReference: routeRef ? {
-          routeId: routeRef.route.name,
-          routeName: routeRef.route.name
-        } : undefined
-      };
-
-      this.emit(CertProvisionerEvents.CERTIFICATE_RENEWED, enhancedData);
-    });
-
-    this.port80Handler.on(Port80HandlerEvents.CERTIFICATE_FAILED, (error) => {
-      this.emit(CertProvisionerEvents.CERTIFICATE_FAILED, error);
-    });
-  }
-
-  /**
-   * Find a route for a given domain
-   */
-  private findRouteForDomain(domain: string): ICertRoute | undefined {
-    return this.certRoutes.find(certRoute => certRoute.domain === domain);
-  }
-
-  /**
-   * Set up forwarding configurations for the Port80Handler
-   */
-  private setupForwardingConfigs(): void {
-    for (const config of this.routeForwards) {
-      const domainOptions: IDomainOptions = {
-        domainName: config.domain,
-        sslRedirect: config.sslRedirect || false,
-        acmeMaintenance: false,
-        forward: config.target ? {
-          ip: config.target.host,
-          port: config.target.port
-        } : undefined
-      };
-      this.port80Handler.addDomain(domainOptions);
-    }
-  }
-
-  /**
-   * Provision certificates for all routes that need them
-   */
-  private async provisionAllCertificates(): Promise<void> {
-    for (const certRoute of this.certRoutes) {
-      await this.provisionCertificateForRoute(certRoute);
-    }
-  }
-
-  /**
-   * Provision a certificate for a route
-   */
-  private async provisionCertificateForRoute(certRoute: ICertRoute): Promise<void> {
-    const { domain, route } = certRoute;
-    const isWildcard = domain.includes('*');
-    let provision: TCertProvisionObject = 'http01';
-
-    // Try to get a certificate from the provision function
-    if (this.certProvisionFunction) {
-      try {
-        provision = await this.certProvisionFunction(domain);
-      } catch (err) {
-        console.error(`certProvider error for ${domain} on route ${route.name || 'unnamed'}:`, err);
-      }
-    } else if (isWildcard) {
-      // No certProvider: cannot handle wildcard without DNS-01 support
-      console.warn(`Skipping wildcard domain without certProvisionFunction: ${domain}`);
-      return;
-    }
-
-    // Store the route reference with the provision type
-    this.provisionMap.set(domain, {
-      type: provision === 'http01' || provision === 'dns01' ? provision : 'static',
-      routeRef: certRoute
-    });
-
-    // Handle different provisioning methods
-    if (provision === 'http01') {
-      if (isWildcard) {
-        console.warn(`Skipping HTTP-01 for wildcard domain: ${domain}`);
-        return;
-      }
-
-      this.port80Handler.addDomain({
-        domainName: domain,
-        sslRedirect: true,
-        acmeMaintenance: true,
-        routeReference: {
-          routeId: route.name || domain,
-          routeName: route.name
-        }
-      });
-    } else if (provision === 'dns01') {
-      // DNS-01 challenges would be handled by the certProvisionFunction
-      // DNS-01 handling would go here if implemented
-      console.log(`DNS-01 challenge type set for ${domain}`);
-    } else {
-      // Static certificate (e.g., DNS-01 provisioned or user-provided)
-      const certObj = provision as plugins.tsclass.network.ICert;
-      const certData: ICertificateData = {
-        domain: certObj.domainName,
-        certificate: certObj.publicKey,
-        privateKey: certObj.privateKey,
-        expiryDate: new Date(certObj.validUntil),
-        source: 'static',
-        isRenewal: false,
-        routeReference: {
-          routeId: route.name || domain,
-          routeName: route.name
-        }
-      };
-
-      this.networkProxyBridge.applyExternalCertificate(certData);
-      this.emit(CertProvisionerEvents.CERTIFICATE_ISSUED, certData);
-    }
-  }
-
-  /**
-   * Schedule certificate renewals using a task manager
-   */
-  private scheduleRenewals(): void {
-    this.renewManager = new plugins.taskbuffer.TaskManager();
-
-    const renewTask = new plugins.taskbuffer.Task({
-      name: 'CertificateRenewals',
-      taskFunction: async () => await this.performRenewals()
-    });
-
-    const hours = this.renewCheckIntervalHours;
-    const cronExpr = `0 0 */${hours} * * *`;
-
-    this.renewManager.addAndScheduleTask(renewTask, cronExpr);
-    this.renewManager.start();
-  }
-
-  /**
-   * Perform renewals for all domains that need it
-   */
-  private async performRenewals(): Promise<void> {
-    for (const [domain, info] of this.provisionMap.entries()) {
-      // Skip wildcard domains for HTTP-01 challenges
-      if (domain.includes('*') && info.type === 'http01') continue;
-
-      try {
-        await this.renewCertificateForDomain(domain, info.type, info.routeRef);
-      } catch (err) {
-        console.error(`Renewal error for ${domain}:`, err);
-      }
-    }
-  }
-
-  /**
-   * Renew a certificate for a specific domain
-   * @param domain Domain to renew
-   * @param provisionType Type of provisioning for this domain
-   * @param certRoute The route reference for this domain
-   */
-  private async renewCertificateForDomain(
-    domain: string,
-    provisionType: 'http01' | 'dns01' | 'static',
-    certRoute?: ICertRoute
-  ): Promise<void> {
-    if (provisionType === 'http01') {
-      await this.port80Handler.renewCertificate(domain);
-    } else if ((provisionType === 'static' || provisionType === 'dns01') && this.certProvisionFunction) {
-      const provision = await this.certProvisionFunction(domain);
-
-      if (provision !== 'http01' && provision !== 'dns01') {
-        const certObj = provision as plugins.tsclass.network.ICert;
-        const routeRef = certRoute?.route;
-
-        const certData: ICertificateData = {
-          domain: certObj.domainName,
-          certificate: certObj.publicKey,
-          privateKey: certObj.privateKey,
-          expiryDate: new Date(certObj.validUntil),
-          source: 'static',
-          isRenewal: true,
-          routeReference: routeRef ? {
-            routeId: routeRef.name || domain,
-            routeName: routeRef.name
-          } : undefined
-        };
-
-        this.networkProxyBridge.applyExternalCertificate(certData);
-        this.emit(CertProvisionerEvents.CERTIFICATE_RENEWED, certData);
-      }
-    }
-  }
-
-  /**
-   * Stop all scheduled renewal tasks.
-   */
-  public async stop(): Promise<void> {
-    if (this.renewManager) {
-      this.renewManager.stop();
-    }
-  }
-
-  /**
-   * Request a certificate on-demand for the given domain.
-   * This will look for a matching route configuration and provision accordingly.
-   *
-   * @param domain Domain name to provision
-   */
-  public async requestCertificate(domain: string): Promise<void> {
-    const isWildcard = domain.includes('*');
-    // Find matching route
-    const certRoute = this.findRouteForDomain(domain);
-
-    // Determine provisioning method
-    let provision: TCertProvisionObject = 'http01';
-
-    if (this.certProvisionFunction) {
-      provision = await this.certProvisionFunction(domain);
-    } else if (isWildcard) {
-      // Cannot perform HTTP-01 on wildcard without certProvider
-      throw new Error(`Cannot request certificate for wildcard domain without certProvisionFunction: ${domain}`);
-    }
-
-    if (provision === 'http01') {
-      if (isWildcard) {
-        throw new Error(`Cannot request HTTP-01 certificate for wildcard domain: ${domain}`);
-      }
-      await this.port80Handler.renewCertificate(domain);
-    } else if (provision === 'dns01') {
-      // DNS-01 challenges would be handled by external mechanisms
-      console.log(`DNS-01 challenge requested for ${domain}`);
-    } else {
-      // Static certificate (e.g., DNS-01 provisioned) supports wildcards
-      const certObj = provision as plugins.tsclass.network.ICert;
-      const certData: ICertificateData = {
-        domain: certObj.domainName,
-        certificate: certObj.publicKey,
-        privateKey: certObj.privateKey,
-        expiryDate: new Date(certObj.validUntil),
-        source: 'static',
-        isRenewal: false,
-        routeReference: certRoute ? {
-          routeId: certRoute.route.name || domain,
-          routeName: certRoute.route.name
-        } : undefined
-      };
-
-      this.networkProxyBridge.applyExternalCertificate(certData);
-      this.emit(CertProvisionerEvents.CERTIFICATE_ISSUED, certData);
-    }
-  }
-
-  /**
-   * Add a new domain for certificate provisioning
-   *
-   * @param domain Domain to add
-   * @param options Domain configuration options
-   */
-  public async addDomain(domain: string, options?: {
-    sslRedirect?: boolean;
-    acmeMaintenance?: boolean;
-    routeId?: string;
-    routeName?: string;
-  }): Promise<void> {
-    const domainOptions: IDomainOptions = {
-      domainName: domain,
-      sslRedirect: options?.sslRedirect ?? true,
-      acmeMaintenance: options?.acmeMaintenance ?? true,
-      routeReference: {
-        routeId: options?.routeId,
-        routeName: options?.routeName
-      }
-    };
-
-    this.port80Handler.addDomain(domainOptions);
-
-    // Find matching route or create a generic one
-    const existingRoute = this.findRouteForDomain(domain);
-    if (existingRoute) {
-      await this.provisionCertificateForRoute(existingRoute);
-    } else {
-      // We don't have a route, just provision the domain
-      const isWildcard = domain.includes('*');
-      let provision: TCertProvisionObject = 'http01';
-
-      if (this.certProvisionFunction) {
-        provision = await this.certProvisionFunction(domain);
-      } else if (isWildcard) {
-        throw new Error(`Cannot request certificate for wildcard domain without certProvisionFunction: ${domain}`);
-      }
-
-      this.provisionMap.set(domain, {
-        type: provision === 'http01' || provision === 'dns01' ? provision : 'static'
-      });
-
-      if (provision !== 'http01' && provision !== 'dns01') {
-        const certObj = provision as plugins.tsclass.network.ICert;
-        const certData: ICertificateData = {
-          domain: certObj.domainName,
-          certificate: certObj.publicKey,
-          privateKey: certObj.privateKey,
-          expiryDate: new Date(certObj.validUntil),
-          source: 'static',
-          isRenewal: false,
-          routeReference: {
-            routeId: options?.routeId,
-            routeName: options?.routeName
-          }
-        };
-
-        this.networkProxyBridge.applyExternalCertificate(certData);
-        this.emit(CertProvisionerEvents.CERTIFICATE_ISSUED, certData);
-      }
-    }
-  }
-
-  /**
-   * Update routes with new configurations
-   * This replaces all existing routes with new ones and re-provisions certificates as needed
-   *
-   * @param newRoutes New route configurations to use
-   */
-  public async updateRoutes(newRoutes: IRouteConfig[]): Promise<void> {
-    // Store the new route configs
-    this.routeConfigs = newRoutes;
-
-    // Extract new certificate routes
-    const newCertRoutes = this.extractCertificateRoutesFromRoutes(newRoutes);
-
-    // Find domains that no longer need certificates
-    const oldDomains = new Set(this.certRoutes.map(r => r.domain));
-    const newDomains = new Set(newCertRoutes.map(r => r.domain));
-
-    // Domains to remove
-    const domainsToRemove = [...oldDomains].filter(d => !newDomains.has(d));
-
-    // Remove obsolete domains from provision map
-    for (const domain of domainsToRemove) {
-      this.provisionMap.delete(domain);
-    }
-
-    // Update the cert routes
-    this.certRoutes = newCertRoutes;
-
-    // Provision certificates for new routes
-    for (const certRoute of newCertRoutes) {
-      if (!oldDomains.has(certRoute.domain)) {
-        await this.provisionCertificateForRoute(certRoute);
-      }
-    }
-  }
-}
-
-// Type alias for backward compatibility
-export type TSmartProxyCertProvisionObject = TCertProvisionObject;

ts/certificate/providers/index.ts

@@ -1,3 +0,0 @@
-/**
- * Certificate providers
- */

ts/certificate/storage/file-storage.ts

@@ -1,234 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as plugins from '../../plugins.js';
-import type { ICertificateData, ICertificates } from '../models/certificate-types.js';
-import { ensureCertificateDirectory } from '../utils/certificate-helpers.js';
-
-/**
- * FileStorage provides file system storage for certificates
- */
-export class FileStorage {
-  private storageDir: string;
-  
-  /**
-   * Creates a new file storage provider
-   * @param storageDir Directory to store certificates
-   */
-  constructor(storageDir: string) {
-    this.storageDir = path.resolve(storageDir);
-    ensureCertificateDirectory(this.storageDir);
-  }
-  
-  /**
-   * Save a certificate to the file system
-   * @param domain Domain name
-   * @param certData Certificate data to save
-   */
-  public async saveCertificate(domain: string, certData: ICertificateData): Promise<void> {
-    const sanitizedDomain = this.sanitizeDomain(domain);
-    const certDir = path.join(this.storageDir, sanitizedDomain);
-    ensureCertificateDirectory(certDir);
-    
-    const certPath = path.join(certDir, 'fullchain.pem');
-    const keyPath = path.join(certDir, 'privkey.pem');
-    const metaPath = path.join(certDir, 'metadata.json');
-    
-    // Write certificate and private key
-    await fs.promises.writeFile(certPath, certData.certificate, 'utf8');
-    await fs.promises.writeFile(keyPath, certData.privateKey, 'utf8');
-    
-    // Write metadata
-    const metadata = {
-      domain: certData.domain,
-      expiryDate: certData.expiryDate.toISOString(),
-      source: certData.source || 'unknown',
-      issuedAt: new Date().toISOString()
-    };
-    
-    await fs.promises.writeFile(
-      metaPath, 
-      JSON.stringify(metadata, null, 2), 
-      'utf8'
-    );
-  }
-  
-  /**
-   * Load a certificate from the file system
-   * @param domain Domain name
-   * @returns Certificate data if found, null otherwise
-   */
-  public async loadCertificate(domain: string): Promise<ICertificateData | null> {
-    const sanitizedDomain = this.sanitizeDomain(domain);
-    const certDir = path.join(this.storageDir, sanitizedDomain);
-    
-    if (!fs.existsSync(certDir)) {
-      return null;
-    }
-    
-    const certPath = path.join(certDir, 'fullchain.pem');
-    const keyPath = path.join(certDir, 'privkey.pem');
-    const metaPath = path.join(certDir, 'metadata.json');
-    
-    try {
-      // Check if all required files exist
-      if (!fs.existsSync(certPath) || !fs.existsSync(keyPath)) {
-        return null;
-      }
-      
-      // Read certificate and private key
-      const certificate = await fs.promises.readFile(certPath, 'utf8');
-      const privateKey = await fs.promises.readFile(keyPath, 'utf8');
-      
-      // Try to read metadata if available
-      let expiryDate = new Date();
-      let source: 'static' | 'http01' | 'dns01' | undefined;
-      
-      if (fs.existsSync(metaPath)) {
-        const metaContent = await fs.promises.readFile(metaPath, 'utf8');
-        const metadata = JSON.parse(metaContent);
-        
-        if (metadata.expiryDate) {
-          expiryDate = new Date(metadata.expiryDate);
-        }
-        
-        if (metadata.source) {
-          source = metadata.source as 'static' | 'http01' | 'dns01';
-        }
-      }
-      
-      return {
-        domain,
-        certificate,
-        privateKey,
-        expiryDate,
-        source
-      };
-    } catch (error) {
-      console.error(`Error loading certificate for ${domain}:`, error);
-      return null;
-    }
-  }
-  
-  /**
-   * Delete a certificate from the file system
-   * @param domain Domain name
-   */
-  public async deleteCertificate(domain: string): Promise<boolean> {
-    const sanitizedDomain = this.sanitizeDomain(domain);
-    const certDir = path.join(this.storageDir, sanitizedDomain);
-    
-    if (!fs.existsSync(certDir)) {
-      return false;
-    }
-    
-    try {
-      // Recursively delete the certificate directory
-      await this.deleteDirectory(certDir);
-      return true;
-    } catch (error) {
-      console.error(`Error deleting certificate for ${domain}:`, error);
-      return false;
-    }
-  }
-  
-  /**
-   * List all domains with stored certificates
-   * @returns Array of domain names
-   */
-  public async listCertificates(): Promise<string[]> {
-    try {
-      const entries = await fs.promises.readdir(this.storageDir, { withFileTypes: true });
-      return entries
-        .filter(entry => entry.isDirectory())
-        .map(entry => entry.name);
-    } catch (error) {
-      console.error('Error listing certificates:', error);
-      return [];
-    }
-  }
-  
-  /**
-   * Check if a certificate is expiring soon
-   * @param domain Domain name
-   * @param thresholdDays Days threshold to consider expiring
-   * @returns Information about expiring certificate or null
-   */
-  public async isExpiringSoon(
-    domain: string, 
-    thresholdDays: number = 30
-  ): Promise<{ domain: string; expiryDate: Date; daysRemaining: number } | null> {
-    const certData = await this.loadCertificate(domain);
-    
-    if (!certData) {
-      return null;
-    }
-    
-    const now = new Date();
-    const expiryDate = certData.expiryDate;
-    const timeRemaining = expiryDate.getTime() - now.getTime();
-    const daysRemaining = Math.floor(timeRemaining / (1000 * 60 * 60 * 24));
-    
-    if (daysRemaining <= thresholdDays) {
-      return {
-        domain,
-        expiryDate,
-        daysRemaining
-      };
-    }
-    
-    return null;
-  }
-  
-  /**
-   * Check all certificates for expiration
-   * @param thresholdDays Days threshold to consider expiring
-   * @returns List of expiring certificates
-   */
-  public async getExpiringCertificates(
-    thresholdDays: number = 30
-  ): Promise<Array<{ domain: string; expiryDate: Date; daysRemaining: number }>> {
-    const domains = await this.listCertificates();
-    const expiringCerts = [];
-    
-    for (const domain of domains) {
-      const expiring = await this.isExpiringSoon(domain, thresholdDays);
-      if (expiring) {
-        expiringCerts.push(expiring);
-      }
-    }
-    
-    return expiringCerts;
-  }
-  
-  /**
-   * Delete a directory recursively
-   * @param directoryPath Directory to delete
-   */
-  private async deleteDirectory(directoryPath: string): Promise<void> {
-    if (fs.existsSync(directoryPath)) {
-      const entries = await fs.promises.readdir(directoryPath, { withFileTypes: true });
-      
-      for (const entry of entries) {
-        const fullPath = path.join(directoryPath, entry.name);
-        
-        if (entry.isDirectory()) {
-          await this.deleteDirectory(fullPath);
-        } else {
-          await fs.promises.unlink(fullPath);
-        }
-      }
-      
-      await fs.promises.rmdir(directoryPath);
-    }
-  }
-  
-  /**
-   * Sanitize a domain name for use as a directory name
-   * @param domain Domain name
-   * @returns Sanitized domain name
-   */
-  private sanitizeDomain(domain: string): string {
-    // Replace wildcard and any invalid filesystem characters
-    return domain.replace(/\*/g, '_wildcard_').replace(/[/\\:*?"<>|]/g, '_');
-  }
-}

ts/certificate/storage/index.ts

@@ -1,3 +0,0 @@
-/**
- * Certificate storage mechanisms
- */

ts/certificate/utils/certificate-helpers.ts

@@ -1,50 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { fileURLToPath } from 'url';
-import type { ICertificates } from '../models/certificate-types.js';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-/**
- * Loads the default SSL certificates from the assets directory
- * @returns The certificate key pair
- */
-export function loadDefaultCertificates(): ICertificates {
-  try {
-    // Need to adjust path from /ts/certificate/utils to /assets/certs
-    const certPath = path.join(__dirname, '..', '..', '..', 'assets', 'certs');
-    const privateKey = fs.readFileSync(path.join(certPath, 'key.pem'), 'utf8');
-    const publicKey = fs.readFileSync(path.join(certPath, 'cert.pem'), 'utf8');
-
-    if (!privateKey || !publicKey) {
-      throw new Error('Failed to load default certificates');
-    }
-
-    return {
-      privateKey,
-      publicKey
-    };
-  } catch (error) {
-    console.error('Error loading default certificates:', error);
-    throw error;
-  }
-}
-
-/**
- * Checks if a certificate file exists at the specified path
- * @param certPath Path to check for certificate
- * @returns True if the certificate exists, false otherwise
- */
-export function certificateExists(certPath: string): boolean {
-  return fs.existsSync(certPath);
-}
-
-/**
- * Ensures the certificate directory exists
- * @param dirPath Path to the certificate directory
- */
-export function ensureCertificateDirectory(dirPath: string): void {
-  if (!fs.existsSync(dirPath)) {
-    fs.mkdirSync(dirPath, { recursive: true });
-  }
-}

ts/common/eventUtils.ts

@@ -1,34 +0,0 @@
-import type { Port80Handler } from '../http/port80/port80-handler.js';
-import { Port80HandlerEvents } from './types.js';
-import type { ICertificateData, ICertificateFailure, ICertificateExpiring } from './types.js';
-
-/**
- * Subscribers callback definitions for Port80Handler events
- */
-export interface Port80HandlerSubscribers {
-  onCertificateIssued?: (data: ICertificateData) => void;
-  onCertificateRenewed?: (data: ICertificateData) => void;
-  onCertificateFailed?: (data: ICertificateFailure) => void;
-  onCertificateExpiring?: (data: ICertificateExpiring) => void;
-}
-
-/**
- * Subscribes to Port80Handler events based on provided callbacks
- */
-export function subscribeToPort80Handler(
-  handler: Port80Handler,
-  subscribers: Port80HandlerSubscribers
-): void {
-  if (subscribers.onCertificateIssued) {
-    handler.on(Port80HandlerEvents.CERTIFICATE_ISSUED, subscribers.onCertificateIssued);
-  }
-  if (subscribers.onCertificateRenewed) {
-    handler.on(Port80HandlerEvents.CERTIFICATE_RENEWED, subscribers.onCertificateRenewed);
-  }
-  if (subscribers.onCertificateFailed) {
-    handler.on(Port80HandlerEvents.CERTIFICATE_FAILED, subscribers.onCertificateFailed);
-  }
-  if (subscribers.onCertificateExpiring) {
-    handler.on(Port80HandlerEvents.CERTIFICATE_EXPIRING, subscribers.onCertificateExpiring);
-  }
-}

ts/common/port80-adapter.ts

@@ -1,111 +0,0 @@
-import * as plugins from '../plugins.js';
-
-import type {
-  IForwardConfig as ILegacyForwardConfig,
-  IDomainOptions
-} from './types.js';
-
-import type {
-  IForwardConfig
-} from '../forwarding/config/forwarding-types.js';
-
-/**
- * Converts a forwarding configuration target to the legacy format
- * for Port80Handler
- */
-export function convertToLegacyForwardConfig(
-  forwardConfig: IForwardConfig
-): ILegacyForwardConfig {
-  // Determine host from the target configuration
-  const host = Array.isArray(forwardConfig.target.host)
-    ? forwardConfig.target.host[0]  // Use the first host in the array
-    : forwardConfig.target.host;
-
-  // Extract port number, handling different port formats
-  let port: number;
-  if (typeof forwardConfig.target.port === 'function') {
-    // Use a default port for function-based ports in adapter context
-    port = 80;
-  } else if (forwardConfig.target.port === 'preserve') {
-    // For 'preserve', use the default port 80 in this adapter context
-    port = 80;
-  } else {
-    port = forwardConfig.target.port;
-  }
-
-  return {
-    ip: host,
-    port: port
-  };
-}
-
-/**
- * Creates Port80Handler domain options from a domain name and forwarding config
- */
-export function createPort80HandlerOptions(
-  domain: string,
-  forwardConfig: IForwardConfig
-): IDomainOptions {
-  // Determine if we should redirect HTTP to HTTPS
-  let sslRedirect = false;
-  if (forwardConfig.http?.redirectToHttps) {
-    sslRedirect = true;
-  }
-  
-  // Determine if ACME maintenance should be enabled
-  // Enable by default for termination types, unless explicitly disabled
-  const requiresTls = 
-    forwardConfig.type === 'https-terminate-to-http' || 
-    forwardConfig.type === 'https-terminate-to-https';
-  
-  const acmeMaintenance = 
-    requiresTls && 
-    forwardConfig.acme?.enabled !== false;
-  
-  // Set up forwarding configuration
-  const options: IDomainOptions = {
-    domainName: domain,
-    sslRedirect,
-    acmeMaintenance
-  };
-  
-  // Add ACME challenge forwarding if configured
-  if (forwardConfig.acme?.forwardChallenges) {
-    options.acmeForward = {
-      ip: Array.isArray(forwardConfig.acme.forwardChallenges.host) 
-        ? forwardConfig.acme.forwardChallenges.host[0]
-        : forwardConfig.acme.forwardChallenges.host,
-      port: forwardConfig.acme.forwardChallenges.port
-    };
-  }
-  
-  // Add HTTP forwarding if this is an HTTP-only config or if HTTP is enabled
-  const supportsHttp = 
-    forwardConfig.type === 'http-only' || 
-    (forwardConfig.http?.enabled !== false &&
-     (forwardConfig.type === 'https-terminate-to-http' || 
-      forwardConfig.type === 'https-terminate-to-https'));
-  
-  if (supportsHttp) {
-    // Determine port value handling different formats
-    let port: number;
-    if (typeof forwardConfig.target.port === 'function') {
-      // Use a default port for function-based ports
-      port = 80;
-    } else if (forwardConfig.target.port === 'preserve') {
-      // For 'preserve', use 80 in this adapter context
-      port = 80;
-    } else {
-      port = forwardConfig.target.port;
-    }
-
-    options.forward = {
-      ip: Array.isArray(forwardConfig.target.host) 
-        ? forwardConfig.target.host[0]
-        : forwardConfig.target.host,
-      port: port
-    };
-  }
-  
-  return options;
-}

ts/common/types.ts

@@ -1,91 +0,0 @@
-import * as plugins from '../plugins.js';
-
-/**
- * Shared types for certificate management and domain options
- */
-
-/**
- * Domain forwarding configuration
- */
-export interface IForwardConfig {
-  ip: string;
-  port: number;
-}
-
-/**
- * Domain configuration options
- */
-export interface IDomainOptions {
-  domainName: string;
-  sslRedirect: boolean;   // if true redirects the request to port 443
-  acmeMaintenance: boolean; // tries to always have a valid cert for this domain
-  forward?: IForwardConfig; // forwards all http requests to that target
-  acmeForward?: IForwardConfig; // forwards letsencrypt requests to this config
-}
-
-/**
- * Certificate data that can be emitted via events or set from outside
- */
-export interface ICertificateData {
-  domain: string;
-  certificate: string;
-  privateKey: string;
-  expiryDate: Date;
-}
-
-/**
- * Events emitted by the Port80Handler
- */
-export enum Port80HandlerEvents {
-  CERTIFICATE_ISSUED = 'certificate-issued',
-  CERTIFICATE_RENEWED = 'certificate-renewed',
-  CERTIFICATE_FAILED = 'certificate-failed',
-  CERTIFICATE_EXPIRING = 'certificate-expiring',
-  MANAGER_STARTED = 'manager-started',
-  MANAGER_STOPPED = 'manager-stopped',
-  REQUEST_FORWARDED = 'request-forwarded',
-}
-
-/**
- * Certificate failure payload type
- */
-export interface ICertificateFailure {
-  domain: string;
-  error: string;
-  isRenewal: boolean;
-}
-
-/**
- * Certificate expiry payload type
- */
-export interface ICertificateExpiring {
-  domain: string;
-  expiryDate: Date;
-  daysRemaining: number;
-}
-/**
- * Forwarding configuration for specific domains in ACME setup
- */
-export interface IDomainForwardConfig {
-  domain: string;
-  forwardConfig?: IForwardConfig;
-  acmeForwardConfig?: IForwardConfig;
-  sslRedirect?: boolean;
-}
-
-/**
- * Unified ACME configuration options used across proxies and handlers
- */
-export interface IAcmeOptions {
-  accountEmail?: string;          // Email for Let's Encrypt account
-  enabled?: boolean;              // Whether ACME is enabled
-  port?: number;                  // Port to listen on for ACME challenges (default: 80)
-  useProduction?: boolean;        // Use production environment (default: staging)
-  httpsRedirectPort?: number;     // Port to redirect HTTP requests to HTTPS (default: 443)
-  renewThresholdDays?: number;    // Days before expiry to renew certificates
-  renewCheckIntervalHours?: number; // How often to check for renewals (in hours)
-  autoRenew?: boolean;            // Whether to automatically renew certificates
-  certificateStore?: string;      // Directory to store certificates
-  skipConfiguredCerts?: boolean;  // Skip domains with existing certificates
-  domainForwards?: IDomainForwardConfig[]; // Domain-specific forwarding configs
-}

ts/core/models/common-types.ts

@@ -34,7 +34,7 @@ export interface ICertificateData {
 }
 
 /**
- * Events emitted by the Port80Handler
+ * @deprecated Events emitted by the Port80Handler - use SmartCertManager instead
  */
 export enum Port80HandlerEvents {
   CERTIFICATE_ISSUED = 'certificate-issued',

ts/core/utils/async-utils.ts

@@ -0,0 +1,275 @@
+/**
+ * Async utility functions for SmartProxy
+ * Provides non-blocking alternatives to synchronous operations
+ */
+
+/**
+ * Delays execution for the specified number of milliseconds
+ * Non-blocking alternative to busy wait loops
+ * @param ms - Number of milliseconds to delay
+ * @returns Promise that resolves after the delay
+ */
+export async function delay(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Retry an async operation with exponential backoff
+ * @param fn - The async function to retry
+ * @param options - Retry options
+ * @returns The result of the function or throws the last error
+ */
+export async function retryWithBackoff<T>(
+  fn: () => Promise<T>,
+  options: {
+    maxAttempts?: number;
+    initialDelay?: number;
+    maxDelay?: number;
+    factor?: number;
+    onRetry?: (attempt: number, error: Error) => void;
+  } = {}
+): Promise<T> {
+  const {
+    maxAttempts = 3,
+    initialDelay = 100,
+    maxDelay = 10000,
+    factor = 2,
+    onRetry
+  } = options;
+
+  let lastError: Error | null = null;
+  let currentDelay = initialDelay;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error: any) {
+      lastError = error;
+      
+      if (attempt === maxAttempts) {
+        throw error;
+      }
+
+      if (onRetry) {
+        onRetry(attempt, error);
+      }
+
+      await delay(currentDelay);
+      currentDelay = Math.min(currentDelay * factor, maxDelay);
+    }
+  }
+
+  throw lastError || new Error('Retry failed');
+}
+
+/**
+ * Execute an async operation with a timeout
+ * @param fn - The async function to execute
+ * @param timeoutMs - Timeout in milliseconds
+ * @param timeoutError - Optional custom timeout error
+ * @returns The result of the function or throws timeout error
+ */
+export async function withTimeout<T>(
+  fn: () => Promise<T>,
+  timeoutMs: number,
+  timeoutError?: Error
+): Promise<T> {
+  const timeoutPromise = new Promise<never>((_, reject) => {
+    setTimeout(() => {
+      reject(timeoutError || new Error(`Operation timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+  });
+
+  return Promise.race([fn(), timeoutPromise]);
+}
+
+/**
+ * Run multiple async operations in parallel with a concurrency limit
+ * @param items - Array of items to process
+ * @param fn - Async function to run for each item
+ * @param concurrency - Maximum number of concurrent operations
+ * @returns Array of results in the same order as input
+ */
+export async function parallelLimit<T, R>(
+  items: T[],
+  fn: (item: T, index: number) => Promise<R>,
+  concurrency: number
+): Promise<R[]> {
+  const results: R[] = new Array(items.length);
+  const executing: Set<Promise<void>> = new Set();
+  
+  for (let i = 0; i < items.length; i++) {
+    const promise = fn(items[i], i).then(result => {
+      results[i] = result;
+      executing.delete(promise);
+    });
+    
+    executing.add(promise);
+    
+    if (executing.size >= concurrency) {
+      await Promise.race(executing);
+    }
+  }
+  
+  await Promise.all(executing);
+  return results;
+}
+
+/**
+ * Debounce an async function
+ * @param fn - The async function to debounce
+ * @param delayMs - Delay in milliseconds
+ * @returns Debounced function with cancel method
+ */
+export function debounceAsync<T extends (...args: any[]) => Promise<any>>(
+  fn: T,
+  delayMs: number
+): T & { cancel: () => void } {
+  let timeoutId: NodeJS.Timeout | null = null;
+  let lastPromise: Promise<any> | null = null;
+
+  const debounced = ((...args: Parameters<T>) => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+
+    lastPromise = new Promise((resolve, reject) => {
+      timeoutId = setTimeout(async () => {
+        timeoutId = null;
+        try {
+          const result = await fn(...args);
+          resolve(result);
+        } catch (error) {
+          reject(error);
+        }
+      }, delayMs);
+    });
+
+    return lastPromise;
+  }) as any;
+
+  debounced.cancel = () => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+
+  return debounced as T & { cancel: () => void };
+}
+
+/**
+ * Create a mutex for ensuring exclusive access to a resource
+ */
+export class AsyncMutex {
+  private queue: Array<() => void> = [];
+  private locked = false;
+
+  async acquire(): Promise<() => void> {
+    if (!this.locked) {
+      this.locked = true;
+      return () => this.release();
+    }
+
+    return new Promise<() => void>(resolve => {
+      this.queue.push(() => {
+        resolve(() => this.release());
+      });
+    });
+  }
+
+  private release(): void {
+    const next = this.queue.shift();
+    if (next) {
+      next();
+    } else {
+      this.locked = false;
+    }
+  }
+
+  async runExclusive<T>(fn: () => Promise<T>): Promise<T> {
+    const release = await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      release();
+    }
+  }
+}
+
+/**
+ * Circuit breaker for protecting against cascading failures
+ */
+export class CircuitBreaker {
+  private failureCount = 0;
+  private lastFailureTime = 0;
+  private state: 'closed' | 'open' | 'half-open' = 'closed';
+
+  constructor(
+    private options: {
+      failureThreshold: number;
+      resetTimeout: number;
+      onStateChange?: (state: 'closed' | 'open' | 'half-open') => void;
+    }
+  ) {}
+
+  async execute<T>(fn: () => Promise<T>): Promise<T> {
+    if (this.state === 'open') {
+      if (Date.now() - this.lastFailureTime > this.options.resetTimeout) {
+        this.setState('half-open');
+      } else {
+        throw new Error('Circuit breaker is open');
+      }
+    }
+
+    try {
+      const result = await fn();
+      this.onSuccess();
+      return result;
+    } catch (error) {
+      this.onFailure();
+      throw error;
+    }
+  }
+
+  private onSuccess(): void {
+    this.failureCount = 0;
+    if (this.state !== 'closed') {
+      this.setState('closed');
+    }
+  }
+
+  private onFailure(): void {
+    this.failureCount++;
+    this.lastFailureTime = Date.now();
+    
+    if (this.failureCount >= this.options.failureThreshold) {
+      this.setState('open');
+    }
+  }
+
+  private setState(state: 'closed' | 'open' | 'half-open'): void {
+    if (this.state !== state) {
+      this.state = state;
+      if (this.options.onStateChange) {
+        this.options.onStateChange(state);
+      }
+    }
+  }
+
+  isOpen(): boolean {
+    return this.state === 'open';
+  }
+
+  getState(): 'closed' | 'open' | 'half-open' {
+    return this.state;
+  }
+
+  recordSuccess(): void {
+    this.onSuccess();
+  }
+
+  recordFailure(): void {
+    this.onFailure();
+  }
+}

ts/core/utils/binary-heap.ts

@@ -0,0 +1,225 @@
+/**
+ * A binary heap implementation for efficient priority queue operations
+ * Supports O(log n) insert and extract operations
+ */
+export class BinaryHeap<T> {
+  private heap: T[] = [];
+  private keyMap?: Map<string, number>; // For efficient key-based lookups
+
+  constructor(
+    private compareFn: (a: T, b: T) => number,
+    private extractKey?: (item: T) => string
+  ) {
+    if (extractKey) {
+      this.keyMap = new Map();
+    }
+  }
+
+  /**
+   * Get the current size of the heap
+   */
+  public get size(): number {
+    return this.heap.length;
+  }
+
+  /**
+   * Check if the heap is empty
+   */
+  public isEmpty(): boolean {
+    return this.heap.length === 0;
+  }
+
+  /**
+   * Peek at the top element without removing it
+   */
+  public peek(): T | undefined {
+    return this.heap[0];
+  }
+
+  /**
+   * Insert a new item into the heap
+   * O(log n) time complexity
+   */
+  public insert(item: T): void {
+    const index = this.heap.length;
+    this.heap.push(item);
+    
+    if (this.keyMap && this.extractKey) {
+      const key = this.extractKey(item);
+      this.keyMap.set(key, index);
+    }
+    
+    this.bubbleUp(index);
+  }
+
+  /**
+   * Extract the top element from the heap
+   * O(log n) time complexity
+   */
+  public extract(): T | undefined {
+    if (this.heap.length === 0) return undefined;
+    if (this.heap.length === 1) {
+      const item = this.heap.pop()!;
+      if (this.keyMap && this.extractKey) {
+        this.keyMap.delete(this.extractKey(item));
+      }
+      return item;
+    }
+    
+    const result = this.heap[0];
+    const lastItem = this.heap.pop()!;
+    this.heap[0] = lastItem;
+    
+    if (this.keyMap && this.extractKey) {
+      this.keyMap.delete(this.extractKey(result));
+      this.keyMap.set(this.extractKey(lastItem), 0);
+    }
+    
+    this.bubbleDown(0);
+    return result;
+  }
+
+  /**
+   * Extract an element that matches the predicate
+   * O(n) time complexity for search, O(log n) for extraction
+   */
+  public extractIf(predicate: (item: T) => boolean): T | undefined {
+    const index = this.heap.findIndex(predicate);
+    if (index === -1) return undefined;
+    
+    return this.extractAt(index);
+  }
+
+  /**
+   * Extract an element by its key (if extractKey was provided)
+   * O(log n) time complexity
+   */
+  public extractByKey(key: string): T | undefined {
+    if (!this.keyMap || !this.extractKey) {
+      throw new Error('extractKey function must be provided to use key-based extraction');
+    }
+    
+    const index = this.keyMap.get(key);
+    if (index === undefined) return undefined;
+    
+    return this.extractAt(index);
+  }
+
+  /**
+   * Check if a key exists in the heap
+   * O(1) time complexity
+   */
+  public hasKey(key: string): boolean {
+    if (!this.keyMap) return false;
+    return this.keyMap.has(key);
+  }
+
+  /**
+   * Get all elements as an array (does not modify heap)
+   * O(n) time complexity
+   */
+  public toArray(): T[] {
+    return [...this.heap];
+  }
+
+  /**
+   * Clear the heap
+   */
+  public clear(): void {
+    this.heap = [];
+    if (this.keyMap) {
+      this.keyMap.clear();
+    }
+  }
+
+  /**
+   * Extract element at specific index
+   */
+  private extractAt(index: number): T {
+    const item = this.heap[index];
+    
+    if (this.keyMap && this.extractKey) {
+      this.keyMap.delete(this.extractKey(item));
+    }
+    
+    if (index === this.heap.length - 1) {
+      this.heap.pop();
+      return item;
+    }
+    
+    const lastItem = this.heap.pop()!;
+    this.heap[index] = lastItem;
+    
+    if (this.keyMap && this.extractKey) {
+      this.keyMap.set(this.extractKey(lastItem), index);
+    }
+    
+    // Try bubbling up first
+    const parentIndex = Math.floor((index - 1) / 2);
+    if (parentIndex >= 0 && this.compareFn(this.heap[index], this.heap[parentIndex]) < 0) {
+      this.bubbleUp(index);
+    } else {
+      this.bubbleDown(index);
+    }
+    
+    return item;
+  }
+
+  /**
+   * Bubble up element at given index to maintain heap property
+   */
+  private bubbleUp(index: number): void {
+    while (index > 0) {
+      const parentIndex = Math.floor((index - 1) / 2);
+      
+      if (this.compareFn(this.heap[index], this.heap[parentIndex]) >= 0) {
+        break;
+      }
+      
+      this.swap(index, parentIndex);
+      index = parentIndex;
+    }
+  }
+
+  /**
+   * Bubble down element at given index to maintain heap property
+   */
+  private bubbleDown(index: number): void {
+    const length = this.heap.length;
+    
+    while (true) {
+      const leftChild = 2 * index + 1;
+      const rightChild = 2 * index + 2;
+      let smallest = index;
+      
+      if (leftChild < length && 
+          this.compareFn(this.heap[leftChild], this.heap[smallest]) < 0) {
+        smallest = leftChild;
+      }
+      
+      if (rightChild < length && 
+          this.compareFn(this.heap[rightChild], this.heap[smallest]) < 0) {
+        smallest = rightChild;
+      }
+      
+      if (smallest === index) break;
+      
+      this.swap(index, smallest);
+      index = smallest;
+    }
+  }
+
+  /**
+   * Swap two elements in the heap
+   */
+  private swap(i: number, j: number): void {
+    const temp = this.heap[i];
+    this.heap[i] = this.heap[j];
+    this.heap[j] = temp;
+    
+    if (this.keyMap && this.extractKey) {
+      this.keyMap.set(this.extractKey(this.heap[i]), i);
+      this.keyMap.set(this.extractKey(this.heap[j]), j);
+    }
+  }
+}

ts/core/utils/enhanced-connection-pool.ts

@@ -0,0 +1,425 @@
+import { LifecycleComponent } from './lifecycle-component.js';
+import { BinaryHeap } from './binary-heap.js';
+import { AsyncMutex } from './async-utils.js';
+import { EventEmitter } from 'events';
+
+/**
+ * Interface for pooled connection
+ */
+export interface IPooledConnection<T> {
+  id: string;
+  connection: T;
+  createdAt: number;
+  lastUsedAt: number;
+  useCount: number;
+  inUse: boolean;
+  metadata?: any;
+}
+
+/**
+ * Configuration options for the connection pool
+ */
+export interface IConnectionPoolOptions<T> {
+  minSize?: number;
+  maxSize?: number;
+  acquireTimeout?: number;
+  idleTimeout?: number;
+  maxUseCount?: number;
+  validateOnAcquire?: boolean;
+  validateOnReturn?: boolean;
+  queueTimeout?: number;
+  connectionFactory: () => Promise<T>;
+  connectionValidator?: (connection: T) => Promise<boolean>;
+  connectionDestroyer?: (connection: T) => Promise<void>;
+  onConnectionError?: (error: Error, connection?: T) => void;
+}
+
+/**
+ * Interface for queued acquire request
+ */
+interface IAcquireRequest<T> {
+  id: string;
+  priority: number;
+  timestamp: number;
+  resolve: (connection: IPooledConnection<T>) => void;
+  reject: (error: Error) => void;
+  timeoutHandle?: NodeJS.Timeout;
+}
+
+/**
+ * Enhanced connection pool with priority queue, backpressure, and lifecycle management
+ */
+export class EnhancedConnectionPool<T> extends LifecycleComponent {
+  private readonly options: Required<Omit<IConnectionPoolOptions<T>, 'connectionValidator' | 'connectionDestroyer' | 'onConnectionError'>> & Pick<IConnectionPoolOptions<T>, 'connectionValidator' | 'connectionDestroyer' | 'onConnectionError'>;
+  private readonly availableConnections: IPooledConnection<T>[] = [];
+  private readonly activeConnections: Map<string, IPooledConnection<T>> = new Map();
+  private readonly waitQueue: BinaryHeap<IAcquireRequest<T>>;
+  private readonly mutex = new AsyncMutex();
+  private readonly eventEmitter = new EventEmitter();
+  
+  private connectionIdCounter = 0;
+  private requestIdCounter = 0;
+  private isClosing = false;
+  
+  // Metrics
+  private metrics = {
+    connectionsCreated: 0,
+    connectionsDestroyed: 0,
+    connectionsAcquired: 0,
+    connectionsReleased: 0,
+    acquireTimeouts: 0,
+    validationFailures: 0,
+    queueHighWaterMark: 0,
+  };
+
+  constructor(options: IConnectionPoolOptions<T>) {
+    super();
+    
+    this.options = {
+      minSize: 0,
+      maxSize: 10,
+      acquireTimeout: 30000,
+      idleTimeout: 300000, // 5 minutes
+      maxUseCount: Infinity,
+      validateOnAcquire: true,
+      validateOnReturn: false,
+      queueTimeout: 60000,
+      ...options,
+    };
+    
+    // Initialize priority queue (higher priority = extracted first)
+    this.waitQueue = new BinaryHeap<IAcquireRequest<T>>(
+      (a, b) => b.priority - a.priority || a.timestamp - b.timestamp,
+      (item) => item.id
+    );
+    
+    // Start maintenance cycle
+    this.startMaintenance();
+    
+    // Initialize minimum connections
+    this.initializeMinConnections();
+  }
+
+  /**
+   * Initialize minimum number of connections
+   */
+  private async initializeMinConnections(): Promise<void> {
+    const promises: Promise<void>[] = [];
+    
+    for (let i = 0; i < this.options.minSize; i++) {
+      promises.push(
+        this.createConnection()
+          .then(conn => {
+            this.availableConnections.push(conn);
+          })
+          .catch(err => {
+            if (this.options.onConnectionError) {
+              this.options.onConnectionError(err);
+            }
+          })
+      );
+    }
+    
+    await Promise.all(promises);
+  }
+
+  /**
+   * Start maintenance timer for idle connection cleanup
+   */
+  private startMaintenance(): void {
+    this.setInterval(() => {
+      this.performMaintenance();
+    }, 30000); // Every 30 seconds
+  }
+
+  /**
+   * Perform maintenance tasks
+   */
+  private async performMaintenance(): Promise<void> {
+    await this.mutex.runExclusive(async () => {
+      const now = Date.now();
+      const toRemove: IPooledConnection<T>[] = [];
+      
+      // Check for idle connections beyond minimum size
+      for (let i = this.availableConnections.length - 1; i >= 0; i--) {
+        const conn = this.availableConnections[i];
+        
+        // Keep minimum connections
+        if (this.availableConnections.length <= this.options.minSize) {
+          break;
+        }
+        
+        // Remove idle connections
+        if (now - conn.lastUsedAt > this.options.idleTimeout) {
+          toRemove.push(conn);
+          this.availableConnections.splice(i, 1);
+        }
+      }
+      
+      // Destroy idle connections
+      for (const conn of toRemove) {
+        await this.destroyConnection(conn);
+      }
+    });
+  }
+
+  /**
+   * Acquire a connection from the pool
+   */
+  public async acquire(priority: number = 0, timeout?: number): Promise<IPooledConnection<T>> {
+    if (this.isClosing) {
+      throw new Error('Connection pool is closing');
+    }
+    
+    return this.mutex.runExclusive(async () => {
+      // Try to get an available connection
+      const connection = await this.tryAcquireConnection();
+      if (connection) {
+        return connection;
+      }
+      
+      // Check if we can create a new connection
+      const totalConnections = this.availableConnections.length + this.activeConnections.size;
+      if (totalConnections < this.options.maxSize) {
+        try {
+          const newConnection = await this.createConnection();
+          return this.checkoutConnection(newConnection);
+        } catch (err) {
+          // Fall through to queue if creation fails
+        }
+      }
+      
+      // Add to wait queue
+      return this.queueAcquireRequest(priority, timeout);
+    });
+  }
+
+  /**
+   * Try to acquire an available connection
+   */
+  private async tryAcquireConnection(): Promise<IPooledConnection<T> | null> {
+    while (this.availableConnections.length > 0) {
+      const connection = this.availableConnections.shift()!;
+      
+      // Check if connection exceeded max use count
+      if (connection.useCount >= this.options.maxUseCount) {
+        await this.destroyConnection(connection);
+        continue;
+      }
+      
+      // Validate connection if required
+      if (this.options.validateOnAcquire && this.options.connectionValidator) {
+        try {
+          const isValid = await this.options.connectionValidator(connection.connection);
+          if (!isValid) {
+            this.metrics.validationFailures++;
+            await this.destroyConnection(connection);
+            continue;
+          }
+        } catch (err) {
+          this.metrics.validationFailures++;
+          await this.destroyConnection(connection);
+          continue;
+        }
+      }
+      
+      return this.checkoutConnection(connection);
+    }
+    
+    return null;
+  }
+
+  /**
+   * Checkout a connection for use
+   */
+  private checkoutConnection(connection: IPooledConnection<T>): IPooledConnection<T> {
+    connection.inUse = true;
+    connection.lastUsedAt = Date.now();
+    connection.useCount++;
+    
+    this.activeConnections.set(connection.id, connection);
+    this.metrics.connectionsAcquired++;
+    
+    this.eventEmitter.emit('acquire', connection);
+    return connection;
+  }
+
+  /**
+   * Queue an acquire request
+   */
+  private queueAcquireRequest(priority: number, timeout?: number): Promise<IPooledConnection<T>> {
+    return new Promise<IPooledConnection<T>>((resolve, reject) => {
+      const request: IAcquireRequest<T> = {
+        id: `req-${this.requestIdCounter++}`,
+        priority,
+        timestamp: Date.now(),
+        resolve,
+        reject,
+      };
+      
+      // Set timeout
+      const timeoutMs = timeout || this.options.queueTimeout;
+      request.timeoutHandle = this.setTimeout(() => {
+        if (this.waitQueue.extractByKey(request.id)) {
+          this.metrics.acquireTimeouts++;
+          reject(new Error(`Connection acquire timeout after ${timeoutMs}ms`));
+        }
+      }, timeoutMs);
+      
+      this.waitQueue.insert(request);
+      this.metrics.queueHighWaterMark = Math.max(
+        this.metrics.queueHighWaterMark, 
+        this.waitQueue.size
+      );
+      
+      this.eventEmitter.emit('enqueue', { queueSize: this.waitQueue.size });
+    });
+  }
+
+  /**
+   * Release a connection back to the pool
+   */
+  public async release(connection: IPooledConnection<T>): Promise<void> {
+    return this.mutex.runExclusive(async () => {
+      if (!connection.inUse || !this.activeConnections.has(connection.id)) {
+        throw new Error('Connection is not active');
+      }
+      
+      this.activeConnections.delete(connection.id);
+      connection.inUse = false;
+      connection.lastUsedAt = Date.now();
+      this.metrics.connectionsReleased++;
+      
+      // Check if connection should be destroyed
+      if (connection.useCount >= this.options.maxUseCount) {
+        await this.destroyConnection(connection);
+        return;
+      }
+      
+      // Validate on return if required
+      if (this.options.validateOnReturn && this.options.connectionValidator) {
+        try {
+          const isValid = await this.options.connectionValidator(connection.connection);
+          if (!isValid) {
+            await this.destroyConnection(connection);
+            return;
+          }
+        } catch (err) {
+          await this.destroyConnection(connection);
+          return;
+        }
+      }
+      
+      // Check if there are waiting requests
+      const request = this.waitQueue.extract();
+      if (request) {
+        this.clearTimeout(request.timeoutHandle!);
+        request.resolve(this.checkoutConnection(connection));
+        this.eventEmitter.emit('dequeue', { queueSize: this.waitQueue.size });
+      } else {
+        // Return to available pool
+        this.availableConnections.push(connection);
+        this.eventEmitter.emit('release', connection);
+      }
+    });
+  }
+
+  /**
+   * Create a new connection
+   */
+  private async createConnection(): Promise<IPooledConnection<T>> {
+    const rawConnection = await this.options.connectionFactory();
+    
+    const connection: IPooledConnection<T> = {
+      id: `conn-${this.connectionIdCounter++}`,
+      connection: rawConnection,
+      createdAt: Date.now(),
+      lastUsedAt: Date.now(),
+      useCount: 0,
+      inUse: false,
+    };
+    
+    this.metrics.connectionsCreated++;
+    this.eventEmitter.emit('create', connection);
+    
+    return connection;
+  }
+
+  /**
+   * Destroy a connection
+   */
+  private async destroyConnection(connection: IPooledConnection<T>): Promise<void> {
+    try {
+      if (this.options.connectionDestroyer) {
+        await this.options.connectionDestroyer(connection.connection);
+      }
+      
+      this.metrics.connectionsDestroyed++;
+      this.eventEmitter.emit('destroy', connection);
+    } catch (err) {
+      if (this.options.onConnectionError) {
+        this.options.onConnectionError(err as Error, connection.connection);
+      }
+    }
+  }
+
+  /**
+   * Get current pool statistics
+   */
+  public getStats() {
+    return {
+      available: this.availableConnections.length,
+      active: this.activeConnections.size,
+      waiting: this.waitQueue.size,
+      total: this.availableConnections.length + this.activeConnections.size,
+      ...this.metrics,
+    };
+  }
+
+  /**
+   * Subscribe to pool events
+   */
+  public on(event: string, listener: Function): void {
+    this.addEventListener(this.eventEmitter, event, listener);
+  }
+
+  /**
+   * Close the pool and cleanup resources
+   */
+  protected async onCleanup(): Promise<void> {
+    this.isClosing = true;
+    
+    // Clear the wait queue
+    while (!this.waitQueue.isEmpty()) {
+      const request = this.waitQueue.extract();
+      if (request) {
+        this.clearTimeout(request.timeoutHandle!);
+        request.reject(new Error('Connection pool is closing'));
+      }
+    }
+    
+    // Wait for active connections to be released (with timeout)
+    const timeout = 30000;
+    const startTime = Date.now();
+    
+    while (this.activeConnections.size > 0 && Date.now() - startTime < timeout) {
+      await new Promise(resolve => {
+        const timer = setTimeout(resolve, 100);
+        if (typeof timer.unref === 'function') {
+          timer.unref();
+        }
+      });
+    }
+    
+    // Destroy all connections
+    const allConnections = [
+      ...this.availableConnections,
+      ...this.activeConnections.values(),
+    ];
+    
+    await Promise.all(allConnections.map(conn => this.destroyConnection(conn)));
+    
+    this.availableConnections.length = 0;
+    this.activeConnections.clear();
+  }
+}

ts/core/utils/event-system.ts

@@ -1,376 +0,0 @@
-import * as plugins from '../../plugins.js';
-import type { 
-  ICertificateData, 
-  ICertificateFailure,
-  ICertificateExpiring
-} from '../models/common-types.js';
-import type { IRouteConfig } from '../../proxies/smart-proxy/models/route-types.js';
-import { Port80HandlerEvents } from '../models/common-types.js';
-
-/**
- * Standardized event names used throughout the system
- */
-export enum ProxyEvents {
-  // Certificate events
-  CERTIFICATE_ISSUED = 'certificate:issued',
-  CERTIFICATE_RENEWED = 'certificate:renewed',
-  CERTIFICATE_FAILED = 'certificate:failed',
-  CERTIFICATE_EXPIRING = 'certificate:expiring',
-  
-  // Component lifecycle events
-  COMPONENT_STARTED = 'component:started',
-  COMPONENT_STOPPED = 'component:stopped',
-  
-  // Connection events
-  CONNECTION_ESTABLISHED = 'connection:established',
-  CONNECTION_CLOSED = 'connection:closed',
-  CONNECTION_ERROR = 'connection:error',
-  
-  // Request events
-  REQUEST_RECEIVED = 'request:received',
-  REQUEST_COMPLETED = 'request:completed',
-  REQUEST_ERROR = 'request:error',
-  
-  // Route events
-  ROUTE_MATCHED = 'route:matched',
-  ROUTE_UPDATED = 'route:updated',
-  ROUTE_ERROR = 'route:error',
-  
-  // Security events
-  SECURITY_BLOCKED = 'security:blocked',
-  SECURITY_BREACH_ATTEMPT = 'security:breach-attempt',
-  
-  // TLS events
-  TLS_HANDSHAKE_STARTED = 'tls:handshake-started',
-  TLS_HANDSHAKE_COMPLETED = 'tls:handshake-completed',
-  TLS_HANDSHAKE_FAILED = 'tls:handshake-failed'
-}
-
-/**
- * Component types for event metadata
- */
-export enum ComponentType {
-  SMART_PROXY = 'smart-proxy',
-  NETWORK_PROXY = 'network-proxy',
-  NFTABLES_PROXY = 'nftables-proxy',
-  PORT80_HANDLER = 'port80-handler',
-  CERTIFICATE_MANAGER = 'certificate-manager',
-  ROUTE_MANAGER = 'route-manager',
-  CONNECTION_MANAGER = 'connection-manager',
-  TLS_MANAGER = 'tls-manager',
-  SECURITY_MANAGER = 'security-manager'
-}
-
-/**
- * Base event data interface
- */
-export interface IEventData {
-  timestamp: number;
-  componentType: ComponentType;
-  componentId?: string;
-}
-
-/**
- * Certificate event data
- */
-export interface ICertificateEventData extends IEventData, ICertificateData {
-  isRenewal?: boolean;
-  source?: string;
-}
-
-/**
- * Certificate failure event data
- */
-export interface ICertificateFailureEventData extends IEventData, ICertificateFailure {}
-
-/**
- * Certificate expiring event data
- */
-export interface ICertificateExpiringEventData extends IEventData, ICertificateExpiring {}
-
-/**
- * Component lifecycle event data 
- */
-export interface IComponentEventData extends IEventData {
-  name: string;
-  version?: string;
-}
-
-/**
- * Connection event data
- */
-export interface IConnectionEventData extends IEventData {
-  connectionId: string;
-  clientIp: string;
-  serverIp?: string;
-  port: number;
-  isTls?: boolean;
-  domain?: string;
-}
-
-/**
- * Request event data
- */
-export interface IRequestEventData extends IEventData {
-  connectionId: string;
-  requestId: string;
-  method?: string;
-  path?: string;
-  statusCode?: number;
-  duration?: number;
-  routeId?: string;
-  routeName?: string;
-}
-
-/**
- * Route event data 
- */
-export interface IRouteEventData extends IEventData {
-  route: IRouteConfig;
-  context?: any;
-}
-
-/**
- * Security event data
- */
-export interface ISecurityEventData extends IEventData {
-  clientIp: string;
-  reason: string;
-  routeId?: string;
-  routeName?: string;
-}
-
-/**
- * TLS event data
- */
-export interface ITlsEventData extends IEventData {
-  connectionId: string;
-  domain?: string;
-  clientIp: string;
-  tlsVersion?: string;
-  cipherSuite?: string;
-  sniHostname?: string;
-}
-
-/**
- * Logger interface for event system 
- */
-export interface IEventLogger {
-  info: (message: string, ...args: any[]) => void;
-  warn: (message: string, ...args: any[]) => void;
-  error: (message: string, ...args: any[]) => void;
-  debug?: (message: string, ...args: any[]) => void;
-}
-
-/**
- * Event handler type 
- */
-export type EventHandler<T> = (data: T) => void;
-
-/**
- * Helper class to standardize event emission and handling
- * across all system components
- */
-export class EventSystem {
-  private emitter: plugins.EventEmitter;
-  private componentType: ComponentType;
-  private componentId: string;
-  private logger?: IEventLogger;
-  
-  constructor(
-    componentType: ComponentType,
-    componentId: string = '',
-    logger?: IEventLogger
-  ) {
-    this.emitter = new plugins.EventEmitter();
-    this.componentType = componentType;
-    this.componentId = componentId;
-    this.logger = logger;
-  }
-  
-  /**
-   * Emit a certificate issued event
-   */
-  public emitCertificateIssued(data: Omit<ICertificateEventData, 'timestamp' | 'componentType' | 'componentId'>): void {
-    const eventData: ICertificateEventData = {
-      ...data,
-      timestamp: Date.now(),
-      componentType: this.componentType,
-      componentId: this.componentId
-    };
-    
-    this.logger?.info?.(`Certificate issued for ${data.domain}`);
-    this.emitter.emit(ProxyEvents.CERTIFICATE_ISSUED, eventData);
-  }
-  
-  /**
-   * Emit a certificate renewed event
-   */
-  public emitCertificateRenewed(data: Omit<ICertificateEventData, 'timestamp' | 'componentType' | 'componentId'>): void {
-    const eventData: ICertificateEventData = {
-      ...data,
-      timestamp: Date.now(),
-      componentType: this.componentType,
-      componentId: this.componentId
-    };
-    
-    this.logger?.info?.(`Certificate renewed for ${data.domain}`);
-    this.emitter.emit(ProxyEvents.CERTIFICATE_RENEWED, eventData);
-  }
-  
-  /**
-   * Emit a certificate failed event
-   */
-  public emitCertificateFailed(data: Omit<ICertificateFailureEventData, 'timestamp' | 'componentType' | 'componentId'>): void {
-    const eventData: ICertificateFailureEventData = {
-      ...data,
-      timestamp: Date.now(),
-      componentType: this.componentType,
-      componentId: this.componentId
-    };
-    
-    this.logger?.error?.(`Certificate issuance failed for ${data.domain}: ${data.error}`);
-    this.emitter.emit(ProxyEvents.CERTIFICATE_FAILED, eventData);
-  }
-  
-  /**
-   * Emit a certificate expiring event
-   */
-  public emitCertificateExpiring(data: Omit<ICertificateExpiringEventData, 'timestamp' | 'componentType' | 'componentId'>): void {
-    const eventData: ICertificateExpiringEventData = {
-      ...data,
-      timestamp: Date.now(),
-      componentType: this.componentType,
-      componentId: this.componentId
-    };
-    
-    this.logger?.warn?.(`Certificate expiring for ${data.domain} in ${data.daysRemaining} days`);
-    this.emitter.emit(ProxyEvents.CERTIFICATE_EXPIRING, eventData);
-  }
-  
-  /**
-   * Emit a component started event
-   */
-  public emitComponentStarted(name: string, version?: string): void {
-    const eventData: IComponentEventData = {
-      name,
-      version,
-      timestamp: Date.now(),
-      componentType: this.componentType,
-      componentId: this.componentId
-    };
-    
-    this.logger?.info?.(`Component ${name} started${version ? ` (v${version})` : ''}`);
-    this.emitter.emit(ProxyEvents.COMPONENT_STARTED, eventData);
-  }
-  
-  /**
-   * Emit a component stopped event
-   */
-  public emitComponentStopped(name: string): void {
-    const eventData: IComponentEventData = {
-      name,
-      timestamp: Date.now(),
-      componentType: this.componentType,
-      componentId: this.componentId
-    };
-    
-    this.logger?.info?.(`Component ${name} stopped`);
-    this.emitter.emit(ProxyEvents.COMPONENT_STOPPED, eventData);
-  }
-  
-  /**
-   * Emit a connection established event
-   */
-  public emitConnectionEstablished(data: Omit<IConnectionEventData, 'timestamp' | 'componentType' | 'componentId'>): void {
-    const eventData: IConnectionEventData = {
-      ...data,
-      timestamp: Date.now(),
-      componentType: this.componentType,
-      componentId: this.componentId
-    };
-    
-    this.logger?.debug?.(`Connection ${data.connectionId} established from ${data.clientIp} on port ${data.port}`);
-    this.emitter.emit(ProxyEvents.CONNECTION_ESTABLISHED, eventData);
-  }
-  
-  /**
-   * Emit a connection closed event
-   */
-  public emitConnectionClosed(data: Omit<IConnectionEventData, 'timestamp' | 'componentType' | 'componentId'>): void {
-    const eventData: IConnectionEventData = {
-      ...data,
-      timestamp: Date.now(),
-      componentType: this.componentType,
-      componentId: this.componentId
-    };
-    
-    this.logger?.debug?.(`Connection ${data.connectionId} closed`);
-    this.emitter.emit(ProxyEvents.CONNECTION_CLOSED, eventData);
-  }
-  
-  /**
-   * Emit a route matched event
-   */
-  public emitRouteMatched(data: Omit<IRouteEventData, 'timestamp' | 'componentType' | 'componentId'>): void {
-    const eventData: IRouteEventData = {
-      ...data,
-      timestamp: Date.now(),
-      componentType: this.componentType,
-      componentId: this.componentId
-    };
-    
-    this.logger?.debug?.(`Route matched: ${data.route.name || data.route.id || 'unnamed'}`);
-    this.emitter.emit(ProxyEvents.ROUTE_MATCHED, eventData);
-  }
-  
-  /**
-   * Subscribe to an event
-   */
-  public on<T>(event: ProxyEvents, handler: EventHandler<T>): void {
-    this.emitter.on(event, handler);
-  }
-  
-  /**
-   * Subscribe to an event once
-   */
-  public once<T>(event: ProxyEvents, handler: EventHandler<T>): void {
-    this.emitter.once(event, handler);
-  }
-  
-  /**
-   * Unsubscribe from an event
-   */
-  public off<T>(event: ProxyEvents, handler: EventHandler<T>): void {
-    this.emitter.off(event, handler);
-  }
-  
-  /**
-   * Map Port80Handler events to standard proxy events
-   */
-  public subscribePort80HandlerEvents(handler: any): void {
-    handler.on(Port80HandlerEvents.CERTIFICATE_ISSUED, (data: ICertificateData) => {
-      this.emitCertificateIssued({
-        ...data,
-        isRenewal: false,
-        source: 'port80handler'
-      });
-    });
-    
-    handler.on(Port80HandlerEvents.CERTIFICATE_RENEWED, (data: ICertificateData) => {
-      this.emitCertificateRenewed({
-        ...data,
-        isRenewal: true,
-        source: 'port80handler'
-      });
-    });
-    
-    handler.on(Port80HandlerEvents.CERTIFICATE_FAILED, (data: ICertificateFailure) => {
-      this.emitCertificateFailed(data);
-    });
-    
-    handler.on(Port80HandlerEvents.CERTIFICATE_EXPIRING, (data: ICertificateExpiring) => {
-      this.emitCertificateExpiring(data);
-    });
-  }
-}

ts/core/utils/event-utils.ts

@@ -1,34 +0,0 @@
-import type { Port80Handler } from '../../http/port80/port80-handler.js';
-import { Port80HandlerEvents } from '../models/common-types.js';
-import type { ICertificateData, ICertificateFailure, ICertificateExpiring } from '../models/common-types.js';
-
-/**
- * Subscribers callback definitions for Port80Handler events
- */
-export interface IPort80HandlerSubscribers {
-  onCertificateIssued?: (data: ICertificateData) => void;
-  onCertificateRenewed?: (data: ICertificateData) => void;
-  onCertificateFailed?: (data: ICertificateFailure) => void;
-  onCertificateExpiring?: (data: ICertificateExpiring) => void;
-}
-
-/**
- * Subscribes to Port80Handler events based on provided callbacks
- */
-export function subscribeToPort80Handler(
-  handler: Port80Handler,
-  subscribers: IPort80HandlerSubscribers
-): void {
-  if (subscribers.onCertificateIssued) {
-    handler.on(Port80HandlerEvents.CERTIFICATE_ISSUED, subscribers.onCertificateIssued);
-  }
-  if (subscribers.onCertificateRenewed) {
-    handler.on(Port80HandlerEvents.CERTIFICATE_RENEWED, subscribers.onCertificateRenewed);
-  }
-  if (subscribers.onCertificateFailed) {
-    handler.on(Port80HandlerEvents.CERTIFICATE_FAILED, subscribers.onCertificateFailed);
-  }
-  if (subscribers.onCertificateExpiring) {
-    handler.on(Port80HandlerEvents.CERTIFICATE_EXPIRING, subscribers.onCertificateExpiring);
-  }
-}

ts/core/utils/fs-utils.ts

@@ -0,0 +1,270 @@
+/**
+ * Async filesystem utilities for SmartProxy
+ * Provides non-blocking alternatives to synchronous filesystem operations
+ */
+
+import * as plugins from '../../plugins.js';
+
+export class AsyncFileSystem {
+  /**
+   * Check if a file or directory exists
+   * @param path - Path to check
+   * @returns Promise resolving to true if exists, false otherwise
+   */
+  static async exists(path: string): Promise<boolean> {
+    try {
+      await plugins.fs.promises.access(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Ensure a directory exists, creating it if necessary
+   * @param dirPath - Directory path to ensure
+   * @returns Promise that resolves when directory is ensured
+   */
+  static async ensureDir(dirPath: string): Promise<void> {
+    await plugins.fs.promises.mkdir(dirPath, { recursive: true });
+  }
+
+  /**
+   * Read a file as string
+   * @param filePath - Path to the file
+   * @param encoding - File encoding (default: utf8)
+   * @returns Promise resolving to file contents
+   */
+  static async readFile(filePath: string, encoding: BufferEncoding = 'utf8'): Promise<string> {
+    return plugins.fs.promises.readFile(filePath, encoding);
+  }
+
+  /**
+   * Read a file as buffer
+   * @param filePath - Path to the file
+   * @returns Promise resolving to file buffer
+   */
+  static async readFileBuffer(filePath: string): Promise<Buffer> {
+    return plugins.fs.promises.readFile(filePath);
+  }
+
+  /**
+   * Write string data to a file
+   * @param filePath - Path to the file
+   * @param data - String data to write
+   * @param encoding - File encoding (default: utf8)
+   * @returns Promise that resolves when file is written
+   */
+  static async writeFile(filePath: string, data: string, encoding: BufferEncoding = 'utf8'): Promise<void> {
+    // Ensure directory exists
+    const dir = plugins.path.dirname(filePath);
+    await this.ensureDir(dir);
+    await plugins.fs.promises.writeFile(filePath, data, encoding);
+  }
+
+  /**
+   * Write buffer data to a file
+   * @param filePath - Path to the file
+   * @param data - Buffer data to write
+   * @returns Promise that resolves when file is written
+   */
+  static async writeFileBuffer(filePath: string, data: Buffer): Promise<void> {
+    const dir = plugins.path.dirname(filePath);
+    await this.ensureDir(dir);
+    await plugins.fs.promises.writeFile(filePath, data);
+  }
+
+  /**
+   * Remove a file
+   * @param filePath - Path to the file
+   * @returns Promise that resolves when file is removed
+   */
+  static async remove(filePath: string): Promise<void> {
+    try {
+      await plugins.fs.promises.unlink(filePath);
+    } catch (error: any) {
+      if (error.code !== 'ENOENT') {
+        throw error;
+      }
+      // File doesn't exist, which is fine
+    }
+  }
+
+  /**
+   * Remove a directory and all its contents
+   * @param dirPath - Path to the directory
+   * @returns Promise that resolves when directory is removed
+   */
+  static async removeDir(dirPath: string): Promise<void> {
+    try {
+      await plugins.fs.promises.rm(dirPath, { recursive: true, force: true });
+    } catch (error: any) {
+      if (error.code !== 'ENOENT') {
+        throw error;
+      }
+    }
+  }
+
+  /**
+   * Read JSON from a file
+   * @param filePath - Path to the JSON file
+   * @returns Promise resolving to parsed JSON
+   */
+  static async readJSON<T = any>(filePath: string): Promise<T> {
+    const content = await this.readFile(filePath);
+    return JSON.parse(content);
+  }
+
+  /**
+   * Write JSON to a file
+   * @param filePath - Path to the file
+   * @param data - Data to write as JSON
+   * @param pretty - Whether to pretty-print JSON (default: true)
+   * @returns Promise that resolves when file is written
+   */
+  static async writeJSON(filePath: string, data: any, pretty = true): Promise<void> {
+    const jsonString = pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+    await this.writeFile(filePath, jsonString);
+  }
+
+  /**
+   * Copy a file from source to destination
+   * @param source - Source file path
+   * @param destination - Destination file path
+   * @returns Promise that resolves when file is copied
+   */
+  static async copyFile(source: string, destination: string): Promise<void> {
+    const destDir = plugins.path.dirname(destination);
+    await this.ensureDir(destDir);
+    await plugins.fs.promises.copyFile(source, destination);
+  }
+
+  /**
+   * Move/rename a file
+   * @param source - Source file path
+   * @param destination - Destination file path
+   * @returns Promise that resolves when file is moved
+   */
+  static async moveFile(source: string, destination: string): Promise<void> {
+    const destDir = plugins.path.dirname(destination);
+    await this.ensureDir(destDir);
+    await plugins.fs.promises.rename(source, destination);
+  }
+
+  /**
+   * Get file stats
+   * @param filePath - Path to the file
+   * @returns Promise resolving to file stats or null if doesn't exist
+   */
+  static async getStats(filePath: string): Promise<plugins.fs.Stats | null> {
+    try {
+      return await plugins.fs.promises.stat(filePath);
+    } catch (error: any) {
+      if (error.code === 'ENOENT') {
+        return null;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * List files in a directory
+   * @param dirPath - Directory path
+   * @returns Promise resolving to array of filenames
+   */
+  static async listFiles(dirPath: string): Promise<string[]> {
+    try {
+      return await plugins.fs.promises.readdir(dirPath);
+    } catch (error: any) {
+      if (error.code === 'ENOENT') {
+        return [];
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * List files in a directory with full paths
+   * @param dirPath - Directory path
+   * @returns Promise resolving to array of full file paths
+   */
+  static async listFilesFullPath(dirPath: string): Promise<string[]> {
+    const files = await this.listFiles(dirPath);
+    return files.map(file => plugins.path.join(dirPath, file));
+  }
+
+  /**
+   * Recursively list all files in a directory
+   * @param dirPath - Directory path
+   * @param fileList - Accumulator for file list (used internally)
+   * @returns Promise resolving to array of all file paths
+   */
+  static async listFilesRecursive(dirPath: string, fileList: string[] = []): Promise<string[]> {
+    const files = await this.listFiles(dirPath);
+    
+    for (const file of files) {
+      const filePath = plugins.path.join(dirPath, file);
+      const stats = await this.getStats(filePath);
+      
+      if (stats?.isDirectory()) {
+        await this.listFilesRecursive(filePath, fileList);
+      } else if (stats?.isFile()) {
+        fileList.push(filePath);
+      }
+    }
+    
+    return fileList;
+  }
+
+  /**
+   * Create a read stream for a file
+   * @param filePath - Path to the file
+   * @param options - Stream options
+   * @returns Read stream
+   */
+  static createReadStream(filePath: string, options?: Parameters<typeof plugins.fs.createReadStream>[1]): plugins.fs.ReadStream {
+    return plugins.fs.createReadStream(filePath, options);
+  }
+
+  /**
+   * Create a write stream for a file
+   * @param filePath - Path to the file
+   * @param options - Stream options
+   * @returns Write stream
+   */
+  static createWriteStream(filePath: string, options?: Parameters<typeof plugins.fs.createWriteStream>[1]): plugins.fs.WriteStream {
+    return plugins.fs.createWriteStream(filePath, options);
+  }
+
+  /**
+   * Ensure a file exists, creating an empty file if necessary
+   * @param filePath - Path to the file
+   * @returns Promise that resolves when file is ensured
+   */
+  static async ensureFile(filePath: string): Promise<void> {
+    const exists = await this.exists(filePath);
+    if (!exists) {
+      await this.writeFile(filePath, '');
+    }
+  }
+
+  /**
+   * Check if a path is a directory
+   * @param path - Path to check
+   * @returns Promise resolving to true if directory, false otherwise
+   */
+  static async isDirectory(path: string): Promise<boolean> {
+    const stats = await this.getStats(path);
+    return stats?.isDirectory() ?? false;
+  }
+
+  /**
+   * Check if a path is a file
+   * @param path - Path to check
+   * @returns Promise resolving to true if file, false otherwise
+   */
+  static async isFile(path: string): Promise<boolean> {
+    const stats = await this.getStats(path);
+    return stats?.isFile() ?? false;
+  }
+}

ts/core/utils/index.ts

@@ -2,7 +2,6 @@
  * Core utility functions
  */
 
-export * from './event-utils.js';
 export * from './validation-utils.js';
 export * from './ip-utils.js';
 export * from './template-utils.js';
@@ -10,5 +9,11 @@ export * from './route-manager.js';
 export * from './route-utils.js';
 export * from './security-utils.js';
 export * from './shared-security-manager.js';
-export * from './event-system.js';
 export * from './websocket-utils.js';
+export * from './logger.js';
+export * from './async-utils.js';
+export * from './fs-utils.js';
+export * from './lifecycle-component.js';
+export * from './binary-heap.js';
+export * from './enhanced-connection-pool.js';
+export * from './socket-utils.js';

ts/core/utils/lifecycle-component.ts

@@ -0,0 +1,251 @@
+/**
+ * Base class for components that need proper resource lifecycle management
+ * Provides automatic cleanup of timers and event listeners to prevent memory leaks
+ */
+export abstract class LifecycleComponent {
+  private timers: Set<NodeJS.Timeout> = new Set();
+  private intervals: Set<NodeJS.Timeout> = new Set();
+  private listeners: Array<{ 
+    target: any; 
+    event: string; 
+    handler: Function;
+    actualHandler?: Function; // The actual handler registered (may be wrapped)
+    once?: boolean;
+  }> = [];
+  private childComponents: Set<LifecycleComponent> = new Set();
+  protected isShuttingDown = false;
+  private cleanupPromise?: Promise<void>;
+
+  /**
+   * Create a managed setTimeout that will be automatically cleaned up
+   */
+  protected setTimeout(handler: Function, timeout: number): NodeJS.Timeout {
+    if (this.isShuttingDown) {
+      // Return a dummy timer if shutting down
+      const dummyTimer = setTimeout(() => {}, 0);
+      if (typeof dummyTimer.unref === 'function') {
+        dummyTimer.unref();
+      }
+      return dummyTimer;
+    }
+
+    const wrappedHandler = () => {
+      this.timers.delete(timer);
+      if (!this.isShuttingDown) {
+        handler();
+      }
+    };
+
+    const timer = setTimeout(wrappedHandler, timeout);
+    this.timers.add(timer);
+    
+    // Allow process to exit even with timer
+    if (typeof timer.unref === 'function') {
+      timer.unref();
+    }
+    
+    return timer;
+  }
+
+  /**
+   * Create a managed setInterval that will be automatically cleaned up
+   */
+  protected setInterval(handler: Function, interval: number): NodeJS.Timeout {
+    if (this.isShuttingDown) {
+      // Return a dummy timer if shutting down
+      const dummyTimer = setInterval(() => {}, interval);
+      if (typeof dummyTimer.unref === 'function') {
+        dummyTimer.unref();
+      }
+      clearInterval(dummyTimer); // Clear immediately since we don't need it
+      return dummyTimer;
+    }
+
+    const wrappedHandler = () => {
+      if (!this.isShuttingDown) {
+        handler();
+      }
+    };
+
+    const timer = setInterval(wrappedHandler, interval);
+    this.intervals.add(timer);
+    
+    // Allow process to exit even with timer
+    if (typeof timer.unref === 'function') {
+      timer.unref();
+    }
+    
+    return timer;
+  }
+
+  /**
+   * Clear a managed timeout
+   */
+  protected clearTimeout(timer: NodeJS.Timeout): void {
+    clearTimeout(timer);
+    this.timers.delete(timer);
+  }
+
+  /**
+   * Clear a managed interval
+   */
+  protected clearInterval(timer: NodeJS.Timeout): void {
+    clearInterval(timer);
+    this.intervals.delete(timer);
+  }
+
+  /**
+   * Add a managed event listener that will be automatically removed on cleanup
+   */
+  protected addEventListener(
+    target: any, 
+    event: string, 
+    handler: Function,
+    options?: { once?: boolean }
+  ): void {
+    if (this.isShuttingDown) {
+      return;
+    }
+
+    // For 'once' listeners, we need to wrap the handler to remove it from our tracking
+    let actualHandler = handler;
+    if (options?.once) {
+      actualHandler = (...args: any[]) => {
+        // Call the original handler
+        handler(...args);
+        
+        // Remove from our internal tracking
+        const index = this.listeners.findIndex(
+          l => l.target === target && l.event === event && l.handler === handler
+        );
+        if (index !== -1) {
+          this.listeners.splice(index, 1);
+        }
+      };
+    }
+
+    // Support both EventEmitter and DOM-style event targets
+    if (typeof target.on === 'function') {
+      if (options?.once) {
+        target.once(event, actualHandler);
+      } else {
+        target.on(event, actualHandler);
+      }
+    } else if (typeof target.addEventListener === 'function') {
+      target.addEventListener(event, actualHandler, options);
+    } else {
+      throw new Error('Target must support on() or addEventListener()');
+    }
+
+    // Store both the original handler and the actual handler registered
+    this.listeners.push({ 
+      target, 
+      event, 
+      handler,
+      actualHandler, // The handler that was actually registered (may be wrapped)
+      once: options?.once 
+    });
+  }
+
+  /**
+   * Remove a specific event listener
+   */
+  protected removeEventListener(target: any, event: string, handler: Function): void {
+    // Remove from target
+    if (typeof target.removeListener === 'function') {
+      target.removeListener(event, handler);
+    } else if (typeof target.removeEventListener === 'function') {
+      target.removeEventListener(event, handler);
+    }
+
+    // Remove from our tracking
+    const index = this.listeners.findIndex(
+      l => l.target === target && l.event === event && l.handler === handler
+    );
+    if (index !== -1) {
+      this.listeners.splice(index, 1);
+    }
+  }
+
+  /**
+   * Register a child component that should be cleaned up when this component is cleaned up
+   */
+  protected registerChildComponent(component: LifecycleComponent): void {
+    this.childComponents.add(component);
+  }
+
+  /**
+   * Unregister a child component
+   */
+  protected unregisterChildComponent(component: LifecycleComponent): void {
+    this.childComponents.delete(component);
+  }
+
+  /**
+   * Override this method to implement component-specific cleanup logic
+   */
+  protected async onCleanup(): Promise<void> {
+    // Override in subclasses
+  }
+
+  /**
+   * Clean up all managed resources
+   */
+  public async cleanup(): Promise<void> {
+    // Return existing cleanup promise if already cleaning up
+    if (this.cleanupPromise) {
+      return this.cleanupPromise;
+    }
+
+    this.cleanupPromise = this.performCleanup();
+    return this.cleanupPromise;
+  }
+
+  private async performCleanup(): Promise<void> {
+    this.isShuttingDown = true;
+    
+    // First, clean up child components
+    const childCleanupPromises: Promise<void>[] = [];
+    for (const child of this.childComponents) {
+      childCleanupPromises.push(child.cleanup());
+    }
+    await Promise.all(childCleanupPromises);
+    this.childComponents.clear();
+
+    // Clear all timers
+    for (const timer of this.timers) {
+      clearTimeout(timer);
+    }
+    this.timers.clear();
+
+    // Clear all intervals
+    for (const timer of this.intervals) {
+      clearInterval(timer);
+    }
+    this.intervals.clear();
+
+    // Remove all event listeners
+    for (const { target, event, handler, actualHandler } of this.listeners) {
+      // Use actualHandler if available (for wrapped handlers), otherwise use the original handler
+      const handlerToRemove = actualHandler || handler;
+      
+      // All listeners need to be removed, including 'once' listeners that might not have fired
+      if (typeof target.removeListener === 'function') {
+        target.removeListener(event, handlerToRemove);
+      } else if (typeof target.removeEventListener === 'function') {
+        target.removeEventListener(event, handlerToRemove);
+      }
+    }
+    this.listeners = [];
+
+    // Call subclass cleanup
+    await this.onCleanup();
+  }
+
+  /**
+   * Check if the component is shutting down
+   */
+  protected isShuttingDownState(): boolean {
+    return this.isShuttingDown;
+  }
+}

ts/core/utils/logger.ts

@@ -0,0 +1,10 @@
+import * as plugins from '../../plugins.js';
+
+export const logger = new plugins.smartlog.Smartlog({
+  logContext: {},
+  minimumLogLevel: 'info',
+});
+
+logger.addLogDestination(new plugins.smartlogDestinationLocal.DestinationLocal());
+
+logger.log('info', 'Logger initialized');

ts/core/utils/route-utils.ts

@@ -209,18 +209,18 @@ export function matchIpPattern(pattern: string, ip: string): boolean {
  * Match an IP against allowed and blocked IP patterns
  * 
  * @param ip IP to check
- * @param allowedIps Array of allowed IP patterns
- * @param blockedIps Array of blocked IP patterns
+ * @param ipAllowList Array of allowed IP patterns
+ * @param ipBlockList Array of blocked IP patterns
  * @returns Whether the IP is allowed
  */
 export function isIpAuthorized(
   ip: string, 
-  allowedIps: string[] = ['*'], 
-  blockedIps: string[] = []
+  ipAllowList: string[] = ['*'], 
+  ipBlockList: string[] = []
 ): boolean {
   // Check blocked IPs first
-  if (blockedIps.length > 0) {
-    for (const pattern of blockedIps) {
+  if (ipBlockList.length > 0) {
+    for (const pattern of ipBlockList) {
       if (matchIpPattern(pattern, ip)) {
         return false; // IP is blocked
       }
@@ -228,13 +228,13 @@ export function isIpAuthorized(
   }
   
   // If there are allowed IPs, check them
-  if (allowedIps.length > 0) {
+  if (ipAllowList.length > 0) {
     // Special case: if '*' is in allowed IPs, all non-blocked IPs are allowed
-    if (allowedIps.includes('*')) {
+    if (ipAllowList.includes('*')) {
       return true;
     }
     
-    for (const pattern of allowedIps) {
+    for (const pattern of ipAllowList) {
       if (matchIpPattern(pattern, ip)) {
         return true; // IP is allowed
       }

ts/core/utils/socket-utils.ts

@@ -0,0 +1,243 @@
+import * as plugins from '../../plugins.js';
+
+export interface CleanupOptions {
+  immediate?: boolean;      // Force immediate destruction
+  allowDrain?: boolean;     // Allow write buffer to drain
+  gracePeriod?: number;     // Ms to wait before force close
+}
+
+export interface SafeSocketOptions {
+  port: number;
+  host: string;
+  onError?: (error: Error) => void;
+  onConnect?: () => void;
+  timeout?: number;
+}
+
+/**
+ * Safely cleanup a socket by removing all listeners and destroying it
+ * @param socket The socket to cleanup
+ * @param socketName Optional name for logging
+ * @param options Cleanup options
+ */
+export function cleanupSocket(
+  socket: plugins.net.Socket | plugins.tls.TLSSocket | null, 
+  socketName?: string,
+  options: CleanupOptions = {}
+): Promise<void> {
+  if (!socket || socket.destroyed) return Promise.resolve();
+  
+  return new Promise<void>((resolve) => {
+    const cleanup = () => {
+      try {
+        // Remove all event listeners
+        socket.removeAllListeners();
+        
+        // Destroy if not already destroyed
+        if (!socket.destroyed) {
+          socket.destroy();
+        }
+      } catch (err) {
+        console.error(`Error cleaning up socket${socketName ? ` (${socketName})` : ''}: ${err}`);
+      }
+      resolve();
+    };
+    
+    if (options.immediate) {
+      // Immediate cleanup (old behavior)
+      socket.unpipe();
+      cleanup();
+    } else if (options.allowDrain && socket.writable) {
+      // Allow pending writes to complete
+      socket.end(() => cleanup());
+      
+      // Force cleanup after grace period
+      if (options.gracePeriod) {
+        setTimeout(() => {
+          if (!socket.destroyed) {
+            cleanup();
+          }
+        }, options.gracePeriod);
+      }
+    } else {
+      // Default: immediate cleanup
+      socket.unpipe();
+      cleanup();
+    }
+  });
+}
+
+/**
+ * Create a cleanup handler for paired sockets (client and server)
+ * @param clientSocket The client socket
+ * @param serverSocket The server socket (optional)
+ * @param onCleanup Optional callback when cleanup is done
+ * @returns A cleanup function that can be called multiple times safely
+ * @deprecated Use createIndependentSocketHandlers for better half-open support
+ */
+export function createSocketCleanupHandler(
+  clientSocket: plugins.net.Socket | plugins.tls.TLSSocket,
+  serverSocket?: plugins.net.Socket | plugins.tls.TLSSocket | null,
+  onCleanup?: (reason: string) => void
+): (reason: string) => void {
+  let cleanedUp = false;
+  
+  return (reason: string) => {
+    if (cleanedUp) return;
+    cleanedUp = true;
+    
+    // Cleanup both sockets (old behavior - too aggressive)
+    cleanupSocket(clientSocket, 'client', { immediate: true });
+    if (serverSocket) {
+      cleanupSocket(serverSocket, 'server', { immediate: true });
+    }
+    
+    // Call cleanup callback if provided
+    if (onCleanup) {
+      onCleanup(reason);
+    }
+  };
+}
+
+/**
+ * Create independent cleanup handlers for paired sockets that support half-open connections
+ * @param clientSocket The client socket
+ * @param serverSocket The server socket
+ * @param onBothClosed Callback when both sockets are closed
+ * @returns Independent cleanup functions for each socket
+ */
+export function createIndependentSocketHandlers(
+  clientSocket: plugins.net.Socket | plugins.tls.TLSSocket,
+  serverSocket: plugins.net.Socket | plugins.tls.TLSSocket,
+  onBothClosed: (reason: string) => void
+): { cleanupClient: (reason: string) => Promise<void>, cleanupServer: (reason: string) => Promise<void> } {
+  let clientClosed = false;
+  let serverClosed = false;
+  let clientReason = '';
+  let serverReason = '';
+  
+  const checkBothClosed = () => {
+    if (clientClosed && serverClosed) {
+      onBothClosed(`client: ${clientReason}, server: ${serverReason}`);
+    }
+  };
+  
+  const cleanupClient = async (reason: string) => {
+    if (clientClosed) return;
+    clientClosed = true;
+    clientReason = reason;
+    
+    // Allow server to continue if still active
+    if (!serverClosed && serverSocket.writable) {
+      // Half-close: stop reading from client, let server finish
+      clientSocket.pause();
+      clientSocket.unpipe(serverSocket);
+      await cleanupSocket(clientSocket, 'client', { allowDrain: true, gracePeriod: 5000 });
+    } else {
+      await cleanupSocket(clientSocket, 'client', { immediate: true });
+    }
+    
+    checkBothClosed();
+  };
+  
+  const cleanupServer = async (reason: string) => {
+    if (serverClosed) return;
+    serverClosed = true;
+    serverReason = reason;
+    
+    // Allow client to continue if still active
+    if (!clientClosed && clientSocket.writable) {
+      // Half-close: stop reading from server, let client finish
+      serverSocket.pause();
+      serverSocket.unpipe(clientSocket);
+      await cleanupSocket(serverSocket, 'server', { allowDrain: true, gracePeriod: 5000 });
+    } else {
+      await cleanupSocket(serverSocket, 'server', { immediate: true });
+    }
+    
+    checkBothClosed();
+  };
+  
+  return { cleanupClient, cleanupServer };
+}
+
+/**
+ * Setup socket error and close handlers with proper cleanup
+ * @param socket The socket to setup handlers for
+ * @param handleClose The cleanup function to call
+ * @param handleTimeout Optional custom timeout handler
+ * @param errorPrefix Optional prefix for error messages
+ */
+export function setupSocketHandlers(
+  socket: plugins.net.Socket | plugins.tls.TLSSocket,
+  handleClose: (reason: string) => void,
+  handleTimeout?: (socket: plugins.net.Socket | plugins.tls.TLSSocket) => void,
+  errorPrefix?: string
+): void {
+  socket.on('error', (error) => {
+    const prefix = errorPrefix || 'Socket';
+    handleClose(`${prefix}_error: ${error.message}`);
+  });
+  
+  socket.on('close', () => {
+    const prefix = errorPrefix || 'socket';
+    handleClose(`${prefix}_closed`);
+  });
+  
+  socket.on('timeout', () => {
+    if (handleTimeout) {
+      handleTimeout(socket);  // Custom timeout handling
+    } else {
+      // Default: just log, don't close
+      console.warn(`Socket timeout: ${errorPrefix || 'socket'}`);
+    }
+  });
+}
+
+/**
+ * Pipe two sockets together with proper cleanup on either end
+ * @param socket1 First socket
+ * @param socket2 Second socket
+ */
+export function pipeSockets(
+  socket1: plugins.net.Socket | plugins.tls.TLSSocket,
+  socket2: plugins.net.Socket | plugins.tls.TLSSocket
+): void {
+  socket1.pipe(socket2);
+  socket2.pipe(socket1);
+}
+
+/**
+ * Create a socket with immediate error handling to prevent crashes
+ * @param options Socket creation options
+ * @returns The created socket
+ */
+export function createSocketWithErrorHandler(options: SafeSocketOptions): plugins.net.Socket {
+  const { port, host, onError, onConnect, timeout } = options;
+  
+  // Create socket with immediate error handler attachment
+  const socket = new plugins.net.Socket();
+  
+  // Attach error handler BEFORE connecting to catch immediate errors
+  socket.on('error', (error) => {
+    console.error(`Socket connection error to ${host}:${port}: ${error.message}`);
+    if (onError) {
+      onError(error);
+    }
+  });
+  
+  // Attach connect handler if provided
+  if (onConnect) {
+    socket.on('connect', onConnect);
+  }
+  
+  // Set timeout if provided
+  if (timeout) {
+    socket.setTimeout(timeout);
+  }
+  
+  // Now attempt to connect - any immediate errors will be caught
+  socket.connect(port, host);
+  
+  return socket;
+}

ts/forwarding/factory/forwarding-factory.ts

@@ -52,6 +52,13 @@ export class ForwardingHandlerFactory {
           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':
@@ -65,6 +72,13 @@ export class ForwardingHandlerFactory {
           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':
@@ -84,6 +98,13 @@ export class ForwardingHandlerFactory {
           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':
@@ -101,6 +122,13 @@ export class ForwardingHandlerFactory {
           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;
     }