@push.rocks/smartproxy 16.0.2 → 16.0.4

package/dist_ts/proxies/network-proxy/certificate-manager.js

@@ -110,6 +110,25 @@ export class CertificateManager {
             this.registerDomainsWithPort80Handler(domains);
         }
     }
+    /**
+     * Update route configurations managed by this certificate manager
+     * This method is called when route configurations change
+     *
+     * @param routes Array of route configurations
+     */
+    updateRouteConfigs(routes) {
+        if (!this.port80Handler) {
+            this.logger.warn('Cannot update routes - Port80Handler is not initialized');
+            return;
+        }
+        // Register domains from routes with Port80Handler
+        this.registerRoutesWithPort80Handler(routes);
+        // Process individual routes for certificate requirements
+        for (const route of routes) {
+            this.processRouteForCertificates(route);
+        }
+        this.logger.info(`Updated certificate management for ${routes.length} routes`);
+    }
     /**
      * Handle newly issued or renewed certificates from Port80Handler
      */
@@ -282,6 +301,7 @@ export class CertificateManager {
     }
     /**
      * Registers domains with Port80Handler for ACME certificate management
+     * @param domains String array of domains to register
      */
     registerDomainsWithPort80Handler(domains) {
         if (!this.port80Handler) {
@@ -312,6 +332,77 @@ export class CertificateManager {
             this.logger.info(`Registered domain for ACME certificate issuance: ${domain}`);
         }
     }
+    /**
+     * Extract domains from route configurations and register with Port80Handler
+     * This method enables direct integration with route-based configuration
+     *
+     * @param routes Array of route configurations
+     */
+    registerRoutesWithPort80Handler(routes) {
+        if (!this.port80Handler) {
+            this.logger.warn('Port80Handler is not initialized');
+            return;
+        }
+        // Extract domains from route configurations
+        const domains = new Set();
+        for (const route of routes) {
+            // Skip disabled routes
+            if (route.enabled === false) {
+                continue;
+            }
+            // Skip routes without HTTPS termination
+            if (route.action.type !== 'forward' || route.action.tls?.mode !== 'terminate') {
+                continue;
+            }
+            // Extract domains from match criteria
+            if (route.match.domains) {
+                if (typeof route.match.domains === 'string') {
+                    domains.add(route.match.domains);
+                }
+                else if (Array.isArray(route.match.domains)) {
+                    for (const domain of route.match.domains) {
+                        domains.add(domain);
+                    }
+                }
+            }
+        }
+        // Register extracted domains
+        this.registerDomainsWithPort80Handler(Array.from(domains));
+    }
+    /**
+     * Process a route config to determine if it requires automatic certificate provisioning
+     * @param route Route configuration to process
+     */
+    processRouteForCertificates(route) {
+        // Skip disabled routes
+        if (route.enabled === false) {
+            return;
+        }
+        // Skip routes without HTTPS termination or auto certificate
+        if (route.action.type !== 'forward' ||
+            route.action.tls?.mode !== 'terminate' ||
+            route.action.tls?.certificate !== 'auto') {
+            return;
+        }
+        // Extract domains from match criteria
+        const domains = [];
+        if (route.match.domains) {
+            if (typeof route.match.domains === 'string') {
+                domains.push(route.match.domains);
+            }
+            else if (Array.isArray(route.match.domains)) {
+                domains.push(...route.match.domains);
+            }
+        }
+        // Request certificates for the domains
+        for (const domain of domains) {
+            if (!domain.includes('*')) { // Skip wildcard domains
+                this.requestCertificate(domain).catch(err => {
+                    this.logger.error(`Error requesting certificate for domain ${domain}:`, err);
+                });
+            }
+        }
+    }
     /**
      * Initialize internal Port80Handler
      */
@@ -370,4 +461,4 @@ export class CertificateManager {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"certificate-manager.js","sourceRoot":"","sources":["../../../ts/proxies/network-proxy/certificate-manager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,kBAAkB,CAAC;AAC5C,OAAO,KAAK,EAAE,MAAM,IAAI,CAAC;AACzB,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAC7B,OAAO,EAAE,aAAa,EAAE,MAAM,KAAK,CAAC;AACpC,OAAO,EAAmE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAClH,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,gDAAgD,CAAC;AACnF,OAAO,EAAE,kBAAkB,EAAE,MAAM,wCAAwC,CAAC;AAC5E,OAAO,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAG3E;;GAEG;AACH,MAAM,OAAO,kBAAkB;IAS7B,YAAoB,OAA6B;QAA7B,YAAO,GAAP,OAAO,CAAsB;QAPzC,qBAAgB,GAAmC,IAAI,GAAG,EAAE,CAAC;QAC7D,kBAAa,GAAyB,IAAI,CAAC;QAC3C,0BAAqB,GAAY,KAAK,CAAC;QAGvC,gBAAW,GAAgC,IAAI,CAAC;QAGtD,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,EAAE,gBAAgB,IAAI,SAAS,CAAC,CAAC;QACrF,IAAI,CAAC,MAAM,GAAG,YAAY,CAAC,OAAO,CAAC,QAAQ,IAAI,MAAM,CAAC,CAAC;QAEvD,4CAA4C;QAC5C,IAAI,CAAC;YACH,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,mBAAmB,CAAC,EAAE,CAAC;gBAC7C,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,mBAAmB,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;gBAC5D,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,wCAAwC,IAAI,CAAC,mBAAmB,EAAE,CAAC,CAAC;YACvF,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,iDAAiD,KAAK,EAAE,CAAC,CAAC;QAC7E,CAAC;QAED,IAAI,CAAC,uBAAuB,EAAE,CAAC;IACjC,CAAC;IAED;;OAEG;IACI,uBAAuB;QAC5B,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;QAC/D,2FAA2F;QAC3F,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;QAE3E,IAAI,CAAC;YACH,IAAI,CAAC,mBAAmB,GAAG;gBACzB,GAAG,EAAE,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,EAAE,MAAM,CAAC;gBAC5D,IAAI,EAAE,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC;aAC/D,CAAC;YACF,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,0CAA0C,CAAC,CAAC;QAC/D,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,oCAAoC,EAAE,KAAK,CAAC,CAAC;YAE/D,6CAA6C;YAC7C,IAAI,CAAC;gBACH,+DAA+D;gBAC/D,sFAAsF;gBACtF,IAAI,CAAC,mBAAmB,GAAG;oBACzB,GAAG,EAAE,sBAAsB;oBAC3B,IAAI,EAAE,uBAAuB;iBAC9B,CAAC;gBACF,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,yCAAyC,CAAC,CAAC;YAC9D,CAAC;YAAC,OAAO,aAAa,EAAE,CAAC;gBACvB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,0CAA0C,EAAE,aAAa,CAAC,CAAC;gBAC7E,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;YACjE,CAAC;QACH,CAAC;IACH,CAAC;IAED;;OAEG;IACI,cAAc,CAAC,MAA4B;QAChD,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC;IAC5B,CAAC;IAED;;OAEG;IACI,sBAAsB;QAC3B,OAAO,EAAE,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;IACzC,CAAC;IAED;;OAEG;IACI,wBAAwB,CAAC,OAAsB;QACpD,IAAI,IAAI,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,qBAAqB,EAAE,CAAC;YACtD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,iEAAiE,CAAC,CAAC;YAEpF,sCAAsC;YACtC,IAAI,IAAI,CAAC,aAAa,KAAK,OAAO,EAAE,CAAC;gBACnC,kDAAkD;gBAClD,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,kBAAkB,CAAC,CAAC;gBAC5E,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,mBAAmB,CAAC,CAAC;gBAC7E,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,kBAAkB,CAAC,CAAC;gBAC5E,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,iBAAiB,CAAC,oBAAoB,CAAC,CAAC;YAChF,CAAC;QACH,CAAC;QAED,2BAA2B;QAC3B,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC;QAC7B,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC;QAElC,oCAAoC;QACpC,wBAAwB,CAAC,IAAI,CAAC,aAAa,EAAE;YAC3C,mBAAmB,EAAE,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,IAAI,CAAC;YAC5D,oBAAoB,EAAE,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,IAAI,CAAC;YAC7D,mBAAmB,EAAE,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,IAAI,CAAC;YAC5D,qBAAqB,EAAE,CAAC,IAAI,EAAE,EAAE;gBAC9B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,mBAAmB,IAAI,CAAC,MAAM,eAAe,IAAI,CAAC,aAAa,OAAO,CAAC,CAAC;YAC3F,CAAC;SACF,CAAC,CAAC;QAEH,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,wDAAwD,CAAC,CAAC;QAE3E,yEAAyE;QACzE,IAAI,IAAI,CAAC,gBAAgB,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC;YACnC,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,CAAC;iBACrD,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,wBAAwB;YAEpE,IAAI,CAAC,gCAAgC,CAAC,OAAO,CAAC,CAAC;QACjD,CAAC;IACH,CAAC;IAED;;OAEG;IACK,uBAAuB,CAAC,IAAmF;QACjH,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC;QAE7D,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,eAAe,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,QAAQ,MAAM,iBAAiB,UAAU,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;QAEnJ,qCAAqC;QACrC,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC;QAEzE,uEAAuE;QACvE,IAAI,CAAC,IAAI,CAAC,qBAAqB,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,gBAAgB,EAAE,CAAC;YACvE,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC;QAC/D,CAAC;IACH,CAAC;IAED;;OAEG;IACK,uBAAuB,CAAC,IAAuC;QACrE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,mCAAmC,IAAI,CAAC,MAAM,KAAK,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;IACrF,CAAC;IAED;;OAEG;IACK,sBAAsB,CAAC,MAAc,EAAE,WAAmB,EAAE,UAAkB;QACpF,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAmB,EAAE,GAAG,MAAM,WAAW,CAAC,CAAC;YAC3E,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAmB,EAAE,GAAG,MAAM,UAAU,CAAC,CAAC;YAEzE,EAAE,CAAC,aAAa,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;YACxC,EAAE,CAAC,aAAa,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;YAEtC,gDAAgD;YAChD,IAAI,CAAC;gBACH,EAAE,CAAC,SAAS,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;YAC/B,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,gDAAgD,MAAM,KAAK,KAAK,EAAE,CAAC,CAAC;YACvF,CAAC;YAED,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,yBAAyB,MAAM,OAAO,QAAQ,EAAE,CAAC,CAAC;QACrE,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,kCAAkC,MAAM,KAAK,KAAK,EAAE,CAAC,CAAC;QAC1E,CAAC;IACH,CAAC;IAED;;;OAGG;IACI,SAAS,CAAC,MAAc,EAAE,EAA+D;QAC9F,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,2BAA2B,MAAM,EAAE,CAAC,CAAC;QAEvD,iDAAiD;QACjD,MAAM,KAAK,GAAG,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAChD,IAAI,KAAK,EAAE,CAAC;YACV,IAAI,CAAC;gBACH,iDAAiD;gBACjD,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,mBAAmB,CAAC;oBAC9C,GAAG,EAAE,KAAK,CAAC,GAAG;oBACd,IAAI,EAAE,KAAK,CAAC,IAAI;iBACjB,CAAC,CAAC;gBACH,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,gCAAgC,MAAM,EAAE,CAAC,CAAC;gBAC5D,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;gBAClB,OAAO;YACT,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,qCAAqC,MAAM,GAAG,EAAE,GAAG,CAAC,CAAC;YACzE,CAAC;QACH,CAAC;QACD,0EAA0E;QAC1E,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACvB,IAAI,CAAC;gBACH,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,kDAAkD,MAAM,EAAE,CAAC,CAAC;gBAC7E,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC;oBAC3B,UAAU,EAAE,MAAM;oBAClB,WAAW,EAAE,KAAK;oBAClB,eAAe,EAAE,IAAI;iBACtB,CAAC,CAAC;YACL,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,uDAAuD,MAAM,EAAE,EAAE,GAAG,CAAC,CAAC;YAC1F,CAAC;QACH,CAAC;QAED,kDAAkD;QAClD,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,IAAI,IAAI,CAAC,aAAa,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YAC9E,6CAA6C;YAC7C,MAAM,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;YAE3D,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACd,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,4BAA4B,MAAM,4BAA4B,CAAC,CAAC;gBAEjF,0CAA0C;gBAC1C,MAAM,aAAa,GAAmB;oBACpC,UAAU,EAAE,MAAM;oBAClB,WAAW,EAAE,IAAI;oBACjB,eAAe,EAAE,IAAI;iBACtB,CAAC;gBAEF,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;YAC9C,CAAC;QACH,CAAC;QAED,mCAAmC;QACnC,IAAI,CAAC;YACH,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,mBAAmB,CAAC;gBAC9C,GAAG,EAAE,IAAI,CAAC,mBAAmB,CAAC,GAAG;gBACjC,IAAI,EAAE,IAAI,CAAC,mBAAmB,CAAC,IAAI;aACpC,CAAC,CAAC;YAEH,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,iCAAiC,MAAM,EAAE,CAAC,CAAC;YAC7D,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QACpB,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,wCAAwC,EAAE,GAAG,CAAC,CAAC;YACjE,EAAE,CAAC,IAAI,KAAK,CAAC,8BAA8B,CAAC,EAAE,IAAI,CAAC,CAAC;QACtD,CAAC;IACH,CAAC;IAED;;OAEG;IACI,sBAAsB,CAAC,MAAc,EAAE,WAAmB,EAAE,UAAkB,EAAE,UAAiB;QACtG,6DAA6D;QAC7D,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACrB,IAAI,CAAC;gBACH,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,MAAM,EAAE;oBAClC,GAAG,EAAE,UAAU;oBACf,IAAI,EAAE,WAAW;iBAClB,CAAC,CAAC;gBACH,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,mCAAmC,MAAM,EAAE,CAAC,CAAC;YACjE,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,yCAAyC,MAAM,GAAG,EAAE,KAAK,CAAC,CAAC;YAC/E,CAAC;QACH,CAAC;QAED,8BAA8B;QAC9B,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,MAAM,EAAE;YAChC,GAAG,EAAE,UAAU;YACf,IAAI,EAAE,WAAW;YACjB,OAAO,EAAE,UAAU;SACpB,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACI,cAAc,CAAC,MAAc;QAClC,OAAO,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAC3C,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,kBAAkB,CAAC,MAAc;QAC5C,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,IAAI,CAAC,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAC/D,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,4CAA4C,CAAC,CAAC;YAC/D,OAAO,KAAK,CAAC;QACf,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,kCAAkC,CAAC,CAAC;YACtD,OAAO,KAAK,CAAC;QACf,CAAC;QAED,4EAA4E;QAC5E,IAAI,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACzB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,mDAAmD,MAAM,EAAE,CAAC,CAAC;YAC/E,OAAO,KAAK,CAAC;QACf,CAAC;QAED,IAAI,CAAC;YACH,oCAAoC;YACpC,MAAM,aAAa,GAAmB;gBACpC,UAAU,EAAE,MAAM;gBAClB,WAAW,EAAE,IAAI;gBACjB,eAAe,EAAE,IAAI;aACtB,CAAC;YAEF,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;YAC5C,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,6CAA6C,MAAM,EAAE,CAAC,CAAC;YACxE,OAAO,IAAI,CAAC;QACd,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,2CAA2C,MAAM,GAAG,EAAE,KAAK,CAAC,CAAC;YAC/E,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAED;;OAEG;IACI,gCAAgC,CAAC,OAAiB;QACvD,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,kCAAkC,CAAC,CAAC;YACrD,OAAO;QACT,CAAC;QAED,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YAC7B,4EAA4E;YAC5E,IAAI,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;gBACzB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,sCAAsC,MAAM,EAAE,CAAC,CAAC;gBACjE,SAAS;YACX,CAAC;YAED,gEAAgE;YAChE,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,mBAAmB,EAAE,CAAC;gBAC3C,MAAM,UAAU,GAAG,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;gBACrD,IAAI,UAAU,EAAE,CAAC;oBACf,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,8CAA8C,MAAM,EAAE,CAAC,CAAC;oBACzE,SAAS;gBACX,CAAC;YACH,CAAC;YAED,8EAA8E;YAC9E,MAAM,aAAa,GAAmB;gBACpC,UAAU,EAAE,MAAM;gBAClB,WAAW,EAAE,IAAI;gBACjB,eAAe,EAAE,IAAI;aACtB,CAAC;YAEF,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;YAC5C,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,oDAAoD,MAAM,EAAE,CAAC,CAAC;QACjF,CAAC;IACH,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,uBAAuB;QAClC,iCAAiC;QACjC,IAAI,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAC/B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,uDAAuD,CAAC,CAAC;YAC1E,OAAO,IAAI,CAAC,aAAa,CAAC;QAC5B,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,CAAC;YAChC,OAAO,IAAI,CAAC;QACd,CAAC;QAED,oCAAoC;QACpC,IAAI,CAAC,aAAa,GAAG,kBAAkB,CAAC;YACtC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI;YAC5B,YAAY,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,YAAY;YAC5C,aAAa,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,aAAa;YAC9C,iBAAiB,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,6BAA6B;YACnE,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO;YAClC,gBAAgB,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,gBAAgB;YACpD,mBAAmB,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,mBAAmB;SAC3D,CAAC,CAAC;QACH,oCAAoC;QACpC,wBAAwB,CAAC,IAAI,CAAC,aAAa,EAAE;YAC3C,mBAAmB,EAAE,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,IAAI,CAAC;YAC5D,oBAAoB,EAAE,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,IAAI,CAAC;YAC7D,mBAAmB,EAAE,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,IAAI,CAAC;YAC5D,qBAAqB,EAAE,CAAC,IAAI,EAAE,EAAE;gBAC9B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,mBAAmB,IAAI,CAAC,MAAM,eAAe,IAAI,CAAC,aAAa,OAAO,CAAC,CAAC;YAC3F,CAAC;SACF,CAAC,CAAC;QAEH,oBAAoB;QACpB,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;YACjC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,iCAAiC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;YAC5E,OAAO,IAAI,CAAC,aAAa,CAAC;QAC5B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,kCAAkC,KAAK,EAAE,CAAC,CAAC;YAC7D,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;YAC1B,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,iBAAiB;QAC5B,IAAI,IAAI,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,qBAAqB,EAAE,CAAC;YACtD,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;gBAChC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC;YAC5C,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,8BAA8B,EAAE,KAAK,CAAC,CAAC;YAC3D,CAAC;QACH,CAAC;IACH,CAAC;CACF"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"certificate-manager.js","sourceRoot":"","sources":["../../../ts/proxies/network-proxy/certificate-manager.ts"],"names":[],"mappings":"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"}

package/dist_ts/proxies/network-proxy/context-creator.d.ts

@@ -0,0 +1,34 @@
+import * as plugins from '../../plugins.js';
+import '../../core/models/socket-augmentation.js';
+import type { IRouteContext, IHttpRouteContext, IHttp2RouteContext } from '../../core/models/route-context.js';
+/**
+ * Context creator for NetworkProxy
+ * Creates route contexts for matching and function evaluation
+ */
+export declare class ContextCreator {
+    /**
+     * Create a route context from HTTP request information
+     */
+    createHttpRouteContext(req: any, options: {
+        tlsVersion?: string;
+        connectionId: string;
+        clientIp: string;
+        serverIp: string;
+    }): IHttpRouteContext;
+    /**
+     * Create a route context from HTTP/2 stream and headers
+     */
+    createHttp2RouteContext(stream: plugins.http2.ServerHttp2Stream, headers: plugins.http2.IncomingHttpHeaders, options: {
+        connectionId: string;
+        clientIp: string;
+        serverIp: string;
+    }): IHttp2RouteContext;
+    /**
+     * Create a basic route context from socket information
+     */
+    createSocketRouteContext(socket: plugins.net.Socket, options: {
+        domain?: string;
+        tlsVersion?: string;
+        connectionId: string;
+    }): IRouteContext;
+}

package/dist_ts/proxies/network-proxy/context-creator.js

@@ -0,0 +1,108 @@
+import * as plugins from '../../plugins.js';
+import '../../core/models/socket-augmentation.js';
+/**
+ * Context creator for NetworkProxy
+ * Creates route contexts for matching and function evaluation
+ */
+export class ContextCreator {
+    /**
+     * Create a route context from HTTP request information
+     */
+    createHttpRouteContext(req, options) {
+        // Parse headers
+        const headers = {};
+        for (const [key, value] of Object.entries(req.headers)) {
+            if (typeof value === 'string') {
+                headers[key.toLowerCase()] = value;
+            }
+            else if (Array.isArray(value) && value.length > 0) {
+                headers[key.toLowerCase()] = value[0];
+            }
+        }
+        // Parse domain from Host header
+        const domain = headers['host']?.split(':')[0] || '';
+        // Parse URL
+        const url = new URL(`http://${domain}${req.url || '/'}`);
+        return {
+            // Connection basics
+            port: req.socket.localPort || 0,
+            domain,
+            clientIp: options.clientIp,
+            serverIp: options.serverIp,
+            // HTTP specifics
+            path: url.pathname,
+            query: url.search ? url.search.substring(1) : '',
+            headers,
+            // TLS information
+            isTls: !!req.socket.encrypted,
+            tlsVersion: options.tlsVersion,
+            // Request objects
+            req,
+            // Metadata
+            timestamp: Date.now(),
+            connectionId: options.connectionId
+        };
+    }
+    /**
+     * Create a route context from HTTP/2 stream and headers
+     */
+    createHttp2RouteContext(stream, headers, options) {
+        // Parse headers, excluding HTTP/2 pseudo-headers
+        const processedHeaders = {};
+        for (const [key, value] of Object.entries(headers)) {
+            if (!key.startsWith(':') && typeof value === 'string') {
+                processedHeaders[key.toLowerCase()] = value;
+            }
+        }
+        // Get domain from :authority pseudo-header
+        const authority = headers[':authority'] || '';
+        const domain = authority.split(':')[0];
+        // Get path from :path pseudo-header
+        const path = headers[':path'] || '/';
+        // Parse the path to extract query string
+        const pathParts = path.split('?');
+        const pathname = pathParts[0];
+        const query = pathParts.length > 1 ? pathParts[1] : '';
+        // Get the socket from the session
+        const socket = stream.session?.socket;
+        return {
+            // Connection basics
+            port: socket?.localPort || 0,
+            domain,
+            clientIp: options.clientIp,
+            serverIp: options.serverIp,
+            // HTTP specifics
+            path: pathname,
+            query,
+            headers: processedHeaders,
+            // HTTP/2 specific properties
+            method: headers[':method'],
+            stream,
+            // TLS information - HTTP/2 is always on TLS in browsers
+            isTls: true,
+            tlsVersion: socket?.getTLSVersion?.() || 'TLSv1.3',
+            // Metadata
+            timestamp: Date.now(),
+            connectionId: options.connectionId
+        };
+    }
+    /**
+     * Create a basic route context from socket information
+     */
+    createSocketRouteContext(socket, options) {
+        return {
+            // Connection basics
+            port: socket.localPort || 0,
+            domain: options.domain,
+            clientIp: socket.remoteAddress?.replace('::ffff:', '') || '0.0.0.0',
+            serverIp: socket.localAddress?.replace('::ffff:', '') || '0.0.0.0',
+            // TLS information
+            isTls: options.tlsVersion !== undefined,
+            tlsVersion: options.tlsVersion,
+            // Metadata
+            timestamp: Date.now(),
+            connectionId: options.connectionId
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/proxies/network-proxy/function-cache.d.ts

@@ -0,0 +1,90 @@
+import type { IRouteContext } from '../../core/models/route-context.js';
+import type { ILogger } from './models/types.js';
+/**
+ * Function cache for NetworkProxy function-based targets
+ *
+ * This cache improves performance for function-based targets by storing
+ * the results of function evaluations and reusing them for similar contexts.
+ */
+export declare class FunctionCache {
+    private hostCache;
+    private portCache;
+    private maxCacheSize;
+    private defaultTtl;
+    private logger;
+    /**
+     * Creates a new function cache
+     *
+     * @param logger Logger for debug output
+     * @param options Cache options
+     */
+    constructor(logger: ILogger, options?: {
+        maxCacheSize?: number;
+        defaultTtl?: number;
+    });
+    /**
+     * Compute a hash for a context object
+     * This is used to identify similar contexts for caching
+     *
+     * @param context The route context to hash
+     * @param functionId Identifier for the function (usually route name or ID)
+     * @returns A string hash
+     */
+    private computeContextHash;
+    /**
+     * Get cached host result for a function and context
+     *
+     * @param context Route context
+     * @param functionId Identifier for the function
+     * @returns Cached host value or undefined if not found
+     */
+    getCachedHost(context: IRouteContext, functionId: string): string | string[] | undefined;
+    /**
+     * Get cached port result for a function and context
+     *
+     * @param context Route context
+     * @param functionId Identifier for the function
+     * @returns Cached port value or undefined if not found
+     */
+    getCachedPort(context: IRouteContext, functionId: string): number | undefined;
+    /**
+     * Store a host function result in the cache
+     *
+     * @param context Route context
+     * @param functionId Identifier for the function
+     * @param value Host value to cache
+     * @param ttl Optional TTL in milliseconds
+     */
+    cacheHost(context: IRouteContext, functionId: string, value: string | string[], ttl?: number): void;
+    /**
+     * Store a port function result in the cache
+     *
+     * @param context Route context
+     * @param functionId Identifier for the function
+     * @param value Port value to cache
+     * @param ttl Optional TTL in milliseconds
+     */
+    cachePort(context: IRouteContext, functionId: string, value: number, ttl?: number): void;
+    /**
+     * Remove expired entries from the cache
+     */
+    private cleanupCache;
+    /**
+     * Prune oldest entries from a cache map
+     * Used when the cache exceeds the maximum size
+     *
+     * @param cache The cache map to prune
+     */
+    private pruneOldestEntries;
+    /**
+     * Get current cache stats
+     */
+    getStats(): {
+        hostCacheSize: number;
+        portCacheSize: number;
+    };
+    /**
+     * Clear all cached entries
+     */
+    clearCache(): void;
+}

package/dist_ts/proxies/network-proxy/function-cache.js

@@ -0,0 +1,198 @@
+/**
+ * Function cache for NetworkProxy function-based targets
+ *
+ * This cache improves performance for function-based targets by storing
+ * the results of function evaluations and reusing them for similar contexts.
+ */
+export class FunctionCache {
+    /**
+     * Creates a new function cache
+     *
+     * @param logger Logger for debug output
+     * @param options Cache options
+     */
+    constructor(logger, options = {}) {
+        // Cache storage
+        this.hostCache = new Map();
+        this.portCache = new Map();
+        this.logger = logger;
+        this.maxCacheSize = options.maxCacheSize || 1000;
+        this.defaultTtl = options.defaultTtl || 5000; // 5 seconds default
+        // Start the cache cleanup timer
+        setInterval(() => this.cleanupCache(), 30000); // Cleanup every 30 seconds
+    }
+    /**
+     * Compute a hash for a context object
+     * This is used to identify similar contexts for caching
+     *
+     * @param context The route context to hash
+     * @param functionId Identifier for the function (usually route name or ID)
+     * @returns A string hash
+     */
+    computeContextHash(context, functionId) {
+        // Extract relevant properties for the hash
+        const hashBase = {
+            functionId,
+            port: context.port,
+            domain: context.domain,
+            clientIp: context.clientIp,
+            path: context.path,
+            query: context.query,
+            isTls: context.isTls,
+            tlsVersion: context.tlsVersion
+        };
+        // Generate a hash string
+        return JSON.stringify(hashBase);
+    }
+    /**
+     * Get cached host result for a function and context
+     *
+     * @param context Route context
+     * @param functionId Identifier for the function
+     * @returns Cached host value or undefined if not found
+     */
+    getCachedHost(context, functionId) {
+        const hash = this.computeContextHash(context, functionId);
+        const cached = this.hostCache.get(hash);
+        // Return if no cached value or expired
+        if (!cached || cached.expiry < Date.now()) {
+            if (cached) {
+                // If expired, remove from cache
+                this.hostCache.delete(hash);
+                this.logger.debug(`Cache miss (expired) for host function: ${functionId}`);
+            }
+            else {
+                this.logger.debug(`Cache miss for host function: ${functionId}`);
+            }
+            return undefined;
+        }
+        this.logger.debug(`Cache hit for host function: ${functionId}`);
+        return cached.value;
+    }
+    /**
+     * Get cached port result for a function and context
+     *
+     * @param context Route context
+     * @param functionId Identifier for the function
+     * @returns Cached port value or undefined if not found
+     */
+    getCachedPort(context, functionId) {
+        const hash = this.computeContextHash(context, functionId);
+        const cached = this.portCache.get(hash);
+        // Return if no cached value or expired
+        if (!cached || cached.expiry < Date.now()) {
+            if (cached) {
+                // If expired, remove from cache
+                this.portCache.delete(hash);
+                this.logger.debug(`Cache miss (expired) for port function: ${functionId}`);
+            }
+            else {
+                this.logger.debug(`Cache miss for port function: ${functionId}`);
+            }
+            return undefined;
+        }
+        this.logger.debug(`Cache hit for port function: ${functionId}`);
+        return cached.value;
+    }
+    /**
+     * Store a host function result in the cache
+     *
+     * @param context Route context
+     * @param functionId Identifier for the function
+     * @param value Host value to cache
+     * @param ttl Optional TTL in milliseconds
+     */
+    cacheHost(context, functionId, value, ttl) {
+        const hash = this.computeContextHash(context, functionId);
+        const expiry = Date.now() + (ttl || this.defaultTtl);
+        // Check if we need to prune the cache before adding
+        if (this.hostCache.size >= this.maxCacheSize) {
+            this.pruneOldestEntries(this.hostCache);
+        }
+        // Store the result
+        this.hostCache.set(hash, { value, expiry, hash });
+        this.logger.debug(`Cached host function result for: ${functionId}`);
+    }
+    /**
+     * Store a port function result in the cache
+     *
+     * @param context Route context
+     * @param functionId Identifier for the function
+     * @param value Port value to cache
+     * @param ttl Optional TTL in milliseconds
+     */
+    cachePort(context, functionId, value, ttl) {
+        const hash = this.computeContextHash(context, functionId);
+        const expiry = Date.now() + (ttl || this.defaultTtl);
+        // Check if we need to prune the cache before adding
+        if (this.portCache.size >= this.maxCacheSize) {
+            this.pruneOldestEntries(this.portCache);
+        }
+        // Store the result
+        this.portCache.set(hash, { value, expiry, hash });
+        this.logger.debug(`Cached port function result for: ${functionId}`);
+    }
+    /**
+     * Remove expired entries from the cache
+     */
+    cleanupCache() {
+        const now = Date.now();
+        let expiredCount = 0;
+        // Clean up host cache
+        for (const [hash, cached] of this.hostCache.entries()) {
+            if (cached.expiry < now) {
+                this.hostCache.delete(hash);
+                expiredCount++;
+            }
+        }
+        // Clean up port cache
+        for (const [hash, cached] of this.portCache.entries()) {
+            if (cached.expiry < now) {
+                this.portCache.delete(hash);
+                expiredCount++;
+            }
+        }
+        if (expiredCount > 0) {
+            this.logger.debug(`Cleaned up ${expiredCount} expired cache entries`);
+        }
+    }
+    /**
+     * Prune oldest entries from a cache map
+     * Used when the cache exceeds the maximum size
+     *
+     * @param cache The cache map to prune
+     */
+    pruneOldestEntries(cache) {
+        // Find the oldest entries
+        const now = Date.now();
+        const itemsToRemove = Math.floor(this.maxCacheSize * 0.2); // Remove 20% of the cache
+        // Convert to array for sorting
+        const entries = Array.from(cache.entries());
+        // Sort by expiry (oldest first)
+        entries.sort((a, b) => a[1].expiry - b[1].expiry);
+        // Remove oldest entries
+        const toRemove = entries.slice(0, itemsToRemove);
+        for (const [hash] of toRemove) {
+            cache.delete(hash);
+        }
+        this.logger.debug(`Pruned ${toRemove.length} oldest cache entries`);
+    }
+    /**
+     * Get current cache stats
+     */
+    getStats() {
+        return {
+            hostCacheSize: this.hostCache.size,
+            portCacheSize: this.portCache.size
+        };
+    }
+    /**
+     * Clear all cached entries
+     */
+    clearCache() {
+        this.hostCache.clear();
+        this.portCache.clear();
+        this.logger.info('Function cache cleared');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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