.gitea/workflows/default_nottags.yaml

@@ -1,66 +0,0 @@
-name: Default (not tags)
-
-on:
-  push:
-    tags-ignore:
-      - '**'
-
-env:
-  IMAGE: code.foss.global/host.today/ht-docker-node:npmci
-  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@/${{gitea.repository}}.git
-  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
-  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
-  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
-  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
-
-jobs:
-  security:
-    runs-on: ubuntu-latest
-    continue-on-error: true
-    container:
-      image: ${{ env.IMAGE }}
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Install pnpm and npmci
-        run: |
-          pnpm install -g pnpm
-          pnpm install -g @ship.zone/npmci
-
-      - name: Run npm prepare
-        run: npmci npm prepare
-
-      - name: Audit production dependencies
-        run: |
-          npmci command npm config set registry https://registry.npmjs.org
-          npmci command pnpm audit --audit-level=high --prod
-        continue-on-error: true
-
-      - name: Audit development dependencies
-        run: |
-          npmci command npm config set registry https://registry.npmjs.org
-          npmci command pnpm audit --audit-level=high --dev
-        continue-on-error: true
-
-  test:
-    if: ${{ always() }}
-    needs: security
-    runs-on: ubuntu-latest
-    container:
-      image: ${{ env.IMAGE }}
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Test stable
-        run: |
-          npmci node install stable
-          npmci npm install
-          npmci npm test
-
-      - name: Test build
-        run: |
-          npmci node install stable
-          npmci npm install
-          npmci npm build

.gitea/workflows/default_tags.yaml

@@ -1,124 +0,0 @@
-name: Default (tags)
-
-on:
-  push:
-    tags:
-      - '*'
-
-env:
-  IMAGE: code.foss.global/host.today/ht-docker-node:npmci
-  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@/${{gitea.repository}}.git
-  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
-  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
-  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
-  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
-
-jobs:
-  security:
-    runs-on: ubuntu-latest
-    continue-on-error: true
-    container:
-      image: ${{ env.IMAGE }}
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Prepare
-        run: |
-          pnpm install -g pnpm
-          pnpm install -g @ship.zone/npmci
-          npmci npm prepare
-
-      - name: Audit production dependencies
-        run: |
-          npmci command npm config set registry https://registry.npmjs.org
-          npmci command pnpm audit --audit-level=high --prod
-        continue-on-error: true
-
-      - name: Audit development dependencies
-        run: |
-          npmci command npm config set registry https://registry.npmjs.org
-          npmci command pnpm audit --audit-level=high --dev
-        continue-on-error: true
-
-  test:
-    if: ${{ always() }}
-    needs: security
-    runs-on: ubuntu-latest
-    container:
-      image: ${{ env.IMAGE }}
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Prepare
-        run: |
-          pnpm install -g pnpm
-          pnpm install -g @ship.zone/npmci
-          npmci npm prepare
-
-      - name: Test stable
-        run: |
-          npmci node install stable
-          npmci npm install
-          npmci npm test
-
-      - name: Test build
-        run: |
-          npmci node install stable
-          npmci npm install
-          npmci npm build
-
-  release:
-    needs: test
-    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
-    runs-on: ubuntu-latest
-    container:
-      image: ${{ env.IMAGE }}
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Prepare
-        run: |
-          pnpm install -g pnpm
-          pnpm install -g @ship.zone/npmci
-          npmci npm prepare
-
-      - name: Release
-        run: |
-          npmci node install stable
-          npmci npm publish
-
-  metadata:
-    needs: test
-    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
-    runs-on: ubuntu-latest
-    container:
-      image: ${{ env.IMAGE }}
-    continue-on-error: true
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Prepare
-        run: |
-          pnpm install -g pnpm
-          pnpm install -g @ship.zone/npmci
-          npmci npm prepare
-
-      - name: Code quality
-        run: |
-          npmci command npm install -g typescript
-          npmci npm install
-
-      - name: Trigger
-        run: npmci trigger
-
-      - name: Build docs and upload artifacts
-        run: |
-          npmci node install stable
-          npmci npm install
-          pnpm install -g @git.zone/tsdoc
-          npmci command tsdoc
-        continue-on-error: true

.gitignore

@@ -3,6 +3,7 @@
 # artifacts
 coverage/
 public/
+pages/
 
 # installs
 node_modules/
@@ -14,7 +15,8 @@ node_modules/
 
 # builds
 dist/
-dist_*/
+dist_web/
+dist_serve/
+dist_ts_web/
 
-#------# custom
-.claude/*
+# custom

.gitlab-ci.yml

@@ -0,0 +1,119 @@
+# gitzone ci_default
+image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+
+cache:
+  paths:
+  - .npmci_cache/
+  key: "$CI_BUILD_STAGE"
+
+stages:
+- security
+- test
+- release
+- metadata
+
+# ====================
+# security stage
+# ====================
+mirror:
+  stage: security
+  script:
+  - npmci git mirror
+  tags:
+  - docker
+  - notpriv
+
+snyk:
+  stage: security
+  script:
+    - npmci npm prepare
+    - npmci command npm install -g snyk
+    - npmci command npm install --ignore-scripts
+    - npmci command snyk test
+  tags:
+  - docker
+  - notpriv
+
+# ====================
+# test stage
+# ====================
+
+testLTS:
+  stage: test
+  script:
+  - npmci npm prepare
+  - npmci node install lts
+  - npmci npm install
+  - npmci npm test
+  coverage: /\d+.?\d+?\%\s*coverage/
+  tags:
+  - docker
+  - priv
+
+testBuild:
+  stage: test
+  script:
+  - npmci npm prepare
+  - npmci node install lts
+  - npmci npm install
+  - npmci command npm run build
+  coverage: /\d+.?\d+?\%\s*coverage/
+  tags:
+  - docker
+  - notpriv
+
+release:
+  stage: release
+  script:
+  - npmci node install lts
+  - npmci npm publish
+  only:
+  - tags
+  tags:
+  - docker
+  - notpriv
+
+# ====================
+# metadata stage
+# ====================
+codequality:
+  stage: metadata
+  allow_failure: true
+  script:
+    - npmci command npm install -g tslint typescript
+    - npmci npm install
+    - npmci command "tslint -c tslint.json ./ts/**/*.ts"
+  tags:
+  - docker
+  - priv
+
+trigger:
+  stage: metadata
+  script:
+  - npmci trigger
+  only:
+  - tags
+  tags:
+  - docker
+  - notpriv
+
+pages:
+  image: hosttoday/ht-docker-dbase:npmci
+  services:
+   - docker:18-dind
+  stage: metadata
+  script:
+    - npmci command npm install -g @gitzone/tsdoc
+    - npmci npm prepare
+    - npmci npm install
+    - npmci command tsdoc
+  tags:
+    - docker
+    - notpriv
+  only:
+    - tags
+  artifacts:
+    expire_in: 1 week
+    paths:
+    - public
+  allow_failure: true

.vscode/launch.json

@@ -2,10 +2,28 @@
   "version": "0.2.0",
   "configurations": [
     {
-      "command": "npm test",
-      "name": "Run npm test",
+      "name": "current file",
+      "type": "node",
       "request": "launch",
-      "type": "node-terminal"
+      "args": [
+        "${relativeFile}"
+      ],
+      "runtimeArgs": ["-r", "@gitzone/tsrun"],
+      "cwd": "${workspaceRoot}",
+      "protocol": "inspector",
+      "internalConsoleOptions": "openOnSessionStart"
+    },
+    {
+      "name": "test.ts",
+      "type": "node",
+      "request": "launch",
+      "args": [
+        "test/test.ts"
+      ],
+      "runtimeArgs": ["-r", "@gitzone/tsrun"],
+      "cwd": "${workspaceRoot}",
+      "protocol": "inspector",
+      "internalConsoleOptions": "openOnSessionStart"
     }
   ]
 }

.vscode/settings.json

@@ -1,26 +0,0 @@
-{
-  "json.schemas": [
-    {
-      "fileMatch": ["/npmextra.json"],
-      "schema": {
-        "type": "object",
-        "properties": {
-          "npmci": {
-            "type": "object",
-            "description": "settings for npmci"
-          },
-          "gitzone": {
-            "type": "object",
-            "description": "settings for gitzone",
-            "properties": {
-              "projectType": {
-                "type": "string",
-                "enum": ["website", "element", "service", "npm", "wcc"]
-              }
-            }
-          }
-        }
-      }
-    }
-  ]
-}

assets/certs/cert.pem

@@ -1,19 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIDCzCCAfOgAwIBAgIUPU4tviz3ZvsMDjCz1NZRT16b0Y4wDQYJKoZIhvcNAQEL
-BQAwFTETMBEGA1UEAwwKcHVzaC5yb2NrczAeFw0yNTAyMDMyMzA5MzRaFw0yNjAy
-MDMyMzA5MzRaMBUxEzARBgNVBAMMCnB1c2gucm9ja3MwggEiMA0GCSqGSIb3DQEB
-AQUAA4IBDwAwggEKAoIBAQCZMkBYD/pYLBv9MiyHTLRT24kQyPeJBtZqryibi1jk
-BT1ZgNl3yo5U6kjj/nYBU/oy7M4OFC0xyaJQ4wpvLHu7xzREqwT9N9WcDcxaahUi
-P8+PsjGyznPrtXa1ASzGAYMNvXyWWp3351UWZHMEs6eY/Y7i8m4+0NwP5h8RNBCF
-KSFS41Ee9rNAMCnQSHZv1vIzKeVYPmYnCVmL7X2kQb+gS6Rvq5sEGLLKMC5QtTwI
-rdkPGpx4xZirIyf8KANbt0sShwUDpiCSuOCtpze08jMzoHLG9Nv97cJQjb/BhiES
-hLL+YjfAUFjq0rQ38zFKLJ87QB9Jym05mY6IadGQLXVXAgMBAAGjUzBRMB0GA1Ud
-DgQWBBQjpowWjrql/Eo2EVjl29xcjuCgkTAfBgNVHSMEGDAWgBQjpowWjrql/Eo2
-EVjl29xcjuCgkTAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQAY
-44vqbaf6ewFrZC0f3Kk4A10lC6qjWkcDFfw+JE8nzt+4+xPqp1eWgZKF2rONyAv2
-nG41Xygt19ByancXLU44KB24LX8F1GV5Oo7CGBA+xtoSPc0JulXw9fGclZDC6XiR
-P/+vhGgCHicbfP2O+N00pOifrTtf2tmOT4iPXRRo4TxmPzuCd+ZJTlBhPlKCmICq
-yGdAiEo6HsSiP+M5qVlNx8s57MhQYk5TpgmI6FU4mO7zfDfSatFonlg+aDbrnaqJ
-v/+km02M+oB460GmKwsSTnThHZgLNCLiKqD8bdziiCQjx5u0GjLI6468o+Aehb8l
-l/x9vWTTk/QKq41X5hFk
------END CERTIFICATE-----

assets/certs/key.pem

@@ -1,28 +0,0 @@
------BEGIN PRIVATE KEY-----
-MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQCZMkBYD/pYLBv9
-MiyHTLRT24kQyPeJBtZqryibi1jkBT1ZgNl3yo5U6kjj/nYBU/oy7M4OFC0xyaJQ
-4wpvLHu7xzREqwT9N9WcDcxaahUiP8+PsjGyznPrtXa1ASzGAYMNvXyWWp3351UW
-ZHMEs6eY/Y7i8m4+0NwP5h8RNBCFKSFS41Ee9rNAMCnQSHZv1vIzKeVYPmYnCVmL
-7X2kQb+gS6Rvq5sEGLLKMC5QtTwIrdkPGpx4xZirIyf8KANbt0sShwUDpiCSuOCt
-pze08jMzoHLG9Nv97cJQjb/BhiEShLL+YjfAUFjq0rQ38zFKLJ87QB9Jym05mY6I
-adGQLXVXAgMBAAECggEARGCBBq1PBHbfoUH5TQSIAlvdEEBa9+602lZG7jIioVfT
-W7Uem5Ctuan+kcDcY9hbNsqqZ+9KgsvoJmlIGXoF2jjeE/4vUmRO9AHWoc5yk2Be
-4NjcxN3QMLdEfiLBnLlFCOd4CdX1ZxZ6TG3WRpV3a1pVIeeqHGB1sKT6Xd/atcwG
-RvpiXzu0SutGxVb6WE9r6hovZ4fVERCyCRczUGrUH5ICbxf6E7L4u8xjEYR4uEKK
-/8ZkDqrWdRASDAdPPMNqnHUEAho/WnxpNeb6B4lvvv2QWxIS9H1OikF/NzWPgVNS
-oPpvtJgjyo5xdgLm3zE4lcSPNVSrh1TBXuAn9TG4WQKBgQDScPFkUNBqjC5iPMof
-bqDHlhlptrHmiv9LC0lgjEDPgIEQfjLfdCugwDk32QyAcb5B60upDYeqCFDkfV/C
-T536qxevYPjPAjahLPHqMxkWpjvtY6NOTgbbcpVtblU2Fj8R8qbyPNADG31LicU9
-GVPtQ4YcVaMWCYbg5107+9dFWQKBgQC6XK+foKK+81RFdrqaNNgebTWTsANnBcZe
-xl0bj6oL5yY0IzroxHvgcNS7UMriWCu+K2xfkUBdMmxU773VN5JQ5k15ezjgtrvc
-8oAaEsxYP4su12JSTC/zsBANUgrNbFj8++qqKYWt2aQc2O/kbZ4MNfekIVFc8AjM
-2X9PxvxKLwKBgHXL7QO3TQLnVyt8VbQEjBFMzwriznB7i+4o8jkOKVU93IEr8zQr
-5iQElcLSR3I6uUJTALYvsaoXH5jXKVwujwL69LYiNQRDe+r6qqvrUHbiNJdsd8Rk
-XuhGGqj34tD04Pcd+h+MtO+YWqmHBBZwcA9XBeIkebbjPFH2kLT8AwN5AoGAYQy9
-hMJxnkE3hIkk+gNE/OtgeE20J+Vw/ZANkrnJEzPHyGUEW41e+W2oyvdzAFZsSTdx
-037f5ujIU58Z27x53NliRT4vS4693H0Iyws5EUfeIoGVuUflvODWKymraHjhCrXh
-6cV/0R5DAabTnsCbCr7b/MRBC8YQvyUQ0KnOXo8CgYBQYGpvJnSWyvsCjtb6apTP
-drjcBhVd0aSBpLGtDdtUCV4oLl9HPy+cLzcGaqckBqCwEq5DKruhMEf7on56bUMd
-m/3ItFk1TnhysAeJHb3zLqmJ9CKBitpqLlsOE7MEXVNmbTYeXU10Uo9yOfyt1i7T
-su+nT5VtyPkmF/l4wZl5+g==
------END PRIVATE KEY-----

certs/static-route/cert.pem

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

certs/static-route/key.pem

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

certs/static-route/meta.json

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

changelog.md

@@ -1,134 +0,0 @@
-# Changelog
-
-## 2025-06-01 - 19.5.19 - fix(smartproxy)
-Fix connection handling and improve route matching edge cases
-
-- Enhanced cleanup logic to prevent connection accumulation under rapid retry scenarios
-- Improved matching for wildcard domains and path parameters in the route configuration
-- Minor refactoring in async utilities and internal socket handling for better performance
-- Updated test suites and documentation for clearer configuration examples
-
-## 2025-05-29 - 19.5.3 - fix(smartproxy)
-Fix route security configuration location and improve ACME timing tests and socket mock implementations
-
-- Move route security from action.security to the top-level route.security to correctly enforce IP allow/block lists (addresses failing in test.route-security.ts)
-- Update readme.problems.md to document the routing security configuration issue with proper instructions
-- Adjust certificate metadata in certs/static-route/meta.json with updated timestamps
-- Update test.acme-timing.ts to export default tap.start() instead of tap.start() to ensure proper parsing
-- Improve socket simulation and event handling mocks in test.http-fix-verification.ts and test.http-forwarding-fix.ts to more reliably mimic net.Socket behavior
-- Minor adjustments in multiple test files to ensure proper port binding, race condition handling and route lookups (e.g. getRoutesForPort implementation)
-
-## 2025-05-29 - 19.5.2 - fix(test)
-Fix ACME challenge route creation and HTTP request parsing in tests
-
-- Replaced the legacy ACME email 'test@example.com' with 'test@acmetest.local' to avoid forbidden domain issues.
-- Mocked the CertificateManager in test/test.acme-route-creation to simulate immediate ACME challenge route addition.
-- Adjusted updateRoutes callback to capture and verify challenge route creation.
-- Enhanced the HTTP request parsing in socket handler by capturing and asserting parsed request details (method, path, headers).
-
-## 2025-05-29 - 19.5.1 - fix(socket-handler)
-Fix socket handler race condition by differentiating between async and sync handlers. Now, async socket handlers complete their setup before initial data is emitted, ensuring that no data is lost. Documentation and tests have been updated to reflect this change.
-
-- Added detailed explanation in readme.hints.md about the race condition issue, root cause, and solution implementation.
-- Provided a code snippet that checks if the socket handler returns a Promise and waits for its resolution before emitting initial data.
-- Updated tests (test.socket-handler-race.ts, test.socket-handler.simple.ts, test.socket-handler.ts) to verify correct behavior of async handlers.
-
-## 2025-05-28 - 19.5.0 - feat(socket-handler)
-Add socket-handler support for custom socket handling in SmartProxy
-
-- Introduce new action type 'socket-handler' in IRouteAction to allow users to provide a custom socket handler function.
-- Update the RouteConnectionHandler to detect 'socket-handler' actions and invoke the handler with the raw socket, giving full control to the user.
-- Provide optional context (such as route configuration, client IP, and port) to the socket handler if needed.
-- Add helper functions in route-helpers for creating socket handler routes and common patterns like echo, proxy, and line-based protocols.
-- Include a detailed implementation plan and usage examples in readme.plan.md.
-
-## 2025-05-28 - 19.4.3 - fix(smartproxy)
-Improve port binding intelligence and ACME challenge route management; update route configuration tests and dependency versions.
-
-- Bumped dev dependency versions in package.json (tsbuild from ^2.5.1 to ^2.6.4, tstest from ^1.9.0 to ^2.3.1, @types/node updated, smartfile from ^11.2.0 to ^11.2.5, smartlog from ^3.1.7 to ^3.1.8)
-- Removed readme.plan.md containing legacy development plan information
-- Normalized route configuration properties across tests (using 'ports' and 'domains' instead of legacy 'port' or 'domain')
-- Enhanced PortManager with reference counting and smarter port conflict detection to avoid redundant bindings
-- Refined ACME challenge route integration to merge with existing port bindings and improve error handling
-- Adjusted test expectations (e.g. using toEqual instead of toBe, and improved timeout handling) to align with current API changes
-
-## 2025-05-20 - 19.4.2 - fix(dependencies)
-Update dependency versions: upgrade @types/node to ^22.15.20 and @push.rocks/smartlog to ^3.1.7 in package.json
-
-- Bump @types/node from ^22.15.19 to ^22.15.20
-- Bump @push.rocks/smartlog from ^3.1.3 to ^3.1.7
-
-## 2025-05-20 - 19.4.1 - fix(smartproxy)
-Bump @push.rocks/smartlog to ^3.1.3 and improve ACME port binding behavior in SmartProxy
-
-- Updated package.json to use @push.rocks/smartlog version ^3.1.3
-- Enhanced tests (test.http-port8080-simple.ts) to verify improved port binding intelligence for ACME challenge routes
-- Ensured that existing port listeners are reused and not re-bound when updating routes
-
-## 2025-05-20 - 19.4.0 - feat(certificate-manager, smart-proxy)
-Improve port binding intelligence for ACME challenges
-
-- Reordered SmartProxy initialization flow to bind ports before initializing the certificate manager
-- Enhanced port binding logic to better handle ACME challenge routes
-- Improved error detection and reporting for port binding conflicts
-- Added better diagnostics for ACME challenge port issues
-- Made route updates more intelligent with detailed port tracking
-- Fixed race condition where ACME routes were added before port 80 was bound
-- Added special handling for ACME port conflicts with improved error messages
-
-## 2025-05-20 - 19.3.14 - fix(certificate-manager, smart-proxy)
-Add error handling around logger calls in route update callback
-
-- Added try/catch blocks around logger calls in certificate-manager.ts
-- Added try/catch blocks around logger calls in smart-proxy.ts related to route updates
-- Provided fallback to console.log when logger fails
-- Ensured core route update functionality continues to work even if logging fails
-
-## 2025-05-20 - 19.3.13 - fix(port-manager, certificate-manager)
-Improve port binding and ACME challenge route integration in SmartProxy
-
-- Added reference counting in PortManager so that routes sharing the same port reuse the existing binding.
-- Enhanced error handling to distinguish internal port conflicts from external ones, with more descriptive messages.
-- Adjusted ACME challenge route addition to merge with existing port bindings when port is already in use.
-- Refactored updateRoutes to release orphaned ports and bind only new required ports, minimizing rebinding operations.
-- Improved certificate-manager logic to provide clearer error notifications when ACME port conflicts occur.
-
-## 2025-05-19 - 19.3.12 - fix(tests)
-Update test mocks to include provisionAllCertificates methods in certificate manager stubs and related objects.
-
-- Added async provisionAllCertificates functions to several test mocks (e.g. in test.port80-management.node.ts, test.route-callback-simple.ts, test.route-update-callback.node.ts, and test.simple-acme-mock.ts) to simulate ACME certificate provisioning.
-- Enhanced logging and port-add history debugging for ACME challenge port addition.
-
-## 2025-05-19 - 19.3.11 - fix(logger)
-Replace raw console logging calls with structured logger usage across certificate management, connection handling, and route processing for improved observability.
-
-- Replaced console.log, console.warn, and console.error in SmartCertManager with logger.log for more consistent logging.
-- Updated ConnectionManager and RouteConnectionHandler to log detailed connection events using a structured logger.
-- Enhanced logging statements with contextual metadata such as connection IDs, remote IPs, target information, and component identifiers.
-- Standardized log output across proxy modules to aid in debugging and monitoring.
-
-## 2025-05-19 - 19.3.10 - fix(certificate-manager, smart-proxy)
-Fix race condition in ACME certificate provisioning and refactor certificate manager initialization to defer provisioning until after port listeners are active
-
-- Removed superfluous provisionCertificatesAfterPortsReady method
-- Made provisionAllCertificates public so that SmartProxy.start() calls it after ports are listening
-- Updated SmartProxy.start() to wait for port setup (via PortManager) before triggering certificate provisioning
-- Improved ACME HTTP-01 challenge timing so that port 80 (or configured ACME port) is guaranteed to be ready
-- Updated documentation (changelog and Acme timing docs) and tests to reflect the change
-
-## 2025-05-19 - 19.3.10 - refactor(certificate-manager, smart-proxy)
-Simplify certificate provisioning code by removing unnecessary wrapper method
-
-- Removed superfluous SmartCertManager.provisionCertificatesAfterPortsReady() method
-- Made SmartCertManager.provisionAllCertificates() public instead
-- Updated SmartProxy.start() to call provisionAllCertificates() directly
-- Updated documentation and tests to reflect the change
-- No functional changes, just code simplification
-
-## 2025-05-19 - 19.3.9 - fix(certificate-manager, smart-proxy)
-Fix ACME certificate provisioning timing to ensure ports are listening first
-
-- Fixed race condition where certificate provisioning would start before ports were listening
-- Modified SmartCertManager.initialize() to defer certificate provisioning
-- Added SmartCertManager.provisionCertificatesAfterPortsReady() for delayed provisioning
-- Updated SmartProxy.start() to call certificate provisioning after ports are ready

npmextra.json

@@ -1,38 +1,17 @@
 {
   "gitzone": {
-    "projectType": "npm",
     "module": {
-      "githost": "code.foss.global",
-      "gitscope": "push.rocks",
+      "githost": "gitlab.com",
+      "gitscope": "pushrocks",
       "gitrepo": "smartproxy",
-      "description": "A powerful proxy package that effectively handles high traffic, with features such as SSL/TLS support, port proxying, WebSocket handling, and dynamic routing with authentication options.",
-      "npmPackagename": "@push.rocks/smartproxy",
+      "shortDescription": "a proxy for handling high workloads of proxying",
+      "npmPackagename": "@pushrocks/smartproxy",
       "license": "MIT",
-      "projectDomain": "push.rocks",
-      "keywords": [
-        "proxy",
-        "network",
-        "traffic management",
-        "SSL",
-        "TLS",
-        "WebSocket",
-        "port proxying",
-        "dynamic routing",
-        "authentication",
-        "real-time applications",
-        "high workload",
-        "HTTPS",
-        "reverse proxy",
-        "server",
-        "network security"
-      ]
+      "projectDomain": "push.rocks"
     }
   },
   "npmci": {
     "npmGlobalTools": [],
     "npmAccessLevel": "public"
-  },
-  "tsdoc": {
-    "legal": "\n## License and Legal Information\n\nThis repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH  \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
   }
 }

package.json

@@ -1,92 +1,44 @@
 {
-  "name": "@push.rocks/smartproxy",
-  "version": "19.5.19",
+  "name": "@pushrocks/smartproxy",
+  "version": "1.0.18",
   "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",
-  "typings": "dist_ts/index.d.ts",
-  "type": "module",
+  "description": "a proxy for handling high workloads of proxying",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
   "author": "Lossless GmbH",
   "license": "MIT",
   "scripts": {
-    "test": "(tstest test/**/test*.ts --verbose --timeout 60 --logfile)",
-    "build": "(tsbuild tsfolders --allowimplicitany)",
-    "format": "(gitzone format)",
-    "buildDocs": "tsdoc"
+    "test": "(tstest test/)",
+    "build": "(tsbuild)",
+    "format": "(gitzone format)"
   },
   "devDependencies": {
-    "@git.zone/tsbuild": "^2.6.4",
-    "@git.zone/tsrun": "^1.2.44",
-    "@git.zone/tstest": "^2.3.1",
-    "@types/node": "^22.15.29",
-    "typescript": "^5.8.3"
+    "@gitzone/tsbuild": "^2.0.22",
+    "@gitzone/tstest": "^1.0.15",
+    "@pushrocks/tapbundle": "^3.0.7",
+    "@types/node": "^12.7.2",
+    "tslint": "^5.19.0",
+    "tslint-config-prettier": "^1.15.0"
   },
   "dependencies": {
-    "@push.rocks/lik": "^6.2.2",
-    "@push.rocks/smartacme": "^8.0.0",
-    "@push.rocks/smartcrypto": "^2.0.4",
-    "@push.rocks/smartdelay": "^3.0.5",
-    "@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",
-    "@push.rocks/taskbuffer": "^3.1.7",
-    "@tsclass/tsclass": "^9.2.0",
-    "@types/minimatch": "^5.1.2",
-    "@types/ws": "^8.18.1",
-    "minimatch": "^10.0.1",
-    "pretty-ms": "^9.2.0",
-    "ws": "^8.18.2"
+    "@pushrocks/smartnetwork": "^1.1.6",
+    "@pushrocks/smartpromise": "^3.0.2",
+    "@pushrocks/smartrequest": "^1.1.23",
+    "@pushrocks/smartspawn": "^2.0.8",
+    "@pushrocks/smartsystem": "^2.0.7",
+    "@tsclass/tsclass": "^2.0.5",
+    "@types/ws": "^6.0.2",
+    "ws": "^7.1.2"
   },
   "files": [
-    "ts/**/*",
-    "ts_web/**/*",
-    "dist/**/*",
-    "dist_*/**/*",
-    "dist_ts/**/*",
-    "dist_ts_web/**/*",
-    "assets/**/*",
+    "ts/*",
+    "ts_web/*",
+    "dist/*",
+    "dist_web/*",
+    "dist_ts_web/*",
+    "assets/*",
     "cli.js",
     "npmextra.json",
     "readme.md"
-  ],
-  "browserslist": [
-    "last 1 chrome versions"
-  ],
-  "keywords": [
-    "proxy",
-    "network",
-    "traffic management",
-    "SSL",
-    "TLS",
-    "WebSocket",
-    "port proxying",
-    "dynamic routing",
-    "authentication",
-    "real-time applications",
-    "high workload",
-    "HTTPS",
-    "reverse proxy",
-    "server",
-    "network security"
-  ],
-  "homepage": "https://code.foss.global/push.rocks/smartproxy#readme",
-  "repository": {
-    "type": "git",
-    "url": "https://code.foss.global/push.rocks/smartproxy.git"
-  },
-  "bugs": {
-    "url": "https://code.foss.global/push.rocks/smartproxy/issues"
-  },
-  "pnpm": {
-    "overrides": {},
-    "onlyBuiltDependencies": [
-      "esbuild",
-      "mongodb-memory-server",
-      "puppeteer"
   ]
-  },
-  "packageManager": "pnpm@10.10.0+sha512.d615db246fe70f25dcfea6d8d73dee782ce23e2245e3c4f6f888249fb568149318637dca73c2c5c8ef2a4ca0d5657fb9567188bfab47f566d1ee6ce987815c39"
 }

readme.hints.md

