@push.rocks/smartproxy 22.4.2 → 23.0.0

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

@@ -1,208 +1,90 @@
 import * as plugins from '../../plugins.js';
-import { ConnectionManager } from './connection-manager.js';
-import { SecurityManager } from './security-manager.js';
-import { TlsManager } from './tls-manager.js';
-import { HttpProxyBridge } from './http-proxy-bridge.js';
-import { TimeoutManager } from './timeout-manager.js';
 import { SharedRouteManager as RouteManager } from '../../core/routing/route-manager.js';
-import { RouteConnectionHandler } from './route-connection-handler.js';
-import { NFTablesManager } from './nftables-manager.js';
-import { SmartCertManager, type ICertStatus } from './certificate-manager.js';
 import type { ISmartProxyOptions } from './models/interfaces.js';
 import type { IRouteConfig } from './models/route-types.js';
-import { AcmeStateManager } from './acme-state-manager.js';
-import { MetricsCollector } from './metrics-collector.js';
 import type { IMetrics } from './models/metrics-types.js';
 /**
- * SmartProxy - Pure route-based API
+ * SmartProxy - Rust-backed proxy engine with TypeScript configuration API.
  *
- * SmartProxy is a unified proxy system that works with routes to define connection handling behavior.
- * Each route contains matching criteria (ports, domains, etc.) and an action to take (forward, redirect, block).
- *
- * Configuration is provided through a set of routes, with each route defining:
- * - What to match (ports, domains, paths, client IPs)
- * - What to do with matching traffic (forward, redirect, block)
- * - How to handle TLS (passthrough, terminate, terminate-and-reencrypt)
- * - Security settings (IP restrictions, connection limits)
- * - Advanced options (timeout, headers, etc.)
+ * All networking (TCP, TLS, HTTP reverse proxy, connection management, security,
+ * NFTables) is handled by the Rust binary. TypeScript is only:
+ * - The npm module interface (types, route helpers)
+ * - The thin IPC wrapper (this class)
+ * - Socket-handler callback relay (for JS-defined handlers)
+ * - Certificate provisioning callbacks (certProvisionFunction)
  */
 export declare class SmartProxy extends plugins.EventEmitter {
-    private portManager;
-    private connectionLogger;
-    private isShuttingDown;
-    connectionManager: ConnectionManager;
-    securityManager: SecurityManager;
-    tlsManager: TlsManager;
-    httpProxyBridge: HttpProxyBridge;
-    timeoutManager: TimeoutManager;
+    settings: ISmartProxyOptions;
     routeManager: RouteManager;
-    routeConnectionHandler: RouteConnectionHandler;
-    nftablesManager: NFTablesManager;
-    certManager: SmartCertManager | null;
-    private globalChallengeRouteActive;
+    private bridge;
+    private preprocessor;
+    private socketHandlerServer;
+    private metricsAdapter;
     private routeUpdateLock;
-    acmeStateManager: AcmeStateManager;
-    metricsCollector: MetricsCollector;
-    private routeOrchestrator;
-    private portUsageMap;
-    /**
-     * Constructor for SmartProxy
-     *
-     * @param settingsArg Configuration options containing routes and other settings
-     * Routes define how traffic is matched and handled, with each route having:
-     * - match: criteria for matching traffic (ports, domains, paths, IPs)
-     * - action: what to do with matched traffic (forward, redirect, block)
-     *
-     * Example:
-     * ```ts
-     * const proxy = new SmartProxy({
-     *   routes: [
-     *     {
-     *       match: {
-     *         ports: 443,
-     *         domains: ['example.com', '*.example.com']
-     *       },
-     *       action: {
-     *         type: 'forward',
-     *         target: { host: '10.0.0.1', port: 8443 },
-     *         tls: { mode: 'passthrough' }
-     *       }
-     *     }
-     *   ],
-     *   defaults: {
-     *     target: { host: 'localhost', port: 8080 },
-     *     security: { ipAllowList: ['*'] }
-     *   }
-     * });
-     * ```
-     */
+    private stopping;
     constructor(settingsArg: ISmartProxyOptions);
     /**
-     * The settings for the SmartProxy
-     */
-    settings: ISmartProxyOptions;
-    /**
-     * Helper method to create and configure certificate manager
-     * This ensures consistent setup including the required ACME callback
-     */
-    private createCertificateManager;
-    /**
-     * Initialize certificate manager
-     */
-    private initializeCertificateManager;
-    /**
-     * Check if we have routes with static certificates
-     */
-    private hasStaticCertRoutes;
-    /**
-     * Start the proxy server with support for both configuration types
+     * Start the proxy.
+     * Spawns the Rust binary, configures socket relay if needed, sends routes, handles cert provisioning.
      */
     start(): Promise<void>;
     /**
-     * Extract domain configurations from routes for certificate provisioning
-     *
-     * Note: This method has been removed as we now work directly with routes
-     */
-    /**
-     * Stop the proxy server
+     * Stop the proxy.
      */
     stop(): Promise<void>;
     /**
-     * Updates the domain configurations for the proxy
-     *
-     * Note: This legacy method has been removed. Use updateRoutes instead.
-     */
-    updateDomainConfigs(): Promise<void>;
-    /**
-     * Verify the challenge route has been properly removed from routes
-     */
-    private verifyChallengeRouteRemoved;
-    /**
-     * Update routes with new configuration
-     *
-     * This method replaces the current route configuration with the provided routes.
-     * It also provisions certificates for routes that require TLS termination and have
-     * `certificate: 'auto'` set in their TLS configuration.
-     *
-     * @param newRoutes Array of route configurations to use
-     *
-     * Example:
-     * ```ts
-     * proxy.updateRoutes([
-     *   {
-     *     match: { ports: 443, domains: 'secure.example.com' },
-     *     action: {
-     *       type: 'forward',
-     *       target: { host: '10.0.0.1', port: 8443 },
-     *       tls: { mode: 'terminate', certificate: 'auto' }
-     *     }
-     *   }
-     * ]);
-     * ```
+     * Update routes atomically.
      */
     updateRoutes(newRoutes: IRouteConfig[]): Promise<void>;
     /**
-     * Manually provision a certificate for a route
+     * Provision a certificate for a named route.
      */
     provisionCertificate(routeName: string): Promise<void>;
     /**
-     * Force renewal of a certificate
+     * Force renewal of a certificate.
      */
     renewCertificate(routeName: string): Promise<void>;
     /**
-     * Get certificate status for a route
+     * Get certificate status for a route (async - calls Rust).
      */
-    getCertificateStatus(routeName: string): ICertStatus | undefined;
+    getCertificateStatus(routeName: string): Promise<any>;
     /**
-     * Get proxy metrics with clean API
-     *
-     * @returns IMetrics interface with grouped metrics methods
+     * Get the metrics interface.
      */
     getMetrics(): IMetrics;
     /**
-     * Validates if a domain name is valid for certificate issuance
+     * Get statistics (async - calls Rust).
      */
-    private isValidDomain;
+    getStatistics(): Promise<any>;
     /**
-     * Add a new listening port without changing the route configuration
-     *
-     * This allows you to add a port listener without updating routes.
-     * Useful for preparing to listen on a port before adding routes for it.
-     *
-     * @param port The port to start listening on
-     * @returns Promise that resolves when the port is listening
+     * Add a listening port at runtime.
      */
     addListeningPort(port: number): Promise<void>;
     /**
-     * Stop listening on a specific port without changing the route configuration
-     *
-     * This allows you to stop a port listener without updating routes.
-     * Useful for temporary maintenance or port changes.
-     *
-     * @param port The port to stop listening on
-     * @returns Promise that resolves when the port is closed
+     * Remove a listening port at runtime.
      */
     removeListeningPort(port: number): Promise<void>;
     /**
-     * Get a list of all ports currently being listened on
-     *
-     * @returns Array of port numbers
-     */
-    getListeningPorts(): number[];
-    /**
-     * Get statistics about current connections
+     * Get all currently listening ports (async - calls Rust).
      */
-    getStatistics(): any;
+    getListeningPorts(): Promise<number[]>;
     /**
-     * Get a list of eligible domains for ACME certificates
+     * Get eligible domains for ACME certificates (sync - reads local routes).
      */
     getEligibleDomainsForCertificates(): string[];
     /**
-     * Get NFTables status
+     * Get NFTables status (async - calls Rust).
      */
     getNfTablesStatus(): Promise<Record<string, any>>;
     /**
-     * Validate ACME configuration
+     * Build the Rust configuration object from TS settings.
      */
-    private validateAcmeConfiguration;
+    private buildRustConfig;
+    /**
+     * For routes with certificate: 'auto', call certProvisionFunction if set.
+     * If the callback returns a cert object, load it into Rust.
+     * If it returns 'http01', let Rust handle ACME.
+     */
+    private provisionCertificatesViaCallback;
+    private isValidDomain;
 }