@push.rocks/smartproxy 15.0.2 → 16.0.3

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,13 +23,34 @@ export interface IRouteMatch {
     path?: string;
     clientIp?: string[];
     tlsVersion?: string[];
+    headers?: Record<string, string | RegExp>;
+}
+/**
+ * Context provided to port and host mapping functions
+ */
+export interface IRouteContext {
+    port: number;
+    domain?: string;
+    clientIp: string;
+    serverIp: string;
+    path?: string;
+    query?: string;
+    headers?: Record<string, string>;
+    isTls: boolean;
+    tlsVersion?: string;
+    routeName?: string;
+    routeId?: string;
+    targetHost?: string | string[];
+    targetPort?: number;
+    timestamp: number;
+    connectionId: string;
 }
 /**
  * Target configuration for forwarding
  */
 export interface IRouteTarget {
-    host: string | string[];
-    port: number;
+    host: string | string[] | ((context: IRouteContext) => string | string[]);
+    port: number | ((context: IRouteContext) => number);
     preservePort?: boolean;
 }
 /**
@@ -49,6 +70,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;
+    options?: Record<string, unknown>;
+}
 /**
  * Security options for route actions
  */
@@ -56,9 +95,38 @@ 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;
+}
+/**
+ * URL rewriting configuration
+ */
+export interface IRouteUrlRewrite {
+    pattern: string;
+    target: string;
+    flags?: string;
+    onlyRewritePath?: boolean;
 }
 /**
  * Advanced options for route actions
@@ -67,6 +135,36 @@ export interface IRouteAdvanced {
     timeout?: number;
     headers?: Record<string, string>;
     keepAlive?: boolean;
+    staticFiles?: IRouteStaticFiles;
+    testResponse?: IRouteTestResponse;
+    urlRewrite?: IRouteUrlRewrite;
+}
+/**
+ * WebSocket configuration
+ */
+export interface IRouteWebSocket {
+    enabled: boolean;
+    pingInterval?: number;
+    pingTimeout?: number;
+    maxPayloadSize?: number;
+    customHeaders?: Record<string, string>;
+    subprotocols?: string[];
+    rewritePath?: string;
+    allowedOrigins?: string[];
+    authenticateRequest?: boolean;
+}
+/**
+ * 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 +174,88 @@ export interface IRouteAction {
     target?: IRouteTarget;
     tls?: IRouteTls;
     redirect?: IRouteRedirect;
+    static?: IRouteStaticFiles;
+    websocket?: IRouteWebSocket;
+    loadBalancing?: IRouteLoadBalancing;
     security?: IRouteSecurity;
     advanced?: IRouteAdvanced;
+    options?: {
+        backendProtocol?: 'http1' | 'http2';
+        [key: string]: any;
+    };
+}
+/**
+ * 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[];
+}
+/**
+ * CORS configuration for a route
+ */
+export interface IRouteCors {
+    enabled: boolean;
+    allowOrigin?: string | string[];
+    allowMethods?: string;
+    allowHeaders?: string;
+    allowCredentials?: boolean;
+    exposeHeaders?: string;
+    maxAge?: number;
+    preflight?: boolean;
+}
+/**
+ * Headers configuration
+ */
+export interface IRouteHeaders {
+    request?: Record<string, string>;
+    response?: Record<string, string>;
+    cors?: IRouteCors;
 }
 /**
  * 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 passes route configurations to NetworkProxy and manages the physical
+ * connection piping between SmartProxy and NetworkProxy for TLS termination.
+ *
+ * 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;
@@ -43,20 +52,24 @@ export declare class NetworkProxyBridge {
      * Stop NetworkProxy
      */
     stop(): Promise<void>;
-    /**
-     * Register domains with Port80Handler
-     */
-    registerDomainsWithPort80Handler(domains: string[]): void;
     /**
      * 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 passes route configurations to NetworkProxy without any
+     * intermediate conversion. NetworkProxy natively understands route configurations.
+     *
+     * @param routes The route configurations to sync to NetworkProxy
      */
-    syncDomainConfigsToNetworkProxy(): Promise<void>;
+    syncRoutesToNetworkProxy(routes: IRouteConfig[]): 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