@@ -1,805 +0,0 @@
-# SmartProxy Project Hints
-
-## Project Overview
-- 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.
-  - `plugins.ts` centralizes native and third-party imports.
-  - Subdirectories: `networkproxy/`, `nftablesproxy/`, `port80handler/`, `redirect/`, `smartproxy/`.
-  - Key classes: `ProxyRouter` (`classes.router.ts`), `SmartProxy` (`classes.smartproxy.ts`), plus handlers/managers.
-- `dist_ts/` – transpiled `.js` and `.d.ts` files mirroring `ts/` structure.
-- `test/` – test suites in TypeScript:
-  - `test.router.ts` – routing logic (hostname matching, wildcards, path parameters, config management).
-  - `test.smartproxy.ts` – proxy behavior tests (TCP forwarding, SNI handling, concurrency, chaining, timeouts).
-  - `test/helpers/` – utilities (e.g., certificates).
-- `assets/certs/` – placeholder certificates for ACME and TLS.
-
-## Development Setup
-- Requires `pnpm` (v10+).
-- Install dependencies: `pnpm install`.
-- Build: `pnpm build` (runs `tsbuild --web --allowimplicitany`).
-- Test: `pnpm test` (runs `tstest test/`).
-- Format: `pnpm format` (runs `gitzone format`).
-
-## 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`:
-  ```ts
-  import * as plugins from './plugins.ts';
-  const server = new plugins.http.Server();
-  ```
-- Reference plugins with full path: `plugins.acme`, `plugins.smartdelay`, `plugins.minimatch`, etc.
-- Path patterns support globs (`*`) and parameters (`:param`) in `ProxyRouter`.
-- Wildcard hostname matching leverages `minimatch` patterns.
-
-## Key Components
-- **ProxyRouter**
-  - Methods: `routeReq`, `routeReqWithDetails`.
-  - Hostname matching: case-insensitive, strips port, supports exact, wildcard, TLD, complex patterns.
-  - Path routing: exact, wildcard, parameter extraction (`pathParams`), returns `pathMatch` and `pathRemainder`.
-  - Config API: `setNewProxyConfigs`, `addProxyConfig`, `removeProxyConfig`, `getHostnames`, `getProxyConfigs`.
-- **SmartProxy**
-  - Manages one or more `net.Server` instances to forward TCP streams.
-  - Options: `preserveSourceIP`, `defaultAllowedIPs`, `globalPortRanges`, `sniEnabled`.
-  - DomainConfigManager: round-robin selection for multiple target IPs.
-  - Graceful shutdown in `stop()`, ensures no lingering servers or sockets.
-
-## Notable Points
-- **TSConfig**: `module: NodeNext`, `verbatimModuleSyntax`, allows `.js` extension imports in TS.
-- Mermaid diagrams and architecture flows in `readme.md` illustrate component interactions and protocol flows.
-- 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.
-- 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.
-
-## Connection Cleanup Improvements (v19.5.12+)
-
-### Issue
-Connections were still counting up during rapid retry scenarios, especially when routing failed or backend connections were refused. This was due to:
-1. **Delayed Cleanup**: Using `initiateCleanupOnce` queued cleanup operations (batch of 100 every 100ms) instead of immediate cleanup
-2. **NFTables Memory Leak**: NFTables connections were never cleaned up, staying in memory forever
-3. **Connection Limit Bypass**: When max connections reached, connection record check happened after creation
-
-### Root Cause Analysis
-1. **Queued vs Immediate Cleanup**:
-   - `initiateCleanupOnce()`: Adds to cleanup queue, processes up to 100 connections every 100ms
-   - `cleanupConnection()`: Immediate synchronous cleanup
-   - Under rapid retries, connections were created faster than the queue could process them
-
-2. **NFTables Connections**: 
-   - Marked with `usingNetworkProxy = true` but never cleaned up
-   - Connection records stayed in memory indefinitely
-
-3. **Error Path Cleanup**:
-   - Many error paths used `socket.end()` (async) followed by cleanup
-   - Created timing windows where connections weren't fully cleaned
-
-### Solution
-1. **Immediate Cleanup**: Changed all error paths from `initiateCleanupOnce()` to `cleanupConnection()` for immediate cleanup
-2. **NFTables Cleanup**: Added socket close listener to clean up connection records when NFTables connections close
-3. **Connection Limit Fix**: Added null check after `createConnection()` to handle rejection properly
-
-### Changes Made in route-connection-handler.ts
-```typescript
-// 1. NFTables cleanup (line 551-553)
-socket.once('close', () => {
-  this.connectionManager.cleanupConnection(record, 'nftables_closed');
-});
-
-// 2. Connection limit check (line 93-96)
-const record = this.connectionManager.createConnection(socket);
-if (!record) {
-  // Connection was rejected due to limit - socket already destroyed
-  return;
-}
-
-// 3. Changed all error paths to use immediate cleanup
-// Before: this.connectionManager.initiateCleanupOnce(record, reason)
-// After: this.connectionManager.cleanupConnection(record, reason)
-```
-
-### Test Coverage
-- `test/test.rapid-retry-cleanup.node.ts` - Verifies connection cleanup under rapid retry scenarios
-- Test shows connection count stays at 0 even with 20 rapid retries with 50ms intervals
-- Confirms both ECONNREFUSED and routing failure scenarios are handled correctly
-
-### Performance Impact
-- **Positive**: No more connection accumulation under load
-- **Positive**: Immediate cleanup reduces memory usage
-- **Consideration**: More frequent cleanup operations, but prevents queue backlog
-
-### Migration Notes
-No configuration changes needed. The improvements are automatic and backward compatible.
-
-## Early Client Disconnect Handling (v19.5.13+)
-
-### Issue
-Connections were accumulating when clients connected but disconnected before sending data or during routing. This occurred in two scenarios:
-1. **TLS Path**: Clients connecting and disconnecting before sending initial TLS handshake data
-2. **Non-TLS Immediate Routing**: Clients disconnecting while backend connection was being established
-
-### Root Cause
-1. **Missing Cleanup Handlers**: During initial data wait and immediate routing, no close/end handlers were attached to catch early disconnections
-2. **Race Condition**: Backend connection attempts continued even after client disconnected, causing unhandled errors
-3. **Timing Window**: Between accepting connection and establishing full bidirectional flow, disconnections weren't properly handled
-
-### Solution
-1. **TLS Path Fix**: Added close/end handlers during initial data wait (lines 224-253 in route-connection-handler.ts)
-2. **Immediate Routing Fix**: Used `setupSocketHandlers` for proper handler attachment (lines 180-205)
-3. **Backend Error Handling**: Check if connection already closed before handling backend errors (line 1144)
-
-### Changes Made
-```typescript
-// 1. TLS path - handle disconnect before initial data
-socket.once('close', () => {
-  if (!initialDataReceived) {
-    this.connectionManager.cleanupConnection(record, 'closed_before_data');
-  }
-});
-
-// 2. Immediate routing path - proper handler setup
-setupSocketHandlers(socket, (reason) => {
-  if (!record.outgoing || record.outgoing.readyState !== 'open') {
-    if (record.outgoing && !record.outgoing.destroyed) {
-      record.outgoing.destroy(); // Abort pending backend connection
-    }
-    this.connectionManager.cleanupConnection(record, reason);
-  }
-}, undefined, 'immediate-route-client');
-
-// 3. Backend connection error handling
-onError: (error) => {
-  if (record.connectionClosed) {
-    logger.log('debug', 'Backend connection failed but client already disconnected');
-    return; // Client already gone, nothing to clean up
-  }
-  // ... normal error handling
-}
-```
-
-### Test Coverage
-- `test/test.connect-disconnect-cleanup.node.ts` - Comprehensive test for early disconnect scenarios
-- Tests verify connection count stays at 0 even with rapid connect/disconnect patterns
-- Covers immediate disconnect, delayed disconnect, and mixed patterns
-
-### Performance Impact
-- **Positive**: No more connection accumulation from early disconnects
-- **Positive**: Immediate cleanup reduces memory usage
-- **Positive**: Prevents resource exhaustion from rapid reconnection attempts
-
-### Migration Notes
-No configuration changes needed. The fix is automatic and backward compatible.
-
-## Proxy Chain Connection Accumulation Fix (v19.5.14+)
-
-### Issue
-When chaining SmartProxies (Client → SmartProxy1 → SmartProxy2 → Backend), connections would accumulate and never be cleaned up. This was particularly severe when the backend was down or closing connections immediately.
-
-### Root Cause
-The half-open connection support was preventing proper cascade cleanup in proxy chains:
-1. Backend closes → SmartProxy2's server socket closes
-2. SmartProxy2 keeps client socket open (half-open support)
-3. SmartProxy1 never gets notified that downstream is closed
-4. Connections accumulate at each proxy in the chain
-
-The issue was in `createIndependentSocketHandlers()` which waited for BOTH sockets to close before cleanup.
-
-### Solution
-1. **Changed default behavior**: When one socket closes, both close immediately
-2. **Made half-open support opt-in**: Only enabled when explicitly requested
-3. **Centralized socket handling**: Created `setupBidirectionalForwarding()` for consistent behavior
-4. **Applied everywhere**: Updated HttpProxyBridge and route-connection-handler to use centralized handling
-
-### Changes Made
-```typescript
-// socket-utils.ts - Default behavior now closes both sockets
-export function createIndependentSocketHandlers(
-  clientSocket, serverSocket, onBothClosed,
-  options: { enableHalfOpen?: boolean } = {} // Half-open is opt-in
-) {
-  // When server closes, immediately close client (unless half-open enabled)
-  if (!clientClosed && !options.enableHalfOpen) {
-    clientSocket.destroy();
-  }
-}
-
-// New centralized function for consistent socket pairing
-export function setupBidirectionalForwarding(
-  clientSocket, serverSocket,
-  handlers: {
-    onClientData?: (chunk) => void;
-    onServerData?: (chunk) => void;
-    onCleanup: (reason) => void;
-    enableHalfOpen?: boolean; // Default: false
-  }
-)
-```
-
-### Test Coverage
-- `test/test.proxy-chain-simple.node.ts` - Verifies proxy chains don't accumulate connections
-- Tests confirm connections stay at 0 even with backend closing immediately
-- Works for any proxy chain configuration (not just localhost)
-
-### Performance Impact
-- **Positive**: No more connection accumulation in proxy chains
-- **Positive**: Immediate cleanup reduces memory usage
-- **Neutral**: Half-open connections still available when needed (opt-in)
-
-### Migration Notes
-No configuration changes needed. The fix applies to all proxy chains automatically.
-
-## Socket Cleanup Handler Deprecation (v19.5.15+)
-
-### Issue
-The deprecated `createSocketCleanupHandler()` function was still being used in forwarding handlers, despite being marked as deprecated.
-
-### Solution
-Updated all forwarding handlers to use the new centralized socket utilities:
-1. **Replaced `createSocketCleanupHandler()`** with `setupBidirectionalForwarding()` in:
-   - `https-terminate-to-https-handler.ts`
-   - `https-terminate-to-http-handler.ts`
-2. **Removed deprecated function** from `socket-utils.ts`
-
-### Benefits
-- Consistent socket handling across all handlers
-- Proper cleanup in proxy chains (no half-open connections by default)
-- Better backpressure handling with the centralized implementation
-- Reduced code duplication
-
-### Migration Notes
-No user-facing changes. All forwarding handlers now use the same robust socket handling as the main SmartProxy connection handler.
-
-## WrappedSocket Class Evaluation for PROXY Protocol (v19.5.19+)
-
-### Current Socket Handling Architecture
-- Sockets are handled directly as `net.Socket` instances throughout the codebase
-- Socket augmentation via TypeScript module augmentation for TLS properties
-- Metadata tracked separately in `IConnectionRecord` objects
-- Socket utilities provide helper functions but don't encapsulate the socket
-- Connection records track extensive metadata (IDs, timestamps, byte counters, TLS state, etc.)
-
-### Evaluation: Should We Introduce a WrappedSocket Class?
-
-**Yes, a WrappedSocket class would make sense**, particularly for PROXY protocol implementation and future extensibility.
-
-### Design Considerations for WrappedSocket
-
-```typescript
-class WrappedSocket {
-  private socket: net.Socket;
-  private connectionId: string;
-  private metadata: {
-    realClientIP?: string;     // From PROXY protocol
-    realClientPort?: number;   // From PROXY protocol
-    proxyIP?: string;          // Immediate connection IP
-    proxyPort?: number;        // Immediate connection port
-    bytesReceived: number;
-    bytesSent: number;
-    lastActivity: number;
-    isTLS: boolean;
-    // ... other metadata
-  };
-  
-  // PROXY protocol handling
-  private proxyProtocolParsed: boolean = false;
-  private pendingData: Buffer[] = [];
-  
-  constructor(socket: net.Socket) {
-    this.socket = socket;
-    this.setupHandlers();
-  }
-  
-  // Getters for clean access
-  get remoteAddress(): string {
-    return this.metadata.realClientIP || this.socket.remoteAddress || '';
-  }
-  
-  get remotePort(): number {
-    return this.metadata.realClientPort || this.socket.remotePort || 0;
-  }
-  
-  get isFromTrustedProxy(): boolean {
-    return !!this.metadata.realClientIP;
-  }
-  
-  // PROXY protocol parsing
-  async parseProxyProtocol(trustedProxies: string[]): Promise<boolean> {
-    // Implementation here
-  }
-  
-  // Delegate socket methods
-  write(data: any): boolean {
-    this.metadata.bytesSent += Buffer.byteLength(data);
-    return this.socket.write(data);
-  }
-  
-  destroy(error?: Error): void {
-    this.socket.destroy(error);
-  }
-  
-  // Event forwarding
-  on(event: string, listener: Function): this {
-    this.socket.on(event, listener);
-    return this;
-  }
-}
-```
-
-### Implementation Benefits
-
-1. **Encapsulation**: Bundle socket + metadata + behavior in one place
-2. **PROXY Protocol Integration**: Cleaner handling without modifying existing socket code
-3. **State Management**: Centralized socket state tracking and validation
-4. **API Consistency**: Uniform interface for all socket operations
-5. **Future Extensibility**: Easy to add new socket-level features (compression, encryption, etc.)
-6. **Type Safety**: Better TypeScript support without module augmentation
-7. **Testing**: Easier to mock and test socket behavior
-
-### Implementation Drawbacks
-
-1. **Major Refactoring**: Would require changes throughout the codebase
-2. **Performance Overhead**: Additional abstraction layer (minimal but present)
-3. **Compatibility**: Need to maintain event emitter compatibility
-4. **Learning Curve**: Developers need to understand the wrapper
-
-### Recommended Approach: Phased Implementation
-
-**Phase 1: PROXY Protocol Only** (Immediate)
-- Create minimal `ProxyProtocolSocket` wrapper for new connections from trusted proxies
-- Use in connection handler when receiving from trusted proxy IPs
-- Minimal disruption to existing code
-
-```typescript
-class ProxyProtocolSocket {
-  constructor(
-    public socket: net.Socket,
-    public realClientIP?: string,
-    public realClientPort?: number
-  ) {}
-  
-  get remoteAddress(): string {
-    return this.realClientIP || this.socket.remoteAddress || '';
-  }
-  
-  get remotePort(): number {
-    return this.realClientPort || this.socket.remotePort || 0;
-  }
-}
-```
-
-**Phase 2: Gradual Migration** (Future)
-- Extend wrapper with more functionality
-- Migrate critical paths to use wrapper
-- Add performance monitoring
-
-**Phase 3: Full Adoption** (Long-term)
-- Complete migration to WrappedSocket
-- Remove socket augmentation
-- Standardize all socket handling
-
-### Decision Summary
-
-✅ **Implement minimal ProxyProtocolSocket for immediate PROXY protocol support**
-- Low risk, high value
-- Solves the immediate proxy chain connection limit issue
-- Sets foundation for future improvements
-- Can be implemented alongside existing code
-
-📋 **Consider full WrappedSocket for future major version**
-- Cleaner architecture
-- Better maintainability
-- But requires significant refactoring

readme.plan.md

@@ -1,517 +0,0 @@
-# PROXY Protocol Implementation Plan
-
-## Overview
-Implement PROXY protocol support in SmartProxy to preserve client IP information through proxy chains, solving the connection limit accumulation issue where inner proxies see all connections as coming from the outer proxy's IP.
-
-## Problem Statement
-- In proxy chains, the inner proxy sees all connections from the outer proxy's IP
-- This causes the inner proxy to hit per-IP connection limits (default: 100)
-- Results in connection rejections while outer proxy accumulates connections
-
-## Solution Design
-
-### 1. Core Features
-
-#### 1.1 PROXY Protocol Parsing
-- Support PROXY protocol v1 (text format) initially
-- Parse incoming PROXY headers to extract:
-  - Real client IP address
-  - Real client port
-  - Proxy IP address
-  - Proxy port
-  - Protocol (TCP4/TCP6)
-
-#### 1.2 PROXY Protocol Generation
-- Add ability to send PROXY protocol headers when forwarding connections
-- Configurable per route or target
-
-#### 1.3 Trusted Proxy IPs
-- New `proxyIPs` array in SmartProxy options
-- Auto-enable PROXY protocol acceptance for connections from these IPs
-- Reject PROXY protocol from untrusted sources (security)
-
-### 2. Configuration Schema
-
-```typescript
-interface ISmartProxyOptions {
-  // ... existing options
-  
-  // List of trusted proxy IPs that can send PROXY protocol
-  proxyIPs?: string[];
-  
-  // Global option to accept PROXY protocol (defaults based on proxyIPs)
-  acceptProxyProtocol?: boolean;
-  
-  // Global option to send PROXY protocol to all targets
-  sendProxyProtocol?: boolean;
-}
-
-interface IRouteAction {
-  // ... existing options
-  
-  // Send PROXY protocol to this specific target
-  sendProxyProtocol?: boolean;
-}
-```
-
-### 3. Implementation Steps
-
-#### Phase 1: WrappedSocket Foundation
-1. Create minimal `ProxyProtocolSocket` class in `ts/core/models/proxy-protocol-socket.ts`
-2. Implement basic socket wrapper with real IP getters
-3. Update `ConnectionManager` to accept wrapped sockets
-4. Create tests for wrapped socket functionality
-
-#### Phase 2: PROXY Protocol Parser
-1. Create `ProxyProtocolParser` class in `ts/core/utils/proxy-protocol.ts`
-2. Implement v1 text format parsing
-3. Add validation and error handling
-4. Integrate parser into ProxyProtocolSocket
-
-#### Phase 3: Connection Handler Integration
-1. Modify `RouteConnectionHandler` to use ProxyProtocolSocket for trusted IPs
-2. Parse PROXY header before TLS detection
-3. Use wrapped socket throughout connection lifecycle
-4. Strip PROXY header before forwarding data
-
-#### Phase 4: Outbound PROXY Protocol
-1. Add PROXY header generation in `setupDirectConnection`
-2. Make it configurable per route
-3. Send header immediately after TCP connection
-4. Use ProxyProtocolSocket for outbound connections too
-
-#### Phase 5: Security & Validation
-1. Validate PROXY headers strictly
-2. Reject malformed headers
-3. Only accept from trusted IPs
-4. Add rate limiting for PROXY protocol parsing
-
-### 4. Design Decision: Socket Wrapper Architecture
-
-#### Option A: Minimal Single Socket Wrapper
-- **Scope**: Wraps individual sockets with metadata
-- **Use Case**: PROXY protocol support with minimal refactoring
-- **Pros**: Simple, low risk, easy migration
-- **Cons**: Still need separate connection management
-
-#### Option B: Comprehensive Connection Wrapper
-- **Scope**: Manages socket pairs (incoming + outgoing) with all utilities
-- **Use Case**: Complete connection lifecycle management
-- **Pros**: 
-  - Encapsulates all socket utilities (forwarding, cleanup, backpressure)
-  - Single object represents entire connection
-  - Cleaner API for connection handling
-- **Cons**: 
-  - Major architectural change
-  - Higher implementation risk
-  - More complex migration
-
-#### Recommendation
-Start with **Option A** (ProxyProtocolSocket) for immediate PROXY protocol support, then evaluate Option B based on:
-- Performance impact of additional abstraction
-- Code simplification benefits
-- Team comfort with architectural change
-
-### 5. Code Changes (Using Option A Initially)
-
-#### 5.1 ProxyProtocolSocket (new file)
-```typescript
-// ts/core/models/proxy-protocol-socket.ts
-export class ProxyProtocolSocket {
-  constructor(
-    public readonly socket: plugins.net.Socket,
-    private realClientIP?: string,
-    private realClientPort?: number
-  ) {}
-  
-  get remoteAddress(): string {
-    return this.realClientIP || this.socket.remoteAddress || '';
-  }
-  
-  get remotePort(): number {
-    return this.realClientPort || this.socket.remotePort || 0;
-  }
-  
-  get isFromTrustedProxy(): boolean {
-    return !!this.realClientIP;
-  }
-  
-  setProxyInfo(ip: string, port: number): void {
-    this.realClientIP = ip;
-    this.realClientPort = port;
-  }
-}
-```
-
-#### 4.2 ProxyProtocolParser (new file)
-```typescript
-// ts/core/utils/proxy-protocol.ts
-export class ProxyProtocolParser {
-  static readonly PROXY_V1_SIGNATURE = 'PROXY ';
-  
-  static parse(chunk: Buffer): IProxyInfo | null {
-    // Implementation
-  }
-  
-  static generate(info: IProxyInfo): Buffer {
-    // Implementation
-  }
-}
-```
-
-#### 4.3 Connection Handler Updates
-```typescript
-// In handleConnection method
-let wrappedSocket: ProxyProtocolSocket | plugins.net.Socket = socket;
-
-// Wrap socket if from trusted proxy
-if (this.settings.proxyIPs?.includes(socket.remoteAddress)) {
-  wrappedSocket = new ProxyProtocolSocket(socket);
-}
-
-// Create connection record with wrapped socket
-const record = this.connectionManager.createConnection(wrappedSocket);
-
-// In handleInitialData method
-if (wrappedSocket instanceof ProxyProtocolSocket) {
-  const proxyInfo = await this.checkForProxyProtocol(chunk);
-  if (proxyInfo) {
-    wrappedSocket.setProxyInfo(proxyInfo.sourceIP, proxyInfo.sourcePort);
-    // Continue with remaining data after PROXY header
-  }
-}
-```
-
-#### 4.4 Security Manager Updates
-- Accept socket or ProxyProtocolSocket
-- Use `socket.remoteAddress` getter for real client IP
-- Transparent handling of both socket types
-
-### 5. Configuration Examples
-
-#### Basic Setup
-```typescript
-// Outer proxy - sends PROXY protocol
-const outerProxy = new SmartProxy({
-  ports: [443],
-  routes: [{
-    name: 'to-inner-proxy',
-    match: { ports: 443 },
-    action: {
-      type: 'forward',
-      target: { host: '195.201.98.232', port: 443 },
-      sendProxyProtocol: true  // Enable for this route
-    }
-  }]
-});
-
-// Inner proxy - accepts PROXY protocol from outer proxy
-const innerProxy = new SmartProxy({
-  ports: [443],
-  proxyIPs: ['212.95.99.130'],  // Outer proxy IP
-  // acceptProxyProtocol: true is automatic for proxyIPs
-  routes: [{
-    name: 'to-backend',
-    match: { ports: 443 },
-    action: {
-      type: 'forward',
-      target: { host: '192.168.5.247', port: 443 }
-    }
-  }]
-});
-```
-
-### 6. Testing Plan
-
-#### Unit Tests
-- PROXY protocol v1 parsing (valid/invalid formats)
-- Header generation
-- Trusted IP validation
-- Connection record updates
-
-#### Integration Tests
-- Single proxy with PROXY protocol
-- Proxy chain with PROXY protocol
-- Security: reject from untrusted IPs
-- Performance: minimal overhead
-- Compatibility: works with TLS passthrough
-
-#### Test Scenarios
-1. **Connection limit test**: Verify inner proxy sees real client IPs
-2. **Security test**: Ensure PROXY protocol rejected from untrusted sources
-3. **Compatibility test**: Verify no impact on non-PROXY connections
-4. **Performance test**: Measure overhead of PROXY protocol parsing
-
-### 7. Security Considerations
-
-1. **IP Spoofing Prevention**
-   - Only accept PROXY protocol from explicitly trusted IPs
-   - Validate all header fields
-   - Reject malformed headers immediately
-
-2. **Resource Protection**
-   - Limit PROXY header size (107 bytes for v1)
-   - Timeout for incomplete headers
-   - Rate limit connection attempts
-
-3. **Logging**
-   - Log all PROXY protocol acceptance/rejection
-   - Include real client IP in all connection logs
-
-### 8. Rollout Strategy
-
-1. **Phase 1**: Deploy parser and acceptance (backward compatible)
-2. **Phase 2**: Enable between controlled proxy pairs
-3. **Phase 3**: Monitor for issues and performance impact
-4. **Phase 4**: Expand to all proxy chains
-
-### 9. Success Metrics
-
-- Inner proxy connection distribution matches outer proxy
-- No more connection limit rejections in proxy chains
-- Accurate client IP logging throughout the chain
-- No performance degradation (<1ms added latency)
-
-### 10. Future Enhancements
-
-- PROXY protocol v2 (binary format) support
-- TLV extensions for additional metadata
-- AWS VPC endpoint ID support
-- Custom metadata fields
-
-## WrappedSocket Class Design
-
-### Overview
-A WrappedSocket class has been evaluated and recommended to provide cleaner PROXY protocol integration and better socket management architecture.
-
-### Rationale for WrappedSocket
-
-#### Current Challenges
-- Sockets handled directly as `net.Socket` instances throughout codebase
-- Metadata tracked separately in `IConnectionRecord` objects
-- Socket augmentation via TypeScript module augmentation for TLS properties
-- PROXY protocol would require modifying socket handling in multiple places
-
-#### Benefits
-1. **Clean PROXY Protocol Integration** - Parse and store real client IP/port without modifying existing socket handling
-2. **Better Encapsulation** - Bundle socket + metadata + behavior together
-3. **Type Safety** - No more module augmentation needed
-4. **Future Extensibility** - Easy to add compression, metrics, etc.
-5. **Simplified Testing** - Easier to mock and test socket behavior
-
-### Implementation Strategy
-
-#### Phase 1: Minimal ProxyProtocolSocket (Immediate)
-Create a minimal wrapper for PROXY protocol support:
-
-```typescript
-class ProxyProtocolSocket {
-  constructor(
-    public socket: net.Socket,
-    public realClientIP?: string,
-    public realClientPort?: number
-  ) {}
-  
-  get remoteAddress(): string {
-    return this.realClientIP || this.socket.remoteAddress || '';
-  }
-  
-  get remotePort(): number {
-    return this.realClientPort || this.socket.remotePort || 0;
-  }
-  
-  get isFromTrustedProxy(): boolean {
-    return !!this.realClientIP;
-  }
-}
-```
-
-Integration points:
-- Use in `RouteConnectionHandler` when receiving from trusted proxy IPs
-- Update `ConnectionManager` to accept wrapped sockets
-- Modify security checks to use `socket.remoteAddress` getter
-
-#### Phase 2: Connection-Aware WrappedSocket (Alternative Design)
-A more comprehensive design that manages both sides of a connection:
-
-```typescript
-// Option A: Single Socket Wrapper (simpler)
-class WrappedSocket extends EventEmitter {
-  private socket: net.Socket;
-  private connectionId: string;
-  private metadata: ISocketMetadata;
-  
-  constructor(socket: net.Socket, metadata?: Partial<ISocketMetadata>) {
-    super();
-    this.socket = socket;
-    this.connectionId = this.generateId();
-    this.metadata = { ...defaultMetadata, ...metadata };
-    this.setupHandlers();
-  }
-  
-  // ... single socket management
-}
-
-// Option B: Connection Pair Wrapper (comprehensive)
-class WrappedConnection extends EventEmitter {
-  private connectionId: string;
-  private incoming: WrappedSocket;
-  private outgoing?: WrappedSocket;
-  private forwardingActive: boolean = false;
-  
-  constructor(incomingSocket: net.Socket) {
-    super();
-    this.connectionId = this.generateId();
-    this.incoming = new WrappedSocket(incomingSocket);
-  }
-  
-  // Connect to backend and set up forwarding
-  async connectToBackend(target: ITarget): Promise<void> {
-    const outgoingSocket = await this.createOutgoingConnection(target);
-    this.outgoing = new WrappedSocket(outgoingSocket);
-    await this.setupBidirectionalForwarding();
-  }
-  
-  // Built-in forwarding logic from socket-utils
-  private async setupBidirectionalForwarding(): Promise<void> {
-    if (!this.outgoing) throw new Error('No outgoing socket');
-    
-    // Handle data forwarding with backpressure
-    this.incoming.on('data', (chunk) => {
-      this.outgoing!.write(chunk, () => {
-        // Handle backpressure
-      });
-    });
-    
-    this.outgoing.on('data', (chunk) => {
-      this.incoming.write(chunk, () => {
-        // Handle backpressure
-      });
-    });
-    
-    // Handle connection lifecycle
-    const cleanup = (reason: string) => {
-      this.forwardingActive = false;
-      this.incoming.destroy();
-      this.outgoing?.destroy();
-      this.emit('closed', reason);
-    };
-    
-    this.incoming.once('close', () => cleanup('incoming_closed'));
-    this.outgoing.once('close', () => cleanup('outgoing_closed'));
-    
-    this.forwardingActive = true;
-  }
-  
-  // PROXY protocol support
-  async handleProxyProtocol(trustedProxies: string[]): Promise<boolean> {
-    if (trustedProxies.includes(this.incoming.socket.remoteAddress)) {
-      const parsed = await this.incoming.parseProxyProtocol();
-      if (parsed && this.outgoing) {
-        // Forward PROXY protocol to backend if configured
-        await this.outgoing.sendProxyProtocol(this.incoming.realClientIP);
-      }
-      return parsed;
-    }
-    return false;
-  }
-  
-  // Consolidated metrics
-  getMetrics(): IConnectionMetrics {
-    return {
-      connectionId: this.connectionId,
-      duration: Date.now() - this.startTime,
-      incoming: this.incoming.getMetrics(),
-      outgoing: this.outgoing?.getMetrics(),
-      totalBytes: this.getTotalBytes(),
-      state: this.getConnectionState()
-    };
-  }
-}
-```
-
-#### Phase 3: Full Migration (Long-term)
-- Replace all `net.Socket` usage with `WrappedSocket`
-- Remove socket augmentation from `socket-augmentation.ts`
-- Update all socket utilities to work with wrapped sockets
-- Standardize socket handling across all components
-
-### Integration with PROXY Protocol
-
-The WrappedSocket class integrates seamlessly with PROXY protocol:
-
-1. **Connection Acceptance**:
-   ```typescript
-   const wrappedSocket = new ProxyProtocolSocket(socket);
-   if (this.isFromTrustedProxy(socket.remoteAddress)) {
-     await wrappedSocket.parseProxyProtocol(this.settings.proxyIPs);
-   }
-   ```
-
-2. **Security Checks**:
-   ```typescript
-   // Automatically uses real client IP if available
-   const clientIP = wrappedSocket.remoteAddress;
-   if (!this.securityManager.isIPAllowed(clientIP)) {
-     wrappedSocket.destroy();
-   }
-   ```
-
-3. **Connection Records**:
-   ```typescript
-   const record = this.connectionManager.createConnection(wrappedSocket);
-   // ConnectionManager uses wrappedSocket.remoteAddress transparently
-   ```
-
-### Option B Example: How It Would Replace Current Architecture
-
-Instead of current approach with separate components:
-```typescript
-// Current: Multiple separate components
-const record = connectionManager.createConnection(socket);
-const { cleanupClient, cleanupServer } = createIndependentSocketHandlers(
-  clientSocket, serverSocket, onBothClosed
-);
-setupBidirectionalForwarding(clientSocket, serverSocket, handlers);
-```
-
-Option B would consolidate everything:
-```typescript
-// Option B: Single connection object
-const connection = new WrappedConnection(incomingSocket);
-await connection.handleProxyProtocol(trustedProxies);
-await connection.connectToBackend({ host: 'server', port: 443 });
-// Everything is handled internally - forwarding, cleanup, metrics
-
-connection.on('closed', (reason) => {
-  logger.log('Connection closed', connection.getMetrics());
-});
-```
-
-This would replace:
-- `IConnectionRecord` - absorbed into WrappedConnection
-- `socket-utils.ts` functions - methods on WrappedConnection
-- Separate incoming/outgoing tracking - unified in one object
-- Manual cleanup coordination - automatic lifecycle management
-
-Additional benefits with Option B:
-- **Connection Pooling Integration**: WrappedConnection could integrate with EnhancedConnectionPool for backend connections
-- **Unified Metrics**: Single point for all connection statistics
-- **Protocol Negotiation**: Handle PROXY, TLS, HTTP/2 upgrade in one place
-- **Resource Management**: Automatic cleanup with LifecycleComponent pattern
-
-### Migration Path
-
-1. **Week 1-2**: Implement minimal ProxyProtocolSocket (Option A)
-2. **Week 3-4**: Test with PROXY protocol implementation
-3. **Month 2**: Prototype WrappedConnection (Option B) if beneficial
-4. **Month 3-6**: Gradual migration if Option B proves valuable
-5. **Future**: Complete adoption in next major version
-
-### Success Criteria
-
-- PROXY protocol works transparently with wrapped sockets
-- No performance regression (<0.1% overhead)
-- Simplified code in connection handlers
-- Better TypeScript type safety
-- Easier to add new socket-level features

readme.routing.md

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

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

@@ -1,22 +0,0 @@
-import { IpUtils } from '../../../ts/core/utils/ip-utils.js';
-
-// Test the overlap case
-const result = IpUtils.isIPAuthorized('127.0.0.1', ['127.0.0.1'], ['127.0.0.1']);
-console.log('Result of IP that is both allowed and blocked:', result);
-
-// Trace through the code logic
-const ip = '127.0.0.1';
-const allowedIPs = ['127.0.0.1'];
-const blockedIPs = ['127.0.0.1'];
-
-console.log('Step 1 check:', (!ip || (allowedIPs.length === 0 && blockedIPs.length === 0)));
-
-// Check if IP is blocked - blocked IPs take precedence
-console.log('blockedIPs length > 0:', blockedIPs.length > 0);
-console.log('isGlobIPMatch result:', IpUtils.isGlobIPMatch(ip, blockedIPs));
-console.log('Step 2 check (is blocked):', (blockedIPs.length > 0 && IpUtils.isGlobIPMatch(ip, blockedIPs)));
-
-// Check if IP is allowed
-console.log('allowedIPs length === 0:', allowedIPs.length === 0);
-console.log('isGlobIPMatch for allowed:', IpUtils.isGlobIPMatch(ip, allowedIPs));
-console.log('Step 3 (is allowed):', allowedIPs.length === 0 || IpUtils.isGlobIPMatch(ip, allowedIPs));

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

@@ -1,200 +0,0 @@
-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

@@ -1,206 +0,0 @@
-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.fs-utils.ts

