@push.rocks/smartproxy 15.0.2 → 16.0.2

package/dist_ts/proxies/smart-proxy/models/route-types.d.ts

@@ -2,7 +2,7 @@ import type { IAcmeOptions } from '../../../certificate/models/certificate-types
 /**
  * Supported action types for route configurations
  */
-export type TRouteActionType = 'forward' | 'redirect' | 'block';
+export type TRouteActionType = 'forward' | 'redirect' | 'block' | 'static';
 /**
  * TLS handling modes for route configurations
  */
@@ -23,6 +23,7 @@ export interface IRouteMatch {
     path?: string;
     clientIp?: string[];
     tlsVersion?: string[];
+    headers?: Record<string, string | RegExp>;
 }
 /**
  * Target configuration for forwarding
@@ -49,6 +50,24 @@ export interface IRouteRedirect {
     to: string;
     status: 301 | 302 | 307 | 308;
 }
+/**
+ * Authentication options
+ */
+export interface IRouteAuthentication {
+    type: 'basic' | 'digest' | 'oauth' | 'jwt';
+    credentials?: {
+        username: string;
+        password: string;
+    }[];
+    realm?: string;
+    jwtSecret?: string;
+    jwtIssuer?: string;
+    oauthProvider?: string;
+    oauthClientId?: string;
+    oauthClientSecret?: string;
+    oauthRedirectUri?: string;
+    [key: string]: any;
+}
 /**
  * Security options for route actions
  */
