@push.rocks/smartproxy 15.0.2 → 16.0.2

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartproxy',
-    version: '15.0.0',
+    version: '16.0.2',
     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.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLHFQQUFxUDtDQUNuUSxDQUFBIn0=

package/dist_ts/certificate/index.d.ts

@@ -10,15 +10,21 @@ export * from './acme/challenge-handler.js';
 export * from './utils/certificate-helpers.js';
 export * from './storage/file-storage.js';
 import { CertProvisioner } from './providers/cert-provisioner.js';
+import type { TCertProvisionObject } from './providers/cert-provisioner.js';
 import type { IAcmeOptions } from './models/certificate-types.js';
-import type { IDomainConfig } from '../forwarding/config/domain-config.js';
+import type { IRouteConfig } from '../proxies/smart-proxy/models/route-types.js';
+/**
+ * Interface for NetworkProxyBridge used by CertProvisioner
+ */
+interface ICertNetworkProxyBridge {
+    applyExternalCertificate(certData: any): void;
+}
 /**
  * Creates a complete certificate provisioning system with default settings
- * @param domainConfigs Domain configurations
+ * @param routeConfigs Route configurations that may need certificates
  * @param acmeOptions ACME options for certificate provisioning
  * @param networkProxyBridge Bridge to apply certificates to network proxy
  * @param certProvider Optional custom certificate provider
  * @returns Configured CertProvisioner
  */
-export declare function createCertificateProvisioner(domainConfigs: IDomainConfig[], acmeOptions: IAcmeOptions, networkProxyBridge: any, // Placeholder until NetworkProxyBridge is migrated
-certProvider?: any): CertProvisioner;
+export declare function createCertificateProvisioner(routeConfigs: IRouteConfig[], acmeOptions: IAcmeOptions, networkProxyBridge: ICertNetworkProxyBridge, certProvider?: (domain: string) => Promise<TCertProvisionObject>): CertProvisioner;

package/dist_ts/certificate/index.js

@@ -20,20 +20,18 @@ import { CertProvisioner } from './providers/cert-provisioner.js';
 import { buildPort80Handler } from './acme/acme-factory.js';
 /**
  * Creates a complete certificate provisioning system with default settings
- * @param domainConfigs Domain configurations
+ * @param routeConfigs Route configurations that may need certificates
  * @param acmeOptions ACME options for certificate provisioning
  * @param networkProxyBridge Bridge to apply certificates to network proxy
  * @param certProvider Optional custom certificate provider
  * @returns Configured CertProvisioner
  */