@@ -1,185 +0,0 @@
-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,156 +0,0 @@
-import { expect, tap } from '@git.zone/tstest/tapbundle';
-import { IpUtils } from '../../../ts/core/utils/ip-utils.js';
-
-tap.test('ip-utils - normalizeIP', async () => {
-  // IPv4 normalization
-  const ipv4Variants = IpUtils.normalizeIP('127.0.0.1');
-  expect(ipv4Variants).toEqual(['127.0.0.1', '::ffff:127.0.0.1']);
-  
-  // IPv6-mapped IPv4 normalization
-  const ipv6MappedVariants = IpUtils.normalizeIP('::ffff:127.0.0.1');
-  expect(ipv6MappedVariants).toEqual(['::ffff:127.0.0.1', '127.0.0.1']);
-  
-  // IPv6 normalization
-  const ipv6Variants = IpUtils.normalizeIP('::1');
-  expect(ipv6Variants).toEqual(['::1']);
-  
-  // Invalid/empty input handling
-  expect(IpUtils.normalizeIP('')).toEqual([]);
-  expect(IpUtils.normalizeIP(null as any)).toEqual([]);
-  expect(IpUtils.normalizeIP(undefined as any)).toEqual([]);
-});
-
-tap.test('ip-utils - isGlobIPMatch', async () => {
-  // Direct matches
-  expect(IpUtils.isGlobIPMatch('127.0.0.1', ['127.0.0.1'])).toEqual(true);
-  expect(IpUtils.isGlobIPMatch('::1', ['::1'])).toEqual(true);
-  
-  // Wildcard matches
-  expect(IpUtils.isGlobIPMatch('127.0.0.1', ['127.0.0.*'])).toEqual(true);
-  expect(IpUtils.isGlobIPMatch('127.0.0.1', ['127.0.*.*'])).toEqual(true);
-  expect(IpUtils.isGlobIPMatch('127.0.0.1', ['127.*.*.*'])).toEqual(true);
-  
-  // IPv4-mapped IPv6 handling
-  expect(IpUtils.isGlobIPMatch('::ffff:127.0.0.1', ['127.0.0.1'])).toEqual(true);
-  expect(IpUtils.isGlobIPMatch('127.0.0.1', ['::ffff:127.0.0.1'])).toEqual(true);
-  
-  // Match multiple patterns
-  expect(IpUtils.isGlobIPMatch('127.0.0.1', ['10.0.0.1', '127.0.0.1', '192.168.1.1'])).toEqual(true);
-  
-  // Non-matching patterns
-  expect(IpUtils.isGlobIPMatch('127.0.0.1', ['10.0.0.1'])).toEqual(false);
-  expect(IpUtils.isGlobIPMatch('127.0.0.1', ['128.0.0.1'])).toEqual(false);
-  expect(IpUtils.isGlobIPMatch('127.0.0.1', ['127.0.0.2'])).toEqual(false);
-  
-  // Edge cases
-  expect(IpUtils.isGlobIPMatch('', ['127.0.0.1'])).toEqual(false);
-  expect(IpUtils.isGlobIPMatch('127.0.0.1', [])).toEqual(false);
-  expect(IpUtils.isGlobIPMatch('127.0.0.1', null as any)).toEqual(false);
-  expect(IpUtils.isGlobIPMatch(null as any, ['127.0.0.1'])).toEqual(false);
-});
-
-tap.test('ip-utils - isIPAuthorized', async () => {
-  // Basic tests to check the core functionality works
-  // No restrictions - all IPs allowed
-  expect(IpUtils.isIPAuthorized('127.0.0.1')).toEqual(true);
-
-  // Basic blocked IP test
-  const blockedIP = '8.8.8.8';
-  const blockedIPs = [blockedIP];
-  expect(IpUtils.isIPAuthorized(blockedIP, [], blockedIPs)).toEqual(false);
-
-  // Basic allowed IP test
-  const allowedIP = '10.0.0.1';
-  const allowedIPs = [allowedIP];
-  expect(IpUtils.isIPAuthorized(allowedIP, allowedIPs)).toEqual(true);
-  expect(IpUtils.isIPAuthorized('192.168.1.1', allowedIPs)).toEqual(false);
-});
-
-tap.test('ip-utils - isPrivateIP', async () => {
-  // Private IPv4 ranges
-  expect(IpUtils.isPrivateIP('10.0.0.1')).toEqual(true);
-  expect(IpUtils.isPrivateIP('172.16.0.1')).toEqual(true);
-  expect(IpUtils.isPrivateIP('172.31.255.255')).toEqual(true);
-  expect(IpUtils.isPrivateIP('192.168.0.1')).toEqual(true);
-  expect(IpUtils.isPrivateIP('127.0.0.1')).toEqual(true);
-  
-  // Public IPv4 addresses
-  expect(IpUtils.isPrivateIP('8.8.8.8')).toEqual(false);
-  expect(IpUtils.isPrivateIP('203.0.113.1')).toEqual(false);
-  
-  // IPv4-mapped IPv6 handling
-  expect(IpUtils.isPrivateIP('::ffff:10.0.0.1')).toEqual(true);
-  expect(IpUtils.isPrivateIP('::ffff:8.8.8.8')).toEqual(false);
-  
-  // Private IPv6 addresses
-  expect(IpUtils.isPrivateIP('::1')).toEqual(true);
-  expect(IpUtils.isPrivateIP('fd00::')).toEqual(true);
-  expect(IpUtils.isPrivateIP('fe80::1')).toEqual(true);
-  
-  // Public IPv6 addresses
-  expect(IpUtils.isPrivateIP('2001:db8::1')).toEqual(false);
-  
-  // Edge cases
-  expect(IpUtils.isPrivateIP('')).toEqual(false);
-  expect(IpUtils.isPrivateIP(null as any)).toEqual(false);
-  expect(IpUtils.isPrivateIP(undefined as any)).toEqual(false);
-});
-
-tap.test('ip-utils - isPublicIP', async () => {
-  // Public IPv4 addresses
-  expect(IpUtils.isPublicIP('8.8.8.8')).toEqual(true);
-  expect(IpUtils.isPublicIP('203.0.113.1')).toEqual(true);
-  
-  // Private IPv4 ranges
-  expect(IpUtils.isPublicIP('10.0.0.1')).toEqual(false);
-  expect(IpUtils.isPublicIP('172.16.0.1')).toEqual(false);
-  expect(IpUtils.isPublicIP('192.168.0.1')).toEqual(false);
-  expect(IpUtils.isPublicIP('127.0.0.1')).toEqual(false);
-  
-  // Public IPv6 addresses
-  expect(IpUtils.isPublicIP('2001:db8::1')).toEqual(true);
-  
-  // Private IPv6 addresses
-  expect(IpUtils.isPublicIP('::1')).toEqual(false);
-  expect(IpUtils.isPublicIP('fd00::')).toEqual(false);
-  expect(IpUtils.isPublicIP('fe80::1')).toEqual(false);
-  
-  // Edge cases - the implementation treats these as non-private, which is technically correct but might not be what users expect
-  const emptyResult = IpUtils.isPublicIP('');
-  expect(emptyResult).toEqual(true);
-
-  const nullResult = IpUtils.isPublicIP(null as any);
-  expect(nullResult).toEqual(true);
-
-  const undefinedResult = IpUtils.isPublicIP(undefined as any);
-  expect(undefinedResult).toEqual(true);
-});
-
-tap.test('ip-utils - cidrToGlobPatterns', async () => {
-  // Class C network
-  const classC = IpUtils.cidrToGlobPatterns('192.168.1.0/24');
-  expect(classC).toEqual(['192.168.1.*']);
-  
-  // Class B network
-  const classB = IpUtils.cidrToGlobPatterns('172.16.0.0/16');
-  expect(classB).toEqual(['172.16.*.*']);
-  
-  // Class A network
-  const classA = IpUtils.cidrToGlobPatterns('10.0.0.0/8');
-  expect(classA).toEqual(['10.*.*.*']);
-  
-  // Small subnet (/28 = 16 addresses)
-  const smallSubnet = IpUtils.cidrToGlobPatterns('192.168.1.0/28');
-  expect(smallSubnet.length).toEqual(16);
-  expect(smallSubnet).toContain('192.168.1.0');
-  expect(smallSubnet).toContain('192.168.1.15');
-  
-  // Invalid inputs
-  expect(IpUtils.cidrToGlobPatterns('')).toEqual([]);
-  expect(IpUtils.cidrToGlobPatterns('192.168.1.0')).toEqual([]);
-  expect(IpUtils.cidrToGlobPatterns('192.168.1.0/')).toEqual([]);
-  expect(IpUtils.cidrToGlobPatterns('192.168.1.0/33')).toEqual([]);
-  expect(IpUtils.cidrToGlobPatterns('invalid/24')).toEqual([]);
-});
-
-export default tap.start();

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

@@ -1,252 +0,0 @@
-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,110 +0,0 @@
-import { expect, tap } from '@git.zone/tstest/tapbundle';
-import * as routeUtils from '../../../ts/core/utils/route-utils.js';
-
-// Test domain matching
-tap.test('Route Utils - Domain Matching - exact domains', async () => {
-  expect(routeUtils.matchDomain('example.com', 'example.com')).toEqual(true);
-});
-
-tap.test('Route Utils - Domain Matching - wildcard domains', async () => {
-  expect(routeUtils.matchDomain('*.example.com', 'sub.example.com')).toEqual(true);
-  expect(routeUtils.matchDomain('*.example.com', 'another.sub.example.com')).toEqual(true);
-  expect(routeUtils.matchDomain('*.example.com', 'example.com')).toEqual(false);
-});
-
-tap.test('Route Utils - Domain Matching - case insensitivity', async () => {
-  expect(routeUtils.matchDomain('example.com', 'EXAMPLE.com')).toEqual(true);
-});
-
-tap.test('Route Utils - Domain Matching - multiple domain patterns', async () => {
-  expect(routeUtils.matchRouteDomain(['example.com', '*.test.com'], 'example.com')).toEqual(true);
-  expect(routeUtils.matchRouteDomain(['example.com', '*.test.com'], 'sub.test.com')).toEqual(true);
-  expect(routeUtils.matchRouteDomain(['example.com', '*.test.com'], 'something.else')).toEqual(false);
-});
-
-// Test path matching
-tap.test('Route Utils - Path Matching - exact paths', async () => {
-  expect(routeUtils.matchPath('/api/users', '/api/users')).toEqual(true);
-});
-
-tap.test('Route Utils - Path Matching - wildcard paths', async () => {
-  expect(routeUtils.matchPath('/api/*', '/api/users')).toEqual(true);
-  expect(routeUtils.matchPath('/api/*', '/api/products')).toEqual(true);
-  expect(routeUtils.matchPath('/api/*', '/something/else')).toEqual(false);
-});
-
-tap.test('Route Utils - Path Matching - complex wildcard patterns', async () => {
-  expect(routeUtils.matchPath('/api/*/details', '/api/users/details')).toEqual(true);
-  expect(routeUtils.matchPath('/api/*/details', '/api/products/details')).toEqual(true);
-  expect(routeUtils.matchPath('/api/*/details', '/api/users/other')).toEqual(false);
-});
-
-// Test IP matching
-tap.test('Route Utils - IP Matching - exact IPs', async () => {
-  expect(routeUtils.matchIpPattern('192.168.1.1', '192.168.1.1')).toEqual(true);
-});
-
-tap.test('Route Utils - IP Matching - wildcard IPs', async () => {
-  expect(routeUtils.matchIpPattern('192.168.1.*', '192.168.1.100')).toEqual(true);
-  expect(routeUtils.matchIpPattern('192.168.1.*', '192.168.2.1')).toEqual(false);
-});
-
-tap.test('Route Utils - IP Matching - CIDR notation', async () => {
-  expect(routeUtils.matchIpPattern('192.168.1.0/24', '192.168.1.100')).toEqual(true);
-  expect(routeUtils.matchIpPattern('192.168.1.0/24', '192.168.2.1')).toEqual(false);
-});
-
-tap.test('Route Utils - IP Matching - IPv6-mapped IPv4 addresses', async () => {
-  expect(routeUtils.matchIpPattern('192.168.1.1', '::ffff:192.168.1.1')).toEqual(true);
-});
-
-tap.test('Route Utils - IP Matching - IP authorization with allow/block lists', async () => {
-  // With allow and block lists
-  expect(routeUtils.isIpAuthorized('192.168.1.1', ['192.168.1.*'], ['192.168.1.5'])).toEqual(true);
-  expect(routeUtils.isIpAuthorized('192.168.1.5', ['192.168.1.*'], ['192.168.1.5'])).toEqual(false);
-  
-  // With only allow list
-  expect(routeUtils.isIpAuthorized('192.168.1.1', ['192.168.1.*'])).toEqual(true);
-  expect(routeUtils.isIpAuthorized('192.168.2.1', ['192.168.1.*'])).toEqual(false);
-  
-  // With only block list
-  expect(routeUtils.isIpAuthorized('192.168.1.5', undefined, ['192.168.1.5'])).toEqual(false);
-  expect(routeUtils.isIpAuthorized('192.168.1.1', undefined, ['192.168.1.5'])).toEqual(true);
-  
-  // With wildcard in allow list
-  expect(routeUtils.isIpAuthorized('192.168.1.1', ['*'], ['192.168.1.5'])).toEqual(true);
-});
-
-// Test route specificity calculation
-tap.test('Route Utils - Route Specificity - calculating correctly', async () => {
-  const basicRoute = { domains: 'example.com' };
-  const pathRoute = { domains: 'example.com', path: '/api' };
-  const wildcardPathRoute = { domains: 'example.com', path: '/api/*' };
-  const headerRoute = { domains: 'example.com', headers: { 'content-type': 'application/json' } };
-  const complexRoute = { 
-    domains: 'example.com', 
-    path: '/api', 
-    headers: { 'content-type': 'application/json' },
-    clientIp: ['192.168.1.1'] 
-  };
-  
-  // Path routes should have higher specificity than domain-only routes
-  expect(routeUtils.calculateRouteSpecificity(pathRoute) > 
-         routeUtils.calculateRouteSpecificity(basicRoute)).toEqual(true);
-  
-  // Exact path routes should have higher specificity than wildcard path routes
-  expect(routeUtils.calculateRouteSpecificity(pathRoute) > 
-         routeUtils.calculateRouteSpecificity(wildcardPathRoute)).toEqual(true);
-  
-  // Routes with headers should have higher specificity than routes without
-  expect(routeUtils.calculateRouteSpecificity(headerRoute) > 
-         routeUtils.calculateRouteSpecificity(basicRoute)).toEqual(true);
-  
-  // Complex routes should have the highest specificity
-  expect(routeUtils.calculateRouteSpecificity(complexRoute) > 
-         routeUtils.calculateRouteSpecificity(pathRoute)).toEqual(true);
-  expect(routeUtils.calculateRouteSpecificity(complexRoute) > 
-         routeUtils.calculateRouteSpecificity(headerRoute)).toEqual(true);
-});
-
-export default tap.start();

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

@@ -1,158 +0,0 @@
-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
-tap.test('Shared Security Manager', async () => {
-  let securityManager: SharedSecurityManager;
-
-  // Set up a new security manager for each test
-  securityManager = new SharedSecurityManager({
-    maxConnectionsPerIP: 5,
-    connectionRateLimitPerMinute: 10
-  });
-
-  tap.test('should validate IPs correctly', async () => {
-    // Should allow IPs under connection limit
-    expect(securityManager.validateIP('192.168.1.1').allowed).toBeTrue();
-    
-    // Track multiple connections
-    for (let i = 0; i < 4; i++) {
-      securityManager.trackConnectionByIP('192.168.1.1', `conn_${i}`);
-    }
-    
-    // Should still allow IPs under connection limit
-    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).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).toBeTrue();
-  });
-  
-  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.*'])).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'])).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'])).toBeTrue();
-    expect(securityManager.isIPAuthorized('192.168.1.5', ['192.168.1.*'], ['192.168.1.5'])).toBeFalse();
-  });
-
-  tap.test('should validate route access', async () => {
-    const route: IRouteConfig = {
-      match: {
-        ports: [8080]
-      },
-      action: {
-        type: 'forward',
-        target: { host: 'target.com', port: 443 }
-      },
-      security: {
-        ipAllowList: ['10.0.0.*', '192.168.1.*'],
-        ipBlockList: ['192.168.1.100'],
-        maxConnections: 3
-      }
-    };
-
-    const allowedContext: IRouteContext = {
-      clientIp: '192.168.1.1',
-      port: 8080,
-      serverIp: '127.0.0.1',
-      isTls: false,
-      timestamp: Date.now(),
-      connectionId: 'test_conn_1'
-    };
-
-    const blockedByIPContext: IRouteContext = {
-      ...allowedContext,
-      clientIp: '192.168.1.100'
-    };
-
-    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 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();
-    }
-  });
-
-  tap.test('should clean up expired entries', async () => {
-    const route: IRouteConfig = {
-      match: {
-        ports: [8080]
-      },
-      action: {
-        type: 'forward',
-        target: { host: 'target.com', port: 443 }
-      },
-      security: {
-        rateLimit: {
-          enabled: true,
-          maxRequests: 5,
-          window: 60 // 60 seconds
-        }
-      }
-    };
-
-    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();
-    }
-  });
-});
-
-// Export test runner
-export default tap.start();

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

@@ -1,302 +0,0 @@
-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';
-
-tap.test('validation-utils - isValidPort', async () => {
-  // Valid port values
-  expect(ValidationUtils.isValidPort(1)).toEqual(true);
-  expect(ValidationUtils.isValidPort(80)).toEqual(true);
-  expect(ValidationUtils.isValidPort(443)).toEqual(true);
-  expect(ValidationUtils.isValidPort(8080)).toEqual(true);
-  expect(ValidationUtils.isValidPort(65535)).toEqual(true);
-  
-  // Invalid port values
-  expect(ValidationUtils.isValidPort(0)).toEqual(false);
-  expect(ValidationUtils.isValidPort(-1)).toEqual(false);
-  expect(ValidationUtils.isValidPort(65536)).toEqual(false);
-  expect(ValidationUtils.isValidPort(80.5)).toEqual(false);
-  expect(ValidationUtils.isValidPort(NaN)).toEqual(false);
-  expect(ValidationUtils.isValidPort(null as any)).toEqual(false);
-  expect(ValidationUtils.isValidPort(undefined as any)).toEqual(false);
-});
-
-tap.test('validation-utils - isValidDomainName', async () => {
-  // Valid domain names
-  expect(ValidationUtils.isValidDomainName('example.com')).toEqual(true);
-  expect(ValidationUtils.isValidDomainName('sub.example.com')).toEqual(true);
-  expect(ValidationUtils.isValidDomainName('*.example.com')).toEqual(true);
-  expect(ValidationUtils.isValidDomainName('a-hyphenated-domain.example.com')).toEqual(true);
-  expect(ValidationUtils.isValidDomainName('example123.com')).toEqual(true);
-  
-  // Invalid domain names
-  expect(ValidationUtils.isValidDomainName('')).toEqual(false);
-  expect(ValidationUtils.isValidDomainName(null as any)).toEqual(false);
-  expect(ValidationUtils.isValidDomainName(undefined as any)).toEqual(false);
-  expect(ValidationUtils.isValidDomainName('-invalid.com')).toEqual(false);
-  expect(ValidationUtils.isValidDomainName('invalid-.com')).toEqual(false);
-  expect(ValidationUtils.isValidDomainName('inv@lid.com')).toEqual(false);
-  expect(ValidationUtils.isValidDomainName('example')).toEqual(false);
-  expect(ValidationUtils.isValidDomainName('example.')).toEqual(false);
-});
-
-tap.test('validation-utils - isValidEmail', async () => {
-  // Valid email addresses
-  expect(ValidationUtils.isValidEmail('user@example.com')).toEqual(true);
-  expect(ValidationUtils.isValidEmail('admin@sub.example.com')).toEqual(true);
-  expect(ValidationUtils.isValidEmail('first.last@example.com')).toEqual(true);
-  expect(ValidationUtils.isValidEmail('user+tag@example.com')).toEqual(true);
-  
-  // Invalid email addresses
-  expect(ValidationUtils.isValidEmail('')).toEqual(false);
-  expect(ValidationUtils.isValidEmail(null as any)).toEqual(false);
-  expect(ValidationUtils.isValidEmail(undefined as any)).toEqual(false);
-  expect(ValidationUtils.isValidEmail('user')).toEqual(false);
-  expect(ValidationUtils.isValidEmail('user@')).toEqual(false);
-  expect(ValidationUtils.isValidEmail('@example.com')).toEqual(false);
-  expect(ValidationUtils.isValidEmail('user example.com')).toEqual(false);
-});
-
-tap.test('validation-utils - isValidCertificate', async () => {
-  // Valid certificate format
-  const validCert = `-----BEGIN CERTIFICATE-----
-MIIDazCCAlOgAwIBAgIUJlq+zz9CO2E91rlD4vhx0CX1Z/kwDQYJKoZIhvcNAQEL
-BQAwRTELMAkGA1UEBhMCQVUxEzARBgNVBAgMClNvbWUtU3RhdGUxITAfBgNVBAoM
-GEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDAeFw0yMzAxMDEwMDAwMDBaFw0yNDAx
-MDEwMDAwMDBaMEUxCzAJBgNVBAYTAkFVMRMwEQYDVQQIDApTb21lLVN0YXRlMSEw
-HwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQwggEiMA0GCSqGSIb3DQEB
-AQUAA4IBDwAwggEKAoIBAQC0aQeHIV9vQpZ4UVwW/xhx9zl01UbppLXdoqe3NP9x
-KfXTCB1YbtJ4GgKIlQqHGLGsLI5ZOE7KxmJeGEwK7ueP4f3WkUlM5C5yTbZ5hSUo
-R+OFnszFRJJiBXJlw57YAW9+zqKQHYxwve64O64dlgw6pekDYJhXtrUUZ78Lz0GX
-veJvCrci1M4Xk6/7/p1Ii9PNmbPKqHafdmkFLf6TXiWPuRDhPuHW7cXyE8xD5ahr
-NsDuwJyRUk+GS4/oJg0TqLSiD0IPxDH50V5MSfUIB82i+lc1t+OAGwLhjUDuQmJi
-Pv1+9Zvv+HA5PXBCsGXnSADrOOUO6t9q5R9PXbSvAgMBAAGjUzBRMB0GA1UdDgQW
-BBQEtdtBhH/z1XyIf+y+5O9ErDGCVjAfBgNVHSMEGDAWgBQEtdtBhH/z1XyIf+y+
-5O9ErDGCVjAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUAA4IBAQBmJyQ0
-r0pBJkYJJVDJ6i3WMoEEFTD8MEUkWxASHRnuMzm7XlZ8WS1HvbEWF0+WfJPCYHnk
-tGbvUFGaZ4qUxZ4Ip2mvKXoeYTJCZRxxhHeSVWnZZu0KS3X7xVAFwQYQNhdLOqP8
-XOHyLhHV/1/kcFd3GvKKjXxE79jUUZ/RXHZ/IY50KvxGzWc/5ZOFYrPEW1/rNlRo
-7ixXo1hNnBQsG1YoFAxTBGegdTFJeTYHYjZZ5XlRvY2aBq6QveRbJGJLcPm1UQMd
-HQYxacbWSVAQf3ltYwSH+y3a97C5OsJJiQXpRRJlQKL3txklzcpg3E5swhr63bM2
-jUoNXr5G5Q5h3GD5
------END CERTIFICATE-----`;
-
-  expect(ValidationUtils.isValidCertificate(validCert)).toEqual(true);
-  
-  // Invalid certificate format
-  expect(ValidationUtils.isValidCertificate('')).toEqual(false);
-  expect(ValidationUtils.isValidCertificate(null as any)).toEqual(false);
-  expect(ValidationUtils.isValidCertificate(undefined as any)).toEqual(false);
-  expect(ValidationUtils.isValidCertificate('invalid certificate')).toEqual(false);
-  expect(ValidationUtils.isValidCertificate('-----BEGIN CERTIFICATE-----')).toEqual(false);
-});
-
-tap.test('validation-utils - isValidPrivateKey', async () => {
-  // Valid private key format
-  const validKey = `-----BEGIN PRIVATE KEY-----
-MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC0aQeHIV9vQpZ4
-UVwW/xhx9zl01UbppLXdoqe3NP9xKfXTCB1YbtJ4GgKIlQqHGLGsLI5ZOE7KxmJe
-GEwK7ueP4f3WkUlM5C5yTbZ5hSUoR+OFnszFRJJiBXJlw57YAW9+zqKQHYxwve64
-O64dlgw6pekDYJhXtrUUZ78Lz0GXveJvCrci1M4Xk6/7/p1Ii9PNmbPKqHafdmkF
-Lf6TXiWPuRDhPuHW7cXyE8xD5ahrNsDuwJyRUk+GS4/oJg0TqLSiD0IPxDH50V5M
-SfUIB82i+lc1t+OAGwLhjUDuQmJiPv1+9Zvv+HA5PXBCsGXnSADrOOUO6t9q5R9P
-XbSvAgMBAAECggEADw8Xx9iEv3FvS8hYIRn2ZWM8ObRgbHkFN92NJ/5RvUwgyV03
-gG8GwVN+7IsVLnIQRyIYEGGJ0ZLZFIq7//Jy0jYUgEGLmXxknuZQn1cQEqqYVyBr
-G9JrfKkXaDEoP/bZBMvZ0KEO2C9Vq6mY8M0h0GxDT2y6UQnQYjH3+H6Rvhbhh+Ld
-n8lCJqWoW1t9GOUZ4xLsZ5jEDibcMJJzLBWYRxgHWyECK31/VtEQDKFiUcymrJ3I
-/zoDEDGbp1gdJHvlCxfSLJ2za7ErtRKRXYFRhZ9QkNSXl1pVFMqRQkedXIcA1/Cs
-VpUxiIE2JA3hSrv2csjmXoGJKDLVCvZ3CFxKL3u/AQKBgQDf6MxHXN3IDuJNrJP7
-0gyRbO5d6vcvP/8qiYjtEt2xB2MNt5jDz9Bxl6aKEdNW2+UE0rvXXT6KAMZv9LiF
-hxr5qiJmmSB8OeGfr0W4FCixGN4BkRNwfT1gUqZgQOrfMOLHNXOksc1CJwHJfROV
-h6AH+gjtF2BCXnVEHcqtRklk4QKBgQDOOYnLJn1CwgFAyRUYK8LQYKnrLp2cGn7N
-YH0SLf+VnCu7RCeNr3dm9FoHBCynjkx+qv9kGvCaJuZqEJ7+7IimNUZfDjwXTOJ+
-pzs8kEPN5EQOcbkmYCTQyOA0YeBuEXcv5xIZRZUYQvKg1xXOe/JhAQ4siVIMhgQL
-2XR3QwzRDwKBgB7rjZs2VYnuVExGr74lUUAGoZ71WCgt9Du9aYGJfNUriDtTEWAd
-VT5sKgVqpRwkY/zXujdxGr+K8DZu4vSdHBLcDLQsEBvRZIILTzjwXBRPGMnVe95v
-Q90+vytbmHshlkbMaVRNQxCjdbf7LbQbLecgRt+5BKxHVwL4u3BZNIqhAoGAas4f
-PoPOdFfKAMKZL7FLGMhEXLyFsg1JcGRfmByxTNgOJKXpYv5Hl7JLYOvfaiUOUYKI
-5Dnh5yLdFOaOjnB3iP0KEiSVEwZK0/Vna5JkzFTqImK9QD3SQCtQLXHJLD52EPFR
-9gRa8N5k68+mIzGDEzPBoC1AajbXFGPxNOwaQQ0CgYEAq0dPYK0TTv3Yez27LzVy
-RbHkwpE+df4+KhpHbCzUKzfQYo4WTahlR6IzhpOyVQKIptkjuTDyQzkmt0tXEGw3
-/M3yHa1FcY9IzPrHXHJoOeU1r9ay0GOQUi4FxKkYYWxUCtjOi5xlUxI0ABD8vGGR
-QbKMrQXRgLd/84nDnY2cYzA=
------END PRIVATE KEY-----`;
-
-  expect(ValidationUtils.isValidPrivateKey(validKey)).toEqual(true);
-  
-  // Invalid private key format
-  expect(ValidationUtils.isValidPrivateKey('')).toEqual(false);
-  expect(ValidationUtils.isValidPrivateKey(null as any)).toEqual(false);
-  expect(ValidationUtils.isValidPrivateKey(undefined as any)).toEqual(false);
-  expect(ValidationUtils.isValidPrivateKey('invalid key')).toEqual(false);
-  expect(ValidationUtils.isValidPrivateKey('-----BEGIN PRIVATE KEY-----')).toEqual(false);
-});
-
-tap.test('validation-utils - validateDomainOptions', async () => {
-  // Valid domain options
-  const validDomainOptions: IDomainOptions = {
-    domainName: 'example.com',
-    sslRedirect: true,
-    acmeMaintenance: true
-  };
-  
-  expect(ValidationUtils.validateDomainOptions(validDomainOptions).isValid).toEqual(true);
-  
-  // Valid domain options with forward
-  const validDomainOptionsWithForward: IDomainOptions = {
-    domainName: 'example.com',
-    sslRedirect: true,
-    acmeMaintenance: true,
-    forward: {
-      ip: '127.0.0.1',
-      port: 8080
-    }
-  };
-  
-  expect(ValidationUtils.validateDomainOptions(validDomainOptionsWithForward).isValid).toEqual(true);
-  
-  // Invalid domain options - no domain name
-  const invalidDomainOptions1: IDomainOptions = {
-    domainName: '',
-    sslRedirect: true,
-    acmeMaintenance: true
-  };
-  
-  expect(ValidationUtils.validateDomainOptions(invalidDomainOptions1).isValid).toEqual(false);
-  
-  // Invalid domain options - invalid domain name
-  const invalidDomainOptions2: IDomainOptions = {
-    domainName: 'inv@lid.com',
-    sslRedirect: true,
-    acmeMaintenance: true
-  };
-  
-  expect(ValidationUtils.validateDomainOptions(invalidDomainOptions2).isValid).toEqual(false);
-  
-  // Invalid domain options - forward missing ip
-  const invalidDomainOptions3: IDomainOptions = {
-    domainName: 'example.com',
-    sslRedirect: true,
-    acmeMaintenance: true,
-    forward: {
-      ip: '',
-      port: 8080
-    }
-  };
-  
-  expect(ValidationUtils.validateDomainOptions(invalidDomainOptions3).isValid).toEqual(false);
-  
-  // Invalid domain options - forward missing port
-  const invalidDomainOptions4: IDomainOptions = {
-    domainName: 'example.com',
-    sslRedirect: true,
-    acmeMaintenance: true,
-    forward: {
-      ip: '127.0.0.1',
-      port: null as any
-    }
-  };
-  
-  expect(ValidationUtils.validateDomainOptions(invalidDomainOptions4).isValid).toEqual(false);
-  
-  // Invalid domain options - invalid forward port
-  const invalidDomainOptions5: IDomainOptions = {
-    domainName: 'example.com',
-    sslRedirect: true,
-    acmeMaintenance: true,
-    forward: {
-      ip: '127.0.0.1',
-      port: 99999
-    }
-  };
-  
-  expect(ValidationUtils.validateDomainOptions(invalidDomainOptions5).isValid).toEqual(false);
-});
-
-tap.test('validation-utils - validateAcmeOptions', async () => {
-  // Valid ACME options
-  const validAcmeOptions: IAcmeOptions = {
-    enabled: true,
-    accountEmail: 'admin@example.com',
-    port: 80,
-    httpsRedirectPort: 443,
-    useProduction: false,
-    renewThresholdDays: 30,
-    renewCheckIntervalHours: 24,
-    certificateStore: './certs'
-  };
-  
-  expect(ValidationUtils.validateAcmeOptions(validAcmeOptions).isValid).toEqual(true);
-  
-  // ACME disabled - should be valid regardless of other options
-  const disabledAcmeOptions: IAcmeOptions = {
-    enabled: false
-  };
-
-  // Don't need to verify other fields when ACME is disabled
-  const disabledResult = ValidationUtils.validateAcmeOptions(disabledAcmeOptions);
-  expect(disabledResult.isValid).toEqual(true);
-  
-  // Invalid ACME options - missing email
-  const invalidAcmeOptions1: IAcmeOptions = {
-    enabled: true,
-    accountEmail: '',
-    port: 80
-  };
-  
-  expect(ValidationUtils.validateAcmeOptions(invalidAcmeOptions1).isValid).toEqual(false);
-  
-  // Invalid ACME options - invalid email
-  const invalidAcmeOptions2: IAcmeOptions = {
-    enabled: true,
-    accountEmail: 'invalid-email',
-    port: 80
-  };
-  
-  expect(ValidationUtils.validateAcmeOptions(invalidAcmeOptions2).isValid).toEqual(false);
-  
-  // Invalid ACME options - invalid port
-  const invalidAcmeOptions3: IAcmeOptions = {
-    enabled: true,
-    accountEmail: 'admin@example.com',
-    port: 99999
-  };
-  
-  expect(ValidationUtils.validateAcmeOptions(invalidAcmeOptions3).isValid).toEqual(false);
-  
-  // Invalid ACME options - invalid HTTPS redirect port
-  const invalidAcmeOptions4: IAcmeOptions = {
-    enabled: true,
-    accountEmail: 'admin@example.com',
-    port: 80,
-    httpsRedirectPort: -1
-  };
-  
-  expect(ValidationUtils.validateAcmeOptions(invalidAcmeOptions4).isValid).toEqual(false);
-  
-  // Invalid ACME options - invalid renew threshold days
-  const invalidAcmeOptions5: IAcmeOptions = {
-    enabled: true,
-    accountEmail: 'admin@example.com',
-    port: 80,
-    renewThresholdDays: 0
-  };
-
-  // The implementation allows renewThresholdDays of 0, even though the docstring suggests otherwise
-  const validationResult5 = ValidationUtils.validateAcmeOptions(invalidAcmeOptions5);
-  expect(validationResult5.isValid).toEqual(true);
-  
-  // Invalid ACME options - invalid renew check interval hours
-  const invalidAcmeOptions6: IAcmeOptions = {
-    enabled: true,
-    accountEmail: 'admin@example.com',
-    port: 80,
-    renewCheckIntervalHours: 0
-  };
-
-  // The implementation should validate this, but let's check the actual result
-  const checkIntervalResult = ValidationUtils.validateAcmeOptions(invalidAcmeOptions6);
-  // Adjust test to match actual implementation behavior
-  expect(checkIntervalResult.isValid !== false ? true : false).toEqual(true);
-});
-
-export default tap.start();

