@push.rocks/smartproxy 15.0.2 → 16.0.2

package/dist_ts/certificate/providers/cert-provisioner.js

@@ -4,21 +4,60 @@ import { Port80Handler } from '../../http/port80/port80-handler.js';
 /**
  * CertProvisioner manages certificate provisioning and renewal workflows,
  * unifying static certificates and HTTP-01 challenges via Port80Handler.
+ *
+ * This class directly works with route configurations instead of converting to domain configs.
  */
 export class CertProvisioner extends plugins.EventEmitter {
     /**
-     * @param domainConfigs Array of domain configuration objects
+     * Extract routes that need certificates
+     * @param routes Route configurations
+     */
+    extractCertificateRoutesFromRoutes(routes) {
+        const certRoutes = [];
+        // Process all HTTPS routes that need certificates
+        for (const route of routes) {
+            // Only process routes with TLS termination that need certificates
+            if (route.action.type === 'forward' &&
+                route.action.tls &&
+                (route.action.tls.mode === 'terminate' || route.action.tls.mode === 'terminate-and-reencrypt') &&
+                route.match.domains) {
+                // Extract domains from the route
+                const domains = Array.isArray(route.match.domains)
+                    ? route.match.domains
+                    : [route.match.domains];
+                // For each domain in the route, create a certRoute entry
+                for (const domain of domains) {
+                    // Skip wildcard domains that can't use ACME unless we have a certProvider
+                    if (domain.includes('*') && (!this.certProvisionFunction || this.certProvisionFunction.length === 0)) {
+                        console.warn(`Skipping wildcard domain that requires a certProvisionFunction: ${domain}`);
+                        continue;
+                    }
+                    certRoutes.push({
+                        domain,
+                        route,
+                        tlsMode: route.action.tls.mode
+                    });
+                }
+            }
+        }
+        return certRoutes;
+    }
+    /**
+     * Constructor for CertProvisioner
+     *
+     * @param routeConfigs Array of route configurations
      * @param port80Handler HTTP-01 challenge handler instance
      * @param networkProxyBridge Bridge for applying external certificates
      * @param certProvider Optional callback returning a static cert or 'http01'
      * @param renewThresholdDays Days before expiry to trigger renewals
      * @param renewCheckIntervalHours Interval in hours to check for renewals
      * @param autoRenew Whether to automatically schedule renewals
-     * @param forwardConfigs Domain forwarding configurations for ACME challenges
+     * @param routeForwards Route-specific forwarding configs for ACME challenges
      */
-    constructor(domainConfigs, port80Handler, networkProxyBridge, certProvider, renewThresholdDays = 30, renewCheckIntervalHours = 24, autoRenew = true, forwardConfigs = []) {
+    constructor(routeConfigs, port80Handler, networkProxyBridge, certProvider, renewThresholdDays = 30, renewCheckIntervalHours = 24, autoRenew = true, routeForwards = []) {
         super();
-        this.domainConfigs = domainConfigs;
+        this.certRoutes = [];
+        this.routeConfigs = routeConfigs;
         this.port80Handler = port80Handler;
         this.networkProxyBridge = networkProxyBridge;
         this.certProvisionFunction = certProvider;
@@ -26,7 +65,9 @@ export class CertProvisioner extends plugins.EventEmitter {
         this.renewCheckIntervalHours = renewCheckIntervalHours;
         this.autoRenew = autoRenew;
         this.provisionMap = new Map();
-        this.forwardConfigs = forwardConfigs;
+        this.routeForwards = routeForwards;
+        // Extract certificate routes during instantiation
+        this.certRoutes = this.extractCertificateRoutesFromRoutes(routeConfigs);
     }
     /**
      * Start initial provisioning and schedule renewals.
@@ -34,10 +75,10 @@ export class CertProvisioner extends plugins.EventEmitter {
     async start() {
         // Subscribe to Port80Handler certificate events
         this.setupEventSubscriptions();
-        // Apply external forwarding for ACME challenges
+        // Apply route forwarding for ACME challenges
         this.setupForwardingConfigs();
-        // Initial provisioning for all domains
-        await this.provisionAllDomains();
+        // Initial provisioning for all domains in routes
+        await this.provisionAllCertificates();
         // Schedule renewals if enabled
         if (this.autoRenew) {
             this.scheduleRenewals();
@@ -47,46 +88,74 @@ export class CertProvisioner extends plugins.EventEmitter {
      * Set up event subscriptions for certificate events
      */
     setupEventSubscriptions() {
-        // We need to reimplement subscribeToPort80Handler here
         this.port80Handler.on(Port80HandlerEvents.CERTIFICATE_ISSUED, (data) => {
-            this.emit(CertProvisionerEvents.CERTIFICATE_ISSUED, { ...data, source: 'http01', isRenewal: false });
+            // Add route reference if we have it
+            const routeRef = this.findRouteForDomain(data.domain);
+            const enhancedData = {
+                ...data,
+                source: 'http01',
+                isRenewal: false,
+                routeReference: routeRef ? {
+                    routeId: routeRef.route.name,
+                    routeName: routeRef.route.name
+                } : undefined
+            };
+            this.emit(CertProvisionerEvents.CERTIFICATE_ISSUED, enhancedData);
         });
         this.port80Handler.on(Port80HandlerEvents.CERTIFICATE_RENEWED, (data) => {
-            this.emit(CertProvisionerEvents.CERTIFICATE_RENEWED, { ...data, source: 'http01', isRenewal: true });
+            // Add route reference if we have it
+            const routeRef = this.findRouteForDomain(data.domain);
+            const enhancedData = {
+                ...data,
+                source: 'http01',
+                isRenewal: true,
+                routeReference: routeRef ? {
+                    routeId: routeRef.route.name,
+                    routeName: routeRef.route.name
+                } : undefined
+            };
+            this.emit(CertProvisionerEvents.CERTIFICATE_RENEWED, enhancedData);
         });
         this.port80Handler.on(Port80HandlerEvents.CERTIFICATE_FAILED, (error) => {
             this.emit(CertProvisionerEvents.CERTIFICATE_FAILED, error);
         });
     }
+    /**
+     * Find a route for a given domain
+     */
+    findRouteForDomain(domain) {
+        return this.certRoutes.find(certRoute => certRoute.domain === domain);
+    }
     /**
      * Set up forwarding configurations for the Port80Handler
      */
     setupForwardingConfigs() {
-        for (const config of this.forwardConfigs) {
+        for (const config of this.routeForwards) {
             const domainOptions = {
                 domainName: config.domain,
                 sslRedirect: config.sslRedirect || false,
                 acmeMaintenance: false,
-                forward: config.forwardConfig,
-                acmeForward: config.acmeForwardConfig
+                forward: config.target ? {
+                    ip: config.target.host,
+                    port: config.target.port
+                } : undefined
             };
             this.port80Handler.addDomain(domainOptions);
         }
     }
     /**
-     * Provision certificates for all configured domains
+     * Provision certificates for all routes that need them
      */
-    async provisionAllDomains() {
-        const domains = this.domainConfigs.flatMap(cfg => cfg.domains);
-        for (const domain of domains) {
-            await this.provisionDomain(domain);
+    async provisionAllCertificates() {
+        for (const certRoute of this.certRoutes) {
+            await this.provisionCertificateForRoute(certRoute);
         }
     }
     /**
-     * Provision a certificate for a single domain
-     * @param domain Domain to provision
+     * Provision a certificate for a route
      */
-    async provisionDomain(domain) {
+    async provisionCertificateForRoute(certRoute) {
+        const { domain, route } = certRoute;
         const isWildcard = domain.includes('*');
         let provision = 'http01';
         // Try to get a certificate from the provision function
@@ -95,7 +164,7 @@ export class CertProvisioner extends plugins.EventEmitter {
                 provision = await this.certProvisionFunction(domain);
             }
             catch (err) {
-                console.error(`certProvider error for ${domain}:`, err);
+                console.error(`certProvider error for ${domain} on route ${route.name || 'unnamed'}:`, err);
             }
         }
         else if (isWildcard) {
@@ -103,27 +172,34 @@ export class CertProvisioner extends plugins.EventEmitter {
             console.warn(`Skipping wildcard domain without certProvisionFunction: ${domain}`);
             return;
         }
+        // Store the route reference with the provision type
+        this.provisionMap.set(domain, {
+            type: provision === 'http01' || provision === 'dns01' ? provision : 'static',
+            routeRef: certRoute
+        });
         // Handle different provisioning methods
         if (provision === 'http01') {
             if (isWildcard) {
                 console.warn(`Skipping HTTP-01 for wildcard domain: ${domain}`);
                 return;
             }
-            this.provisionMap.set(domain, 'http01');
             this.port80Handler.addDomain({
                 domainName: domain,
                 sslRedirect: true,
-                acmeMaintenance: true
+                acmeMaintenance: true,
+                routeReference: {
+                    routeId: route.name || domain,
+                    routeName: route.name
+                }
             });
         }
         else if (provision === 'dns01') {
             // DNS-01 challenges would be handled by the certProvisionFunction
-            this.provisionMap.set(domain, 'dns01');
             // DNS-01 handling would go here if implemented
+            console.log(`DNS-01 challenge type set for ${domain}`);
         }
         else {
             // Static certificate (e.g., DNS-01 provisioned or user-provided)
-            this.provisionMap.set(domain, 'static');
             const certObj = provision;
             const certData = {
                 domain: certObj.domainName,
@@ -131,7 +207,11 @@ export class CertProvisioner extends plugins.EventEmitter {
                 privateKey: certObj.privateKey,
                 expiryDate: new Date(certObj.validUntil),
                 source: 'static',
-                isRenewal: false
+                isRenewal: false,
+                routeReference: {
+                    routeId: route.name || domain,
+                    routeName: route.name
+                }
             };
             this.networkProxyBridge.applyExternalCertificate(certData);
             this.emit(CertProvisionerEvents.CERTIFICATE_ISSUED, certData);
@@ -155,12 +235,12 @@ export class CertProvisioner extends plugins.EventEmitter {
      * Perform renewals for all domains that need it
      */
     async performRenewals() {
-        for (const [domain, type] of this.provisionMap.entries()) {
+        for (const [domain, info] of this.provisionMap.entries()) {
             // Skip wildcard domains for HTTP-01 challenges
-            if (domain.includes('*') && type === 'http01')
+            if (domain.includes('*') && info.type === 'http01')
                 continue;
             try {
-                await this.renewDomain(domain, type);
+                await this.renewCertificateForDomain(domain, info.type, info.routeRef);
             }
             catch (err) {
                 console.error(`Renewal error for ${domain}:`, err);
@@ -171,8 +251,9 @@ export class CertProvisioner extends plugins.EventEmitter {
      * Renew a certificate for a specific domain
      * @param domain Domain to renew
      * @param provisionType Type of provisioning for this domain
+     * @param certRoute The route reference for this domain
      */
-    async renewDomain(domain, provisionType) {
+    async renewCertificateForDomain(domain, provisionType, certRoute) {
         if (provisionType === 'http01') {
             await this.port80Handler.renewCertificate(domain);
         }
@@ -180,13 +261,18 @@ export class CertProvisioner extends plugins.EventEmitter {
             const provision = await this.certProvisionFunction(domain);
             if (provision !== 'http01' && provision !== 'dns01') {
                 const certObj = provision;
+                const routeRef = certRoute?.route;
                 const certData = {
                     domain: certObj.domainName,
                     certificate: certObj.publicKey,
                     privateKey: certObj.privateKey,
                     expiryDate: new Date(certObj.validUntil),
                     source: 'static',
-                    isRenewal: true
+                    isRenewal: true,
+                    routeReference: routeRef ? {
+                        routeId: routeRef.name || domain,
+                        routeName: routeRef.name
+                    } : undefined
                 };
                 this.networkProxyBridge.applyExternalCertificate(certData);
                 this.emit(CertProvisionerEvents.CERTIFICATE_RENEWED, certData);
@@ -203,10 +289,14 @@ export class CertProvisioner extends plugins.EventEmitter {
     }
     /**
      * Request a certificate on-demand for the given domain.
+     * This will look for a matching route configuration and provision accordingly.
+     *
      * @param domain Domain name to provision
      */
     async requestCertificate(domain) {
         const isWildcard = domain.includes('*');
+        // Find matching route
+        const certRoute = this.findRouteForDomain(domain);
         // Determine provisioning method
         let provision = 'http01';
         if (this.certProvisionFunction) {
@@ -224,7 +314,6 @@ export class CertProvisioner extends plugins.EventEmitter {
         }
         else if (provision === 'dns01') {
             // DNS-01 challenges would be handled by external mechanisms
-            // This is a placeholder for future implementation
             console.log(`DNS-01 challenge requested for ${domain}`);
         }
         else {
@@ -236,7 +325,11 @@ export class CertProvisioner extends plugins.EventEmitter {
                 privateKey: certObj.privateKey,
                 expiryDate: new Date(certObj.validUntil),
                 source: 'static',
-                isRenewal: false
+                isRenewal: false,
+                routeReference: certRoute ? {
+                    routeId: certRoute.route.name || domain,
+                    routeName: certRoute.route.name
+                } : undefined
             };
             this.networkProxyBridge.applyExternalCertificate(certData);
             this.emit(CertProvisionerEvents.CERTIFICATE_ISSUED, certData);
@@ -244,19 +337,86 @@ export class CertProvisioner extends plugins.EventEmitter {
     }
     /**
      * Add a new domain for certificate provisioning
+     *
      * @param domain Domain to add
      * @param options Domain configuration options
      */
     async addDomain(domain, options) {
         const domainOptions = {
             domainName: domain,
-            sslRedirect: options?.sslRedirect || true,
-            acmeMaintenance: options?.acmeMaintenance || true
+            sslRedirect: options?.sslRedirect ?? true,
+            acmeMaintenance: options?.acmeMaintenance ?? true,
+            routeReference: {
+                routeId: options?.routeId,
+                routeName: options?.routeName
+            }
         };
         this.port80Handler.addDomain(domainOptions);
-        await this.provisionDomain(domain);
+        // Find matching route or create a generic one
+        const existingRoute = this.findRouteForDomain(domain);
+        if (existingRoute) {
+            await this.provisionCertificateForRoute(existingRoute);
+        }
+        else {
+            // We don't have a route, just provision the domain
+            const isWildcard = domain.includes('*');
+            let provision = 'http01';
+            if (this.certProvisionFunction) {
+                provision = await this.certProvisionFunction(domain);
+            }
+            else if (isWildcard) {
+                throw new Error(`Cannot request certificate for wildcard domain without certProvisionFunction: ${domain}`);
+            }
+            this.provisionMap.set(domain, {
+                type: provision === 'http01' || provision === 'dns01' ? provision : 'static'
+            });
+            if (provision !== 'http01' && provision !== 'dns01') {
+                const certObj = provision;
+                const certData = {
+                    domain: certObj.domainName,
+                    certificate: certObj.publicKey,
+                    privateKey: certObj.privateKey,
+                    expiryDate: new Date(certObj.validUntil),
+                    source: 'static',
+                    isRenewal: false,
+                    routeReference: {
+                        routeId: options?.routeId,
+                        routeName: options?.routeName
+                    }
+                };
+                this.networkProxyBridge.applyExternalCertificate(certData);
+                this.emit(CertProvisionerEvents.CERTIFICATE_ISSUED, certData);
+            }
+        }
+    }
+    /**
+     * Update routes with new configurations
+     * This replaces all existing routes with new ones and re-provisions certificates as needed
+     *
+     * @param newRoutes New route configurations to use
+     */
+    async updateRoutes(newRoutes) {
+        // Store the new route configs
+        this.routeConfigs = newRoutes;
+        // Extract new certificate routes
+        const newCertRoutes = this.extractCertificateRoutesFromRoutes(newRoutes);
+        // Find domains that no longer need certificates
+        const oldDomains = new Set(this.certRoutes.map(r => r.domain));
+        const newDomains = new Set(newCertRoutes.map(r => r.domain));
+        // Domains to remove
+        const domainsToRemove = [...oldDomains].filter(d => !newDomains.has(d));
+        // Remove obsolete domains from provision map
+        for (const domain of domainsToRemove) {
+            this.provisionMap.delete(domain);
+        }
+        // Update the cert routes
+        this.certRoutes = newCertRoutes;
+        // Provision certificates for new routes
+        for (const certRoute of newCertRoutes) {
+            if (!oldDomains.has(certRoute.domain)) {
+                await this.provisionCertificateForRoute(certRoute);
+            }
+        }
     }
 }
-// For backward compatibility
-export { CertProvisioner as CertificateProvisioner };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cert-provisioner.js","sourceRoot":"","sources":["../../../ts/certificate/providers/cert-provisioner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,kBAAkB,CAAC;AAG5C,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAC7F,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAiBpE;;;GAGG;AACH,MAAM,OAAO,eAAgB,SAAQ,OAAO,CAAC,YAAY;IAavD;;;;;;;;;OASG;IACH,YACE,aAA8B,EAC9B,aAA4B,EAC5B,kBAAuC,EACvC,YAAgE,EAChE,qBAA6B,EAAE,EAC/B,0BAAkC,EAAE,EACpC,YAAqB,IAAI,EACzB,iBAAyC,EAAE;QAE3C,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QACnC,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QACnC,IAAI,CAAC,kBAAkB,GAAG,kBAAkB,CAAC;QAC7C,IAAI,CAAC,qBAAqB,GAAG,YAAY,CAAC;QAC1C,IAAI,CAAC,kBAAkB,GAAG,kBAAkB,CAAC;QAC7C,IAAI,CAAC,uBAAuB,GAAG,uBAAuB,CAAC;QACvD,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,YAAY,GAAG,IAAI,GAAG,EAAE,CAAC;QAC9B,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;IACvC,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,KAAK;QAChB,gDAAgD;QAChD,IAAI,CAAC,uBAAuB,EAAE,CAAC;QAE/B,gDAAgD;QAChD,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAE9B,uCAAuC;QACvC,MAAM,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAEjC,+BAA+B;QAC/B,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACnB,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC1B,CAAC;IACH,CAAC;IAED;;OAEG;IACK,uBAAuB;QAC7B,uDAAuD;QACvD,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,mBAAmB,CAAC,kBAAkB,EAAE,CAAC,IAAsB,EAAE,EAAE;YACvF,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAAC,kBAAkB,EAAE,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;QACvG,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,mBAAmB,CAAC,mBAAmB,EAAE,CAAC,IAAsB,EAAE,EAAE;YACxF,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAAC,mBAAmB,EAAE,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACvG,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,mBAAmB,CAAC,kBAAkB,EAAE,CAAC,KAAK,EAAE,EAAE;YACtE,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAAC,kBAAkB,EAAE,KAAK,CAAC,CAAC;QAC7D,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACK,sBAAsB;QAC5B,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;YACzC,MAAM,aAAa,GAAmB;gBACpC,UAAU,EAAE,MAAM,CAAC,MAAM;gBACzB,WAAW,EAAE,MAAM,CAAC,WAAW,IAAI,KAAK;gBACxC,eAAe,EAAE,KAAK;gBACtB,OAAO,EAAE,MAAM,CAAC,aAAa;gBAC7B,WAAW,EAAE,MAAM,CAAC,iBAAiB;aACtC,CAAC;YACF,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;QAC9C,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,mBAAmB;QAC/B,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAE/D,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YAC7B,MAAM,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;QACrC,CAAC;IACH,CAAC;IAED;;;OAGG;IACK,KAAK,CAAC,eAAe,CAAC,MAAc;QAC1C,MAAM,UAAU,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;QACxC,IAAI,SAAS,GAAyB,QAAQ,CAAC;QAE/C,uDAAuD;QACvD,IAAI,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAC/B,IAAI,CAAC;gBACH,SAAS,GAAG,MAAM,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;YACvD,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,OAAO,CAAC,KAAK,CAAC,0BAA0B,MAAM,GAAG,EAAE,GAAG,CAAC,CAAC;YAC1D,CAAC;QACH,CAAC;aAAM,IAAI,UAAU,EAAE,CAAC;YACtB,iEAAiE;YACjE,OAAO,CAAC,IAAI,CAAC,2DAA2D,MAAM,EAAE,CAAC,CAAC;YAClF,OAAO;QACT,CAAC;QAED,wCAAwC;QACxC,IAAI,SAAS,KAAK,QAAQ,EAAE,CAAC;YAC3B,IAAI,UAAU,EAAE,CAAC;gBACf,OAAO,CAAC,IAAI,CAAC,yCAAyC,MAAM,EAAE,CAAC,CAAC;gBAChE,OAAO;YACT,CAAC;YAED,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;YACxC,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC;gBAC3B,UAAU,EAAE,MAAM;gBAClB,WAAW,EAAE,IAAI;gBACjB,eAAe,EAAE,IAAI;aACtB,CAAC,CAAC;QACL,CAAC;aAAM,IAAI,SAAS,KAAK,OAAO,EAAE,CAAC;YACjC,kEAAkE;YAClE,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;YACvC,+CAA+C;QACjD,CAAC;aAAM,CAAC;YACN,iEAAiE;YACjE,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;YACxC,MAAM,OAAO,GAAG,SAA0C,CAAC;YAC3D,MAAM,QAAQ,GAAqB;gBACjC,MAAM,EAAE,OAAO,CAAC,UAAU;gBAC1B,WAAW,EAAE,OAAO,CAAC,SAAS;gBAC9B,UAAU,EAAE,OAAO,CAAC,UAAU;gBAC9B,UAAU,EAAE,IAAI,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC;gBACxC,MAAM,EAAE,QAAQ;gBAChB,SAAS,EAAE,KAAK;aACjB,CAAC;YAEF,IAAI,CAAC,kBAAkB,CAAC,wBAAwB,CAAC,QAAQ,CAAC,CAAC;YAC3D,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAC;QAChE,CAAC;IACH,CAAC;IAED;;OAEG;IACK,gBAAgB;QACtB,IAAI,CAAC,YAAY,GAAG,IAAI,OAAO,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC;QAEzD,MAAM,SAAS,GAAG,IAAI,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC;YAC5C,IAAI,EAAE,qBAAqB;YAC3B,YAAY,EAAE,KAAK,IAAI,EAAE,CAAC,MAAM,IAAI,CAAC,eAAe,EAAE;SACvD,CAAC,CAAC;QAEH,MAAM,KAAK,GAAG,IAAI,CAAC,uBAAuB,CAAC;QAC3C,MAAM,QAAQ,GAAG,SAAS,KAAK,QAAQ,CAAC;QAExC,IAAI,CAAC,YAAY,CAAC,kBAAkB,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;QAC1D,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;IAC5B,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,eAAe;QAC3B,KAAK,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,EAAE,CAAC;YACzD,+CAA+C;YAC/C,IAAI,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,IAAI,KAAK,QAAQ;gBAAE,SAAS;YAExD,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;YACvC,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,OAAO,CAAC,KAAK,CAAC,qBAAqB,MAAM,GAAG,EAAE,GAAG,CAAC,CAAC;YACrD,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,WAAW,CAAC,MAAc,EAAE,aAA4C;QACpF,IAAI,aAAa,KAAK,QAAQ,EAAE,CAAC;YAC/B,MAAM,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;QACpD,CAAC;aAAM,IAAI,CAAC,aAAa,KAAK,QAAQ,IAAI,aAAa,KAAK,OAAO,CAAC,IAAI,IAAI,CAAC,qBAAqB,EAAE,CAAC;YACnG,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;YAE3D,IAAI,SAAS,KAAK,QAAQ,IAAI,SAAS,KAAK,OAAO,EAAE,CAAC;gBACpD,MAAM,OAAO,GAAG,SAA0C,CAAC;gBAC3D,MAAM,QAAQ,GAAqB;oBACjC,MAAM,EAAE,OAAO,CAAC,UAAU;oBAC1B,WAAW,EAAE,OAAO,CAAC,SAAS;oBAC9B,UAAU,EAAE,OAAO,CAAC,UAAU;oBAC9B,UAAU,EAAE,IAAI,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC;oBACxC,MAAM,EAAE,QAAQ;oBAChB,SAAS,EAAE,IAAI;iBAChB,CAAC;gBAEF,IAAI,CAAC,kBAAkB,CAAC,wBAAwB,CAAC,QAAQ,CAAC,CAAC;gBAC3D,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAAC,mBAAmB,EAAE,QAAQ,CAAC,CAAC;YACjE,CAAC;QACH,CAAC;IACH,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,IAAI;QACf,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;QAC3B,CAAC;IACH,CAAC;IAED;;;OAGG;IACI,KAAK,CAAC,kBAAkB,CAAC,MAAc;QAC5C,MAAM,UAAU,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;QAExC,gCAAgC;QAChC,IAAI,SAAS,GAAyB,QAAQ,CAAC;QAE/C,IAAI,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAC/B,SAAS,GAAG,MAAM,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;QACvD,CAAC;aAAM,IAAI,UAAU,EAAE,CAAC;YACtB,0DAA0D;YAC1D,MAAM,IAAI,KAAK,CAAC,iFAAiF,MAAM,EAAE,CAAC,CAAC;QAC7G,CAAC;QAED,IAAI,SAAS,KAAK,QAAQ,EAAE,CAAC;YAC3B,IAAI,UAAU,EAAE,CAAC;gBACf,MAAM,IAAI,KAAK,CAAC,2DAA2D,MAAM,EAAE,CAAC,CAAC;YACvF,CAAC;YACD,MAAM,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;QACpD,CAAC;aAAM,IAAI,SAAS,KAAK,OAAO,EAAE,CAAC;YACjC,4DAA4D;YAC5D,kDAAkD;YAClD,OAAO,CAAC,GAAG,CAAC,kCAAkC,MAAM,EAAE,CAAC,CAAC;QAC1D,CAAC;aAAM,CAAC;YACN,mEAAmE;YACnE,MAAM,OAAO,GAAG,SAA0C,CAAC;YAC3D,MAAM,QAAQ,GAAqB;gBACjC,MAAM,EAAE,OAAO,CAAC,UAAU;gBAC1B,WAAW,EAAE,OAAO,CAAC,SAAS;gBAC9B,UAAU,EAAE,OAAO,CAAC,UAAU;gBAC9B,UAAU,EAAE,IAAI,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC;gBACxC,MAAM,EAAE,QAAQ;gBAChB,SAAS,EAAE,KAAK;aACjB,CAAC;YAEF,IAAI,CAAC,kBAAkB,CAAC,wBAAwB,CAAC,QAAQ,CAAC,CAAC;YAC3D,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAAC,kBAAkB,EAAE,QAAQ,CAAC,CAAC;QAChE,CAAC;IACH,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,SAAS,CAAC,MAAc,EAAE,OAGtC;QACC,MAAM,aAAa,GAAmB;YACpC,UAAU,EAAE,MAAM;YAClB,WAAW,EAAE,OAAO,EAAE,WAAW,IAAI,IAAI;YACzC,eAAe,EAAE,OAAO,EAAE,eAAe,IAAI,IAAI;SAClD,CAAC;QAEF,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;QAC5C,MAAM,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;IACrC,CAAC;CACF;AAED,6BAA6B;AAC7B,OAAO,EAAE,eAAe,IAAI,sBAAsB,EAAE,CAAA"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cert-provisioner.js","sourceRoot":"","sources":["../../../ts/certificate/providers/cert-provisioner.ts"],"names":[],"mappings":"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"}

package/dist_ts/forwarding/config/forwarding-types.d.ts

@@ -1,79 +1,11 @@
 import type * as plugins from '../../plugins.js';
 /**
+ * @deprecated The legacy forwarding types are being replaced by the route-based configuration system.
+ * See /ts/proxies/smart-proxy/models/route-types.ts for the new route-based configuration.
+ *
  * The primary forwarding types supported by SmartProxy
  */
 export type TForwardingType = 'http-only' | 'https-passthrough' | 'https-terminate-to-http' | 'https-terminate-to-https';
-/**
- * Target configuration for forwarding
- */
-export interface ITargetConfig {
-    host: string | string[];
-    port: number;
-}
-/**
- * HTTP-specific options for forwarding
- */
-export interface IHttpOptions {
-    enabled?: boolean;
-    redirectToHttps?: boolean;
-    headers?: Record<string, string>;
-}
-/**
- * HTTPS-specific options for forwarding
- */
-export interface IHttpsOptions {
-    customCert?: {
-        key: string;
-        cert: string;
-    };
-    forwardSni?: boolean;
-}
-/**
- * ACME certificate handling options
- */
-export interface IAcmeForwardingOptions {
-    enabled?: boolean;
-    maintenance?: boolean;
-    production?: boolean;
-    forwardChallenges?: {
-        host: string;
-        port: number;
-        useTls?: boolean;
-    };
-}
-/**
- * Security options for forwarding
- */
-export interface ISecurityOptions {
-    allowedIps?: string[];
-    blockedIps?: string[];
-    maxConnections?: number;
-}
-/**
- * Advanced options for forwarding
- */
-export interface IAdvancedOptions {
-    portRanges?: Array<{
-        from: number;
-        to: number;
-    }>;
-    networkProxyPort?: number;
-    keepAlive?: boolean;
-    timeout?: number;
-    headers?: Record<string, string>;
-}
-/**
- * Unified forwarding configuration interface
- */
-export interface IForwardConfig {
-    type: TForwardingType;
-    target: ITargetConfig;
-    http?: IHttpOptions;
-    https?: IHttpsOptions;
-    acme?: IAcmeForwardingOptions;
-    security?: ISecurityOptions;
-    advanced?: IAdvancedOptions;
-}
 /**
  * Event types emitted by forwarding handlers
  */
@@ -95,10 +27,42 @@ export interface IForwardingHandler extends plugins.EventEmitter {
     handleConnection(socket: plugins.net.Socket): void;
     handleHttpRequest(req: plugins.http.IncomingMessage, res: plugins.http.ServerResponse): void;
 }
+import { createHttpRoute, createHttpsTerminateRoute, createHttpsPassthroughRoute, createHttpToHttpsRedirect, createCompleteHttpsServer, createLoadBalancerRoute } from '../../proxies/smart-proxy/utils/route-helpers.js';
+export { createHttpRoute, createHttpsTerminateRoute, createHttpsPassthroughRoute, createHttpToHttpsRedirect, createCompleteHttpsServer, createLoadBalancerRoute };
+export interface IForwardConfig {
+    type: TForwardingType;
+    target: {
+        host: string | string[];
+        port: number;
+    };
+    http?: any;
+    https?: any;
+    acme?: any;
+    security?: any;
+    advanced?: any;
+    [key: string]: any;
+}
+export interface IDeprecatedForwardConfig {
+    type: TForwardingType;
+    target: {
+        host: string | string[];
+        port: number;
+    };
+    [key: string]: any;
+}
+/**
+ * @deprecated Use createHttpRoute instead
+ */
+export declare const httpOnly: (partialConfig: Partial<IDeprecatedForwardConfig> & Pick<IDeprecatedForwardConfig, "target">) => IDeprecatedForwardConfig;
+/**
+ * @deprecated Use createHttpsTerminateRoute instead
+ */
+export declare const tlsTerminateToHttp: (partialConfig: Partial<IDeprecatedForwardConfig> & Pick<IDeprecatedForwardConfig, "target">) => IDeprecatedForwardConfig;
+/**
+ * @deprecated Use createHttpsTerminateRoute with reencrypt option instead
+ */
+export declare const tlsTerminateToHttps: (partialConfig: Partial<IDeprecatedForwardConfig> & Pick<IDeprecatedForwardConfig, "target">) => IDeprecatedForwardConfig;
 /**
- * Helper function types for common forwarding patterns
+ * @deprecated Use createHttpsPassthroughRoute instead
  */
-export declare const httpOnly: (partialConfig: Partial<IForwardConfig> & Pick<IForwardConfig, "target">) => IForwardConfig;
-export declare const tlsTerminateToHttp: (partialConfig: Partial<IForwardConfig> & Pick<IForwardConfig, "target">) => IForwardConfig;
-export declare const tlsTerminateToHttps: (partialConfig: Partial<IForwardConfig> & Pick<IForwardConfig, "target">) => IForwardConfig;
-export declare const httpsPassthrough: (partialConfig: Partial<IForwardConfig> & Pick<IForwardConfig, "target">) => IForwardConfig;
+export declare const httpsPassthrough: (partialConfig: Partial<IDeprecatedForwardConfig> & Pick<IDeprecatedForwardConfig, "target">) => IDeprecatedForwardConfig;

package/dist_ts/forwarding/config/forwarding-types.js

@@ -12,39 +12,40 @@ export var ForwardingHandlerEvents;
     ForwardingHandlerEvents["CERTIFICATE_NEEDED"] = "certificate-needed";
     ForwardingHandlerEvents["CERTIFICATE_LOADED"] = "certificate-loaded";
 })(ForwardingHandlerEvents || (ForwardingHandlerEvents = {}));
+// Import and re-export the route-based helpers for seamless transition
+import { createHttpRoute, createHttpsTerminateRoute, createHttpsPassthroughRoute, createHttpToHttpsRedirect, createCompleteHttpsServer, createLoadBalancerRoute } from '../../proxies/smart-proxy/utils/route-helpers.js';
+export { createHttpRoute, createHttpsTerminateRoute, createHttpsPassthroughRoute, createHttpToHttpsRedirect, createCompleteHttpsServer, createLoadBalancerRoute };
+import { domainConfigToRouteConfig } from '../../proxies/smart-proxy/utils/route-migration-utils.js';
 /**
- * Helper function types for common forwarding patterns
+ * @deprecated Use createHttpRoute instead
  */
 export const httpOnly = (partialConfig) => ({
     type: 'http-only',
     target: partialConfig.target,
-    http: { enabled: true, ...(partialConfig.http || {}) },
-    ...(partialConfig.security ? { security: partialConfig.security } : {}),
-    ...(partialConfig.advanced ? { advanced: partialConfig.advanced } : {})
+    ...(partialConfig)
 });
+/**
+ * @deprecated Use createHttpsTerminateRoute instead
+ */
 export const tlsTerminateToHttp = (partialConfig) => ({
     type: 'https-terminate-to-http',
     target: partialConfig.target,
-    https: { ...(partialConfig.https || {}) },
-    acme: { enabled: true, maintenance: true, ...(partialConfig.acme || {}) },
-    http: { enabled: true, redirectToHttps: true, ...(partialConfig.http || {}) },
-    ...(partialConfig.security ? { security: partialConfig.security } : {}),
-    ...(partialConfig.advanced ? { advanced: partialConfig.advanced } : {})
+    ...(partialConfig)
 });
+/**
+ * @deprecated Use createHttpsTerminateRoute with reencrypt option instead
+ */
 export const tlsTerminateToHttps = (partialConfig) => ({
     type: 'https-terminate-to-https',
     target: partialConfig.target,
-    https: { ...(partialConfig.https || {}) },
-    acme: { enabled: true, maintenance: true, ...(partialConfig.acme || {}) },
-    http: { enabled: true, redirectToHttps: true, ...(partialConfig.http || {}) },
-    ...(partialConfig.security ? { security: partialConfig.security } : {}),
-    ...(partialConfig.advanced ? { advanced: partialConfig.advanced } : {})
+    ...(partialConfig)
 });
+/**
+ * @deprecated Use createHttpsPassthroughRoute instead
+ */
 export const httpsPassthrough = (partialConfig) => ({
     type: 'https-passthrough',
     target: partialConfig.target,
-    https: { forwardSni: true, ...(partialConfig.https || {}) },
-    ...(partialConfig.security ? { security: partialConfig.security } : {}),
-    ...(partialConfig.advanced ? { advanced: partialConfig.advanced } : {})
+    ...(partialConfig)
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9yd2FyZGluZy10eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL2ZvcndhcmRpbmcvY29uZmlnL2ZvcndhcmRpbmctdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBY0E7O0dBRUc7QUFDSCxNQUFNLENBQU4sSUFBWSx1QkFTWDtBQVRELFdBQVksdUJBQXVCO0lBQ2pDLGtEQUF1QixDQUFBO0lBQ3ZCLHdEQUE2QixDQUFBO0lBQzdCLDBDQUFlLENBQUE7SUFDZiw0REFBaUMsQ0FBQTtJQUNqQyx3REFBNkIsQ0FBQTtJQUM3QiwwREFBK0IsQ0FBQTtJQUMvQixvRUFBeUMsQ0FBQTtJQUN6QyxvRUFBeUMsQ0FBQTtBQUMzQyxDQUFDLEVBVFcsdUJBQXVCLEtBQXZCLHVCQUF1QixRQVNsQztBQVdELHVFQUF1RTtBQUN2RSxPQUFPLEVBQ0wsZUFBZSxFQUNmLHlCQUF5QixFQUN6QiwyQkFBMkIsRUFDM0IseUJBQXlCLEVBQ3pCLHlCQUF5QixFQUN6Qix1QkFBdUIsRUFDeEIsTUFBTSxrREFBa0QsQ0FBQztBQUUxRCxPQUFPLEVBQ0wsZUFBZSxFQUNmLHlCQUF5QixFQUN6QiwyQkFBMkIsRUFDM0IseUJBQXlCLEVBQ3pCLHlCQUF5QixFQUN6Qix1QkFBdUIsRUFDeEIsQ0FBQztBQVdGLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLDBEQUEwRCxDQUFDO0FBMEJyRzs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLFFBQVEsR0FBRyxDQUN0QixhQUEyRixFQUNqRSxFQUFFLENBQUMsQ0FBQztJQUM5QixJQUFJLEVBQUUsV0FBVztJQUNqQixNQUFNLEVBQUUsYUFBYSxDQUFDLE1BQU07SUFDNUIsR0FBRyxDQUFDLGFBQWEsQ0FBQztDQUNuQixDQUFDLENBQUM7QUFFSDs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLGtCQUFrQixHQUFHLENBQ2hDLGFBQTJGLEVBQ2pFLEVBQUUsQ0FBQyxDQUFDO0lBQzlCLElBQUksRUFBRSx5QkFBeUI7SUFDL0IsTUFBTSxFQUFFLGFBQWEsQ0FBQyxNQUFNO0lBQzVCLEdBQUcsQ0FBQyxhQUFhLENBQUM7Q0FDbkIsQ0FBQyxDQUFDO0FBRUg7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRyxDQUNqQyxhQUEyRixFQUNqRSxFQUFFLENBQUMsQ0FBQztJQUM5QixJQUFJLEVBQUUsMEJBQTBCO0lBQ2hDLE1BQU0sRUFBRSxhQUFhLENBQUMsTUFBTTtJQUM1QixHQUFHLENBQUMsYUFBYSxDQUFDO0NBQ25CLENBQUMsQ0FBQztBQUVIOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sZ0JBQWdCLEdBQUcsQ0FDOUIsYUFBMkYsRUFDakUsRUFBRSxDQUFDLENBQUM7SUFDOUIsSUFBSSxFQUFFLG1CQUFtQjtJQUN6QixNQUFNLEVBQUUsYUFBYSxDQUFDLE1BQU07SUFDNUIsR0FBRyxDQUFDLGFBQWEsQ0FBQztDQUNuQixDQUFDLENBQUMifQ==