-export function createCertificateProvisioner(domainConfigs, acmeOptions, networkProxyBridge, // Placeholder until NetworkProxyBridge is migrated
-certProvider // Placeholder until cert provider type is properly defined
-) {
+export function createCertificateProvisioner(routeConfigs, acmeOptions, networkProxyBridge, certProvider) {
     // Build the Port80Handler for ACME challenges
     const port80Handler = buildPort80Handler(acmeOptions);
     // Extract ACME-specific configuration
-    const { renewThresholdDays = 30, renewCheckIntervalHours = 24, autoRenew = true, domainForwards = [] } = acmeOptions;
+    const { renewThresholdDays = 30, renewCheckIntervalHours = 24, autoRenew = true, routeForwards = [] } = acmeOptions;
     // Create and return the certificate provisioner
-    return new CertProvisioner(domainConfigs, port80Handler, networkProxyBridge, certProvider, renewThresholdDays, renewCheckIntervalHours, autoRenew, domainForwards);
+    return new CertProvisioner(routeConfigs, port80Handler, networkProxyBridge, certProvider, renewThresholdDays, renewCheckIntervalHours, autoRenew, routeForwards);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9jZXJ0aWZpY2F0ZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSCwrQkFBK0I7QUFDL0IsY0FBYywrQkFBK0IsQ0FBQztBQUU5QyxxQkFBcUI7QUFDckIsY0FBYyxnQ0FBZ0MsQ0FBQztBQUUvQyx3QkFBd0I7QUFDeEIsY0FBYyxpQ0FBaUMsQ0FBQztBQUVoRCx1QkFBdUI7QUFDdkIsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLDZCQUE2QixDQUFDO0FBRTVDLHdCQUF3QjtBQUN4QixjQUFjLGdDQUFnQyxDQUFDO0FBRS9DLHNCQUFzQjtBQUN0QixjQUFjLDJCQUEyQixDQUFDO0FBRTFDLGdGQUFnRjtBQUNoRixPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFDbEUsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFJNUQ7Ozs7Ozs7R0FPRztBQUNILE1BQU0sVUFBVSw0QkFBNEIsQ0FDMUMsYUFBOEIsRUFDOUIsV0FBeUIsRUFDekIsa0JBQXVCLEVBQUUsbURBQW1EO0FBQzVFLFlBQWtCLENBQUMsMkRBQTJEOztJQUU5RSw4Q0FBOEM7SUFDOUMsTUFBTSxhQUFhLEdBQUcsa0JBQWtCLENBQUMsV0FBVyxDQUFDLENBQUM7SUFFdEQsc0NBQXNDO0lBQ3RDLE1BQU0sRUFDSixrQkFBa0IsR0FBRyxFQUFFLEVBQ3ZCLHVCQUF1QixHQUFHLEVBQUUsRUFDNUIsU0FBUyxHQUFHLElBQUksRUFDaEIsY0FBYyxHQUFHLEVBQUUsRUFDcEIsR0FBRyxXQUFXLENBQUM7SUFFaEIsZ0RBQWdEO0lBQ2hELE9BQU8sSUFBSSxlQUFlLENBQ3hCLGFBQWEsRUFDYixhQUFhLEVBQ2Isa0JBQWtCLEVBQ2xCLFlBQVksRUFDWixrQkFBa0IsRUFDbEIsdUJBQXVCLEVBQ3ZCLFNBQVMsRUFDVCxjQUFjLENBQ2YsQ0FBQztBQUNKLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9jZXJ0aWZpY2F0ZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSCwrQkFBK0I7QUFDL0IsY0FBYywrQkFBK0IsQ0FBQztBQUU5QyxxQkFBcUI7QUFDckIsY0FBYyxnQ0FBZ0MsQ0FBQztBQUUvQyx3QkFBd0I7QUFDeEIsY0FBYyxpQ0FBaUMsQ0FBQztBQUVoRCx1QkFBdUI7QUFDdkIsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLDZCQUE2QixDQUFDO0FBRTVDLHdCQUF3QjtBQUN4QixjQUFjLGdDQUFnQyxDQUFDO0FBRS9DLHNCQUFzQjtBQUN0QixjQUFjLDJCQUEyQixDQUFDO0FBRTFDLGdGQUFnRjtBQUNoRixPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFFbEUsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFXNUQ7Ozs7Ozs7R0FPRztBQUNILE1BQU0sVUFBVSw0QkFBNEIsQ0FDMUMsWUFBNEIsRUFDNUIsV0FBeUIsRUFDekIsa0JBQTJDLEVBQzNDLFlBQWdFO0lBRWhFLDhDQUE4QztJQUM5QyxNQUFNLGFBQWEsR0FBRyxrQkFBa0IsQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUV0RCxzQ0FBc0M7SUFDdEMsTUFBTSxFQUNKLGtCQUFrQixHQUFHLEVBQUUsRUFDdkIsdUJBQXVCLEdBQUcsRUFBRSxFQUM1QixTQUFTLEdBQUcsSUFBSSxFQUNoQixhQUFhLEdBQUcsRUFBRSxFQUNuQixHQUFHLFdBQVcsQ0FBQztJQUVoQixnREFBZ0Q7SUFDaEQsT0FBTyxJQUFJLGVBQWUsQ0FDeEIsWUFBWSxFQUNaLGFBQWEsRUFDYixrQkFBa0IsRUFDbEIsWUFBWSxFQUNaLGtCQUFrQixFQUNsQix1QkFBdUIsRUFDdkIsU0FBUyxFQUNULGFBQWEsQ0FDZCxDQUFDO0FBQ0osQ0FBQyJ9

package/dist_ts/certificate/models/certificate-types.d.ts

@@ -9,6 +9,10 @@ export interface ICertificateData {
     expiryDate: Date;
     source?: 'static' | 'http01' | 'dns01';
     isRenewal?: boolean;
+    routeReference?: {
+        routeId?: string;
+        routeName?: string;
+    };
 }
 /**
  * Certificates pair (private and public keys)
@@ -24,6 +28,10 @@ export interface ICertificateFailure {
     domain: string;
     error: string;
     isRenewal: boolean;
+    routeReference?: {
+        routeId?: string;
+        routeName?: string;
+    };
 }
 /**
  * Certificate expiry payload type
@@ -32,32 +40,44 @@ export interface ICertificateExpiring {
     domain: string;
     expiryDate: Date;
     daysRemaining: number;
+    routeReference?: {
+        routeId?: string;
+        routeName?: string;
+    };
 }
 /**
- * Domain forwarding configuration
+ * Route-specific forwarding configuration for ACME challenges
  */
-export interface IForwardConfig {
-    ip: string;
-    port: number;
-}
-/**
- * Domain-specific forwarding configuration for ACME challenges
- */
-export interface IDomainForwardConfig {
+export interface IRouteForwardConfig {
     domain: string;
-    forwardConfig?: IForwardConfig;
-    acmeForwardConfig?: IForwardConfig;
+    target: {
+        host: string;
+        port: number;
+    };
     sslRedirect?: boolean;
 }
 /**
- * Domain configuration options
+ * Domain configuration options for Port80Handler
+ *
+ * This is used internally by the Port80Handler to manage domains
+ * but will eventually be replaced with route-based options.
  */
 export interface IDomainOptions {
     domainName: string;
     sslRedirect: boolean;
     acmeMaintenance: boolean;
-    forward?: IForwardConfig;
-    acmeForward?: IForwardConfig;
+    forward?: {
+        ip: string;
+        port: number;
+    };
+    acmeForward?: {
+        ip: string;
+        port: number;
+    };
+    routeReference?: {
+        routeId?: string;
+        routeName?: string;
+    };
 }
 /**
  * Unified ACME configuration options used across proxies and handlers
@@ -73,5 +93,5 @@ export interface IAcmeOptions {
     autoRenew?: boolean;
     certificateStore?: string;
     skipConfiguredCerts?: boolean;
-    domainForwards?: IDomainForwardConfig[];
+    routeForwards?: IRouteForwardConfig[];
 }

package/dist_ts/certificate/providers/cert-provisioner.d.ts

@@ -1,11 +1,10 @@
 import * as plugins from '../../plugins.js';
-import type { IDomainConfig } from '../../forwarding/config/domain-config.js';
-import type { ICertificateData, IDomainForwardConfig } from '../models/certificate-types.js';
+import type { IRouteConfig } from '../../proxies/smart-proxy/models/route-types.js';
+import type { ICertificateData, IRouteForwardConfig } from '../models/certificate-types.js';
 import { Port80Handler } from '../../http/port80/port80-handler.js';
 interface INetworkProxyBridge {
     applyExternalCertificate(certData: ICertificateData): void;
 }
-export type TSmartProxyCertProvisionObject = plugins.tsclass.network.ICert | 'http01';
 /**
  * Type for static certificate provisioning
  */
@@ -13,29 +12,39 @@ export type TCertProvisionObject = plugins.tsclass.network.ICert | 'http01' | 'd
 /**
  * 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 declare class CertProvisioner extends plugins.EventEmitter {
-    private domainConfigs;
+    private routeConfigs;
+    private certRoutes;
     private port80Handler;
     private networkProxyBridge;
     private certProvisionFunction?;
-    private forwardConfigs;
+    private routeForwards;
     private renewThresholdDays;
     private renewCheckIntervalHours;
     private autoRenew;
     private renewManager?;
     private provisionMap;
     /**
-     * @param domainConfigs Array of domain configuration objects
+     * Extract routes that need certificates
+     * @param routes Route configurations
+     */
+    private extractCertificateRoutesFromRoutes;
+    /**
+     * 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: IDomainConfig[], port80Handler: Port80Handler, networkProxyBridge: INetworkProxyBridge, certProvider?: (domain: string) => Promise<TCertProvisionObject>, renewThresholdDays?: number, renewCheckIntervalHours?: number, autoRenew?: boolean, forwardConfigs?: IDomainForwardConfig[]);
+    constructor(routeConfigs: IRouteConfig[], port80Handler: Port80Handler, networkProxyBridge: INetworkProxyBridge, certProvider?: (domain: string) => Promise<TCertProvisionObject>, renewThresholdDays?: number, renewCheckIntervalHours?: number, autoRenew?: boolean, routeForwards?: IRouteForwardConfig[]);
     /**
      * Start initial provisioning and schedule renewals.
      */
@@ -44,19 +53,22 @@ export declare class CertProvisioner extends plugins.EventEmitter {
      * Set up event subscriptions for certificate events
      */
     private setupEventSubscriptions;
+    /**
+     * Find a route for a given domain
+     */
+    private findRouteForDomain;
     /**
      * Set up forwarding configurations for the Port80Handler
      */
     private setupForwardingConfigs;
     /**
-     * Provision certificates for all configured domains
+     * Provision certificates for all routes that need them
      */
-    private provisionAllDomains;
+    private provisionAllCertificates;
     /**
-     * Provision a certificate for a single domain
-     * @param domain Domain to provision
+     * Provision a certificate for a route
      */
-    private provisionDomain;
+    private provisionCertificateForRoute;
     /**
      * Schedule certificate renewals using a task manager
      */
@@ -69,25 +81,39 @@ export declare 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
      */
-    private renewDomain;
+    private renewCertificateForDomain;
     /**
      * Stop all scheduled renewal tasks.
      */
     stop(): Promise<void>;
     /**
      * 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
      */
     requestCertificate(domain: string): Promise<void>;
     /**
      * Add a new domain for certificate provisioning
+     *
      * @param domain Domain to add
      * @param options Domain configuration options
      */
     addDomain(domain: string, options?: {
         sslRedirect?: boolean;
         acmeMaintenance?: boolean;
+        routeId?: string;
+        routeName?: string;
     }): Promise<void>;
+    /**
+     * 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
+     */
+    updateRoutes(newRoutes: IRouteConfig[]): Promise<void>;
 }
-export { CertProvisioner as CertificateProvisioner };
+export type TSmartProxyCertProvisionObject = TCertProvisionObject;
+export {};