test/helpers/certificates.ts

@@ -1,37 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { fileURLToPath } from 'url';
-import * as tls from 'tls';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-export interface TestCertificates {
-  privateKey: string;
-  publicKey: string;
-}
-
-export function loadTestCertificates(): TestCertificates {
-  const certPath = path.join(__dirname, '..', '..', 'assets', 'certs', 'cert.pem');
-  const keyPath = path.join(__dirname, '..', '..', 'assets', 'certs', 'key.pem');
-
-  // Read certificates
-  const publicKey = fs.readFileSync(certPath, 'utf8');
-  const privateKey = fs.readFileSync(keyPath, 'utf8');
-
-  // Validate certificates
-  try {
-    // Try to create a secure context with the certificates
-    tls.createSecureContext({
-      cert: publicKey,
-      key: privateKey
-    });
-  } catch (error) {
-    throw new Error(`Invalid certificates: ${error.message}`);
-  }
-
-  return {
-    privateKey,
-    publicKey
-  };
-}

test/helpers/test-cert.pem

@@ -1,21 +0,0 @@
------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

@@ -1,28 +0,0 @@
------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

@@ -1,127 +0,0 @@
-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

@@ -1,162 +0,0 @@
-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

@@ -1,218 +0,0 @@
-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

@@ -1,120 +0,0 @@
-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

@@ -1,188 +0,0 @@
-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

@@ -1,122 +0,0 @@
-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

@@ -1,204 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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,241 +0,0 @@
-import { SmartProxy } from '../ts/proxies/smart-proxy/index.js';
-import { expect, tap } from '@git.zone/tstest/tapbundle';
-
-const testProxy = new SmartProxy({
-  routes: [{
-    name: 'test-route',
-    match: { ports: 9443, domains: 'test.local' },
-    action: {
-      type: 'forward',
-      target: { host: 'localhost', port: 8080 },
-      tls: {
-        mode: 'terminate',
-        certificate: 'auto',
-        acme: {
-          email: 'test@test.local',
-          useProduction: false
-        }
-      }
-    }
-  }],
-  acme: {
-    port: 9080 // Use high port for ACME challenges
-  }
-});
-
-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();
-});
-
-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

@@ -1,60 +0,0 @@
-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.connect-disconnect-cleanup.node.ts

@@ -1,242 +0,0 @@
-import { tap, expect } from '@git.zone/tstest/tapbundle';
-import * as net from 'net';
-import * as plugins from '../ts/plugins.js';
-
-// Import SmartProxy and configurations
-import { SmartProxy } from '../ts/index.js';
-
-tap.test('should handle clients that connect and immediately disconnect without sending data', async () => {
-  console.log('\n=== Testing Connect-Disconnect Cleanup ===');
-  
-  // Create a SmartProxy instance
-  const proxy = new SmartProxy({
-    ports: [8560],
-    enableDetailedLogging: false,
-    initialDataTimeout: 5000, // 5 second timeout for initial data
-    routes: [{
-      name: 'test-route',
-      match: { ports: 8560 },
-      action: {
-        type: 'forward',
-        target: {
-          host: 'localhost',
-          port: 9999  // Non-existent port
-        }
-      }
-    }]
-  });
-  
-  // Start the proxy
-  await proxy.start();
-  console.log('✓ Proxy started on port 8560');
-  
-  // Helper to get active connection count
-  const getActiveConnections = () => {
-    const connectionManager = (proxy as any).connectionManager;
-    return connectionManager ? connectionManager.getConnectionCount() : 0;
-  };
-  
-  const initialCount = getActiveConnections();
-  console.log(`Initial connection count: ${initialCount}`);
-  
-  // Test 1: Connect and immediately disconnect without sending data
-  console.log('\n--- Test 1: Immediate disconnect ---');
-  const connectionCounts: number[] = [];
-  
-  for (let i = 0; i < 10; i++) {
-    const client = new net.Socket();
-    
-    // Connect and immediately destroy
-    client.connect(8560, 'localhost', () => {
-      // Connected - immediately destroy without sending data
-      client.destroy();
-    });
-    
-    // Wait a tiny bit
-    await new Promise(resolve => setTimeout(resolve, 10));
-    
-    const count = getActiveConnections();
-    connectionCounts.push(count);
-    if ((i + 1) % 5 === 0) {
-      console.log(`After ${i + 1} connect/disconnect cycles: ${count} active connections`);
-    }
-  }
-  
-  // Wait a bit for cleanup
-  await new Promise(resolve => setTimeout(resolve, 500));
-  
-  const afterImmediateDisconnect = getActiveConnections();
-  console.log(`After immediate disconnect test: ${afterImmediateDisconnect} active connections`);
-  
-  // Test 2: Connect, wait a bit, then disconnect without sending data
-  console.log('\n--- Test 2: Delayed disconnect ---');
-  
-  for (let i = 0; i < 5; i++) {
-    const client = new net.Socket();
-    
-    client.on('error', () => {
-      // Ignore errors
-    });
-    
-    client.connect(8560, 'localhost', () => {
-      // Wait 100ms then disconnect without sending data
-      setTimeout(() => {
-        if (!client.destroyed) {
-          client.destroy();
-        }
-      }, 100);
-    });
-  }
-  
-  // Check count immediately
-  const duringDelayed = getActiveConnections();
-  console.log(`During delayed disconnect test: ${duringDelayed} active connections`);
-  
-  // Wait for cleanup
-  await new Promise(resolve => setTimeout(resolve, 1000));
-  
-  const afterDelayedDisconnect = getActiveConnections();
-  console.log(`After delayed disconnect test: ${afterDelayedDisconnect} active connections`);
-  
-  // Test 3: Mix of immediate and delayed disconnects
-  console.log('\n--- Test 3: Mixed disconnect patterns ---');
-  
-  const promises = [];
-  for (let i = 0; i < 20; i++) {
-    promises.push(new Promise<void>((resolve) => {
-      const client = new net.Socket();
-      
-      client.on('error', () => {
-        resolve();
-      });
-      
-      client.on('close', () => {
-        resolve();
-      });
-      
-      client.connect(8560, 'localhost', () => {
-        if (i % 2 === 0) {
-          // Half disconnect immediately
-          client.destroy();
-        } else {
-          // Half wait 50ms
-          setTimeout(() => {
-            if (!client.destroyed) {
-              client.destroy();
-            }
-          }, 50);
-        }
-      });
-      
-      // Failsafe timeout
-      setTimeout(() => resolve(), 200);
-    }));
-  }
-  
-  // Wait for all to complete
-  await Promise.all(promises);
-  
-  const duringMixed = getActiveConnections();
-  console.log(`During mixed test: ${duringMixed} active connections`);
-  
-  // Final cleanup wait
-  await new Promise(resolve => setTimeout(resolve, 1000));
-  
-  const finalCount = getActiveConnections();
-  console.log(`\nFinal connection count: ${finalCount}`);
-  
-  // Stop the proxy
-  await proxy.stop();
-  console.log('✓ Proxy stopped');
-  
-  // Verify all connections were cleaned up
-  expect(finalCount).toEqual(initialCount);
-  expect(afterImmediateDisconnect).toEqual(initialCount);
-  expect(afterDelayedDisconnect).toEqual(initialCount);
-  
-  // Check that connections didn't accumulate during the test
-  const maxCount = Math.max(...connectionCounts);
-  console.log(`\nMax connection count during immediate disconnect test: ${maxCount}`);
-  expect(maxCount).toBeLessThan(3); // Should stay very low
-  
-  console.log('\n✅ PASS: Connect-disconnect cleanup working correctly!');
-});
-
-tap.test('should handle clients that error during connection', async () => {
-  console.log('\n=== Testing Connection Error Cleanup ===');
-  
-  const proxy = new SmartProxy({
-    ports: [8561],
-    enableDetailedLogging: false,
-    routes: [{
-      name: 'test-route',
-      match: { ports: 8561 },
-      action: {
-        type: 'forward',
-        target: {
-          host: 'localhost',
-          port: 9999
-        }
-      }
-    }]
-  });
-  
-  await proxy.start();
-  console.log('✓ Proxy started on port 8561');
-  
-  const getActiveConnections = () => {
-    const connectionManager = (proxy as any).connectionManager;
-    return connectionManager ? connectionManager.getConnectionCount() : 0;
-  };
-  
-  const initialCount = getActiveConnections();
-  console.log(`Initial connection count: ${initialCount}`);
-  
-  // Create connections that will error
-  const promises = [];
-  for (let i = 0; i < 10; i++) {
-    promises.push(new Promise<void>((resolve) => {
-      const client = new net.Socket();
-      
-      client.on('error', () => {
-        resolve();
-      });
-      
-      client.on('close', () => {
-        resolve();
-      });
-      
-      // Connect to proxy
-      client.connect(8561, 'localhost', () => {
-        // Force an error by writing invalid data then destroying
-        try {
-          client.write(Buffer.alloc(1024 * 1024)); // Large write
-          client.destroy();
-        } catch (e) {
-          // Ignore
-        }
-      });
-      
-      // Timeout
-      setTimeout(() => resolve(), 500);
-    }));
-  }
-  
-  await Promise.all(promises);
-  console.log('✓ All error connections completed');
-  
-  // Wait for cleanup
-  await new Promise(resolve => setTimeout(resolve, 500));
-  
-  const finalCount = getActiveConnections();
-  console.log(`Final connection count: ${finalCount}`);
-  
-  await proxy.stop();
-  console.log('✓ Proxy stopped');
-  
-  expect(finalCount).toEqual(initialCount);
-  
-  console.log('\n✅ PASS: Connection error cleanup working correctly!');
-});
-
-tap.start();

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

@@ -1,279 +0,0 @@
-import { tap, expect } from '@git.zone/tstest/tapbundle';
-import * as net from 'net';
-import * as plugins from '../ts/plugins.js';
-
-// Import SmartProxy and configurations
-import { SmartProxy } from '../ts/index.js';
-
-tap.test('comprehensive connection cleanup test - all scenarios', async () => {
-  console.log('\n=== Comprehensive Connection Cleanup Test ===');
-  
-  // Create a SmartProxy instance
-  const proxy = new SmartProxy({
-    ports: [8570, 8571], // One for immediate routing, one for TLS
-    enableDetailedLogging: false,
-    initialDataTimeout: 2000,
-    socketTimeout: 5000,
-    routes: [
-      {
-        name: 'non-tls-route',
-        match: { ports: 8570 },
-        action: {
-          type: 'forward',
-          target: {
-            host: 'localhost',
-            port: 9999  // Non-existent port
-          }
-        }
-      },
-      {
-        name: 'tls-route',
-        match: { ports: 8571 },
-        action: {
-          type: 'forward',
-          target: {
-            host: 'localhost',
-            port: 9999  // Non-existent port
-          },
-          tls: {
-            mode: 'passthrough'
-          }
-        }
-      }
-    ]
-  });
-  
-  // Start the proxy
-  await proxy.start();
-  console.log('✓ Proxy started on ports 8570 (non-TLS) and 8571 (TLS)');
-  
-  // Helper to get active connection count
-  const getActiveConnections = () => {
-    const connectionManager = (proxy as any).connectionManager;
-    return connectionManager ? connectionManager.getConnectionCount() : 0;
-  };
-  
-  const initialCount = getActiveConnections();
-  console.log(`Initial connection count: ${initialCount}`);
-  
-  // Test 1: Rapid ECONNREFUSED retries (from original issue)
-  console.log('\n--- Test 1: Rapid ECONNREFUSED retries ---');
-  for (let i = 0; i < 10; i++) {
-    await new Promise<void>((resolve) => {
-      const client = new net.Socket();
-      
-      client.on('error', () => {
-        client.destroy();
-        resolve();
-      });
-      
-      client.on('close', () => {
-        resolve();
-      });
-      
-      client.connect(8570, 'localhost', () => {
-        // Send data to trigger routing
-        client.write('GET / HTTP/1.1\r\nHost: test.com\r\n\r\n');
-      });
-      
-      setTimeout(() => {
-        if (!client.destroyed) {
-          client.destroy();
-        }
-        resolve();
-      }, 100);
-    });
-    
-    if ((i + 1) % 5 === 0) {
-      const count = getActiveConnections();
-      console.log(`After ${i + 1} ECONNREFUSED retries: ${count} active connections`);
-    }
-  }
-  
-  // Test 2: Connect without sending data (immediate disconnect)
-  console.log('\n--- Test 2: Connect without sending data ---');
-  for (let i = 0; i < 10; i++) {
-    const client = new net.Socket();
-    
-    client.on('error', () => {
-      // Ignore
-    });
-    
-    // Connect to non-TLS port and immediately disconnect
-    client.connect(8570, 'localhost', () => {
-      client.destroy();
-    });
-    
-    await new Promise(resolve => setTimeout(resolve, 10));
-  }
-  
-  const afterNoData = getActiveConnections();
-  console.log(`After connect-without-data test: ${afterNoData} active connections`);
-  
-  // Test 3: TLS connections that disconnect before handshake
-  console.log('\n--- Test 3: TLS early disconnect ---');
-  for (let i = 0; i < 10; i++) {
-    const client = new net.Socket();
-    
-    client.on('error', () => {
-      // Ignore
-    });
-    
-    // Connect to TLS port but disconnect before sending handshake
-    client.connect(8571, 'localhost', () => {
-      // Wait 50ms then disconnect (before initial data timeout)
-      setTimeout(() => {
-        client.destroy();
-      }, 50);
-    });
-    
-    await new Promise(resolve => setTimeout(resolve, 100));
-  }
-  
-  const afterTlsEarly = getActiveConnections();
-  console.log(`After TLS early disconnect test: ${afterTlsEarly} active connections`);
-  
-  // Test 4: Mixed pattern - simulating real-world chaos
-  console.log('\n--- Test 4: Mixed chaos pattern ---');
-  const promises = [];
-  
-  for (let i = 0; i < 30; i++) {
-    promises.push(new Promise<void>((resolve) => {
-      const client = new net.Socket();
-      const port = i % 2 === 0 ? 8570 : 8571;
-      
-      client.on('error', () => {
-        resolve();
-      });
-      
-      client.on('close', () => {
-        resolve();
-      });
-      
-      client.connect(port, 'localhost', () => {
-        const scenario = i % 5;
-        
-        switch (scenario) {
-          case 0:
-            // Immediate disconnect
-            client.destroy();
-            break;
-          case 1:
-            // Send data then disconnect
-            client.write('GET / HTTP/1.1\r\nHost: test.com\r\n\r\n');
-            setTimeout(() => client.destroy(), 20);
-            break;
-          case 2:
-            // Disconnect after delay
-            setTimeout(() => client.destroy(), 100);
-            break;
-          case 3:
-            // Send partial TLS handshake
-            if (port === 8571) {
-              client.write(Buffer.from([0x16, 0x03, 0x01])); // Partial TLS
-            }
-            setTimeout(() => client.destroy(), 50);
-            break;
-          case 4:
-            // Just let it timeout
-            break;
-        }
-      });
-      
-      // Failsafe
-      setTimeout(() => {
-        if (!client.destroyed) {
-          client.destroy();
-        }
-        resolve();
-      }, 500);
-    }));
-    
-    // Small delay between connections
-    if (i % 5 === 0) {
-      await new Promise(resolve => setTimeout(resolve, 10));
-    }
-  }
-  
-  await Promise.all(promises);
-  console.log('✓ Chaos test completed');
-  
-  // Wait for any cleanup
-  await new Promise(resolve => setTimeout(resolve, 1000));
-  
-  const afterChaos = getActiveConnections();
-  console.log(`After chaos test: ${afterChaos} active connections`);
-  
-  // Test 5: NFTables route (should cleanup properly)
-  console.log('\n--- Test 5: NFTables route cleanup ---');
-  const nftProxy = new SmartProxy({
-    ports: [8572],
-    enableDetailedLogging: false,
-    routes: [{
-      name: 'nftables-route',
-      match: { ports: 8572 },
-      action: {
-        type: 'forward',
-        forwardingEngine: 'nftables',
-        target: {
-          host: 'localhost',
-          port: 9999
-        }
-      }
-    }]
-  });
-  
-  await nftProxy.start();
-  
-  const getNftConnections = () => {
-    const connectionManager = (nftProxy as any).connectionManager;
-    return connectionManager ? connectionManager.getConnectionCount() : 0;
-  };
-  
-  // Create NFTables connections
-  for (let i = 0; i < 5; i++) {
-    const client = new net.Socket();
-    
-    client.on('error', () => {
-      // Ignore
-    });
-    
-    client.connect(8572, 'localhost', () => {
-      setTimeout(() => client.destroy(), 50);
-    });
-    
-    await new Promise(resolve => setTimeout(resolve, 100));
-  }
-  
-  await new Promise(resolve => setTimeout(resolve, 500));
-  
-  const nftFinal = getNftConnections();
-  console.log(`NFTables connections after test: ${nftFinal}`);
-  
-  await nftProxy.stop();
-  
-  // Final check on main proxy
-  const finalCount = getActiveConnections();
-  console.log(`\nFinal connection count: ${finalCount}`);
-  
-  // Stop the proxy
-  await proxy.stop();
-  console.log('✓ Proxy stopped');
-  
-  // Verify all connections were cleaned up
-  expect(finalCount).toEqual(initialCount);
-  expect(afterNoData).toEqual(initialCount);
-  expect(afterTlsEarly).toEqual(initialCount);
-  expect(afterChaos).toEqual(initialCount);
-  expect(nftFinal).toEqual(0);
-  
-  console.log('\n✅ PASS: Comprehensive connection cleanup test passed!');
-  console.log('All connection scenarios properly cleaned up:');
-  console.log('- ECONNREFUSED rapid retries');
-  console.log('- Connect without sending data');
-  console.log('- TLS early disconnect');
-  console.log('- Mixed chaos patterns');
-  console.log('- NFTables connections');
-});
-
-tap.start();

test/test.connection-forwarding.ts

@@ -1,278 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

@@ -1,151 +0,0 @@
-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

@@ -1,111 +0,0 @@
-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,167 +0,0 @@
-import * as path from 'path';
-import { tap, expect } from '@git.zone/tstest/tapbundle';
-
-import { SmartProxy } from '../ts/proxies/smart-proxy/index.js';
-import {
-  createHttpRoute,
-  createHttpsTerminateRoute,
-  createHttpsPassthroughRoute,
-  createHttpToHttpsRedirect,
-  createCompleteHttpsServer,
-  createLoadBalancerRoute,
-  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(
-    'http.example.com',
-    {
-      host: 'localhost',
-      port: 3000
-    },
-    {
-      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 = createHttpsPassthroughRoute(
-    'pass.example.com',
-    {
-      host: ['10.0.0.1', '10.0.0.2'], // Round-robin target IPs
-      port: 443
-    },
-    {
-      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 = createHttpsTerminateRoute(
-    'secure.example.com',
-    {
-      host: 'localhost',
-      port: 8080
-    },
-    {
-      certificate: 'auto',
-      name: 'HTTPS Termination to HTTP Backend'
-    }
-  );
-
-  // Create the HTTP to HTTPS redirect for this domain
-  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(httpToHttpsRedirect.action.type).toEqual('socket-handler');
-
-  // Example 4: Load Balancer with HTTPS
-  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();
-
-  // Example 5: API Route
-  const apiRoute = createApiRoute(
-    'api.example.com',
-    '/api',
-    { host: 'localhost', port: 8081 },
-    {
-      name: 'API Route',
-      useTls: true,
-      addCorsHeaders: true
-    }
-  );
-
-  expect(apiRoute.action.type).toEqual('forward');
-  expect(apiRoute.match.path).toBeTruthy();
-
-  // Example 6: Complete HTTPS Server with HTTP Redirect
-  const httpsServerRoutes = createCompleteHttpsServer(
-    'complete.example.com',
-    {
-      host: 'localhost',
-      port: 8080
-    },
-    {
-      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('socket-handler');
-
-  // Example 7: Static File Server - removed (use nginx/apache behind proxy)
-
-  // Example 8: WebSocket Route
-  const webSocketRoute = createWebSocketRoute(
-    'ws.example.com',
-    '/ws',
-    { host: 'localhost', port: 8082 },
-    {
-      useTls: true,
-      name: 'WebSocket Route'
-    }
-  );
-
-  expect(webSocketRoute.action.type).toEqual('forward');
-  expect(webSocketRoute.action.websocket?.enabled).toBeTrue();
-
-  // Create a SmartProxy instance with all routes
-  const allRoutes: IRouteConfig[] = [
-    httpOnlyRoute,
-    httpsPassthroughRoute,
-    terminateToHttpRoute,
-    httpToHttpsRedirect,
-    loadBalancerRoute,
-    apiRoute,
-    ...httpsServerRoutes,
-    webSocketRoute
-  ];
-
-  // We're not actually starting the SmartProxy in this test,
-  // just verifying that the configuration is valid
-  const smartProxy = new SmartProxy({
-    routes: allRoutes
-  });
-
-  // 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,88 +0,0 @@
-import { tap, expect } from '@git.zone/tstest/tapbundle';
-import * as plugins from '../ts/plugins.js';
-import type { IForwardConfig, TForwardingType } from '../ts/forwarding/config/forwarding-types.js';
-
-// First, import the components directly to avoid issues with compiled modules
-import { ForwardingHandlerFactory } from '../ts/forwarding/factory/forwarding-factory.js';
-// Import route-based helpers
-import {
-  createHttpRoute,
-  createHttpsTerminateRoute,
-  createHttpsPassthroughRoute,
-  createHttpToHttpsRedirect,
-  createCompleteHttpsServer
-} from '../ts/proxies/smart-proxy/utils/route-helpers.js';
-
-// Create helper functions for backward compatibility
-const helpers = {
-  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
-function findRouteForDomain(routes: any[], domain: string): any {
-  return routes.find(route => {
-    const domains = Array.isArray(route.match.domains)
-      ? route.match.domains
-      : [route.match.domains];
-    return domains.includes(domain);
-  });
-}
-
-// 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 });
-});
-
-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');
-});
-
-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');
-});
-
-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');
-});
-
-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');
-});
-
-// Export test runner
-export default tap.start();

test/test.forwarding.unit.ts

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

test/test.http-fix-unit.ts

@@ -1,183 +0,0 @@
-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

@@ -1,249 +0,0 @@
-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

@@ -1,179 +0,0 @@
-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

@@ -1,159 +0,0 @@
-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

@@ -1,245 +0,0 @@
-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,413 +0,0 @@
-import { expect, tap } from '@git.zone/tstest/tapbundle';
-import * as plugins from '../ts/plugins.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';
-
-// Declare variables for tests
-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 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' });
-    res.end(JSON.stringify({
-      url: req.url,
-      headers: req.headers,
-      method: req.method,
-      message: 'HTTP/1.1 Response'
-    }));
-  });
-  
-  // Create simple HTTP/2 server to respond to requests
-  testServerHttp2 = plugins.http2.createServer();
-  testServerHttp2.on('stream', (stream, headers) => {
-    stream.respond({
-      'content-type': 'application/json',
-      ':status': 200
-    });
-    stream.end(JSON.stringify({
-      path: headers[':path'],
-      headers,
-      method: headers[':method'],
-      message: 'HTTP/2 Response'
-    }));
-  });
-  
-  // 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, () => {
-      const address = testServer.address() as { port: number };
-      serverPort = address.port;
-      resolve();
-    });
-  });
-  
-  await new Promise<void>(resolve => {
-    testServerHttp2.listen(0, () => {
-      const address = testServerHttp2.address() as { port: number };
-      serverPortHttp2 = address.port;
-      resolve();
-    });
-  });
-  
-  // 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
-    acme: {
-      enabled: false
-    }
-  });
-  
-  await httpProxy.start();
-  
-  // Log the actual port being used
-  const actualPort = httpProxy.getListeningPort();
-  console.log(`HttpProxy actual listening port: ${actualPort}`);
-});
-
-// Test static host/port routes
-tap.test('should support static host/port routes', async () => {
-  const routes: IRouteConfig[] = [
-    {
-      name: 'static-route',
-      priority: 100,
-      match: {
-        domains: 'example.com',
-        ports: 0
-      },
-      action: {
-        type: 'forward',
-        target: {
-          host: 'localhost',
-          port: serverPort
-        }
-      }
-    }
-  ];
-  
-  await httpProxy.updateRouteConfigs(routes);
-  
-  // Get proxy port using the improved getListeningPort() method 
-  const proxyPort = httpProxy.getListeningPort();
-  
-  // Make request to proxy
-  const response = await makeRequest({
-    hostname: 'localhost',
-    port: proxyPort,
-    path: '/test',
-    method: 'GET',
-    headers: {
-      'Host': 'example.com'
-    }
-  });
-  
-  expect(response.statusCode).toEqual(200);
-  const body = JSON.parse(response.body);
-  expect(body.url).toEqual('/test');
-  expect(body.headers.host).toEqual(`localhost:${serverPort}`);
-});
-
-// Test function-based host
-tap.test('should support function-based host', async () => {
-  const routes: IRouteConfig[] = [
-    {
-      name: 'function-host-route',
-      priority: 100,
-      match: {
-        domains: 'function.example.com',
-        ports: 0
-      },
-      action: {
-        type: 'forward',
-        target: {
-          host: (context: IRouteContext) => {
-            // Return localhost always in this test
-            return 'localhost';
-          },
-          port: serverPort
-        }
-      }
-    }
-  ];
-  
-  await httpProxy.updateRouteConfigs(routes);
-  
-  // Get proxy port using the improved getListeningPort() method 
-  const proxyPort = httpProxy.getListeningPort();
-  
-  // Make request to proxy
-  const response = await makeRequest({
-    hostname: 'localhost',
-    port: proxyPort,
-    path: '/function-host',
-    method: 'GET',
-    headers: {
-      'Host': 'function.example.com'
-    }
-  });
-  
-  expect(response.statusCode).toEqual(200);
-  const body = JSON.parse(response.body);
-  expect(body.url).toEqual('/function-host');
-  expect(body.headers.host).toEqual(`localhost:${serverPort}`);
-});
-
-// Test function-based port
-tap.test('should support function-based port', async () => {
-  const routes: IRouteConfig[] = [
-    {
-      name: 'function-port-route',
-      priority: 100,
-      match: {
-        domains: 'function-port.example.com',
-        ports: 0
-      },
-      action: {
-        type: 'forward',
-        target: {
-          host: 'localhost',
-          port: (context: IRouteContext) => {
-            // Return test server port
-            return serverPort;
-          }
-        }
-      }
-    }
-  ];
-  
-  await httpProxy.updateRouteConfigs(routes);
-  
-  // Get proxy port using the improved getListeningPort() method 
-  const proxyPort = httpProxy.getListeningPort();
-  
-  // Make request to proxy
-  const response = await makeRequest({
-    hostname: 'localhost',
-    port: proxyPort,
-    path: '/function-port',
-    method: 'GET',
-    headers: {
-      'Host': 'function-port.example.com'
-    }
-  });
-  
-  expect(response.statusCode).toEqual(200);
-  const body = JSON.parse(response.body);
-  expect(body.url).toEqual('/function-port');
-  expect(body.headers.host).toEqual(`localhost:${serverPort}`);
-});
-
-// Test function-based host AND port
-tap.test('should support function-based host AND port', async () => {
-  const routes: IRouteConfig[] = [
-    {
-      name: 'function-both-route',
-      priority: 100,
-      match: {
-        domains: 'function-both.example.com',
-        ports: 0
-      },
-      action: {
-        type: 'forward',
-        target: {
-          host: (context: IRouteContext) => {
-            return 'localhost';
-          },
-          port: (context: IRouteContext) => {
-            return serverPort;
-          }
-        }
-      }
-    }
-  ];
-  
-  await httpProxy.updateRouteConfigs(routes);
-  
-  // Get proxy port using the improved getListeningPort() method 
-  const proxyPort = httpProxy.getListeningPort();
-  
-  // Make request to proxy
-  const response = await makeRequest({
-    hostname: 'localhost',
-    port: proxyPort,
-    path: '/function-both',
-    method: 'GET',
-    headers: {
-      'Host': 'function-both.example.com'
-    }
-  });
-  
-  expect(response.statusCode).toEqual(200);
-  const body = JSON.parse(response.body);
-  expect(body.url).toEqual('/function-both');
-  expect(body.headers.host).toEqual(`localhost:${serverPort}`);
-});
-
-// Test context-based routing with path
-tap.test('should support context-based routing with path', async () => {
-  const routes: IRouteConfig[] = [
-    {
-      name: 'context-path-route',
-      priority: 100,
-      match: {
-        domains: 'context.example.com',
-        ports: 0
-      },
-      action: {
-        type: 'forward',
-        target: {
-          host: (context: IRouteContext) => {
-            // Use path to determine host
-            if (context.path?.startsWith('/api')) {
-              return 'localhost';
-            } else {
-              return '127.0.0.1'; // Another way to reference localhost
-            }
-          },
-          port: serverPort
-        }
-      }
-    }
-  ];
-  
-  await httpProxy.updateRouteConfigs(routes);
-  
-  // Get proxy port using the improved getListeningPort() method 
-  const proxyPort = httpProxy.getListeningPort();
-  
-  // Make request to proxy with /api path
-  const apiResponse = await makeRequest({
-    hostname: 'localhost',
-    port: proxyPort,
-    path: '/api/test',
-    method: 'GET',
-    headers: {
-      'Host': 'context.example.com'
-    }
-  });
-  
-  expect(apiResponse.statusCode).toEqual(200);
-  const apiBody = JSON.parse(apiResponse.body);
-  expect(apiBody.url).toEqual('/api/test');
-  
-  // Make request to proxy with non-api path
-  const nonApiResponse = await makeRequest({
-    hostname: 'localhost',
-    port: proxyPort,
-    path: '/web/test',
-    method: 'GET',
-    headers: {
-      'Host': 'context.example.com'
-    }
-  });
-  
-  expect(nonApiResponse.statusCode).toEqual(200);
-  const nonApiBody = JSON.parse(nonApiResponse.body);
-  expect(nonApiBody.url).toEqual('/web/test');
-});
-
-// Cleanup test environment
-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, 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, 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
-async function makeRequest(options: plugins.http.RequestOptions): Promise<{ statusCode: number, headers: plugins.http.IncomingHttpHeaders, body: string }> {
-  return new Promise((resolve, reject) => {
-    // Use HTTPS with rejectUnauthorized: false to accept self-signed certificates
-    const req = plugins.https.request({
-      ...options,
-      rejectUnauthorized: false, // Accept self-signed certificates
-    }, (res) => {
-      let body = '';
-      res.on('data', (chunk) => {
-        body += chunk;
-      });
-      res.on('end', () => {
-        resolve({
-          statusCode: res.statusCode || 0,
-          headers: res.headers,
-          body
-        });
-      });
-    });
-    
-    req.on('error', (err) => {
-      console.error(`Request error: ${err.message}`);
-      reject(err);
-    });
-    
-    req.end();
-  });
-}
-
-// Start the tests
-tap.start().then(() => {
-  // Ensure process exits after tests complete
-  process.exit(0);
-});