@@ -1,10 +1,17 @@
 import * as plugins from '../../plugins.js';
 import { NetworkProxy } from '../network-proxy/index.js';
 import { Port80Handler } from '../../http/port80/port80-handler.js';
-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 passes route configurations to NetworkProxy and manages the physical
+ * connection piping between SmartProxy and NetworkProxy for TLS termination.
+ *
+ * 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) {
@@ -33,7 +40,7 @@ export class NetworkProxyBridge {
      */
     async initialize() {
         if (!this.networkProxy && this.settings.useNetworkProxy && this.settings.useNetworkProxy.length > 0) {
-            // Configure NetworkProxy options based on PortProxy settings
+            // Configure NetworkProxy options based on SmartProxy settings
             const networkProxyOptions = {
                 port: this.settings.networkProxyPort,
                 portProxyIntegration: true,
@@ -46,8 +53,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 || []);
         }
     }
     /**
@@ -57,29 +64,8 @@ export class NetworkProxyBridge {
         if (!this.networkProxy)
             return;
         console.log(`Received certificate for ${data.domain} from Port80Handler, updating NetworkProxy`);
-        try {
-            // Find existing config for this domain
-            const existingConfigs = this.networkProxy.getProxyConfigs()
-                .filter(config => config.hostName === data.domain);
-            if (existingConfigs.length > 0) {
-                // Update existing configs with new certificate
-                for (const config of existingConfigs) {
-                    config.privateKey = data.privateKey;
-                    config.publicKey = data.certificate;
-                }
-                // Apply updated configs
-                this.networkProxy.updateProxyConfigs(existingConfigs)
-                    .then(() => console.log(`Updated certificate for ${data.domain} in NetworkProxy`))
-                    .catch(err => console.log(`Error updating certificate in NetworkProxy: ${err}`));
-            }
-            else {
-                // Create a new config for this domain
-                console.log(`No existing config found for ${data.domain}, creating new config in NetworkProxy`);
-            }
-        }
-        catch (err) {
-            console.log(`Error handling certificate event: ${err}`);
-        }
+        // Apply certificate directly to NetworkProxy
+        this.networkProxy.updateCertificate(data.domain, data.certificate, data.privateKey);
     }
     /**
      * Apply an external (static) certificate into NetworkProxy
@@ -89,7 +75,8 @@ export class NetworkProxyBridge {
             console.log(`NetworkProxy not initialized: cannot apply external certificate for ${data.domain}`);
             return;
         }
-        this.handleCertificateEvent(data);
+        // Apply certificate directly to NetworkProxy
+        this.networkProxy.updateCertificate(data.domain, data.certificate, data.privateKey);
     }
     /**
      * Get the NetworkProxy instance
@@ -127,34 +114,6 @@ export class NetworkProxyBridge {
             }
         }
     }
-    /**
-     * Register domains with Port80Handler
-     */
-    registerDomainsWithPort80Handler(domains) {
-        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}`);
-                continue;
-            }
-            // Register the domain
-            try {
-                this.port80Handler.addDomain({
-                    domainName: domain,
-                    sslRedirect: true,
-                    acmeMaintenance: true
-                });
-                console.log(`Registered domain with Port80Handler: ${domain}`);
-            }
-            catch (err) {
-                console.log(`Error registering domain ${domain} with Port80Handler: ${err}`);
-            }
-        }
-    }
     /**
      * Forwards a TLS connection to a NetworkProxy for handling
      */
@@ -199,72 +158,46 @@ export class NetworkProxyBridge {
             // Now set up bidirectional piping between client and NetworkProxy
             socket.pipe(proxySocket);
             proxySocket.pipe(socket);
-            // Update activity on data transfer (caller should handle this)
             if (this.settings.enableDetailedLogging) {
                 console.log(`[${connectionId}] TLS connection successfully forwarded to NetworkProxy`);
             }
         });
     }
     /**
-     * Synchronizes domain configurations to NetworkProxy
+     * Synchronizes routes to NetworkProxy
+     *
+     * This method directly passes route configurations to NetworkProxy without any
+     * intermediate conversion. NetworkProxy natively understands route configurations.
+     *
+     * @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;
         }
         try {
-            // Get SSL certificates from assets
-            // Import fs directly since it's not in plugins
-            const fs = await import('fs');
-            let certPair;
-            try {
-                certPair = {
-                    key: fs.readFileSync('assets/certs/key.pem', 'utf8'),
-                    cert: fs.readFileSync('assets/certs/cert.pem', 'utf8'),
-                };
-            }
-            catch (certError) {
-                console.log(`Warning: Could not read default certificates: ${certError}`);
-                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 = {
-                    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
-            await this.networkProxy.updateProxyConfigs(proxyConfigs);
-            console.log(`Successfully synchronized ${proxyConfigs.length} domain configurations to NetworkProxy`);
+            // Filter only routes that are applicable to NetworkProxy (TLS termination)
+            const networkProxyRoutes = routes.filter(route => {
+                return (route.action.type === 'forward' &&
+                    route.action.tls &&
+                    (route.action.tls.mode === 'terminate' || route.action.tls.mode === 'terminate-and-reencrypt'));
+            });
+            // Pass routes directly to NetworkProxy
+            await this.networkProxy.updateRouteConfigs(networkProxyRoutes);
+            console.log(`Synced ${networkProxyRoutes.length} routes directly to NetworkProxy`);
         }
         catch (err) {
-            console.log(`Failed to sync configurations: ${err}`);
+            console.log(`Error syncing routes to NetworkProxy: ${err}`);
         }
     }
     /**
      * 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 +207,20 @@ 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
+                    };
+                }
+                // Register the domain for certificate issuance
+                this.port80Handler.addDomain(domainOptions);
                 console.log(`Domain ${domain} registered for certificate issuance`);
                 return true;
             }
@@ -313,4 +254,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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"}

package/dist_ts/proxies/smart-proxy/port-manager.d.ts

@@ -0,0 +1,81 @@
+import * as plugins from '../../plugins.js';
+import type { ISmartProxyOptions } from './models/interfaces.js';
+import { RouteConnectionHandler } from './route-connection-handler.js';
+/**
+ * PortManager handles the dynamic creation and removal of port listeners
+ *
+ * This class provides methods to add and remove listening ports at runtime,
+ * allowing SmartProxy to adapt to configuration changes without requiring
+ * a full restart.
+ */
+export declare class PortManager {
+    private servers;
+    private settings;
+    private routeConnectionHandler;
+    private isShuttingDown;
+    /**
+     * Create a new PortManager
+     *
+     * @param settings The SmartProxy settings
+     * @param routeConnectionHandler The handler for new connections
+     */
+    constructor(settings: ISmartProxyOptions, routeConnectionHandler: RouteConnectionHandler);
+    /**
+     * Start listening on a specific port
+     *
+     * @param port The port number to listen on
+     * @returns Promise that resolves when the server is listening or rejects on error
+     */
+    addPort(port: number): Promise<void>;
+    /**
+     * Stop listening on a specific port
+     *
+     * @param port The port to stop listening on
+     * @returns Promise that resolves when the server is closed
+     */
+    removePort(port: number): Promise<void>;
+    /**
+     * Add multiple ports at once
+     *
+     * @param ports Array of ports to add
+     * @returns Promise that resolves when all servers are listening
+     */
+    addPorts(ports: number[]): Promise<void>;
+    /**
+     * Remove multiple ports at once
+     *
+     * @param ports Array of ports to remove
+     * @returns Promise that resolves when all servers are closed
+     */
+    removePorts(ports: number[]): Promise<void>;
+    /**
+     * Update listening ports to match the provided list
+     *
+     * This will add any ports that aren't currently listening,
+     * and remove any ports that are no longer needed.
+     *
+     * @param ports Array of ports that should be listening
+     * @returns Promise that resolves when all operations are complete
+     */
+    updatePorts(ports: number[]): Promise<void>;
+    /**
+     * Get all ports that are currently listening
+     *
+     * @returns Array of port numbers
+     */
+    getListeningPorts(): number[];
+    /**
+     * Mark the port manager as shutting down
+     */
+    setShuttingDown(isShuttingDown: boolean): void;
+    /**
+     * Close all listening servers
+     *
+     * @returns Promise that resolves when all servers are closed
+     */
+    closeAll(): Promise<void>;
+    /**
+     * Get all server instances (for testing or debugging)
+     */
+    getServers(): Map<number, plugins.net.Server>;
+}