@@ -56,9 +75,29 @@ export interface IRouteSecurity {
     allowedIps?: string[];
     blockedIps?: string[];
     maxConnections?: number;
-    authentication?: {
-        type: 'basic' | 'digest' | 'oauth';
-    };
+    authentication?: IRouteAuthentication;
+}
+/**
+ * Static file server configuration
+ */
+export interface IRouteStaticFiles {
+    root: string;
+    index?: string[];
+    headers?: Record<string, string>;
+    directory?: string;
+    indexFiles?: string[];
+    cacheControl?: string;
+    expires?: number;
+    followSymlinks?: boolean;
+    disableDirectoryListing?: boolean;
+}
+/**
+ * Test route response configuration
+ */
+export interface IRouteTestResponse {
+    status: number;
+    headers: Record<string, string>;
+    body: string;
 }
 /**
  * Advanced options for route actions
@@ -67,6 +106,30 @@ export interface IRouteAdvanced {
     timeout?: number;
     headers?: Record<string, string>;
     keepAlive?: boolean;
+    staticFiles?: IRouteStaticFiles;
+    testResponse?: IRouteTestResponse;
+}
+/**
+ * WebSocket configuration
+ */
+export interface IRouteWebSocket {
+    enabled: boolean;
+    pingInterval?: number;
+    pingTimeout?: number;
+    maxPayloadSize?: number;
+}
+/**
+ * Load balancing configuration
+ */
+export interface IRouteLoadBalancing {
+    algorithm: 'round-robin' | 'least-connections' | 'ip-hash';
+    healthCheck?: {
+        path: string;
+        interval: number;
+        timeout: number;
+        unhealthyThreshold: number;
+        healthyThreshold: number;
+    };
 }
 /**
  * Action configuration for route handling
@@ -76,19 +139,70 @@ export interface IRouteAction {
     target?: IRouteTarget;
     tls?: IRouteTls;
     redirect?: IRouteRedirect;
+    static?: IRouteStaticFiles;
+    websocket?: IRouteWebSocket;
+    loadBalancing?: IRouteLoadBalancing;
     security?: IRouteSecurity;
     advanced?: IRouteAdvanced;
 }
+/**
+ * Rate limiting configuration
+ */
+export interface IRouteRateLimit {
+    enabled: boolean;
+    maxRequests: number;
+    window: number;
+    keyBy?: 'ip' | 'path' | 'header';
+    headerName?: string;
+    errorMessage?: string;
+}
+/**
+ * Security features for routes
+ */
+export interface IRouteSecurity {
+    rateLimit?: IRouteRateLimit;
+    basicAuth?: {
+        enabled: boolean;
+        users: Array<{
+            username: string;
+            password: string;
+        }>;
+        realm?: string;
+        excludePaths?: string[];
+    };
+    jwtAuth?: {
+        enabled: boolean;
+        secret: string;
+        algorithm?: string;
+        issuer?: string;
+        audience?: string;
+        expiresIn?: number;
+        excludePaths?: string[];
+    };
+    ipAllowList?: string[];
+    ipBlockList?: string[];
+}
+/**
+ * Headers configuration
+ */
+export interface IRouteHeaders {
+    request?: Record<string, string>;
+    response?: Record<string, string>;
+}
 /**
  * The core unified configuration interface
  */
 export interface IRouteConfig {
+    id?: string;
     match: IRouteMatch;
     action: IRouteAction;
+    headers?: IRouteHeaders;
+    security?: IRouteSecurity;
     name?: string;
     description?: string;
     priority?: number;
     tags?: string[];
+    enabled?: boolean;
 }
 /**
  * Unified SmartProxy options with routes-based configuration

package/dist_ts/proxies/smart-proxy/network-proxy-bridge.d.ts

@@ -3,8 +3,17 @@ import { NetworkProxy } from '../network-proxy/index.js';
 import { Port80Handler } from '../../http/port80/port80-handler.js';
 import type { ICertificateData } from '../../certificate/models/certificate-types.js';
 import type { IConnectionRecord, ISmartProxyOptions } from './models/interfaces.js';
+import type { IRouteConfig } from './models/route-types.js';
 /**
  * Manages NetworkProxy integration for TLS termination
+ *
+ * NetworkProxyBridge connects SmartProxy with NetworkProxy to handle TLS termination.
+ * It directly maps route configurations to NetworkProxy configuration format and manages
+ * certificate provisioning through Port80Handler when ACME is enabled.
+ *
+ * It is used by SmartProxy for routes that have:
+ * - TLS mode of 'terminate' or 'terminate-and-reencrypt'
+ * - Certificate set to 'auto' or custom certificate
  */
 export declare class NetworkProxyBridge {
     private settings;
@@ -44,19 +53,76 @@ export declare class NetworkProxyBridge {
      */
     stop(): Promise<void>;
     /**
-     * Register domains with Port80Handler
+     * Register domains from routes with Port80Handler for certificate management
+     *
+     * Extracts domains from routes that require TLS termination and registers them
+     * with the Port80Handler for certificate issuance and renewal.
+     *
+     * @param routes The route configurations to extract domains from
      */
-    registerDomainsWithPort80Handler(domains: string[]): void;
+    registerDomainsWithPort80Handler(routes: IRouteConfig[]): void;
+    /**
+     * Finds the route reference for a given domain
+     *
+     * @param domain The domain to find a route reference for
+     * @param routes The routes to search
+     * @returns The route reference if found, undefined otherwise
+     */
+    private findRouteReferenceForDomain;
     /**
      * Forwards a TLS connection to a NetworkProxy for handling
      */
     forwardToNetworkProxy(connectionId: string, socket: plugins.net.Socket, record: IConnectionRecord, initialData: Buffer, customProxyPort?: number, onError?: (reason: string) => void): void;
     /**
-     * Synchronizes domain configurations to NetworkProxy
+     * Synchronizes routes to NetworkProxy
+     *
+     * This method directly maps route configurations to NetworkProxy format and updates
+     * the NetworkProxy with these configurations. It handles:
+     *
+     * - Extracting domain, target, and certificate information from routes
+     * - Converting TLS mode settings to NetworkProxy configuration
+     * - Applying security and advanced settings
+     * - Registering domains for ACME certificate provisioning when needed
+     *
+     * @param routes The route configurations to sync to NetworkProxy
+     */
+    syncRoutesToNetworkProxy(routes: IRouteConfig[]): Promise<void>;
+    /**
+     * Map routes directly to NetworkProxy configuration format
+     *
+     * This method directly maps route configurations to NetworkProxy's format
+     * without any intermediate domain-based representation. It processes each route
+     * and creates appropriate NetworkProxy configs for domains that require TLS termination.
+     *
+     * @param routes Array of route configurations to map
+     * @param defaultCertPair Default certificate to use if no custom certificate is specified
+     * @returns Array of NetworkProxy configurations
+     */
+    mapRoutesToNetworkProxyConfigs(routes: IRouteConfig[], defaultCertPair: {
+        key: string;
+        cert: string;
+    }): plugins.tsclass.network.IReverseProxyConfig[];
+    /**
+     * @deprecated This method is kept for backward compatibility.
+     * Use mapRoutesToNetworkProxyConfigs() instead.
+     */
+    convertRoutesToNetworkProxyConfigs(routes: IRouteConfig[], defaultCertPair: {
+        key: string;
+        cert: string;
+    }): plugins.tsclass.network.IReverseProxyConfig[];
+    /**
+     * @deprecated This method is deprecated and will be removed in a future version.
+     * Use syncRoutesToNetworkProxy() instead.
+     *
+     * This legacy method exists only for backward compatibility and
+     * simply forwards to syncRoutesToNetworkProxy().
      */
     syncDomainConfigsToNetworkProxy(): Promise<void>;
     /**
      * Request a certificate for a specific domain
+     *
+     * @param domain The domain to request a certificate for
+     * @param routeName Optional route name to associate with this certificate
      */
-    requestCertificate(domain: string): Promise<boolean>;
+    requestCertificate(domain: string, routeName?: string): Promise<boolean>;
 }

package/dist_ts/proxies/smart-proxy/network-proxy-bridge.js

@@ -5,6 +5,14 @@ import { Port80HandlerEvents } from '../../core/models/common-types.js';
 import { subscribeToPort80Handler } from '../../core/utils/event-utils.js';
 /**
  * Manages NetworkProxy integration for TLS termination
+ *
+ * NetworkProxyBridge connects SmartProxy with NetworkProxy to handle TLS termination.
+ * It directly maps route configurations to NetworkProxy configuration format and manages
+ * certificate provisioning through Port80Handler when ACME is enabled.
+ *
+ * It is used by SmartProxy for routes that have:
+ * - TLS mode of 'terminate' or 'terminate-and-reencrypt'
+ * - Certificate set to 'auto' or custom certificate
  */
 export class NetworkProxyBridge {
     constructor(settings) {
@@ -46,8 +54,8 @@ export class NetworkProxyBridge {
             if (this.port80Handler) {
                 this.networkProxy.setExternalPort80Handler(this.port80Handler);
             }
-            // Convert and apply domain configurations to NetworkProxy
-            await this.syncDomainConfigsToNetworkProxy();
+            // Apply route configurations to NetworkProxy
+            await this.syncRoutesToNetworkProxy(this.settings.routes || []);
         }
     }
     /**
@@ -128,25 +136,50 @@ export class NetworkProxyBridge {
         }
     }
     /**
-     * Register domains with Port80Handler
+     * Register domains from routes with Port80Handler for certificate management
+     *
+     * Extracts domains from routes that require TLS termination and registers them
+     * with the Port80Handler for certificate issuance and renewal.
+     *
+     * @param routes The route configurations to extract domains from
      */
-    registerDomainsWithPort80Handler(domains) {
+    registerDomainsWithPort80Handler(routes) {
         if (!this.port80Handler) {
             console.log('Cannot register domains - Port80Handler not initialized');
             return;
         }
-        for (const domain of domains) {
-            // Skip wildcards
-            if (domain.includes('*')) {
-                console.log(`Skipping wildcard domain for ACME: ${domain}`);
+        // Extract domains from routes that require TLS termination
+        const domainsToRegister = new Set();
+        for (const route of routes) {
+            // Skip routes without domains or TLS configuration
+            if (!route.match.domains || !route.action.tls)
                 continue;
+            // Only register domains for routes that terminate TLS
+            if (route.action.tls.mode !== 'terminate' && route.action.tls.mode !== 'terminate-and-reencrypt')
+                continue;
+            // Extract domains from route
+            const domains = Array.isArray(route.match.domains)
+                ? route.match.domains
+                : [route.match.domains];
+            // Add each domain to the set (avoiding duplicates)
+            for (const domain of domains) {
+                // Skip wildcards
+                if (domain.includes('*')) {
+                    console.log(`Skipping wildcard domain for ACME: ${domain}`);
+                    continue;
+                }
+                domainsToRegister.add(domain);
             }
-            // Register the domain
+        }
+        // Register each unique domain with Port80Handler
+        for (const domain of domainsToRegister) {
             try {
                 this.port80Handler.addDomain({
                     domainName: domain,
                     sslRedirect: true,
-                    acmeMaintenance: true
+                    acmeMaintenance: true,
+                    // Include route reference if we can find it
+                    routeReference: this.findRouteReferenceForDomain(domain, routes)
                 });
                 console.log(`Registered domain with Port80Handler: ${domain}`);
             }
@@ -155,6 +188,30 @@ export class NetworkProxyBridge {
             }
         }
     }
+    /**
+     * Finds the route reference for a given domain
+     *
+     * @param domain The domain to find a route reference for
+     * @param routes The routes to search
+     * @returns The route reference if found, undefined otherwise
+     */
+    findRouteReferenceForDomain(domain, routes) {
+        // Find the first route that matches this domain
+        for (const route of routes) {
+            if (!route.match.domains)
+                continue;
+            const domains = Array.isArray(route.match.domains)
+                ? route.match.domains
+                : [route.match.domains];
+            if (domains.includes(domain)) {
+                return {
+                    routeId: undefined, // No explicit IDs in our current routes
+                    routeName: route.name
+                };
+            }
+        }
+        return undefined;
+    }
     /**
      * Forwards a TLS connection to a NetworkProxy for handling
      */
@@ -206,9 +263,19 @@ export class NetworkProxyBridge {
         });
     }
     /**
-     * Synchronizes domain configurations to NetworkProxy
+     * Synchronizes routes to NetworkProxy
+     *
+     * This method directly maps route configurations to NetworkProxy format and updates
+     * the NetworkProxy with these configurations. It handles:
+     *
+     * - Extracting domain, target, and certificate information from routes
+     * - Converting TLS mode settings to NetworkProxy configuration
+     * - Applying security and advanced settings
+     * - Registering domains for ACME certificate provisioning when needed
+     *
+     * @param routes The route configurations to sync to NetworkProxy
      */
-    async syncDomainConfigsToNetworkProxy() {
+    async syncRoutesToNetworkProxy(routes) {
         if (!this.networkProxy) {
             console.log('Cannot sync configurations - NetworkProxy not initialized');
             return;
@@ -217,9 +284,9 @@ export class NetworkProxyBridge {
             // Get SSL certificates from assets
             // Import fs directly since it's not in plugins
             const fs = await import('fs');
-            let certPair;
+            let defaultCertPair;
             try {
-                certPair = {
+                defaultCertPair = {
                     key: fs.readFileSync('assets/certs/key.pem', 'utf8'),
                     cert: fs.readFileSync('assets/certs/cert.pem', 'utf8'),
                 };
@@ -229,42 +296,110 @@ export class NetworkProxyBridge {
                 console.log('Using empty certificate placeholders - ACME will generate proper certificates if enabled');
                 // Use empty placeholders - NetworkProxy will use its internal defaults
                 // or ACME will generate proper ones if enabled
-                certPair = {
+                defaultCertPair = {
                     key: '',
                     cert: '',
                 };
             }
-            // Convert domain configs to NetworkProxy configs
-            const proxyConfigs = this.networkProxy.convertSmartProxyConfigs(this.settings.domainConfigs, certPair);
-            // Log ACME-eligible domains
-            const acmeEnabled = !!this.settings.acme?.enabled;
-            if (acmeEnabled) {
-                const acmeEligibleDomains = proxyConfigs
-                    .filter((config) => !config.hostName.includes('*')) // Exclude wildcards
-                    .map((config) => config.hostName);
-                if (acmeEligibleDomains.length > 0) {
-                    console.log(`Domains eligible for ACME certificates: ${acmeEligibleDomains.join(', ')}`);
-                    // Register these domains with Port80Handler if available
-                    if (this.port80Handler) {
-                        this.registerDomainsWithPort80Handler(acmeEligibleDomains);
-                    }
-                }
-                else {
-                    console.log('No domains eligible for ACME certificates found in configuration');
-                }
-            }
-            // Update NetworkProxy with the converted configs
+            // Map routes directly to NetworkProxy configs
+            const proxyConfigs = this.mapRoutesToNetworkProxyConfigs(routes, defaultCertPair);
+            // Update the proxy configs
             await this.networkProxy.updateProxyConfigs(proxyConfigs);
-            console.log(`Successfully synchronized ${proxyConfigs.length} domain configurations to NetworkProxy`);
+            console.log(`Synced ${proxyConfigs.length} configurations to NetworkProxy`);
+            // Register domains with Port80Handler for certificate issuance
+            if (this.port80Handler) {
+                this.registerDomainsWithPort80Handler(routes);
+            }
         }
         catch (err) {
-            console.log(`Failed to sync configurations: ${err}`);
+            console.log(`Error syncing routes to NetworkProxy: ${err}`);
         }
     }
+    /**
+     * Map routes directly to NetworkProxy configuration format
+     *
+     * This method directly maps route configurations to NetworkProxy's format
+     * without any intermediate domain-based representation. It processes each route
+     * and creates appropriate NetworkProxy configs for domains that require TLS termination.
+     *
+     * @param routes Array of route configurations to map
+     * @param defaultCertPair Default certificate to use if no custom certificate is specified
+     * @returns Array of NetworkProxy configurations
+     */
+    mapRoutesToNetworkProxyConfigs(routes, defaultCertPair) {
+        const configs = [];
+        for (const route of routes) {
+            // Skip routes without domains
+            if (!route.match.domains)
+                continue;
+            // Skip non-forward routes
+            if (route.action.type !== 'forward')
+                continue;
+            // Skip routes without TLS configuration
+            if (!route.action.tls || !route.action.target)
+                continue;
+            // Skip routes that don't require TLS termination
+            if (route.action.tls.mode !== 'terminate' && route.action.tls.mode !== 'terminate-and-reencrypt')
+                continue;
+            // Get domains from route
+            const domains = Array.isArray(route.match.domains)
+                ? route.match.domains
+                : [route.match.domains];
+            // Create a config for each domain
+            for (const domain of domains) {
+                // Get certificate
+                let certKey = defaultCertPair.key;
+                let certCert = defaultCertPair.cert;
+                // Use custom certificate if specified
+                if (route.action.tls.certificate !== 'auto' && typeof route.action.tls.certificate === 'object') {
+                    certKey = route.action.tls.certificate.key;
+                    certCert = route.action.tls.certificate.cert;
+                }
+                // Determine target hosts and ports
+                const targetHosts = Array.isArray(route.action.target.host)
+                    ? route.action.target.host
+                    : [route.action.target.host];
+                const targetPort = route.action.target.port;
+                // Create the NetworkProxy config
+                const config = {
+                    hostName: domain,
+                    privateKey: certKey,
+                    publicKey: certCert,
+                    destinationIps: targetHosts,
+                    destinationPorts: [targetPort]
+                    // Note: We can't include additional metadata as it's not supported in the interface
+                };
+                configs.push(config);
+            }
+        }
+        return configs;
+    }
+    /**
+     * @deprecated This method is kept for backward compatibility.
+     * Use mapRoutesToNetworkProxyConfigs() instead.
+     */
+    convertRoutesToNetworkProxyConfigs(routes, defaultCertPair) {
+        return this.mapRoutesToNetworkProxyConfigs(routes, defaultCertPair);
+    }
+    /**
+     * @deprecated This method is deprecated and will be removed in a future version.
+     * Use syncRoutesToNetworkProxy() instead.
+     *
+     * This legacy method exists only for backward compatibility and
+     * simply forwards to syncRoutesToNetworkProxy().
+     */
+    async syncDomainConfigsToNetworkProxy() {
+        console.log('DEPRECATED: Method syncDomainConfigsToNetworkProxy will be removed in a future version.');
+        console.log('Please use syncRoutesToNetworkProxy() instead for direct route-based configuration.');
+        await this.syncRoutesToNetworkProxy(this.settings.routes || []);
+    }
     /**
      * Request a certificate for a specific domain
+     *
+     * @param domain The domain to request a certificate for
+     * @param routeName Optional route name to associate with this certificate
      */
-    async requestCertificate(domain) {
+    async requestCertificate(domain, routeName) {
         // Delegate to Port80Handler if available
         if (this.port80Handler) {
             try {
@@ -274,12 +409,27 @@ export class NetworkProxyBridge {
                     console.log(`Certificate already exists for ${domain}`);
                     return true;
                 }
-                // Register the domain for certificate issuance
-                this.port80Handler.addDomain({
+                // Build the domain options
+                const domainOptions = {
                     domainName: domain,
                     sslRedirect: true,
-                    acmeMaintenance: true
-                });
+                    acmeMaintenance: true,
+                };
+                // Add route reference if available
+                if (routeName) {
+                    domainOptions.routeReference = {
+                        routeName
+                    };
+                }
+                else {
+                    // Try to find a route reference from the current routes
+                    const routeReference = this.findRouteReferenceForDomain(domain, this.settings.routes || []);
+                    if (routeReference) {
+                        domainOptions.routeReference = routeReference;
+                    }
+                }
+                // Register the domain for certificate issuance
+                this.port80Handler.addDomain(domainOptions);
                 console.log(`Domain ${domain} registered for certificate issuance`);
                 return true;
             }
@@ -313,4 +463,4 @@ export class NetworkProxyBridge {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"network-proxy-bridge.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/network-proxy-bridge.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"network-proxy-bridge.js","sourceRoot":"","sources":["../../../ts/proxies/smart-proxy/network-proxy-bridge.ts"],"names":[],"mappings":"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"}