test/test.httpproxy.ts

@@ -1,596 +0,0 @@
-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

@@ -1,192 +0,0 @@
-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.nftables-forwarding.ts

@@ -1,116 +0,0 @@
-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

@@ -1,96 +0,0 @@
-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

@@ -1,349 +0,0 @@
-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

@@ -1,184 +0,0 @@
-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

@@ -1,164 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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,259 +0,0 @@
-import { expect, tap } from '@git.zone/tstest/tapbundle';
-import * as net from 'net';
-import { SmartProxy } from '../ts/proxies/smart-proxy/index.js';
-import {
-  createPortMappingRoute,
-  createOffsetPortMappingRoute,
-  createDynamicRoute,
-  createSmartLoadBalancer,
-  createPortOffset
-} from '../ts/proxies/smart-proxy/utils/route-helpers.js';
-import type { IRouteConfig, IRouteContext } from '../ts/proxies/smart-proxy/models/route-types.js';
-
-// Test server and client utilities
-let testServers: Array<{ server: net.Server; port: number }> = [];
-let smartProxy: SmartProxy;
-
-const TEST_PORT_START = 4000;
-const PROXY_PORT_START = 5000;
-const TEST_DATA = 'Hello through dynamic port mapper!';
-
-// Cleanup function to close all servers and proxies
-function cleanup() {
-  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
-function createTestServer(port: number): Promise<net.Server> {
-  return new Promise((resolve) => {
-    const server = net.createServer((socket) => {
-      socket.on('data', (data) => {
-        // Echo the received data back with a server identifier
-        socket.write(`Server ${port} says: ${data.toString()}`);
-      });
-      socket.on('error', (error) => {
-        console.error(`[Test Server] Socket error on port ${port}:`, error);
-      });
-    });
-    
-    server.listen(port, () => {
-      console.log(`[Test Server] Listening on port ${port}`);
-      testServers.push({ server, port });
-      resolve(server);
-    });
-  });
-}
-
-// Helper: Creates a test client connection with timeout
-function createTestClient(port: number, data: string): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const client = new net.Socket();
-    let response = '';
-    
-    const timeout = setTimeout(() => {
-      client.destroy();
-      reject(new Error(`Client connection timeout to port ${port}`));
-    }, 5000);
-    
-    client.connect(port, 'localhost', () => {
-      console.log(`[Test Client] Connected to server on port ${port}`);
-      client.write(data);
-    });
-    
-    client.on('data', (chunk) => {
-      response += chunk.toString();
-      client.end();
-    });
-    
-    client.on('end', () => {
-      clearTimeout(timeout);
-      resolve(response);
-    });
-    
-    client.on('error', (error) => {
-      clearTimeout(timeout);
-      reject(error);
-    });
-  });
-}
-
-// Set up test environment
-tap.test('setup port mapping test environment', async () => {
-  // Create multiple test servers on different ports
-  await Promise.all([
-    createTestServer(TEST_PORT_START),     // Server on port 4000
-    createTestServer(TEST_PORT_START + 1), // Server on port 4001
-    createTestServer(TEST_PORT_START + 2), // Server on port 4002
-  ]);
-  
-  // Create a SmartProxy with dynamic port mapping routes
-  smartProxy = new SmartProxy({
-    routes: [
-      // Simple function that returns the same port (identity mapping)
-      createPortMappingRoute({
-        sourcePortRange: PROXY_PORT_START,
-        targetHost: 'localhost',
-        portMapper: (context) => TEST_PORT_START,
-        name: 'Identity Port Mapping'
-      }),
-      
-      // Offset port mapping from 5001 to 4001 (offset -1000)
-      createOffsetPortMappingRoute({
-        ports: PROXY_PORT_START + 1,
-        targetHost: 'localhost',
-        offset: -1000,
-        name: 'Offset Port Mapping (-1000)'
-      }),
-      
-      // Dynamic route with conditional port mapping
-      createDynamicRoute({
-        ports: [PROXY_PORT_START + 2, PROXY_PORT_START + 3],
-        targetHost: (context) => {
-          // Dynamic host selection based on port
-          return context.port === PROXY_PORT_START + 2 ? 'localhost' : '127.0.0.1';
-        },
-        portMapper: (context) => {
-          // Port mapping logic based on incoming port
-          if (context.port === PROXY_PORT_START + 2) {
-            return TEST_PORT_START;
-          } else {
-            return TEST_PORT_START + 2;
-          }
-        },
-        name: 'Dynamic Host and Port Mapping'
-      }),
-      
-      // Smart load balancer for domain-based routing
-      createSmartLoadBalancer({
-        ports: PROXY_PORT_START + 4,
-        domainTargets: {
-          'test1.example.com': 'localhost',
-          'test2.example.com': '127.0.0.1'
-        },
-        portMapper: (context) => {
-          // Use different backend ports based on domain
-          if (context.domain === 'test1.example.com') {
-            return TEST_PORT_START;
-          } else {
-            return TEST_PORT_START + 1;
-          }
-        },
-        defaultTarget: 'localhost',
-        name: 'Smart Domain Load Balancer'
-      })
-    ]
-  });
-  
-  // Start the SmartProxy
-  await smartProxy.start();
-});
-
-// Test 1: Simple identity port mapping (5000 -> 4000)
-tap.test('should map port using identity function', async () => {
-  const response = await createTestClient(PROXY_PORT_START, TEST_DATA);
-  expect(response).toEqual(`Server ${TEST_PORT_START} says: ${TEST_DATA}`);
-});
-
-// Test 2: Offset port mapping (5001 -> 4001)
-tap.test('should map port using offset function', async () => {
-  const response = await createTestClient(PROXY_PORT_START + 1, TEST_DATA);
-  expect(response).toEqual(`Server ${TEST_PORT_START + 1} says: ${TEST_DATA}`);
-});
-
-// Test 3: Dynamic port and host mapping (conditional logic)
-tap.test('should map port using dynamic logic', async () => {
-  const response = await createTestClient(PROXY_PORT_START + 2, TEST_DATA);
-  expect(response).toEqual(`Server ${TEST_PORT_START} says: ${TEST_DATA}`);
-});
-
-// Test 4: Test reuse of createPortOffset helper
-tap.test('should use createPortOffset helper for port mapping', async () => {
-  // Test the createPortOffset helper
-  const offsetFn = createPortOffset(-1000);
-  const context = {
-    port: PROXY_PORT_START + 1,
-    clientIp: '127.0.0.1',
-    serverIp: '127.0.0.1',
-    isTls: false,
-    timestamp: Date.now(),
-    connectionId: 'test-connection'
-  } as IRouteContext;
-  
-  const mappedPort = offsetFn(context);
-  expect(mappedPort).toEqual(TEST_PORT_START + 1);
-});
-
-// Test 5: Test error handling for invalid port mapping functions
-tap.test('should handle errors in port mapping functions', async () => {
-  // Create a route with a function that throws an error
-  const errorRoute: IRouteConfig = {
-    match: {
-      ports: PROXY_PORT_START + 5
-    },
-    action: {
-      type: 'forward',
-      target: {
-        host: 'localhost',
-        port: () => {
-          throw new Error('Test error in port mapping function');
-        }
-      }
-    },
-    name: 'Error Route'
-  };
-  
-  // Add the route to SmartProxy
-  await smartProxy.updateRoutes([...smartProxy.settings.routes, errorRoute]);
-  
-  // The connection should fail or timeout
-  try {
-    await createTestClient(PROXY_PORT_START + 5, TEST_DATA);
-    // Connection should not succeed
-    expect(false).toBeTrue();
-  } catch (error) {
-    // Connection failed as expected
-    expect(true).toBeTrue();
-  }
-});
-
-// Cleanup
-tap.test('cleanup port mapping test environment', async () => {
-  // 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

@@ -1,281 +0,0 @@
-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.proxy-chain-simple.node.ts

@@ -1,195 +0,0 @@
-import { tap, expect } from '@git.zone/tstest/tapbundle';
-import * as net from 'net';
-import * as plugins from '../ts/plugins.js';
-
-// Import SmartProxy and configurations
-import { SmartProxy } from '../ts/index.js';
-
-tap.test('simple proxy chain test - identify connection accumulation', async () => {
-  console.log('\n=== Simple Proxy Chain Test ===');
-  console.log('Setup: Client → SmartProxy1 (8590) → SmartProxy2 (8591) → Backend (down)');
-  
-  // Create backend server that accepts and immediately closes connections
-  const backend = net.createServer((socket) => {
-    console.log('Backend: Connection received, closing immediately');
-    socket.destroy();
-  });
-  
-  await new Promise<void>((resolve) => {
-    backend.listen(9998, () => {
-      console.log('✓ Backend server started on port 9998 (closes connections immediately)');
-      resolve();
-    });
-  });
-  
-  // Create SmartProxy2 (downstream)
-  const proxy2 = new SmartProxy({
-    ports: [8591],
-    enableDetailedLogging: true,
-    socketTimeout: 5000,
-    routes: [{
-      name: 'to-backend',
-      match: { ports: 8591 },
-      action: {
-        type: 'forward',
-        target: {
-          host: 'localhost',
-          port: 9998  // Backend that closes immediately
-        }
-      }
-    }]
-  });
-  
-  // Create SmartProxy1 (upstream)
-  const proxy1 = new SmartProxy({
-    ports: [8590],
-    enableDetailedLogging: true,
-    socketTimeout: 5000,
-    routes: [{
-      name: 'to-proxy2',
-      match: { ports: 8590 },
-      action: {
-        type: 'forward',
-        target: {
-          host: 'localhost',
-          port: 8591  // Forward to proxy2
-        }
-      }
-    }]
-  });
-  
-  await proxy2.start();
-  console.log('✓ SmartProxy2 started on port 8591');
-  
-  await proxy1.start();
-  console.log('✓ SmartProxy1 started on port 8590');
-  
-  // Helper to get connection counts
-  const getConnectionCounts = () => {
-    const conn1 = (proxy1 as any).connectionManager;
-    const conn2 = (proxy2 as any).connectionManager;
-    return {
-      proxy1: conn1 ? conn1.getConnectionCount() : 0,
-      proxy2: conn2 ? conn2.getConnectionCount() : 0
-    };
-  };
-  
-  console.log('\n--- Making 5 sequential connections ---');
-  
-  for (let i = 0; i < 5; i++) {
-    console.log(`\n=== Connection ${i + 1} ===`);
-    
-    const counts = getConnectionCounts();
-    console.log(`Before: Proxy1=${counts.proxy1}, Proxy2=${counts.proxy2}`);
-    
-    await new Promise<void>((resolve) => {
-      const client = new net.Socket();
-      let dataReceived = false;
-      
-      client.on('data', (data) => {
-        console.log(`Client received data: ${data.toString()}`);
-        dataReceived = true;
-      });
-      
-      client.on('error', (err) => {
-        console.log(`Client error: ${err.code}`);
-        resolve();
-      });
-      
-      client.on('close', () => {
-        console.log(`Client closed (data received: ${dataReceived})`);
-        resolve();
-      });
-      
-      client.connect(8590, 'localhost', () => {
-        console.log('Client connected to Proxy1');
-        // Send HTTP request
-        client.write('GET / HTTP/1.1\r\nHost: test.com\r\n\r\n');
-      });
-      
-      // Timeout
-      setTimeout(() => {
-        if (!client.destroyed) {
-          console.log('Client timeout, destroying');
-          client.destroy();
-        }
-        resolve();
-      }, 2000);
-    });
-    
-    // Wait a bit and check counts
-    await new Promise(resolve => setTimeout(resolve, 500));
-    
-    const afterCounts = getConnectionCounts();
-    console.log(`After: Proxy1=${afterCounts.proxy1}, Proxy2=${afterCounts.proxy2}`);
-    
-    if (afterCounts.proxy1 > 0 || afterCounts.proxy2 > 0) {
-      console.log('⚠️  WARNING: Connections not cleaned up!');
-    }
-  }
-  
-  console.log('\n--- Test with backend completely down ---');
-  
-  // Stop backend
-  backend.close();
-  await new Promise(resolve => setTimeout(resolve, 100));
-  console.log('✓ Backend stopped');
-  
-  // Make more connections with backend down
-  for (let i = 0; i < 3; i++) {
-    console.log(`\n=== Connection ${i + 6} (backend down) ===`);
-    
-    const counts = getConnectionCounts();
-    console.log(`Before: Proxy1=${counts.proxy1}, Proxy2=${counts.proxy2}`);
-    
-    await new Promise<void>((resolve) => {
-      const client = new net.Socket();
-      
-      client.on('error', () => {
-        resolve();
-      });
-      
-      client.on('close', () => {
-        resolve();
-      });
-      
-      client.connect(8590, 'localhost', () => {
-        client.write('GET / HTTP/1.1\r\nHost: test.com\r\n\r\n');
-      });
-      
-      setTimeout(() => {
-        if (!client.destroyed) {
-          client.destroy();
-        }
-        resolve();
-      }, 1000);
-    });
-    
-    await new Promise(resolve => setTimeout(resolve, 500));
-    
-    const afterCounts = getConnectionCounts();
-    console.log(`After: Proxy1=${afterCounts.proxy1}, Proxy2=${afterCounts.proxy2}`);
-  }
-  
-  // Final check
-  console.log('\n--- Final Check ---');
-  await new Promise(resolve => setTimeout(resolve, 1000));
-  
-  const finalCounts = getConnectionCounts();
-  console.log(`Final counts: Proxy1=${finalCounts.proxy1}, Proxy2=${finalCounts.proxy2}`);
-  
-  await proxy1.stop();
-  await proxy2.stop();
-  
-  // Verify
-  if (finalCounts.proxy1 > 0 || finalCounts.proxy2 > 0) {
-    console.log('\n❌ FAIL: Connections accumulated!');
-  } else {
-    console.log('\n✅ PASS: No connection accumulation');
-  }
-  
-  expect(finalCounts.proxy1).toEqual(0);
-  expect(finalCounts.proxy2).toEqual(0);
-});
-
-tap.start();

test/test.proxy-chaining-accumulation.node.ts

@@ -1,368 +0,0 @@
-import { tap, expect } from '@git.zone/tstest/tapbundle';
-import * as net from 'net';
-import * as plugins from '../ts/plugins.js';
-
-// Import SmartProxy and configurations
-import { SmartProxy } from '../ts/index.js';
-
-tap.test('should handle proxy chaining without connection accumulation', async () => {
-  console.log('\n=== Testing Proxy Chaining Connection Accumulation ===');
-  console.log('Setup: Client → SmartProxy1 → SmartProxy2 → Backend (down)');
-  
-  // Create SmartProxy2 (downstream proxy)
-  const proxy2 = new SmartProxy({
-    ports: [8581],
-    enableDetailedLogging: false,
-    socketTimeout: 5000,
-    routes: [{
-      name: 'backend-route',
-      match: { ports: 8581 },
-      action: {
-        type: 'forward',
-        target: {
-          host: 'localhost',
-          port: 9999  // Non-existent backend
-        }
-      }
-    }]
-  });
-  
-  // Create SmartProxy1 (upstream proxy)
-  const proxy1 = new SmartProxy({
-    ports: [8580],
-    enableDetailedLogging: false,
-    socketTimeout: 5000,
-    routes: [{
-      name: 'chain-route',
-      match: { ports: 8580 },
-      action: {
-        type: 'forward',
-        target: {
-          host: 'localhost',
-          port: 8581  // Forward to proxy2
-        }
-      }
-    }]
-  });
-  
-  // Start both proxies
-  await proxy2.start();
-  console.log('✓ SmartProxy2 started on port 8581');
-  
-  await proxy1.start();
-  console.log('✓ SmartProxy1 started on port 8580');
-  
-  // Helper to get connection counts
-  const getConnectionCounts = () => {
-    const conn1 = (proxy1 as any).connectionManager;
-    const conn2 = (proxy2 as any).connectionManager;
-    return {
-      proxy1: conn1 ? conn1.getConnectionCount() : 0,
-      proxy2: conn2 ? conn2.getConnectionCount() : 0
-    };
-  };
-  
-  const initialCounts = getConnectionCounts();
-  console.log(`\nInitial connection counts - Proxy1: ${initialCounts.proxy1}, Proxy2: ${initialCounts.proxy2}`);
-  
-  // Test 1: Single connection attempt
-  console.log('\n--- Test 1: Single connection through chain ---');
-  
-  await new Promise<void>((resolve) => {
-    const client = new net.Socket();
-    
-    client.on('error', (err) => {
-      console.log(`Client received error: ${err.code}`);
-      resolve();
-    });
-    
-    client.on('close', () => {
-      console.log('Client connection closed');
-      resolve();
-    });
-    
-    client.connect(8580, 'localhost', () => {
-      console.log('Client connected to Proxy1');
-      // Send data to trigger routing
-      client.write('GET / HTTP/1.1\r\nHost: test.com\r\n\r\n');
-    });
-    
-    // Timeout
-    setTimeout(() => {
-      if (!client.destroyed) {
-        client.destroy();
-      }
-      resolve();
-    }, 1000);
-  });
-  
-  // Check connections after single attempt
-  await new Promise(resolve => setTimeout(resolve, 500));
-  let counts = getConnectionCounts();
-  console.log(`After single connection - Proxy1: ${counts.proxy1}, Proxy2: ${counts.proxy2}`);
-  
-  // Test 2: Multiple simultaneous connections
-  console.log('\n--- Test 2: Multiple simultaneous connections ---');
-  
-  const promises = [];
-  for (let i = 0; i < 10; i++) {
-    promises.push(new Promise<void>((resolve) => {
-      const client = new net.Socket();
-      
-      client.on('error', () => {
-        resolve();
-      });
-      
-      client.on('close', () => {
-        resolve();
-      });
-      
-      client.connect(8580, 'localhost', () => {
-        // Send data
-        client.write(`GET /test${i} HTTP/1.1\r\nHost: test.com\r\n\r\n`);
-      });
-      
-      // Timeout
-      setTimeout(() => {
-        if (!client.destroyed) {
-          client.destroy();
-        }
-        resolve();
-      }, 500);
-    }));
-  }
-  
-  await Promise.all(promises);
-  console.log('✓ All simultaneous connections completed');
-  
-  // Check connections
-  counts = getConnectionCounts();
-  console.log(`After simultaneous connections - Proxy1: ${counts.proxy1}, Proxy2: ${counts.proxy2}`);
-  
-  // Test 3: Rapid serial connections (simulating retries)
-  console.log('\n--- Test 3: Rapid serial connections (retries) ---');
-  
-  for (let i = 0; i < 20; i++) {
-    await new Promise<void>((resolve) => {
-      const client = new net.Socket();
-      
-      client.on('error', () => {
-        resolve();
-      });
-      
-      client.on('close', () => {
-        resolve();
-      });
-      
-      client.connect(8580, 'localhost', () => {
-        client.write('GET / HTTP/1.1\r\nHost: test.com\r\n\r\n');
-        // Quick disconnect to simulate retry behavior
-        setTimeout(() => client.destroy(), 50);
-      });
-      
-      // Timeout
-      setTimeout(() => {
-        if (!client.destroyed) {
-          client.destroy();
-        }
-        resolve();
-      }, 200);
-    });
-    
-    if ((i + 1) % 5 === 0) {
-      counts = getConnectionCounts();
-      console.log(`After ${i + 1} retries - Proxy1: ${counts.proxy1}, Proxy2: ${counts.proxy2}`);
-    }
-    
-    // Small delay between retries
-    await new Promise(resolve => setTimeout(resolve, 50));
-  }
-  
-  // Test 4: Long-lived connection attempt
-  console.log('\n--- Test 4: Long-lived connection attempt ---');
-  
-  await new Promise<void>((resolve) => {
-    const client = new net.Socket();
-    
-    client.on('error', () => {
-      resolve();
-    });
-    
-    client.on('close', () => {
-      console.log('Long-lived client closed');
-      resolve();
-    });
-    
-    client.connect(8580, 'localhost', () => {
-      console.log('Long-lived client connected');
-      // Send data periodically
-      const interval = setInterval(() => {
-        if (!client.destroyed && client.writable) {
-          client.write('PING\r\n');
-        } else {
-          clearInterval(interval);
-        }
-      }, 100);
-      
-      // Close after 2 seconds
-      setTimeout(() => {
-        clearInterval(interval);
-        client.destroy();
-      }, 2000);
-    });
-    
-    // Timeout
-    setTimeout(() => {
-      if (!client.destroyed) {
-        client.destroy();
-      }
-      resolve();
-    }, 3000);
-  });
-  
-  // Final check
-  await new Promise(resolve => setTimeout(resolve, 1000));
-  
-  const finalCounts = getConnectionCounts();
-  console.log(`\nFinal connection counts - Proxy1: ${finalCounts.proxy1}, Proxy2: ${finalCounts.proxy2}`);
-  
-  // Monitor for a bit to see if connections are cleaned up
-  console.log('\nMonitoring connection cleanup...');
-  for (let i = 0; i < 3; i++) {
-    await new Promise(resolve => setTimeout(resolve, 500));
-    counts = getConnectionCounts();
-    console.log(`After ${(i + 1) * 0.5}s - Proxy1: ${counts.proxy1}, Proxy2: ${counts.proxy2}`);
-  }
-  
-  // Stop proxies
-  await proxy1.stop();
-  console.log('\n✓ SmartProxy1 stopped');
-  
-  await proxy2.stop();
-  console.log('✓ SmartProxy2 stopped');
-  
-  // Analysis
-  console.log('\n=== Analysis ===');
-  if (finalCounts.proxy1 > 0 || finalCounts.proxy2 > 0) {
-    console.log('❌ FAIL: Connections accumulated!');
-    console.log(`Proxy1 leaked ${finalCounts.proxy1} connections`);
-    console.log(`Proxy2 leaked ${finalCounts.proxy2} connections`);
-  } else {
-    console.log('✅ PASS: No connection accumulation detected');
-  }
-  
-  // Verify
-  expect(finalCounts.proxy1).toEqual(0);
-  expect(finalCounts.proxy2).toEqual(0);
-});
-
-tap.test('should handle proxy chain with HTTP traffic', async () => {
-  console.log('\n=== Testing Proxy Chain with HTTP Traffic ===');
-  
-  // Create SmartProxy2 with HTTP handling
-  const proxy2 = new SmartProxy({
-    ports: [8583],
-    useHttpProxy: [8583],  // Enable HTTP proxy handling
-    httpProxyPort: 8584,
-    enableDetailedLogging: false,
-    routes: [{
-      name: 'http-backend',
-      match: { ports: 8583 },
-      action: {
-        type: 'forward',
-        target: {
-          host: 'localhost',
-          port: 9999  // Non-existent backend
-        }
-      }
-    }]
-  });
-  
-  // Create SmartProxy1 with HTTP handling
-  const proxy1 = new SmartProxy({
-    ports: [8582],
-    useHttpProxy: [8582],  // Enable HTTP proxy handling
-    httpProxyPort: 8585,
-    enableDetailedLogging: false,
-    routes: [{
-      name: 'http-chain',
-      match: { ports: 8582 },
-      action: {
-        type: 'forward',
-        target: {
-          host: 'localhost',
-          port: 8583  // Forward to proxy2
-        }
-      }
-    }]
-  });
-  
-  await proxy2.start();
-  console.log('✓ SmartProxy2 (HTTP) started on port 8583');
-  
-  await proxy1.start();
-  console.log('✓ SmartProxy1 (HTTP) started on port 8582');
-  
-  // Helper to get connection counts
-  const getConnectionCounts = () => {
-    const conn1 = (proxy1 as any).connectionManager;
-    const conn2 = (proxy2 as any).connectionManager;
-    return {
-      proxy1: conn1 ? conn1.getConnectionCount() : 0,
-      proxy2: conn2 ? conn2.getConnectionCount() : 0
-    };
-  };
-  
-  console.log('\nSending HTTP requests through chain...');
-  
-  // Make HTTP requests
-  for (let i = 0; i < 5; i++) {
-    await new Promise<void>((resolve) => {
-      const client = new net.Socket();
-      let responseData = '';
-      
-      client.on('data', (data) => {
-        responseData += data.toString();
-        // Check if we got a complete HTTP response
-        if (responseData.includes('\r\n\r\n')) {
-          console.log(`Response ${i + 1}: ${responseData.split('\r\n')[0]}`);
-          client.destroy();
-        }
-      });
-      
-      client.on('error', () => {
-        resolve();
-      });
-      
-      client.on('close', () => {
-        resolve();
-      });
-      
-      client.connect(8582, 'localhost', () => {
-        client.write(`GET /test${i} HTTP/1.1\r\nHost: test.com\r\nConnection: close\r\n\r\n`);
-      });
-      
-      setTimeout(() => {
-        if (!client.destroyed) {
-          client.destroy();
-        }
-        resolve();
-      }, 1000);
-    });
-    
-    await new Promise(resolve => setTimeout(resolve, 100));
-  }
-  
-  await new Promise(resolve => setTimeout(resolve, 1000));
-  
-  const finalCounts = getConnectionCounts();
-  console.log(`\nFinal HTTP proxy counts - Proxy1: ${finalCounts.proxy1}, Proxy2: ${finalCounts.proxy2}`);
-  
-  await proxy1.stop();
-  await proxy2.stop();
-  
-  expect(finalCounts.proxy1).toEqual(0);
-  expect(finalCounts.proxy2).toEqual(0);
-});
-
-tap.start();

test/test.race-conditions.node.ts

@@ -1,185 +0,0 @@
-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.rapid-retry-cleanup.node.ts

@@ -1,201 +0,0 @@
-import { tap, expect } from '@git.zone/tstest/tapbundle';
-import * as net from 'net';
-import * as plugins from '../ts/plugins.js';
-
-// Import SmartProxy and configurations
-import { SmartProxy } from '../ts/index.js';
-
-tap.test('should handle rapid connection retries without leaking connections', async () => {
-  console.log('\n=== Testing Rapid Connection Retry Cleanup ===');
-  
-  // Create a SmartProxy instance
-  const proxy = new SmartProxy({
-    ports: [8550],
-    enableDetailedLogging: false,
-    maxConnectionLifetime: 10000,
-    socketTimeout: 5000,
-    routes: [{
-      name: 'test-route',
-      match: { ports: 8550 },
-      action: {
-        type: 'forward',
-        target: {
-          host: 'localhost',
-          port: 9999  // Non-existent port to force connection failures
-        }
-      }
-    }]
-  });
-  
-  // Start the proxy
-  await proxy.start();
-  console.log('✓ Proxy started on port 8550');
-  
-  // Helper to get active connection count
-  const getActiveConnections = () => {
-    const connectionManager = (proxy as any).connectionManager;
-    return connectionManager ? connectionManager.getConnectionCount() : 0;
-  };
-  
-  // Track connection counts
-  const connectionCounts: number[] = [];
-  const initialCount = getActiveConnections();
-  console.log(`Initial connection count: ${initialCount}`);
-  
-  // Simulate rapid retries
-  const retryCount = 20;
-  const retryDelay = 50; // 50ms between retries
-  let successfulConnections = 0;
-  let failedConnections = 0;
-  
-  console.log(`\nSimulating ${retryCount} rapid connection attempts...`);
-  
-  for (let i = 0; i < retryCount; i++) {
-    await new Promise<void>((resolve) => {
-      const client = new net.Socket();
-      
-      client.on('error', () => {
-        failedConnections++;
-        client.destroy();
-        resolve();
-      });
-      
-      client.on('close', () => {
-        resolve();
-      });
-      
-      client.connect(8550, 'localhost', () => {
-        // Send some data to trigger routing
-        client.write('GET / HTTP/1.1\r\nHost: test.com\r\n\r\n');
-        successfulConnections++;
-      });
-      
-      // Force close after a short time
-      setTimeout(() => {
-        if (!client.destroyed) {
-          client.destroy();
-        }
-      }, 100);
-    });
-    
-    // Small delay between retries
-    await new Promise(resolve => setTimeout(resolve, retryDelay));
-    
-    // Check connection count after each attempt
-    const currentCount = getActiveConnections();
-    connectionCounts.push(currentCount);
-    
-    if ((i + 1) % 5 === 0) {
-      console.log(`After ${i + 1} attempts: ${currentCount} active connections`);
-    }
-  }
-  
-  console.log(`\nConnection attempts complete:`);
-  console.log(`- Successful: ${successfulConnections}`);
-  console.log(`- Failed: ${failedConnections}`);
-  
-  // Wait a bit for any pending cleanups
-  console.log('\nWaiting for cleanup...');
-  await new Promise(resolve => setTimeout(resolve, 1000));
-  
-  // Check final connection count
-  const finalCount = getActiveConnections();
-  console.log(`\nFinal connection count: ${finalCount}`);
-  
-  // Analyze connection count trend
-  const maxCount = Math.max(...connectionCounts);
-  const avgCount = connectionCounts.reduce((a, b) => a + b, 0) / connectionCounts.length;
-  
-  console.log(`\nConnection count statistics:`);
-  console.log(`- Maximum: ${maxCount}`);
-  console.log(`- Average: ${avgCount.toFixed(2)}`);
-  console.log(`- Initial: ${initialCount}`);
-  console.log(`- Final: ${finalCount}`);
-  
-  // Stop the proxy
-  await proxy.stop();
-  console.log('\n✓ Proxy stopped');
-  
-  // Verify results
-  expect(finalCount).toEqual(initialCount);
-  expect(maxCount).toBeLessThan(10); // Should not accumulate many connections
-  
-  console.log('\n✅ PASS: Connection cleanup working correctly under rapid retries!');
-});
-
-tap.test('should handle routing failures without leaking connections', async () => {
-  console.log('\n=== Testing Routing Failure Cleanup ===');
-  
-  // Create a SmartProxy instance with no routes
-  const proxy = new SmartProxy({
-    ports: [8551],
-    enableDetailedLogging: false,
-    maxConnectionLifetime: 10000,
-    socketTimeout: 5000,
-    routes: [] // No routes - all connections will fail routing
-  });
-  
-  // Start the proxy
-  await proxy.start();
-  console.log('✓ Proxy started on port 8551 with no routes');
-  
-  // Helper to get active connection count
-  const getActiveConnections = () => {
-    const connectionManager = (proxy as any).connectionManager;
-    return connectionManager ? connectionManager.getConnectionCount() : 0;
-  };
-  
-  const initialCount = getActiveConnections();
-  console.log(`Initial connection count: ${initialCount}`);
-  
-  // Create multiple connections that will fail routing
-  const connectionPromises = [];
-  for (let i = 0; i < 10; i++) {
-    connectionPromises.push(new Promise<void>((resolve) => {
-      const client = new net.Socket();
-      
-      client.on('error', () => {
-        client.destroy();
-        resolve();
-      });
-      
-      client.on('close', () => {
-        resolve();
-      });
-      
-      client.connect(8551, 'localhost', () => {
-        // Send data to trigger routing (which will fail)
-        client.write('GET / HTTP/1.1\r\nHost: test.com\r\n\r\n');
-      });
-      
-      // Force close after a short time
-      setTimeout(() => {
-        if (!client.destroyed) {
-          client.destroy();
-        }
-        resolve();
-      }, 500);
-    }));
-  }
-  
-  // Wait for all connections to complete
-  await Promise.all(connectionPromises);
-  console.log('✓ All connection attempts completed');
-  
-  // Wait for cleanup
-  await new Promise(resolve => setTimeout(resolve, 500));
-  
-  const finalCount = getActiveConnections();
-  console.log(`Final connection count: ${finalCount}`);
-  
-  // Stop the proxy
-  await proxy.stop();
-  console.log('✓ Proxy stopped');
-  
-  // Verify no connections leaked
-  expect(finalCount).toEqual(initialCount);
-  
-  console.log('\n✅ PASS: Routing failures cleaned up correctly!');
-});
-
-tap.start();

test/test.route-callback-simple.ts

@@ -1,116 +0,0 @@
-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,565 +0,0 @@
-/**
- * Tests for the unified route-based configuration system
- */
-import { expect, tap } from '@git.zone/tstest/tapbundle';
-
-// Import from core modules
-import { SmartProxy } from '../ts/proxies/smart-proxy/index.js';
-
-// Import route utilities and helpers
-import {
-  findMatchingRoutes,
-  findBestMatchingRoute,
-  routeMatchesDomain,
-  routeMatchesPort,
-  routeMatchesPath,
-  routeMatchesHeaders,
-  mergeRouteConfigs,
-  generateRouteId,
-  cloneRoute
-} from '../ts/proxies/smart-proxy/utils/route-utils.js';
-
-import {
-  validateRouteConfig,
-  validateRoutes,
-  isValidDomain,
-  isValidPort,
-  hasRequiredPropertiesForAction,
-  assertValidRoute
-} from '../ts/proxies/smart-proxy/utils/route-validators.js';
-
-import {
-  createHttpRoute,
-  createHttpsTerminateRoute,
-  createHttpsPassthroughRoute,
-  createHttpToHttpsRedirect,
-  createCompleteHttpsServer,
-  createLoadBalancerRoute,
-  createApiRoute,
-  createWebSocketRoute
-} from '../ts/proxies/smart-proxy/utils/route-helpers.js';
-
-// Import test helpers
-import { loadTestCertificates } from './helpers/certificates.js';
-
-import type { IRouteConfig } from '../ts/proxies/smart-proxy/models/route-types.js';
-
-// --------------------------------- Route Creation Tests ---------------------------------
-
-tap.test('Routes: Should create basic HTTP route', async () => {
-  // Create a simple HTTP route
-  const httpRoute = createHttpRoute('example.com', { host: 'localhost', port: 3000 }, {
-    name: 'Basic HTTP Route'
-  });
-
-  // Validate the route configuration
-  expect(httpRoute.match.ports).toEqual(80);
-  expect(httpRoute.match.domains).toEqual('example.com');
-  expect(httpRoute.action.type).toEqual('forward');
-  expect(httpRoute.action.target?.host).toEqual('localhost');
-  expect(httpRoute.action.target?.port).toEqual(3000);
-  expect(httpRoute.name).toEqual('Basic HTTP Route');
-});
-
-tap.test('Routes: Should create HTTPS route with TLS termination', async () => {
-  // Create an HTTPS route with TLS termination
-  const httpsRoute = createHttpsTerminateRoute('secure.example.com', { host: 'localhost', port: 8080 }, {
-    certificate: 'auto',
-    name: 'HTTPS Route'
-  });
-
-  // Validate the route configuration
-  expect(httpsRoute.match.ports).toEqual(443); // Default HTTPS port
-  expect(httpsRoute.match.domains).toEqual('secure.example.com');
-  expect(httpsRoute.action.type).toEqual('forward');
-  expect(httpsRoute.action.tls?.mode).toEqual('terminate');
-  expect(httpsRoute.action.tls?.certificate).toEqual('auto');
-  expect(httpsRoute.action.target?.host).toEqual('localhost');
-  expect(httpsRoute.action.target?.port).toEqual(8080);
-  expect(httpsRoute.name).toEqual('HTTPS Route');
-});
-
-tap.test('Routes: Should create HTTP to HTTPS redirect', async () => {
-  // Create an HTTP to HTTPS redirect
-  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('socket-handler');
-  expect(redirectRoute.action.socketHandler).toBeDefined();
-});
-
-tap.test('Routes: Should create complete HTTPS server with redirects', async () => {
-  // Create a complete HTTPS server setup
-  const routes = createCompleteHttpsServer('example.com', { host: 'localhost', port: 8080 }, {
-    certificate: 'auto'
-  });
-
-  // Validate that we got two routes (HTTPS route and HTTP redirect)
-  expect(routes.length).toEqual(2);
-
-  // Validate HTTPS route
-  const httpsRoute = routes[0];
-  expect(httpsRoute.match.ports).toEqual(443);
-  expect(httpsRoute.match.domains).toEqual('example.com');
-  expect(httpsRoute.action.type).toEqual('forward');
-  expect(httpsRoute.action.tls?.mode).toEqual('terminate');
-
-  // Validate HTTP redirect route
-  const redirectRoute = routes[1];
-  expect(redirectRoute.match.ports).toEqual(80);
-  expect(redirectRoute.action.type).toEqual('socket-handler');
-  expect(redirectRoute.action.socketHandler).toBeDefined();
-});
-
-tap.test('Routes: Should create load balancer route', async () => {
-  // Create a load balancer route
-  const lbRoute = createLoadBalancerRoute(
-    'app.example.com',
-    ['10.0.0.1', '10.0.0.2', '10.0.0.3'],
-    8080,
-    {
-      tls: {
-        mode: 'terminate',
-        certificate: 'auto'
-      },
-      name: 'Load Balanced Route'
-    }
-  );
-
-  // Validate the route configuration
-  expect(lbRoute.match.domains).toEqual('app.example.com');
-  expect(lbRoute.action.type).toEqual('forward');
-  expect(Array.isArray(lbRoute.action.target?.host)).toBeTrue();
-  expect((lbRoute.action.target?.host as string[]).length).toEqual(3);
-  expect((lbRoute.action.target?.host as string[])[0]).toEqual('10.0.0.1');
-  expect(lbRoute.action.target?.port).toEqual(8080);
-  expect(lbRoute.action.tls?.mode).toEqual('terminate');
-});
-
-tap.test('Routes: Should create API route with CORS', async () => {
-  // Create an API route with CORS headers
-  const apiRoute = createApiRoute('api.example.com', '/v1', { host: 'localhost', port: 3000 }, {
-    useTls: true,
-    certificate: 'auto',
-    addCorsHeaders: true,
-    name: 'API Route'
-  });
-
-  // Validate the route configuration
-  expect(apiRoute.match.domains).toEqual('api.example.com');
-  expect(apiRoute.match.path).toEqual('/v1/*');
-  expect(apiRoute.action.type).toEqual('forward');
-  expect(apiRoute.action.tls?.mode).toEqual('terminate');
-  expect(apiRoute.action.target?.host).toEqual('localhost');
-  expect(apiRoute.action.target?.port).toEqual(3000);
-  
-  // Check CORS headers
-  expect(apiRoute.headers).toBeDefined();
-  if (apiRoute.headers?.response) {
-    expect(apiRoute.headers.response['Access-Control-Allow-Origin']).toEqual('*');
-    expect(apiRoute.headers.response['Access-Control-Allow-Methods']).toInclude('GET');
-  }
-});
-
-tap.test('Routes: Should create WebSocket route', async () => {
-  // Create a WebSocket route
-  const wsRoute = createWebSocketRoute('ws.example.com', '/socket', { host: 'localhost', port: 5000 }, {
-    useTls: true,
-    certificate: 'auto',
-    pingInterval: 15000,
-    name: 'WebSocket Route'
-  });
-
-  // Validate the route configuration
-  expect(wsRoute.match.domains).toEqual('ws.example.com');
-  expect(wsRoute.match.path).toEqual('/socket');
-  expect(wsRoute.action.type).toEqual('forward');
-  expect(wsRoute.action.tls?.mode).toEqual('terminate');
-  expect(wsRoute.action.target?.host).toEqual('localhost');
-  expect(wsRoute.action.target?.port).toEqual(5000);
-  
-  // Check WebSocket configuration
-  expect(wsRoute.action.websocket).toBeDefined();
-  if (wsRoute.action.websocket) {
-    expect(wsRoute.action.websocket.enabled).toBeTrue();
-    expect(wsRoute.action.websocket.pingInterval).toEqual(15000);
-  }
-});
-
-// 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
-  const certs = loadTestCertificates();
-
-  // Create a SmartProxy instance with route-based configuration
-  const proxy = new SmartProxy({
-    routes: [
-      createHttpRoute('example.com', { host: 'localhost', port: 3000 }, {
-        name: 'HTTP Route'
-      }),
-      createHttpsTerminateRoute('secure.example.com', { host: 'localhost', port: 8443 }, {
-        certificate: {
-          key: certs.privateKey,
-          cert: certs.publicKey
-        },
-        name: 'HTTPS Route'
-      })
-    ],
-    defaults: {
-      target: {
-        host: 'localhost',
-        port: 8080
-      },
-      security: {
-        ipAllowList: ['127.0.0.1', '192.168.0.*'],
-        maxConnections: 100
-      }
-    },
-    // Additional settings
-    initialDataTimeout: 10000,
-    inactivityTimeout: 300000,
-    enableDetailedLogging: true
-  });
-
-  // Simply verify the instance was created successfully
-  expect(typeof proxy).toEqual('object');
-  expect(typeof proxy.start).toEqual('function');
-  expect(typeof proxy.stop).toEqual('function');
-});
-
-// --------------------------------- Edge Case Tests ---------------------------------
-
-tap.test('Edge Case - Empty Routes Array', async () => {
-  // Attempting to find routes in an empty array
-  const emptyRoutes: IRouteConfig[] = [];
-  const matches = findMatchingRoutes(emptyRoutes, { domain: 'example.com', port: 80 });
-  
-  expect(matches).toBeInstanceOf(Array);
-  expect(matches.length).toEqual(0);
-  
-  const bestMatch = findBestMatchingRoute(emptyRoutes, { domain: 'example.com', port: 80 });
-  expect(bestMatch).toBeUndefined();
-});
-
-tap.test('Edge Case - Multiple Matching Routes with Same Priority', async () => {
-  // Create multiple routes with identical priority but different targets
-  const route1 = createHttpRoute('example.com', { host: 'server1', port: 3000 });
-  const route2 = createHttpRoute('example.com', { host: 'server2', port: 3000 });
-  const route3 = createHttpRoute('example.com', { host: 'server3', port: 3000 });
-  
-  // Set all to the same priority
-  route1.priority = 100;
-  route2.priority = 100;
-  route3.priority = 100;
-  
-  const routes = [route1, route2, route3];
-  
-  // Find matching routes
-  const matches = findMatchingRoutes(routes, { domain: 'example.com', port: 80 });
-  
-  // Should find all three routes
-  expect(matches.length).toEqual(3);
-  
-  // First match could be any of the routes since they have the same priority
-  // But the implementation should be consistent (likely keep the original order)
-  const bestMatch = findBestMatchingRoute(routes, { domain: 'example.com', port: 80 });
-  expect(bestMatch).not.toBeUndefined();
-});
-
-tap.test('Edge Case - Wildcard Domains and Path Matching', async () => {
-  // Create routes with wildcard domains and path patterns
-  const wildcardApiRoute = createApiRoute('*.example.com', '/api', { host: 'api-server', port: 3000 }, {
-    useTls: true,
-    certificate: 'auto'
-  });
-  
-  const exactApiRoute = createApiRoute('api.example.com', '/api', { host: 'specific-api-server', port: 3001 }, {
-    useTls: true,
-    certificate: 'auto',
-    priority: 200 // Higher priority
-  });
-  
-  const routes = [wildcardApiRoute, exactApiRoute];
-  
-  // Test with a specific subdomain that matches both routes
-  const matches = findMatchingRoutes(routes, { domain: 'api.example.com', path: '/api/users', port: 443 });
-  
-  // Should match both routes
-  expect(matches.length).toEqual(2);
-  
-  // The exact domain match should have higher priority
-  const bestMatch = findBestMatchingRoute(routes, { domain: 'api.example.com', path: '/api/users', port: 443 });
-  expect(bestMatch).not.toBeUndefined();
-  if (bestMatch) {
-    expect(bestMatch.action.target.port).toEqual(3001); // Should match the exact domain route
-  }
-  
-  // Test with a different subdomain - should only match the wildcard route
-  const otherMatches = findMatchingRoutes(routes, { domain: 'other.example.com', path: '/api/products', port: 443 });
-  expect(otherMatches.length).toEqual(1);
-  expect(otherMatches[0].action.target.port).toEqual(3000); // Should match the wildcard domain route
-});
-
-tap.test('Edge Case - Disabled Routes', async () => {
-  // Create enabled and disabled routes
-  const enabledRoute = createHttpRoute('example.com', { host: 'server1', port: 3000 });
-  const disabledRoute = createHttpRoute('example.com', { host: 'server2', port: 3001 });
-  disabledRoute.enabled = false;
-  
-  const routes = [enabledRoute, disabledRoute];
-  
-  // Find matching routes
-  const matches = findMatchingRoutes(routes, { domain: 'example.com', port: 80 });
-  
-  // Should only find the enabled route
-  expect(matches.length).toEqual(1);
-  expect(matches[0].action.target.port).toEqual(3000);
-});
-
-tap.test('Edge Case - Complex Path and Headers Matching', async () => {
-  // Create route with complex path and headers matching
-  const complexRoute: IRouteConfig = {
-    match: {
-      domains: 'api.example.com',
-      ports: 443,
-      path: '/api/v2/*',
-      headers: {
-        'Content-Type': 'application/json',
-        'X-API-Key': 'valid-key'
-      }
-    },
-    action: {
-      type: 'forward',
-      target: {
-        host: 'internal-api',
-        port: 8080
-      },
-      tls: {
-        mode: 'terminate',
-        certificate: 'auto'
-      }
-    },
-    name: 'Complex API Route'
-  };
-  
-  // Test with matching criteria
-  const matchingPath = routeMatchesPath(complexRoute, '/api/v2/users');
-  expect(matchingPath).toBeTrue();
-  
-  const matchingHeaders = routeMatchesHeaders(complexRoute, {
-    'Content-Type': 'application/json',
-    'X-API-Key': 'valid-key',
-    'Accept': 'application/json'
-  });
-  expect(matchingHeaders).toBeTrue();
-  
-  // Test with non-matching criteria
-  const nonMatchingPath = routeMatchesPath(complexRoute, '/api/v1/users');
-  expect(nonMatchingPath).toBeFalse();
-  
-  const nonMatchingHeaders = routeMatchesHeaders(complexRoute, {
-    'Content-Type': 'application/json',
-    'X-API-Key': 'invalid-key'
-  });
-  expect(nonMatchingHeaders).toBeFalse();
-});
-
-tap.test('Edge Case - Port Range Matching', async () => {
-  // Create route with port range matching
-  const portRangeRoute: IRouteConfig = {
-    match: {
-      domains: 'example.com',
-      ports: [{ from: 8000, to: 9000 }]
-    },
-    action: {
-      type: 'forward',
-      target: {
-        host: 'backend',
-        port: 3000
-      }
-    },
-    name: 'Port Range Route'
-  };
-  
-  // Test with ports in the range
-  expect(routeMatchesPort(portRangeRoute, 8000)).toBeTrue(); // Lower bound
-  expect(routeMatchesPort(portRangeRoute, 8500)).toBeTrue(); // Middle
-  expect(routeMatchesPort(portRangeRoute, 9000)).toBeTrue(); // Upper bound
-  
-  // Test with ports outside the range
-  expect(routeMatchesPort(portRangeRoute, 7999)).toBeFalse(); // Just below
-  expect(routeMatchesPort(portRangeRoute, 9001)).toBeFalse(); // Just above
-  
-  // Test with multiple port ranges
-  const multiRangeRoute: IRouteConfig = {
-    match: {
-      domains: 'example.com',
-      ports: [
-        { from: 80, to: 90 },
-        { from: 8000, to: 9000 }
-      ]
-    },
-    action: {
-      type: 'forward',
-      target: {
-        host: 'backend',
-        port: 3000
-      }
-    },
-    name: 'Multi Range Route'
-  };
-  
-  expect(routeMatchesPort(multiRangeRoute, 85)).toBeTrue();
-  expect(routeMatchesPort(multiRangeRoute, 8500)).toBeTrue();
-  expect(routeMatchesPort(multiRangeRoute, 100)).toBeFalse();
-});
-
-// --------------------------------- Wildcard Domain Tests ---------------------------------
-
-tap.test('Wildcard Domain Handling', async () => {
-  // Create routes with different wildcard patterns
-  const simpleDomainRoute = createHttpRoute('example.com', { host: 'server1', port: 3000 });
-  const wildcardSubdomainRoute = createHttpRoute('*.example.com', { host: 'server2', port: 3001 });
-  const specificSubdomainRoute = createHttpRoute('api.example.com', { host: 'server3', port: 3002 });
-
-  // Set explicit priorities to ensure deterministic matching
-  specificSubdomainRoute.priority = 200; // Highest priority for specific domain
-  wildcardSubdomainRoute.priority = 100; // Medium priority for wildcard
-  simpleDomainRoute.priority = 50;       // Lowest priority for generic domain
-
-  const routes = [simpleDomainRoute, wildcardSubdomainRoute, specificSubdomainRoute];
-
-  // Test exact domain match
-  expect(routeMatchesDomain(simpleDomainRoute, 'example.com')).toBeTrue();
-  expect(routeMatchesDomain(simpleDomainRoute, 'sub.example.com')).toBeFalse();
-
-  // Test wildcard subdomain match
-  expect(routeMatchesDomain(wildcardSubdomainRoute, 'any.example.com')).toBeTrue();
-  expect(routeMatchesDomain(wildcardSubdomainRoute, 'nested.sub.example.com')).toBeTrue();
-  expect(routeMatchesDomain(wildcardSubdomainRoute, 'example.com')).toBeFalse();
-
-  // Test specific subdomain match
-  expect(routeMatchesDomain(specificSubdomainRoute, 'api.example.com')).toBeTrue();
-  expect(routeMatchesDomain(specificSubdomainRoute, 'other.example.com')).toBeFalse();
-  expect(routeMatchesDomain(specificSubdomainRoute, 'sub.api.example.com')).toBeFalse();
-
-  // Test finding best match when multiple domains match
-  const specificSubdomainRequest = { domain: 'api.example.com', port: 80 };
-  const bestSpecificMatch = findBestMatchingRoute(routes, specificSubdomainRequest);
-  expect(bestSpecificMatch).not.toBeUndefined();
-  if (bestSpecificMatch) {
-    // Find which route was matched
-    const matchedPort = bestSpecificMatch.action.target.port;
-    console.log(`Matched route with port: ${matchedPort}`);
-
-    // Verify it's the specific subdomain route (with highest priority)
-    expect(bestSpecificMatch.priority).toEqual(200);
-  }
-
-  // Test with a subdomain that matches wildcard but not specific
-  const otherSubdomainRequest = { domain: 'other.example.com', port: 80 };
-  const bestWildcardMatch = findBestMatchingRoute(routes, otherSubdomainRequest);
-  expect(bestWildcardMatch).not.toBeUndefined();
-  if (bestWildcardMatch) {
-    // Find which route was matched
-    const matchedPort = bestWildcardMatch.action.target.port;
-    console.log(`Matched route with port: ${matchedPort}`);
-
-    // Verify it's the wildcard subdomain route (with medium priority)
-    expect(bestWildcardMatch.priority).toEqual(100);
-  }
-});
-
-// --------------------------------- Integration Tests ---------------------------------
-
-tap.test('Route Integration - Combining Multiple Route Types', async () => {
-  // Create a comprehensive set of routes for a full application
-  const routes: IRouteConfig[] = [
-    // Main website with HTTPS and HTTP redirect
-    ...createCompleteHttpsServer('example.com', { host: 'web-server', port: 8080 }, {
-      certificate: 'auto'
-    }),
-    
-    // API endpoints
-    createApiRoute('api.example.com', '/v1', { host: 'api-server', port: 3000 }, {
-      useTls: true,
-      certificate: 'auto',
-      addCorsHeaders: true
-    }),
-    
-    // WebSocket for real-time updates
-    createWebSocketRoute('ws.example.com', '/live', { host: 'websocket-server', port: 5000 }, {
-      useTls: true,
-      certificate: 'auto'
-    }),
-    
-    
-    // Legacy system with passthrough
-    createHttpsPassthroughRoute('legacy.example.com', { host: 'legacy-server', port: 443 })
-  ];
-  
-  // Validate all routes
-  const validationResult = validateRoutes(routes);
-  expect(validationResult.valid).toBeTrue();
-  expect(validationResult.errors.length).toEqual(0);
-  
-  // Test route matching for different endpoints
-  
-  // Web server (HTTPS)
-  const webServerMatch = findBestMatchingRoute(routes, { domain: 'example.com', port: 443 });
-  expect(webServerMatch).not.toBeUndefined();
-  if (webServerMatch) {
-    expect(webServerMatch.action.type).toEqual('forward');
-    expect(webServerMatch.action.target.host).toEqual('web-server');
-  }
-  
-  // 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('socket-handler');
-  }
-  
-  // API server
-  const apiMatch = findBestMatchingRoute(routes, { 
-    domain: 'api.example.com', 
-    port: 443,
-    path: '/v1/users'
-  });
-  expect(apiMatch).not.toBeUndefined();
-  if (apiMatch) {
-    expect(apiMatch.action.type).toEqual('forward');
-    expect(apiMatch.action.target.host).toEqual('api-server');
-  }
-  
-  // WebSocket server
-  const wsMatch = findBestMatchingRoute(routes, { 
-    domain: 'ws.example.com', 
-    port: 443,
-    path: '/live'
-  });
-  expect(wsMatch).not.toBeUndefined();
-  if (wsMatch) {
-    expect(wsMatch.action.type).toEqual('forward');
-    expect(wsMatch.action.target.host).toEqual('websocket-server');
-    expect(wsMatch.action.websocket?.enabled).toBeTrue();
-  }
-  
-  // Static assets route was removed - static file serving should be handled externally
-  
-  // Legacy system
-  const legacyMatch = findBestMatchingRoute(routes, { 
-    domain: 'legacy.example.com', 
-    port: 443
-  });
-  expect(legacyMatch).not.toBeUndefined();
-  if (legacyMatch) {
-    expect(legacyMatch.action.type).toEqual('forward');
-    expect(legacyMatch.action.tls?.mode).toEqual('passthrough');
-  }
-});
-
-export default tap.start();

