@push.rocks/smartproxy 18.1.0 → 19.0.0

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

@@ -0,0 +1,168 @@
+import * as plugins from '../../plugins.js';
+import { RouteManager } from './route-manager.js';
+import type { ISmartProxyOptions } from './models/interfaces.js';
+import type { IRouteConfig } from './models/route-types.js';
+/**
+ * SmartProxy - Pure route-based 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.)
+ */
+export declare class SmartProxy extends plugins.EventEmitter {
+    private portManager;
+    private connectionLogger;
+    private isShuttingDown;
+    private connectionManager;
+    private securityManager;
+    private tlsManager;
+    private networkProxyBridge;
+    private timeoutManager;
+    routeManager: RouteManager;
+    private routeConnectionHandler;
+    private nftablesManager;
+    private port80Handler;
+    private certProvisioner?;
+    /**
+     * 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: ['*'] }
+     *   }
+     * });
+     * ```
+     */
+    constructor(settingsArg: ISmartProxyOptions);
+    /**
+     * The settings for the SmartProxy
+     */
+    settings: ISmartProxyOptions;
+    /**
+     * Initialize the Port80Handler for ACME certificate management
+     */
+    private initializePort80Handler;
+    /**
+     * Start the proxy server with support for both configuration types
+     */
+    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(): Promise<void>;
+    /**
+     * Updates the domain configurations for the proxy
+     *
+     * Note: This legacy method has been removed. Use updateRoutes instead.
+     */
+    updateDomainConfigs(): Promise<void>;
+    /**
+     * 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' }
+     *     }
+     *   }
+     * ]);
+     * ```
+     */
+    updateRoutes(newRoutes: 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 the certificate
+     */
+    requestCertificate(domain: string, routeName?: string): Promise<boolean>;
+    /**
+     * Validates if a domain name is valid for certificate issuance
+     */
+    private isValidDomain;
+    /**
+     * 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
+     */
+    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
+     */
+    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
+     */
+    getStatistics(): any;
+    /**
+     * Get a list of eligible domains for ACME certificates
+     */
+    getEligibleDomainsForCertificates(): string[];
+    /**
+     * Get NFTables status
+     */
+    getNfTablesStatus(): Promise<Record<string, any>>;
+    /**
+     * Get status of certificates managed by Port80Handler
+     */
+    getCertificateStatus(): any;
+}