test/test.route-security-integration.ts

@@ -1,279 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,275 +0,0 @@
-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

@@ -1,339 +0,0 @@
-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,998 +0,0 @@
-import { tap, expect } from '@git.zone/tstest/tapbundle';
-import * as plugins from '../ts/plugins.js';
-
-// Import from individual modules to avoid naming conflicts
-import {
-  // Route helpers
-  createHttpRoute,
-  createHttpsTerminateRoute,
-  createApiRoute,
-  createWebSocketRoute,
-  createHttpToHttpsRedirect,
-  createHttpsPassthroughRoute,
-  createCompleteHttpsServer,
-  createLoadBalancerRoute
-} from '../ts/proxies/smart-proxy/utils/route-helpers.js';
-
-import {
-  // Route validators
-  validateRouteConfig,
-  validateRoutes,
-  isValidDomain,
-  isValidPort,
-  validateRouteMatch,
-  validateRouteAction,
-  hasRequiredPropertiesForAction,
-  assertValidRoute
-} from '../ts/proxies/smart-proxy/utils/route-validators.js';
-
-import {
-  // Route utilities
-  mergeRouteConfigs,
-  findMatchingRoutes,
-  findBestMatchingRoute,
-  routeMatchesDomain,
-  routeMatchesPort,
-  routeMatchesPath,
-  routeMatchesHeaders,
-  generateRouteId,
-  cloneRoute
-} from '../ts/proxies/smart-proxy/utils/route-utils.js';
-
-import {
-  // Route patterns
-  createApiGatewayRoute,
-  createWebSocketRoute as createWebSocketPattern,
-  createLoadBalancerRoute as createLbPattern,
-  addRateLimiting,
-  addBasicAuth,
-  addJwtAuth
-} from '../ts/proxies/smart-proxy/utils/route-patterns.js';
-
-import type {
-  IRouteConfig,
-  IRouteMatch,
-  IRouteAction,
-  IRouteTarget,
-  IRouteTls,
-  TRouteActionType
-} from '../ts/proxies/smart-proxy/models/route-types.js';
-
-// --------------------------------- Route Validation Tests ---------------------------------
-
-tap.test('Route Validation - isValidDomain', async () => {
-  // Valid domains
-  expect(isValidDomain('example.com')).toBeTrue();
-  expect(isValidDomain('sub.example.com')).toBeTrue();
-  expect(isValidDomain('*.example.com')).toBeTrue();
-  
-  // Invalid domains
-  expect(isValidDomain('example')).toBeFalse();
-  expect(isValidDomain('example.')).toBeFalse();
-  expect(isValidDomain('example..com')).toBeFalse();
-  expect(isValidDomain('*.*.example.com')).toBeFalse();
-  expect(isValidDomain('-example.com')).toBeFalse();
-});
-
-tap.test('Route Validation - isValidPort', async () => {
-  // Valid ports
-  expect(isValidPort(80)).toBeTrue();
-  expect(isValidPort(443)).toBeTrue();
-  expect(isValidPort(8080)).toBeTrue();
-  expect(isValidPort([80, 443])).toBeTrue();
-  
-  // Invalid ports
-  expect(isValidPort(0)).toBeFalse();
-  expect(isValidPort(65536)).toBeFalse();
-  expect(isValidPort(-1)).toBeFalse();
-  expect(isValidPort([0, 80])).toBeFalse();
-});
-
-tap.test('Route Validation - validateRouteMatch', async () => {
-  // Valid match configuration
-  const validMatch: IRouteMatch = {
-    ports: 80,
-    domains: 'example.com'
-  };
-  const validResult = validateRouteMatch(validMatch);
-  expect(validResult.valid).toBeTrue();
-  expect(validResult.errors.length).toEqual(0);
-  
-  // Invalid match configuration (invalid domain)
-  const invalidMatch: IRouteMatch = {
-    ports: 80,
-    domains: 'invalid..domain'
-  };
-  const invalidResult = validateRouteMatch(invalidMatch);
-  expect(invalidResult.valid).toBeFalse();
-  expect(invalidResult.errors.length).toBeGreaterThan(0);
-  expect(invalidResult.errors[0]).toInclude('Invalid domain');
-  
-  // Invalid match configuration (invalid port)
-  const invalidPortMatch: IRouteMatch = {
-    ports: 0,
-    domains: 'example.com'
-  };
-  const invalidPortResult = validateRouteMatch(invalidPortMatch);
-  expect(invalidPortResult.valid).toBeFalse();
-  expect(invalidPortResult.errors.length).toBeGreaterThan(0);
-  expect(invalidPortResult.errors[0]).toInclude('Invalid port');
-  
-  // Test path validation
-  const invalidPathMatch: IRouteMatch = {
-    ports: 80,
-    domains: 'example.com',
-    path: 'invalid-path-without-slash'
-  };
-  const invalidPathResult = validateRouteMatch(invalidPathMatch);
-  expect(invalidPathResult.valid).toBeFalse();
-  expect(invalidPathResult.errors.length).toBeGreaterThan(0);
-  expect(invalidPathResult.errors[0]).toInclude('starting with /');
-});
-
-tap.test('Route Validation - validateRouteAction', async () => {
-  // Valid forward action
-  const validForwardAction: IRouteAction = {
-    type: 'forward',
-    target: {
-      host: 'localhost',
-      port: 3000
-    }
-  };
-  const validForwardResult = validateRouteAction(validForwardAction);
-  expect(validForwardResult.valid).toBeTrue();
-  expect(validForwardResult.errors.length).toEqual(0);
-  
-  // Valid socket-handler action
-  const validSocketAction: IRouteAction = {
-    type: 'socket-handler',
-    socketHandler: (socket, context) => {
-      socket.end();
-    }
-  };
-  const validSocketResult = validateRouteAction(validSocketAction);
-  expect(validSocketResult.valid).toBeTrue();
-  expect(validSocketResult.errors.length).toEqual(0);
-  
-  // Invalid action (missing target)
-  const invalidAction: IRouteAction = {
-    type: 'forward'
-  };
-  const invalidResult = validateRouteAction(invalidAction);
-  expect(invalidResult.valid).toBeFalse();
-  expect(invalidResult.errors.length).toBeGreaterThan(0);
-  expect(invalidResult.errors[0]).toInclude('Target is required');
-  
-  // Invalid action (missing socket handler)
-  const invalidSocketAction: IRouteAction = {
-    type: 'socket-handler'
-  };
-  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 () => {
-  // Valid route config
-  const validRoute = createHttpRoute('example.com', { host: 'localhost', port: 3000 });
-  const validResult = validateRouteConfig(validRoute);
-  expect(validResult.valid).toBeTrue();
-  expect(validResult.errors.length).toEqual(0);
-  
-  // Invalid route config (missing target)
-  const invalidRoute: IRouteConfig = {
-    match: {
-      domains: 'example.com',
-      ports: 80
-    },
-    action: {
-      type: 'forward'
-    },
-    name: 'Invalid Route'
-  };
-  const invalidResult = validateRouteConfig(invalidRoute);
-  expect(invalidResult.valid).toBeFalse();
-  expect(invalidResult.errors.length).toBeGreaterThan(0);
-});
-
-tap.test('Route Validation - validateRoutes', async () => {
-  // Create valid and invalid routes
-  const routes = [
-    createHttpRoute('example.com', { host: 'localhost', port: 3000 }),
-    {
-      match: {
-        domains: 'invalid..domain',
-        ports: 80
-      },
-      action: {
-        type: 'forward',
-        target: {
-          host: 'localhost',
-          port: 3000
-        }
-      }
-    } as IRouteConfig,
-    createHttpsTerminateRoute('secure.example.com', { host: 'localhost', port: 3001 })
-  ];
-  
-  const result = validateRoutes(routes);
-  expect(result.valid).toBeFalse();
-  expect(result.errors.length).toEqual(1);
-  expect(result.errors[0].index).toEqual(1); // The second route is invalid
-  expect(result.errors[0].errors.length).toBeGreaterThan(0);
-  expect(result.errors[0].errors[0]).toInclude('Invalid domain');
-});
-
-tap.test('Route Validation - hasRequiredPropertiesForAction', async () => {
-  // Forward action
-  const forwardRoute = createHttpRoute('example.com', { host: 'localhost', port: 3000 });
-  expect(hasRequiredPropertiesForAction(forwardRoute, 'forward')).toBeTrue();
-  
-  // Socket handler action (redirect functionality)
-  const redirectRoute = createHttpToHttpsRedirect('example.com');
-  expect(hasRequiredPropertiesForAction(redirectRoute, 'socket-handler')).toBeTrue();
-  
-  // Socket handler action
-  const socketRoute: IRouteConfig = {
-    match: {
-      domains: 'socket.example.com',
-      ports: 80
-    },
-    action: {
-      type: 'socket-handler',
-      socketHandler: (socket, context) => {
-        socket.end();
-      }
-    },
-    name: 'Socket Handler Route'
-  };
-  expect(hasRequiredPropertiesForAction(socketRoute, 'socket-handler')).toBeTrue();
-  
-  // Missing required properties
-  const invalidForwardRoute: IRouteConfig = {
-    match: {
-      domains: 'example.com',
-      ports: 80
-    },
-    action: {
-      type: 'forward'
-    },
-    name: 'Invalid Forward Route'
-  };
-  expect(hasRequiredPropertiesForAction(invalidForwardRoute, 'forward')).toBeFalse();
-});
-
-tap.test('Route Validation - assertValidRoute', async () => {
-  // Valid route
-  const validRoute = createHttpRoute('example.com', { host: 'localhost', port: 3000 });
-  expect(() => assertValidRoute(validRoute)).not.toThrow();
-  
-  // Invalid route
-  const invalidRoute: IRouteConfig = {
-    match: {
-      domains: 'example.com',
-      ports: 80
-    },
-    action: {
-      type: 'forward'
-    },
-    name: 'Invalid Route'
-  };
-  expect(() => assertValidRoute(invalidRoute)).toThrow();
-});
-
-// --------------------------------- Route Utilities Tests ---------------------------------
-
-tap.test('Route Utilities - mergeRouteConfigs', async () => {
-  // Base route
-  const baseRoute = createHttpRoute('example.com', { host: 'localhost', port: 3000 });
-  
-  // Override with different name and port
-  const overrideRoute: Partial<IRouteConfig> = {
-    name: 'Merged Route',
-    match: {
-      ports: 8080
-    }
-  };
-  
-  // Merge configs
-  const mergedRoute = mergeRouteConfigs(baseRoute, overrideRoute);
-  
-  // Check merged properties
-  expect(mergedRoute.name).toEqual('Merged Route');
-  expect(mergedRoute.match.ports).toEqual(8080);
-  expect(mergedRoute.match.domains).toEqual('example.com');
-  expect(mergedRoute.action.type).toEqual('forward');
-  
-  // Test merging action properties
-  const actionOverride: Partial<IRouteConfig> = {
-    action: {
-      type: 'forward',
-      target: {
-        host: 'new-host.local',
-        port: 5000
-      }
-    }
-  };
-  
-  const actionMergedRoute = mergeRouteConfigs(baseRoute, actionOverride);
-  expect(actionMergedRoute.action.target.host).toEqual('new-host.local');
-  expect(actionMergedRoute.action.target.port).toEqual(5000);
-  
-  // Test replacing action with socket handler
-  const typeChangeOverride: Partial<IRouteConfig> = {
-    action: {
-      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('socket-handler');
-  expect(typeChangedRoute.action.socketHandler).toBeDefined();
-  expect(typeChangedRoute.action.target).toBeUndefined();
-});
-
-tap.test('Route Matching - routeMatchesDomain', async () => {
-  // Create route with wildcard domain
-  const wildcardRoute = createHttpRoute('*.example.com', { host: 'localhost', port: 3000 });
-  
-  // Create route with exact domain
-  const exactRoute = createHttpRoute('example.com', { host: 'localhost', port: 3000 });
-  
-  // Create route with multiple domains
-  const multiDomainRoute = createHttpRoute(['example.com', 'example.org'], { host: 'localhost', port: 3000 });
-  
-  // Test wildcard domain matching
-  expect(routeMatchesDomain(wildcardRoute, 'sub.example.com')).toBeTrue();
-  expect(routeMatchesDomain(wildcardRoute, 'another.example.com')).toBeTrue();
-  expect(routeMatchesDomain(wildcardRoute, 'example.com')).toBeFalse();
-  expect(routeMatchesDomain(wildcardRoute, 'example.org')).toBeFalse();
-  
-  // Test exact domain matching
-  expect(routeMatchesDomain(exactRoute, 'example.com')).toBeTrue();
-  expect(routeMatchesDomain(exactRoute, 'sub.example.com')).toBeFalse();
-  
-  // Test multiple domains matching
-  expect(routeMatchesDomain(multiDomainRoute, 'example.com')).toBeTrue();
-  expect(routeMatchesDomain(multiDomainRoute, 'example.org')).toBeTrue();
-  expect(routeMatchesDomain(multiDomainRoute, 'example.net')).toBeFalse();
-  
-  // Test case insensitivity
-  expect(routeMatchesDomain(exactRoute, 'Example.Com')).toBeTrue();
-});
-
-tap.test('Route Matching - routeMatchesPort', async () => {
-  // Create routes with different port configurations
-  const singlePortRoute = createHttpRoute('example.com', { host: 'localhost', port: 3000 });
-  
-  const multiPortRoute: IRouteConfig = {
-    match: {
-      domains: 'example.com',
-      ports: [80, 8080]
-    },
-    action: {
-      type: 'forward',
-      target: {
-        host: 'localhost',
-        port: 3000
-      }
-    }
-  };
-  
-  const portRangeRoute: IRouteConfig = {
-    match: {
-      domains: 'example.com',
-      ports: [{ from: 8000, to: 9000 }]
-    },
-    action: {
-      type: 'forward',
-      target: {
-        host: 'localhost',
-        port: 3000
-      }
-    }
-  };
-  
-  // Test single port matching
-  expect(routeMatchesPort(singlePortRoute, 80)).toBeTrue();
-  expect(routeMatchesPort(singlePortRoute, 443)).toBeFalse();
-  
-  // Test multi-port matching
-  expect(routeMatchesPort(multiPortRoute, 80)).toBeTrue();
-  expect(routeMatchesPort(multiPortRoute, 8080)).toBeTrue();
-  expect(routeMatchesPort(multiPortRoute, 3000)).toBeFalse();
-  
-  // Test port range matching
-  expect(routeMatchesPort(portRangeRoute, 8000)).toBeTrue();
-  expect(routeMatchesPort(portRangeRoute, 8500)).toBeTrue();
-  expect(routeMatchesPort(portRangeRoute, 9000)).toBeTrue();
-  expect(routeMatchesPort(portRangeRoute, 7999)).toBeFalse();
-  expect(routeMatchesPort(portRangeRoute, 9001)).toBeFalse();
-});
-
-tap.test('Route Matching - routeMatchesPath', async () => {
-  // Create route with path configuration
-  const exactPathRoute: IRouteConfig = {
-    match: {
-      domains: 'example.com',
-      ports: 80,
-      path: '/api'
-    },
-    action: {
-      type: 'forward',
-      target: {
-        host: 'localhost',
-        port: 3000
-      }
-    }
-  };
-  
-  const trailingSlashPathRoute: IRouteConfig = {
-    match: {
-      domains: 'example.com',
-      ports: 80,
-      path: '/api/'
-    },
-    action: {
-      type: 'forward',
-      target: {
-        host: 'localhost',
-        port: 3000
-      }
-    }
-  };
-  
-  const wildcardPathRoute: IRouteConfig = {
-    match: {
-      domains: 'example.com',
-      ports: 80,
-      path: '/api/*'
-    },
-    action: {
-      type: 'forward',
-      target: {
-        host: 'localhost',
-        port: 3000
-      }
-    }
-  };
-  
-  // Test exact path matching
-  expect(routeMatchesPath(exactPathRoute, '/api')).toBeTrue();
-  expect(routeMatchesPath(exactPathRoute, '/api/users')).toBeFalse();
-  expect(routeMatchesPath(exactPathRoute, '/app')).toBeFalse();
-  
-  // Test trailing slash path matching
-  expect(routeMatchesPath(trailingSlashPathRoute, '/api/')).toBeTrue();
-  expect(routeMatchesPath(trailingSlashPathRoute, '/api/users')).toBeTrue();
-  expect(routeMatchesPath(trailingSlashPathRoute, '/app/')).toBeFalse();
-  
-  // Test wildcard path matching
-  expect(routeMatchesPath(wildcardPathRoute, '/api/users')).toBeTrue();
-  expect(routeMatchesPath(wildcardPathRoute, '/api/products')).toBeTrue();
-  expect(routeMatchesPath(wildcardPathRoute, '/app/api')).toBeFalse();
-});
-
-tap.test('Route Matching - routeMatchesHeaders', async () => {
-  // Create route with header matching
-  const headerRoute: IRouteConfig = {
-    match: {
-      domains: 'example.com',
-      ports: 80,
-      headers: {
-        'Content-Type': 'application/json',
-        'X-Custom-Header': 'value'
-      }
-    },
-    action: {
-      type: 'forward',
-      target: {
-        host: 'localhost',
-        port: 3000
-      }
-    }
-  };
-  
-  // Test header matching
-  expect(routeMatchesHeaders(headerRoute, {
-    'Content-Type': 'application/json',
-    'X-Custom-Header': 'value'
-  })).toBeTrue();
-  
-  expect(routeMatchesHeaders(headerRoute, {
-    'Content-Type': 'application/json',
-    'X-Custom-Header': 'value',
-    'Extra-Header': 'something'
-  })).toBeTrue();
-  
-  expect(routeMatchesHeaders(headerRoute, {
-    'Content-Type': 'application/json'
-  })).toBeFalse();
-  
-  expect(routeMatchesHeaders(headerRoute, {
-    'Content-Type': 'text/html',
-    'X-Custom-Header': 'value'
-  })).toBeFalse();
-  
-  // Route without header matching should match any headers
-  const noHeaderRoute = createHttpRoute('example.com', { host: 'localhost', port: 3000 });
-  expect(routeMatchesHeaders(noHeaderRoute, {
-    'Content-Type': 'application/json'
-  })).toBeTrue();
-});
-
-tap.test('Route Finding - findMatchingRoutes', async () => {
-  // Create multiple routes
-  const routes: IRouteConfig[] = [
-    createHttpRoute('example.com', { host: 'localhost', port: 3000 }),
-    createHttpsTerminateRoute('secure.example.com', { host: 'localhost', port: 3001 }),
-    createApiRoute('api.example.com', '/v1', { host: 'localhost', port: 3002 }),
-    createWebSocketRoute('ws.example.com', '/socket', { host: 'localhost', port: 3003 })
-  ];
-  
-  // Set priorities
-  routes[0].priority = 10;
-  routes[1].priority = 20;
-  routes[2].priority = 30;
-  routes[3].priority = 40;
-  
-  // Find routes for different criteria
-  const httpMatches = findMatchingRoutes(routes, { domain: 'example.com', port: 80 });
-  expect(httpMatches.length).toEqual(1);
-  expect(httpMatches[0].name).toInclude('HTTP Route');
-  
-  const httpsMatches = findMatchingRoutes(routes, { domain: 'secure.example.com', port: 443 });
-  expect(httpsMatches.length).toEqual(1);
-  expect(httpsMatches[0].name).toInclude('HTTPS Route');
-  
-  const apiMatches = findMatchingRoutes(routes, { domain: 'api.example.com', path: '/v1/users' });
-  expect(apiMatches.length).toEqual(1);
-  expect(apiMatches[0].name).toInclude('API Route');
-  
-  const wsMatches = findMatchingRoutes(routes, { domain: 'ws.example.com', path: '/socket' });
-  expect(wsMatches.length).toEqual(1);
-  expect(wsMatches[0].name).toInclude('WebSocket Route');
-  
-  // Test finding multiple routes that match same criteria
-  const route1 = createHttpRoute('example.com', { host: 'localhost', port: 3000 });
-  route1.priority = 10;
-  
-  const route2 = createHttpRoute('example.com', { host: 'localhost', port: 3001 });
-  route2.priority = 20;
-  route2.match.path = '/api';
-  
-  const multiMatchRoutes = [route1, route2];
-  
-  const multiMatches = findMatchingRoutes(multiMatchRoutes, { domain: 'example.com', port: 80 });
-  expect(multiMatches.length).toEqual(2);
-  expect(multiMatches[0].priority).toEqual(20); // Higher priority should be first
-  expect(multiMatches[1].priority).toEqual(10);
-  
-  // Test disabled routes
-  const disabledRoute = createHttpRoute('example.com', { host: 'localhost', port: 3000 });
-  disabledRoute.enabled = false;
-  
-  const enabledRoutes = findMatchingRoutes([disabledRoute], { domain: 'example.com', port: 80 });
-  expect(enabledRoutes.length).toEqual(0);
-});
-
-tap.test('Route Finding - findBestMatchingRoute', async () => {
-  // Create multiple routes with different priorities
-  const route1 = createHttpRoute('example.com', { host: 'localhost', port: 3000 });
-  route1.priority = 10;
-  
-  const route2 = createHttpRoute('example.com', { host: 'localhost', port: 3001 });
-  route2.priority = 20;
-  route2.match.path = '/api';
-  
-  const route3 = createHttpRoute('example.com', { host: 'localhost', port: 3002 });
-  route3.priority = 30;
-  route3.match.path = '/api/users';
-  
-  const routes = [route1, route2, route3];
-  
-  // Find best route for different criteria
-  const bestGeneral = findBestMatchingRoute(routes, { domain: 'example.com', port: 80 });
-  expect(bestGeneral).not.toBeUndefined();
-  expect(bestGeneral?.priority).toEqual(30);
-  
-  // Test when no routes match
-  const noMatch = findBestMatchingRoute(routes, { domain: 'unknown.com', port: 80 });
-  expect(noMatch).toBeUndefined();
-});
-
-tap.test('Route Utilities - generateRouteId', async () => {
-  // Test ID generation for different route types
-  const httpRoute = createHttpRoute('example.com', { host: 'localhost', port: 3000 });
-  const httpId = generateRouteId(httpRoute);
-  expect(httpId).toInclude('example-com');
-  expect(httpId).toInclude('80');
-  expect(httpId).toInclude('forward');
-  
-  const httpsRoute = createHttpsTerminateRoute('secure.example.com', { host: 'localhost', port: 3001 });
-  const httpsId = generateRouteId(httpsRoute);
-  expect(httpsId).toInclude('secure-example-com');
-  expect(httpsId).toInclude('443');
-  expect(httpsId).toInclude('forward');
-  
-  const multiDomainRoute = createHttpRoute(['example.com', 'example.org'], { host: 'localhost', port: 3000 });
-  const multiDomainId = generateRouteId(multiDomainRoute);
-  expect(multiDomainId).toInclude('example-com-example-org');
-});
-
-tap.test('Route Utilities - cloneRoute', async () => {
-  // Create a route and clone it
-  const originalRoute = createHttpsTerminateRoute('example.com', { host: 'localhost', port: 3000 }, {
-    certificate: 'auto',
-    name: 'Original Route'
-  });
-  
-  const clonedRoute = cloneRoute(originalRoute);
-  
-  // Check that the values are identical
-  expect(clonedRoute.name).toEqual(originalRoute.name);
-  expect(clonedRoute.match.domains).toEqual(originalRoute.match.domains);
-  expect(clonedRoute.action.type).toEqual(originalRoute.action.type);
-  expect(clonedRoute.action.target.port).toEqual(originalRoute.action.target.port);
-  
-  // Modify the clone and check that the original is unchanged
-  clonedRoute.name = 'Modified Clone';
-  expect(originalRoute.name).toEqual('Original Route');
-});
-
-// --------------------------------- Route Helper Tests ---------------------------------
-
-tap.test('Route Helpers - createHttpRoute', 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);
-  
-  const validationResult = validateRouteConfig(route);
-  expect(validationResult.valid).toBeTrue();
-});
-
-tap.test('Route Helpers - createHttpsTerminateRoute', async () => {
-  const route = createHttpsTerminateRoute('example.com', { host: 'localhost', port: 3000 }, {
-    certificate: 'auto'
-  });
-  
-  expect(route.match.domains).toEqual('example.com');
-  expect(route.match.ports).toEqual(443);
-  expect(route.action.type).toEqual('forward');
-  expect(route.action.tls.mode).toEqual('terminate');
-  expect(route.action.tls.certificate).toEqual('auto');
-  
-  const validationResult = validateRouteConfig(route);
-  expect(validationResult.valid).toBeTrue();
-});
-
-tap.test('Route Helpers - createHttpToHttpsRedirect', async () => {
-  const route = createHttpToHttpsRedirect('example.com');
-  
-  expect(route.match.domains).toEqual('example.com');
-  expect(route.match.ports).toEqual(80);
-  expect(route.action.type).toEqual('socket-handler');
-  expect(route.action.socketHandler).toBeDefined();
-  
-  const validationResult = validateRouteConfig(route);
-  expect(validationResult.valid).toBeTrue();
-});
-
-tap.test('Route Helpers - createHttpsPassthroughRoute', async () => {
-  const route = createHttpsPassthroughRoute('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.tls.mode).toEqual('passthrough');
-  
-  const validationResult = validateRouteConfig(route);
-  expect(validationResult.valid).toBeTrue();
-});
-
-tap.test('Route Helpers - createCompleteHttpsServer', async () => {
-  const routes = createCompleteHttpsServer('example.com', { host: 'localhost', port: 3000 }, {
-    certificate: 'auto'
-  });
-  
-  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.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('socket-handler');
-  
-  const validation1 = validateRouteConfig(routes[0]);
-  const validation2 = validateRouteConfig(routes[1]);
-  expect(validation1.valid).toBeTrue();
-  expect(validation2.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 }, {
-    useTls: true,
-    certificate: 'auto',
-    addCorsHeaders: true
-  });
-  
-  expect(route.match.domains).toEqual('api.example.com');
-  expect(route.match.ports).toEqual(443);
-  expect(route.match.path).toEqual('/v1/*');
-  expect(route.action.type).toEqual('forward');
-  expect(route.action.tls.mode).toEqual('terminate');
-  
-  // Check CORS headers if they exist
-  if (route.headers && route.headers.response) {
-    expect(route.headers.response['Access-Control-Allow-Origin']).toEqual('*');
-  }
-  
-  const validationResult = validateRouteConfig(route);
-  expect(validationResult.valid).toBeTrue();
-});
-
-tap.test('Route Helpers - createWebSocketRoute', async () => {
-  const route = createWebSocketRoute('ws.example.com', '/socket', { host: 'localhost', port: 3000 }, {
-    useTls: true,
-    certificate: 'auto',
-    pingInterval: 15000
-  });
-  
-  expect(route.match.domains).toEqual('ws.example.com');
-  expect(route.match.ports).toEqual(443);
-  expect(route.match.path).toEqual('/socket');
-  expect(route.action.type).toEqual('forward');
-  expect(route.action.tls.mode).toEqual('terminate');
-  
-  // Check websocket configuration if it exists
-  if (route.action.websocket) {
-    expect(route.action.websocket.enabled).toBeTrue();
-    expect(route.action.websocket.pingInterval).toEqual(15000);
-  }
-  
-  const validationResult = validateRouteConfig(route);
-  expect(validationResult.valid).toBeTrue();
-});
-
-tap.test('Route Helpers - createLoadBalancerRoute', async () => {
-  const route = createLoadBalancerRoute(
-    'loadbalancer.example.com',
-    ['server1.local', 'server2.local', 'server3.local'],
-    8080,
-    {
-      tls: {
-        mode: 'terminate',
-        certificate: 'auto'
-      }
-    }
-  );
-  
-  expect(route.match.domains).toEqual('loadbalancer.example.com');
-  expect(route.match.ports).toEqual(443);
-  expect(route.action.type).toEqual('forward');
-  expect(Array.isArray(route.action.target.host)).toBeTrue();
-  if (Array.isArray(route.action.target.host)) {
-    expect(route.action.target.host.length).toEqual(3);
-  }
-  expect(route.action.target.port).toEqual(8080);
-  expect(route.action.tls.mode).toEqual('terminate');
-  
-  const validationResult = validateRouteConfig(route);
-  expect(validationResult.valid).toBeTrue();
-});
-
-// --------------------------------- Route Pattern Tests ---------------------------------
-
-tap.test('Route Patterns - createApiGatewayRoute', async () => {
-  // Create API Gateway route
-  const apiGatewayRoute = createApiGatewayRoute(
-    'api.example.com',
-    '/v1',
-    { host: 'localhost', port: 3000 },
-    {
-      useTls: true,
-      addCorsHeaders: true
-    }
-  );
-  
-  // Validate route configuration
-  expect(apiGatewayRoute.match.domains).toEqual('api.example.com');
-  expect(apiGatewayRoute.match.path).toInclude('/v1');
-  expect(apiGatewayRoute.action.type).toEqual('forward');
-  expect(apiGatewayRoute.action.target.port).toEqual(3000);
-  
-  // Check TLS configuration
-  if (apiGatewayRoute.action.tls) {
-    expect(apiGatewayRoute.action.tls.mode).toEqual('terminate');
-  }
-  
-  // Check CORS headers
-  if (apiGatewayRoute.headers && apiGatewayRoute.headers.response) {
-    expect(apiGatewayRoute.headers.response['Access-Control-Allow-Origin']).toEqual('*');
-  }
-  
-  const result = validateRouteConfig(apiGatewayRoute);
-  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
-  const wsRoute = createWebSocketPattern(
-    'ws.example.com',
-    { host: 'localhost', port: 3000 },
-    {
-      useTls: true,
-      path: '/socket',
-      pingInterval: 10000
-    }
-  );
-  
-  // Validate route configuration
-  expect(wsRoute.match.domains).toEqual('ws.example.com');
-  expect(wsRoute.match.path).toEqual('/socket');
-  expect(wsRoute.action.type).toEqual('forward');
-  expect(wsRoute.action.target.port).toEqual(3000);
-  
-  // Check TLS configuration
-  if (wsRoute.action.tls) {
-    expect(wsRoute.action.tls.mode).toEqual('terminate');
-  }
-  
-  // Check websocket configuration if it exists
-  if (wsRoute.action.websocket) {
-    expect(wsRoute.action.websocket.enabled).toBeTrue();
-    expect(wsRoute.action.websocket.pingInterval).toEqual(10000);
-  }
-  
-  const result = validateRouteConfig(wsRoute);
-  expect(result.valid).toBeTrue();
-});
-
-tap.test('Route Patterns - createLoadBalancerRoute pattern', async () => {
-  // Create load balancer route pattern with missing algorithm as it might not be implemented yet
-  try {
-    const lbRoute = createLbPattern(
-      'lb.example.com',
-      [
-        { host: 'server1.local', port: 8080 },
-        { host: 'server2.local', port: 8080 },
-        { host: 'server3.local', port: 8080 }
-      ],
-      {
-        useTls: true
-      }
-    );
-    
-    // Validate route configuration
-    expect(lbRoute.match.domains).toEqual('lb.example.com');
-    expect(lbRoute.action.type).toEqual('forward');
-    
-    // Check target hosts
-    if (Array.isArray(lbRoute.action.target.host)) {
-      expect(lbRoute.action.target.host.length).toEqual(3);
-    }
-    
-    // Check TLS configuration
-    if (lbRoute.action.tls) {
-      expect(lbRoute.action.tls.mode).toEqual('terminate');
-    }
-    
-    const result = validateRouteConfig(lbRoute);
-    expect(result.valid).toBeTrue();
-  } catch (error) {
-    // If the pattern is not implemented yet, skip this test
-    console.log('Load balancer pattern might not be fully implemented yet');
-  }
-});
-
-tap.test('Route Security - addRateLimiting', async () => {
-  // Create base route
-  const baseRoute = createHttpRoute('example.com', { host: 'localhost', port: 3000 });
-
-  // Add rate limiting
-  const secureRoute = addRateLimiting(baseRoute, {
-    maxRequests: 100,
-    window: 60, // 1 minute
-    keyBy: 'ip'
-  });
-
-  // Check if rate limiting is applied
-  if (secureRoute.security) {
-    expect(secureRoute.security.rateLimit?.enabled).toBeTrue();
-    expect(secureRoute.security.rateLimit?.maxRequests).toEqual(100);
-    expect(secureRoute.security.rateLimit?.window).toEqual(60);
-    expect(secureRoute.security.rateLimit?.keyBy).toEqual('ip');
-  } else {
-    // Skip this test if security features are not implemented yet
-    console.log('Security features not implemented yet in route configuration');
-  }
-
-  // Just check that the route itself is valid
-  const result = validateRouteConfig(secureRoute);
-  expect(result.valid).toBeTrue();
-});
-
-tap.test('Route Security - addBasicAuth', async () => {
-  // Create base route
-  const baseRoute = createHttpRoute('example.com', { host: 'localhost', port: 3000 });
-
-  // Add basic authentication
-  const authRoute = addBasicAuth(baseRoute, {
-    users: [
-      { username: 'admin', password: 'secret' },
-      { username: 'user', password: 'password' }
-    ],
-    realm: 'Protected Area',
-    excludePaths: ['/public']
-  });
-
-  // Check if basic auth is applied
-  if (authRoute.security) {
-    expect(authRoute.security.basicAuth?.enabled).toBeTrue();
-    expect(authRoute.security.basicAuth?.users.length).toEqual(2);
-    expect(authRoute.security.basicAuth?.realm).toEqual('Protected Area');
-    expect(authRoute.security.basicAuth?.excludePaths).toInclude('/public');
-  } else {
-    // Skip this test if security features are not implemented yet
-    console.log('Security features not implemented yet in route configuration');
-  }
-
-  // Check that the route itself is valid
-  const result = validateRouteConfig(authRoute);
-  expect(result.valid).toBeTrue();
-});
-
-tap.test('Route Security - addJwtAuth', async () => {
-  // Create base route
-  const baseRoute = createHttpRoute('example.com', { host: 'localhost', port: 3000 });
-
-  // Add JWT authentication
-  const jwtRoute = addJwtAuth(baseRoute, {
-    secret: 'your-jwt-secret-key',
-    algorithm: 'HS256',
-    issuer: 'auth.example.com',
-    audience: 'api.example.com',
-    expiresIn: 3600
-  });
-
-  // Check if JWT auth is applied
-  if (jwtRoute.security) {
-    expect(jwtRoute.security.jwtAuth?.enabled).toBeTrue();
-    expect(jwtRoute.security.jwtAuth?.secret).toEqual('your-jwt-secret-key');
-    expect(jwtRoute.security.jwtAuth?.algorithm).toEqual('HS256');
-    expect(jwtRoute.security.jwtAuth?.issuer).toEqual('auth.example.com');
-    expect(jwtRoute.security.jwtAuth?.audience).toEqual('api.example.com');
-    expect(jwtRoute.security.jwtAuth?.expiresIn).toEqual(3600);
-  } else {
-    // Skip this test if security features are not implemented yet
-    console.log('Security features not implemented yet in route configuration');
-  }
-
-  // Check that the route itself is valid
-  const result = validateRouteConfig(jwtRoute);
-  expect(result.valid).toBeTrue();
-});
-
-export default tap.start();

test/test.router.ts

@@ -1,392 +0,0 @@
-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/routing/router/proxy-router.js';
-
-// Test proxies and configurations
-let router: ProxyRouter;
-
-// Sample hostname for testing
-const TEST_DOMAIN = 'example.com';
-const TEST_SUBDOMAIN = 'api.example.com';
-const TEST_WILDCARD = '*.example.com';
-
-// Helper: Creates a mock HTTP request for testing
-function createMockRequest(host: string, url: string = '/'): http.IncomingMessage {
-  const req = {
-    headers: { host },
-    url,
-    socket: {
-      remoteAddress: '127.0.0.1'
-    }
-  } as any;
-  return req;
-}
-
-// Helper: Creates a test proxy configuration
-function createProxyConfig(
-  hostname: string, 
-  destinationIp: string = '10.0.0.1',
-  destinationPort: number = 8080
-): tsclass.network.IReverseProxyConfig {
-  return {
-    hostName: hostname,
-    publicKey: 'mock-cert',
-    privateKey: 'mock-key',
-    destinationIps: [destinationIp],
-    destinationPorts: [destinationPort],
-  } as tsclass.network.IReverseProxyConfig;
-}
-
-// SETUP: Create a ProxyRouter instance
-tap.test('setup proxy router test environment', async () => {
-  router = new ProxyRouter();
-  
-  // Initialize with empty config
-  router.setNewProxyConfigs([]);
-});
-
-// Test basic routing by hostname
-tap.test('should route requests by hostname', async () => {
-  const config = createProxyConfig(TEST_DOMAIN);
-  router.setNewProxyConfigs([config]);
-  
-  const req = createMockRequest(TEST_DOMAIN);
-  const result = router.routeReq(req);
-  
-  expect(result).toBeTruthy();
-  expect(result).toEqual(config);
-});
-
-// Test handling of hostname with port number
-tap.test('should handle hostname with port number', async () => {
-  const config = createProxyConfig(TEST_DOMAIN);
-  router.setNewProxyConfigs([config]);
-  
-  const req = createMockRequest(`${TEST_DOMAIN}:443`);
-  const result = router.routeReq(req);
-  
-  expect(result).toBeTruthy();
-  expect(result).toEqual(config);
-});
-
-// Test case-insensitive hostname matching
-tap.test('should perform case-insensitive hostname matching', async () => {
-  const config = createProxyConfig(TEST_DOMAIN.toLowerCase());
-  router.setNewProxyConfigs([config]);
-  
-  const req = createMockRequest(TEST_DOMAIN.toUpperCase());
-  const result = router.routeReq(req);
-  
-  expect(result).toBeTruthy();
-  expect(result).toEqual(config);
-});
-
-// Test handling of unmatched hostnames
-tap.test('should return undefined for unmatched hostnames', async () => {
-  const config = createProxyConfig(TEST_DOMAIN);
-  router.setNewProxyConfigs([config]);
-  
-  const req = createMockRequest('unknown.domain.com');
-  const result = router.routeReq(req);
-  
-  expect(result).toBeUndefined();
-});
-
-// Test adding path patterns
-tap.test('should match requests using path patterns', async () => {
-  const config = createProxyConfig(TEST_DOMAIN);
-  router.setNewProxyConfigs([config]);
-  
-  // Add a path pattern to the config
-  router.setPathPattern(config, '/api/users');
-  
-  // Test that path matches
-  const req1 = createMockRequest(TEST_DOMAIN, '/api/users');
-  const result1 = router.routeReqWithDetails(req1);
-  
-  expect(result1).toBeTruthy();
-  expect(result1.config).toEqual(config);
-  expect(result1.pathMatch).toEqual('/api/users');
-  
-  // Test that non-matching path doesn't match
-  const req2 = createMockRequest(TEST_DOMAIN, '/web/users');
-  const result2 = router.routeReqWithDetails(req2);
-  
-  expect(result2).toBeUndefined();
-});
-
-// Test handling wildcard patterns
-tap.test('should support wildcard path patterns', async () => {
-  const config = createProxyConfig(TEST_DOMAIN);
-  router.setNewProxyConfigs([config]);
-  
-  router.setPathPattern(config, '/api/*');
-  
-  // Test with path that matches the wildcard pattern
-  const req = createMockRequest(TEST_DOMAIN, '/api/users/123');
-  const result = router.routeReqWithDetails(req);
-  
-  expect(result).toBeTruthy();
-  expect(result.config).toEqual(config);
-  expect(result.pathMatch).toEqual('/api');
-  
-  // Print the actual value to diagnose issues
-  console.log('Path remainder value:', result.pathRemainder);
-  expect(result.pathRemainder).toBeTruthy();
-  expect(result.pathRemainder).toEqual('/users/123');
-});
-
-// Test extracting path parameters
-tap.test('should extract path parameters from URL', async () => {
-  const config = createProxyConfig(TEST_DOMAIN);
-  router.setNewProxyConfigs([config]);
-  
-  router.setPathPattern(config, '/users/:id/profile');
-  
-  const req = createMockRequest(TEST_DOMAIN, '/users/123/profile');
-  const result = router.routeReqWithDetails(req);
-  
-  expect(result).toBeTruthy();
-  expect(result.config).toEqual(config);
-  expect(result.pathParams).toBeTruthy();
-  expect(result.pathParams.id).toEqual('123');
-});
-
-// Test multiple configs for same hostname with different paths
-tap.test('should support multiple configs for same hostname with different paths', async () => {
-  const apiConfig = createProxyConfig(TEST_DOMAIN, '10.0.0.1', 8001);
-  const webConfig = createProxyConfig(TEST_DOMAIN, '10.0.0.2', 8002);
-  
-  // Add both configs
-  router.setNewProxyConfigs([apiConfig, webConfig]);
-  
-  // Set different path patterns
-  router.setPathPattern(apiConfig, '/api');
-  router.setPathPattern(webConfig, '/web');
-  
-  // Test API path routes to API config
-  const apiReq = createMockRequest(TEST_DOMAIN, '/api/users');
-  const apiResult = router.routeReq(apiReq);
-  
-  expect(apiResult).toEqual(apiConfig);
-  
-  // Test web path routes to web config
-  const webReq = createMockRequest(TEST_DOMAIN, '/web/dashboard');
-  const webResult = router.routeReq(webReq);
-  
-  expect(webResult).toEqual(webConfig);
-  
-  // Test unknown path returns undefined
-  const unknownReq = createMockRequest(TEST_DOMAIN, '/unknown');
-  const unknownResult = router.routeReq(unknownReq);
-  
-  expect(unknownResult).toBeUndefined();
-});
-
-// Test wildcard subdomains
-tap.test('should match wildcard subdomains', async () => {
-  const wildcardConfig = createProxyConfig(TEST_WILDCARD);
-  router.setNewProxyConfigs([wildcardConfig]);
-  
-  // Test that subdomain.example.com matches *.example.com
-  const req = createMockRequest('subdomain.example.com');
-  const result = router.routeReq(req);
-  
-  expect(result).toBeTruthy();
-  expect(result).toEqual(wildcardConfig);
-});
-
-// Test TLD wildcards (example.*)
-tap.test('should match TLD wildcards', async () => {
-  const tldWildcardConfig = createProxyConfig('example.*');
-  router.setNewProxyConfigs([tldWildcardConfig]);
-  
-  // Test that example.com matches example.*
-  const req1 = createMockRequest('example.com');
-  const result1 = router.routeReq(req1);
-  expect(result1).toBeTruthy();
-  expect(result1).toEqual(tldWildcardConfig);
-  
-  // Test that example.org matches example.*
-  const req2 = createMockRequest('example.org');
-  const result2 = router.routeReq(req2);
-  expect(result2).toBeTruthy();
-  expect(result2).toEqual(tldWildcardConfig);
-  
-  // Test that subdomain.example.com doesn't match example.*
-  const req3 = createMockRequest('subdomain.example.com');
-  const result3 = router.routeReq(req3);
-  expect(result3).toBeUndefined();
-});
-
-// Test complex pattern matching (*.lossless*)
-tap.test('should match complex wildcard patterns', async () => {
-  const complexWildcardConfig = createProxyConfig('*.lossless*');
-  router.setNewProxyConfigs([complexWildcardConfig]);
-  
-  // Test that sub.lossless.com matches *.lossless*
-  const req1 = createMockRequest('sub.lossless.com');
-  const result1 = router.routeReq(req1);
-  expect(result1).toBeTruthy();
-  expect(result1).toEqual(complexWildcardConfig);
-  
-  // Test that api.lossless.org matches *.lossless*
-  const req2 = createMockRequest('api.lossless.org');
-  const result2 = router.routeReq(req2);
-  expect(result2).toBeTruthy();
-  expect(result2).toEqual(complexWildcardConfig);
-  
-  // Test that losslessapi.com matches *.lossless*
-  const req3 = createMockRequest('losslessapi.com');
-  const result3 = router.routeReq(req3);
-  expect(result3).toBeUndefined(); // Should not match as it doesn't have a subdomain
-});
-
-// Test default configuration fallback
-tap.test('should fall back to default configuration', async () => {
-  const defaultConfig = createProxyConfig('*');
-  const specificConfig = createProxyConfig(TEST_DOMAIN);
-  
-  router.setNewProxyConfigs([defaultConfig, specificConfig]);
-  
-  // Test specific domain routes to specific config
-  const specificReq = createMockRequest(TEST_DOMAIN);
-  const specificResult = router.routeReq(specificReq);
-  
-  expect(specificResult).toEqual(specificConfig);
-  
-  // Test unknown domain falls back to default config
-  const unknownReq = createMockRequest('unknown.com');
-  const unknownResult = router.routeReq(unknownReq);
-  
-  expect(unknownResult).toEqual(defaultConfig);
-});
-
-// Test priority between exact and wildcard matches
-tap.test('should prioritize exact hostname over wildcard', async () => {
-  const wildcardConfig = createProxyConfig(TEST_WILDCARD);
-  const exactConfig = createProxyConfig(TEST_SUBDOMAIN);
-  
-  router.setNewProxyConfigs([wildcardConfig, exactConfig]);
-  
-  // Test that exact match takes priority
-  const req = createMockRequest(TEST_SUBDOMAIN);
-  const result = router.routeReq(req);
-  
-  expect(result).toEqual(exactConfig);
-});
-
-// Test adding and removing configurations
-tap.test('should manage configurations correctly', async () => {
-  router.setNewProxyConfigs([]);
-  
-  // Add a config
-  const config = createProxyConfig(TEST_DOMAIN);
-  router.addProxyConfig(config);
-  
-  // Verify routing works
-  const req = createMockRequest(TEST_DOMAIN);
-  let result = router.routeReq(req);
-  
-  expect(result).toEqual(config);
-  
-  // Remove the config and verify it no longer routes
-  const removed = router.removeProxyConfig(TEST_DOMAIN);
-  expect(removed).toBeTrue();
-  
-  result = router.routeReq(req);
-  expect(result).toBeUndefined();
-});
-
-// Test path pattern specificity
-tap.test('should prioritize more specific path patterns', async () => {
-  const genericConfig = createProxyConfig(TEST_DOMAIN, '10.0.0.1', 8001);
-  const specificConfig = createProxyConfig(TEST_DOMAIN, '10.0.0.2', 8002);
-  
-  router.setNewProxyConfigs([genericConfig, specificConfig]);
-  
-  router.setPathPattern(genericConfig, '/api/*');
-  router.setPathPattern(specificConfig, '/api/users');
-  
-  // The more specific '/api/users' should match before the '/api/*' wildcard
-  const req = createMockRequest(TEST_DOMAIN, '/api/users');
-  const result = router.routeReq(req);
-  
-  expect(result).toEqual(specificConfig);
-});
-
-// Test getHostnames method
-tap.test('should retrieve all configured hostnames', async () => {
-  router.setNewProxyConfigs([
-    createProxyConfig(TEST_DOMAIN),
-    createProxyConfig(TEST_SUBDOMAIN)
-  ]);
-  
-  const hostnames = router.getHostnames();
-  
-  expect(hostnames.length).toEqual(2);
-  expect(hostnames).toContain(TEST_DOMAIN.toLowerCase());
-  expect(hostnames).toContain(TEST_SUBDOMAIN.toLowerCase());
-});
-
-// Test handling missing host header
-tap.test('should handle missing host header', async () => {
-  const defaultConfig = createProxyConfig('*');
-  router.setNewProxyConfigs([defaultConfig]);
-  
-  const req = createMockRequest('');
-  req.headers.host = undefined;
-  
-  const result = router.routeReq(req);
-  
-  expect(result).toEqual(defaultConfig);
-});
-
-// Test complex path parameters
-tap.test('should handle complex path parameters', async () => {
-  const config = createProxyConfig(TEST_DOMAIN);
-  router.setNewProxyConfigs([config]);
-  
-  router.setPathPattern(config, '/api/:version/users/:userId/posts/:postId');
-  
-  const req = createMockRequest(TEST_DOMAIN, '/api/v1/users/123/posts/456');
-  const result = router.routeReqWithDetails(req);
-  
-  expect(result).toBeTruthy();
-  expect(result.config).toEqual(config);
-  expect(result.pathParams).toBeTruthy();
-  expect(result.pathParams.version).toEqual('v1');
-  expect(result.pathParams.userId).toEqual('123');
-  expect(result.pathParams.postId).toEqual('456');
-});
-
-// Performance test
-tap.test('should handle many configurations efficiently', async () => {
-  const configs = [];
-  
-  // Create many configs with different hostnames
-  for (let i = 0; i < 100; i++) {
-    configs.push(createProxyConfig(`host-${i}.example.com`));
-  }
-  
-  router.setNewProxyConfigs(configs);
-  
-  // Test middle of the list to avoid best/worst case
-  const req = createMockRequest('host-50.example.com');
-  const result = router.routeReq(req);
-  
-  expect(result).toEqual(configs[50]);
-});
-
-// Test cleanup
-tap.test('cleanup proxy router test environment', async () => {
-  // Clear all configurations
-  router.setNewProxyConfigs([]);
-  
-  // Verify empty state
-  expect(router.getHostnames().length).toEqual(0);
-  expect(router.getProxyConfigs().length).toEqual(0);
-});
-
-export default tap.start();

test/test.simple-acme-mock.ts

@@ -1,88 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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,443 +0,0 @@
-import { expect, tap } from '@git.zone/tstest/tapbundle';
-import * as net from 'net';
-import { SmartProxy } from '../ts/proxies/smart-proxy/index.js';
-
-let testServer: net.Server;
-let smartProxy: SmartProxy;
-const TEST_SERVER_PORT = 4000;
-const PROXY_PORT = 4001;
-const TEST_DATA = 'Hello through port proxy!';
-
-// Track all created servers and proxies for proper cleanup
-const allServers: net.Server[] = [];
-const allProxies: SmartProxy[] = [];
-
-// Helper: Creates a test TCP server that listens on a given port and host.
-function createTestServer(port: number, host: string = 'localhost'): Promise<net.Server> {
-  return new Promise((resolve) => {
-    const server = net.createServer((socket) => {
-      socket.on('data', (data) => {
-        // Echo the received data back with a prefix.
-        socket.write(`Echo: ${data.toString()}`);
-      });
-      socket.on('error', (error) => {
-        console.error(`[Test Server] Socket error on ${host}:${port}:`, error);
-      });
-    });
-    server.listen(port, host, () => {
-      console.log(`[Test Server] Listening on ${host}:${port}`);
-      allServers.push(server); // Track this server
-      resolve(server);
-    });
-  });
-}
-
-// Helper: Creates a test client connection.
-function createTestClient(port: number, data: string): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const client = new net.Socket();
-    let response = '';
-    
-    const timeout = setTimeout(() => {
-      client.destroy();
-      reject(new Error(`Client connection timeout to port ${port}`));
-    }, 5000);
-    
-    client.connect(port, 'localhost', () => {
-      console.log('[Test Client] Connected to server');
-      client.write(data);
-    });
-    client.on('data', (chunk) => {
-      response += chunk.toString();
-      client.end();
-    });
-    client.on('end', () => {
-      clearTimeout(timeout);
-      resolve(response);
-    });
-    client.on('error', (error) => {
-      clearTimeout(timeout);
-      reject(error);
-    });
-  });
-}
-
-// SETUP: Create a test server and a PortProxy instance.
-tap.test('setup port proxy test environment', async () => {
-  testServer = await createTestServer(TEST_SERVER_PORT);
-  smartProxy = new SmartProxy({
-    routes: [
-      {
-        match: {
-          ports: PROXY_PORT
-        },
-        action: {
-          type: 'forward',
-          target: {
-            host: 'localhost',
-            port: TEST_SERVER_PORT
-          }
-        }
-      }
-    ],
-    defaults: {
-      security: {
-        ipAllowList: ['127.0.0.1']
-      }
-    }
-  });
-  allProxies.push(smartProxy); // Track this proxy
-});
-
-// Test that the proxy starts and its servers are listening.
-tap.test('should start port proxy', async () => {
-  await smartProxy.start();
-  // Check if the proxy is listening by verifying the ports are active
-  expect(smartProxy.getListeningPorts().length).toBeGreaterThan(0);
-});
-
-// Test basic TCP forwarding.
-tap.test('should forward TCP connections and data to localhost', async () => {
-  const response = await createTestClient(PROXY_PORT, TEST_DATA);
-  expect(response).toEqual(`Echo: ${TEST_DATA}`);
-});
-
-// Test proxy with a custom target host.
-tap.test('should forward TCP connections to custom host', async () => {
-  const customHostProxy = new SmartProxy({
-    routes: [
-      {
-        match: {
-          ports: PROXY_PORT + 1
-        },
-        action: {
-          type: 'forward',
-          target: {
-            host: '127.0.0.1',
-            port: TEST_SERVER_PORT
-          }
-        }
-      }
-    ],
-    defaults: {
-      security: {
-        ipAllowList: ['127.0.0.1']
-      }
-    }
-  });
-  allProxies.push(customHostProxy); // Track this proxy
-  
-  await customHostProxy.start();
-  const response = await createTestClient(PROXY_PORT + 1, TEST_DATA);
-  expect(response).toEqual(`Echo: ${TEST_DATA}`);
-  await customHostProxy.stop();
-  
-  // Remove from tracking after stopping
-  const index = allProxies.indexOf(customHostProxy);
-  if (index !== -1) allProxies.splice(index, 1);
-});
-
-// Test custom IP forwarding
-// Modified to work in Docker/CI environments without needing 127.0.0.2
-tap.test('should forward connections to custom IP', async () => {
-  // Set up ports that are FAR apart to avoid any possible confusion
-  const forcedProxyPort = PROXY_PORT + 2;      // 4003 - The port that our proxy listens on
-  const targetServerPort = TEST_SERVER_PORT + 200;  // 4200 - Target test server on different port
-  
-  // Create a test server listening on a unique port on 127.0.0.1 (works in all environments)
-  const testServer2 = await createTestServer(targetServerPort, '127.0.0.1');
-
-  // We're simulating routing to a different IP by using a different port
-  // This tests the core functionality without requiring multiple IPs
-  const domainProxy = new SmartProxy({
-    routes: [
-      {
-        match: {
-          ports: forcedProxyPort
-        },
-        action: {
-          type: 'forward',
-          target: {
-            host: '127.0.0.1',
-            port: targetServerPort
-          }
-        }
-      }
-    ],
-    defaults: {
-      security: {
-        ipAllowList: ['127.0.0.1', '::ffff:127.0.0.1']
-      }
-    }
-  });
-  allProxies.push(domainProxy); // Track this proxy
-
-  await domainProxy.start();
-
-  // Send a single test connection
-  const response = await createTestClient(forcedProxyPort, TEST_DATA);
-  expect(response).toEqual(`Echo: ${TEST_DATA}`);
-
-  await domainProxy.stop();
-  
-  // Remove from tracking after stopping
-  const proxyIndex = allProxies.indexOf(domainProxy);
-  if (proxyIndex !== -1) allProxies.splice(proxyIndex, 1);
-  
-  // Close the test server
-  await new Promise<void>((resolve) => testServer2.close(() => resolve()));
-  
-  // Remove from tracking
-  const serverIndex = allServers.indexOf(testServer2);
-  if (serverIndex !== -1) allServers.splice(serverIndex, 1);
-});
-
-// Test handling of multiple concurrent connections.
-tap.test('should handle multiple concurrent connections', async () => {
-  const concurrentRequests = 5;
-  const requests = Array(concurrentRequests).fill(null).map((_, i) =>
-    createTestClient(PROXY_PORT, `${TEST_DATA} ${i + 1}`)
-  );
-  const responses = await Promise.all(requests);
-  responses.forEach((response, i) => {
-    expect(response).toEqual(`Echo: ${TEST_DATA} ${i + 1}`);
-  });
-});
-
-// Test connection timeout handling.
-tap.test('should handle connection timeouts', async () => {
-  const client = new net.Socket();
-  await new Promise<void>((resolve) => {
-    // Add a timeout to ensure we don't hang here
-    const timeout = setTimeout(() => {
-      client.destroy();
-      resolve();
-    }, 3000);
-    
-    client.connect(PROXY_PORT, 'localhost', () => {
-      // Do not send any data to trigger a timeout.
-      client.on('close', () => {
-        clearTimeout(timeout);
-        resolve();
-      });
-    });
-    
-    client.on('error', () => {
-      clearTimeout(timeout);
-      client.destroy();
-      resolve();
-    });
-  });
-});
-
-// Test stopping the port proxy.
-tap.test('should stop port proxy', async () => {
-  await smartProxy.stop();
-  // Verify that there are no listening ports after stopping
-  expect(smartProxy.getListeningPorts().length).toEqual(0);
-  
-  // Remove from tracking
-  const index = allProxies.indexOf(smartProxy);
-  if (index !== -1) allProxies.splice(index, 1);
-});
-
-// Test chained proxies with and without source IP preservation.
-tap.test('should support optional source IP preservation in chained proxies', async () => {
-  // Chained proxies without IP preservation.
-  const firstProxyDefault = new SmartProxy({
-    routes: [
-      {
-        match: {
-          ports: PROXY_PORT + 4
-        },
-        action: {
-          type: 'forward',
-          target: {
-            host: 'localhost',
-            port: PROXY_PORT + 5
-          }
-        }
-      }
-    ],
-    defaults: {
-      security: {
-        ipAllowList: ['127.0.0.1', '::ffff:127.0.0.1']
-      }
-    }
-  });
-  const secondProxyDefault = new SmartProxy({
-    routes: [
-      {
-        match: {
-          ports: PROXY_PORT + 5
-        },
-        action: {
-          type: 'forward',
-          target: {
-            host: 'localhost',
-            port: TEST_SERVER_PORT
-          }
-        }
-      }
-    ],
-    defaults: {
-      security: {
-        ipAllowList: ['127.0.0.1', '::ffff:127.0.0.1']
-      }
-    }
-  });
-  
-  allProxies.push(firstProxyDefault, secondProxyDefault); // Track these proxies
-  
-  await secondProxyDefault.start();
-  await firstProxyDefault.start();
-  const response1 = await createTestClient(PROXY_PORT + 4, TEST_DATA);
-  expect(response1).toEqual(`Echo: ${TEST_DATA}`);
-  await firstProxyDefault.stop();
-  await secondProxyDefault.stop();
-  
-  // Remove from tracking
-  const index1 = allProxies.indexOf(firstProxyDefault);
-  if (index1 !== -1) allProxies.splice(index1, 1);
-  const index2 = allProxies.indexOf(secondProxyDefault);
-  if (index2 !== -1) allProxies.splice(index2, 1);
-
-  // Chained proxies with IP preservation.
-  const firstProxyPreserved = new SmartProxy({
-    routes: [
-      {
-        match: {
-          ports: PROXY_PORT + 6
-        },
-        action: {
-          type: 'forward',
-          target: {
-            host: 'localhost',
-            port: PROXY_PORT + 7
-          }
-        }
-      }
-    ],
-    defaults: {
-      security: {
-        ipAllowList: ['127.0.0.1']
-      },
-      preserveSourceIP: true
-    },
-    preserveSourceIP: true
-  });
-  const secondProxyPreserved = new SmartProxy({
-    routes: [
-      {
-        match: {
-          ports: PROXY_PORT + 7
-        },
-        action: {
-          type: 'forward',
-          target: {
-            host: 'localhost',
-            port: TEST_SERVER_PORT
-          }
-        }
-      }
-    ],
-    defaults: {
-      security: {
-        ipAllowList: ['127.0.0.1']
-      },
-      preserveSourceIP: true
-    },
-    preserveSourceIP: true
-  });
-  
-  allProxies.push(firstProxyPreserved, secondProxyPreserved); // Track these proxies
-  
-  await secondProxyPreserved.start();
-  await firstProxyPreserved.start();
-  const response2 = await createTestClient(PROXY_PORT + 6, TEST_DATA);
-  expect(response2).toEqual(`Echo: ${TEST_DATA}`);
-  await firstProxyPreserved.stop();
-  await secondProxyPreserved.stop();
-  
-  // Remove from tracking
-  const index3 = allProxies.indexOf(firstProxyPreserved);
-  if (index3 !== -1) allProxies.splice(index3, 1);
-  const index4 = allProxies.indexOf(secondProxyPreserved);
-  if (index4 !== -1) allProxies.splice(index4, 1);
-});
-
-// Test round-robin behavior for multiple target hosts in a domain config.
-tap.test('should use round robin for multiple target hosts in domain config', async () => {
-  // Create a domain config with multiple hosts in the target
-  // Create a route with multiple target hosts
-  const routeConfig = {
-    match: {
-      ports: 80,
-      domains: ['rr.test']
-    },
-    action: {
-      type: 'forward' as const,
-      target: {
-        host: ['hostA', 'hostB'], // Array of hosts for round-robin
-        port: 80
-      }
-    }
-  };
-
-  const proxyInstance = new SmartProxy({
-    routes: [routeConfig]
-  });
-
-  // Don't track this proxy as it doesn't actually start or listen
-
-  // Use the RouteConnectionHandler to test the round-robin functionality
-  // For route based configuration, we need to implement a different approach for testing
-  // Since there's no direct access to getTargetHost
-
-  // In a route-based approach, the target host selection would happen in the
-  // connection setup process, which isn't directly accessible without
-  // making actual connections. We'll skip the direct test.
-
-  // For route-based approach, the actual round-robin logic happens in connection handling
-  // Just make sure our config has the expected hosts
-  expect(Array.isArray(routeConfig.action.target.host)).toBeTrue();
-  expect(routeConfig.action.target.host).toContain('hostA');
-  expect(routeConfig.action.target.host).toContain('hostB');
-});
-
-// CLEANUP: Tear down all servers and proxies
-tap.test('cleanup port proxy test environment', async () => {
-  // Stop all remaining proxies
-  for (const proxy of [...allProxies]) {
-    try {
-      await proxy.stop();
-      const index = allProxies.indexOf(proxy);
-      if (index !== -1) allProxies.splice(index, 1);
-    } catch (err) {
-      console.error(`Error stopping proxy: ${err}`);
-    }
-  }
-  
-  // Close all remaining servers
-  for (const server of [...allServers]) {
-    try {
-      await new Promise<void>((resolve) => {
-        if (server.listening) {
-          server.close(() => resolve());
-        } else {
-          resolve();
-        }
-      });
-      const index = allServers.indexOf(server);
-      if (index !== -1) allServers.splice(index, 1);
-    } catch (err) {
-      console.error(`Error closing server: ${err}`);
-    }
-  }
-  
-  // Verify all resources are cleaned up
-  expect(allProxies.length).toEqual(0);
-  expect(allServers.length).toEqual(0);
-});
-
-export default tap.start();

test/test.socket-handler-race.ts

@@ -1,83 +0,0 @@
-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

@@ -1,173 +0,0 @@
-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();

test/test.ts

@@ -0,0 +1,22 @@
+import { expect, tap } from '@pushrocks/tapbundle';
+import * as smartproxy from '../ts/index';
+
+let testProxy: smartproxy.SmartProxy;
+
+tap.test('first test', async () => {
+  testProxy = new smartproxy.SmartProxy();
+});
+
+tap.test('should start the testproxy', async () => {
+  await testProxy.start();
+});
+
+tap.test('should wait for 5 seconds', async (tools) => {
+  await tools.delayFor(5000);
+});
+
+tap.test('should close the testproxy', async () => {
+  await testProxy.stop();
+});
+
+tap.start();

ts/00_commitinfo_data.ts

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

ts/core/events/index.ts

@@ -1,3 +0,0 @@
-/**
- * Common event definitions
- */

ts/core/index.ts

@@ -1,8 +0,0 @@
-/**
- * Core functionality module
- */
-
-// Export submodules
-export * from './models/index.js';
-export * from './utils/index.js';
-export * from './events/index.js';

ts/core/models/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;
-}
-
-/**
- * @deprecated Events emitted by the Port80Handler - use SmartCertManager 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 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/index.ts

@@ -1,7 +0,0 @@
-/**
- * Core data models and interfaces
- */
-
-export * from './common-types.js';
-export * from './socket-augmentation.js';
-export * from './route-context.js';

ts/core/models/route-context.ts

@@ -1,113 +0,0 @@
-import * as plugins from '../../plugins.js';
-
-/**
- * Shared Route Context Interface
- * 
- * This interface defines the route context object that is used by both
- * SmartProxy and NetworkProxy, ensuring consistent context throughout the system.
- */
-
-/**
- * Route context for route matching and function-based target resolution
- */
-export interface IRouteContext {
-  // Connection basics
-  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
-  
-  // HTTP specifics (NetworkProxy only)
-  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
-  
-  // Routing information
-  routeName?: string;    // The name of the matched route
-  routeId?: string;      // The ID of the matched route
-  
-  // Resolved values
-  targetHost?: string | string[]; // The resolved target host
-  targetPort?: number;   // The resolved target port
-  
-  // Request metadata
-  timestamp: number;     // The request timestamp
-  connectionId: string;  // Unique connection identifier
-}
-
-/**
- * Extended context interface with HTTP-specific objects
- * Used only in NetworkProxy for HTTP request handling
- */
-export interface IHttpRouteContext extends IRouteContext {
-  req?: plugins.http.IncomingMessage;
-  res?: plugins.http.ServerResponse;
-  method?: string; // HTTP method (GET, POST, etc.)
-}
-
-/**
- * Extended context interface with HTTP/2-specific objects
- * Used only in NetworkProxy for HTTP/2 request handling
- */
-export interface IHttp2RouteContext extends IHttpRouteContext {
-  stream?: plugins.http2.ServerHttp2Stream;
-  headers?: Record<string, string>; // HTTP/2 pseudo-headers like :method, :path
-}
-
-/**
- * Create a basic route context from connection information
- */
-export function createBaseRouteContext(options: {
-  port: number;
-  clientIp: string;
-  serverIp: string;
-  domain?: string;
-  isTls: boolean;
-  tlsVersion?: string;
-  connectionId: string;
-}): IRouteContext {
-  return {
-    ...options,
-    timestamp: Date.now(),
-  };
-}
-
-/**
- * Convert IHttpRouteContext to IRouteContext
- * This is used to ensure type compatibility when passing HTTP-specific context 
- * to methods that require the base IRouteContext type
- */
-export function toBaseContext(httpContext: IHttpRouteContext): IRouteContext {
-  // Create a new object with only the properties from IRouteContext
-  const baseContext: IRouteContext = {
-    port: httpContext.port,
-    domain: httpContext.domain,
-    clientIp: httpContext.clientIp,
-    serverIp: httpContext.serverIp,
-    path: httpContext.path,
-    query: httpContext.query,
-    headers: httpContext.headers,
-    isTls: httpContext.isTls,
-    tlsVersion: httpContext.tlsVersion,
-    routeName: httpContext.routeName,
-    routeId: httpContext.routeId,
-    timestamp: httpContext.timestamp,
-    connectionId: httpContext.connectionId
-  };
-  
-  // Only copy targetHost if it's a string
-  if (httpContext.targetHost) {
-    baseContext.targetHost = httpContext.targetHost;
-  }
-  
-  // Copy targetPort if it exists
-  if (httpContext.targetPort) {
-    baseContext.targetPort = httpContext.targetPort;
-  }
-  
-  return baseContext;
-}

ts/core/models/socket-augmentation.ts

@@ -1,33 +0,0 @@
-import * as plugins from '../../plugins.js';
-
-// Augment the Node.js Socket type to include TLS-related properties
-// This helps TypeScript understand properties that are dynamically added by Node.js
-declare module 'net' {
-  interface Socket {
-    // TLS-related properties
-    encrypted?: boolean;    // Indicates if the socket is encrypted (TLS/SSL)
-    authorizationError?: Error; // Authentication error if TLS handshake failed
-    
-    // TLS-related methods
-    getTLSVersion?(): string;  // Returns the TLS version (e.g., 'TLSv1.2', 'TLSv1.3')
-    getPeerCertificate?(detailed?: boolean): any;  // Returns the peer's certificate
-    getSession?(): Buffer;   // Returns the TLS session data
-  }
-}
-
-// Export a utility function to check if a socket is a TLS socket
-export function isTLSSocket(socket: plugins.net.Socket): boolean {
-  return 'encrypted' in socket && !!socket.encrypted;
-}
-
-// Export a utility function to safely get the TLS version
-export function getTLSVersion(socket: plugins.net.Socket): string | null {
-  if (socket.getTLSVersion) {
-    try {
-      return socket.getTLSVersion();
-    } catch (e) {
-      return null;
-    }
-  }
-  return null;
-}

ts/core/utils/async-utils.ts

@@ -1,275 +0,0 @@
-/**
- * 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

@@ -1,225 +0,0 @@
-/**
- * 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

@@ -1,425 +0,0 @@
-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/fs-utils.ts

@@ -1,270 +0,0 @@
-/**
- * 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

@@ -1,19 +0,0 @@
-/**
- * Core utility functions
- */
-
-export * from './validation-utils.js';
-export * from './ip-utils.js';
-export * from './template-utils.js';
-export * from './route-manager.js';
-export * from './route-utils.js';
-export * from './security-utils.js';
-export * from './shared-security-manager.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/ip-utils.ts

@@ -1,175 +0,0 @@
-import * as plugins from '../../plugins.js';
-
-/**
- * Utility class for IP address operations
- */
-export class IpUtils {
-  /**
-   * Check if the IP matches any of the glob patterns
-   *
-   * This method checks IP addresses against glob patterns and handles IPv4/IPv6 normalization.
-   * It's used to implement IP filtering based on security configurations.
-   *
-   * @param ip - The IP address to check
-   * @param patterns - Array of glob patterns
-   * @returns true if IP matches any pattern, false otherwise
-   */
-  public static isGlobIPMatch(ip: string, patterns: string[]): boolean {
-    if (!ip || !patterns || patterns.length === 0) return false;
-
-    // Normalize the IP being checked
-    const normalizedIPVariants = this.normalizeIP(ip);
-    if (normalizedIPVariants.length === 0) return false;
-
-    // Normalize the pattern IPs for consistent comparison
-    const expandedPatterns = patterns.flatMap(pattern => this.normalizeIP(pattern));
-
-    // Check for any match between normalized IP variants and patterns
-    return normalizedIPVariants.some((ipVariant) =>
-      expandedPatterns.some((pattern) => plugins.minimatch(ipVariant, pattern))
-    );
-  }
-
-  /**
-   * Normalize IP addresses for consistent comparison
-   * 
-   * @param ip The IP address to normalize
-   * @returns Array of normalized IP forms
-   */
-  public static normalizeIP(ip: string): string[] {
-    if (!ip) return [];
-    
-    // Handle IPv4-mapped IPv6 addresses (::ffff:127.0.0.1)
-    if (ip.startsWith('::ffff:')) {
-      const ipv4 = ip.slice(7);
-      return [ip, ipv4];
-    }
-    
-    // Handle IPv4 addresses by also checking IPv4-mapped form
-    if (/^\d{1,3}(\.\d{1,3}){3}$/.test(ip)) {
-      return [ip, `::ffff:${ip}`];
-    }
-    
-    return [ip];
-  }
-
-  /**
-   * Check if an IP is authorized using security rules
-   *
-   * @param ip - The IP address to check
-   * @param allowedIPs - Array of allowed IP patterns
-   * @param blockedIPs - Array of blocked IP patterns
-   * @returns true if IP is authorized, false if blocked
-   */
-  public static isIPAuthorized(ip: string, allowedIPs: string[] = [], blockedIPs: string[] = []): boolean {
-    // Skip IP validation if no rules are defined
-    if (!ip || (allowedIPs.length === 0 && blockedIPs.length === 0)) {
-      return true;
-    }
-
-    // First check if IP is blocked - blocked IPs take precedence
-    if (blockedIPs.length > 0 && this.isGlobIPMatch(ip, blockedIPs)) {
-      return false;
-    }
-
-    // Then check if IP is allowed (if no allowed IPs are specified, all non-blocked IPs are allowed)
-    return allowedIPs.length === 0 || this.isGlobIPMatch(ip, allowedIPs);
-  }
-
-  /**
-   * Check if an IP address is a private network address
-   * 
-   * @param ip The IP address to check
-   * @returns true if the IP is a private network address, false otherwise
-   */
-  public static isPrivateIP(ip: string): boolean {
-    if (!ip) return false;
-
-    // Handle IPv4-mapped IPv6 addresses
-    if (ip.startsWith('::ffff:')) {
-      ip = ip.slice(7);
-    }
-
-    // Check IPv4 private ranges
-    if (/^\d{1,3}(\.\d{1,3}){3}$/.test(ip)) {
-      const parts = ip.split('.').map(Number);
-      
-      // Check common private ranges
-      // 10.0.0.0/8
-      if (parts[0] === 10) return true;
-      
-      // 172.16.0.0/12
-      if (parts[0] === 172 && parts[1] >= 16 && parts[1] <= 31) return true;
-      
-      // 192.168.0.0/16
-      if (parts[0] === 192 && parts[1] === 168) return true;
-      
-      // 127.0.0.0/8 (localhost)
-      if (parts[0] === 127) return true;
-      
-      return false;
-    }
-    
-    // IPv6 local addresses
-    return ip === '::1' || ip.startsWith('fc00:') || ip.startsWith('fd00:') || ip.startsWith('fe80:');
-  }
-
-  /**
-   * Check if an IP address is a public network address
-   * 
-   * @param ip The IP address to check
-   * @returns true if the IP is a public network address, false otherwise
-   */
-  public static isPublicIP(ip: string): boolean {
-    return !this.isPrivateIP(ip);
-  }
-
-  /**
-   * Convert a subnet CIDR to an IP range for filtering
-   * 
-   * @param cidr The CIDR notation (e.g., "192.168.1.0/24")
-   * @returns Array of glob patterns that match the CIDR range
-   */
-  public static cidrToGlobPatterns(cidr: string): string[] {
-    if (!cidr || !cidr.includes('/')) return [];
-    
-    const [ipPart, prefixPart] = cidr.split('/');
-    const prefix = parseInt(prefixPart, 10);
-    
-    if (isNaN(prefix) || prefix < 0 || prefix > 32) return [];
-    
-    // For IPv4 only for now
-    if (!/^\d{1,3}(\.\d{1,3}){3}$/.test(ipPart)) return [];
-    
-    const ipParts = ipPart.split('.').map(Number);
-    const fullMask = Math.pow(2, 32 - prefix) - 1;
-    
-    // Convert IP to a numeric value
-    const ipNum = (ipParts[0] << 24) | (ipParts[1] << 16) | (ipParts[2] << 8) | ipParts[3];
-    
-    // Calculate network address (IP & ~fullMask)
-    const networkNum = ipNum & ~fullMask;
-    
-    // For large ranges, return wildcard patterns
-    if (prefix <= 8) {
-      return [`${(networkNum >>> 24) & 255}.*.*.*`];
-    } else if (prefix <= 16) {
-      return [`${(networkNum >>> 24) & 255}.${(networkNum >>> 16) & 255}.*.*`];
-    } else if (prefix <= 24) {
-      return [`${(networkNum >>> 24) & 255}.${(networkNum >>> 16) & 255}.${(networkNum >>> 8) & 255}.*`];
-    }
-    
-    // For small ranges, create individual IP patterns
-    const patterns = [];
-    const maxAddresses = Math.min(256, Math.pow(2, 32 - prefix));
-    
-    for (let i = 0; i < maxAddresses; i++) {
-      const currentIpNum = networkNum + i;
-      patterns.push(
-        `${(currentIpNum >>> 24) & 255}.${(currentIpNum >>> 16) & 255}.${(currentIpNum >>> 8) & 255}.${currentIpNum & 255}`
-      );
-    }
-    
-    return patterns;
-  }
-}

ts/core/utils/lifecycle-component.ts

@@ -1,251 +0,0 @@
-/**
- * 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

@@ -1,10 +0,0 @@
-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');