@push.rocks/smartproxy 18.0.2 → 18.2.0

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

@@ -0,0 +1,41 @@
+/**
+ * Simplified SmartProxy with mandatory certificate provider
+ */
+import * as plugins from '../../plugins.js';
+import type { SimplifiedSmartProxyOptions } from './models/simplified-smartproxy-config.js';
+import type { IRouteConfig } from './models/route-types.js';
+/**
+ * Simplified SmartProxy implementation
+ */
+export declare class SimplifiedSmartProxy extends plugins.EventEmitter {
+    private options;
+    private networkProxy;
+    private certificateManager?;
+    private port80Handler?;
+    private logger;
+    constructor(options: SimplifiedSmartProxyOptions);
+    /**
+     * Start the proxy
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the proxy
+     */
+    stop(): Promise<void>;
+    /**
+     * Initialize certificate management
+     */
+    private initializeCertificateManagement;
+    /**
+     * Update route configurations dynamically
+     */
+    updateRoutes(routes: IRouteConfig[]): Promise<void>;
+    /**
+     * Get listening port
+     */
+    getPort(): number;
+}
+/**
+ * Factory function for creating SimplifiedSmartProxy
+ */
+export declare function createSimplifiedSmartProxy(options: SimplifiedSmartProxyOptions): SimplifiedSmartProxy;

package/dist_ts/proxies/smart-proxy/simplified-smart-proxy.js

@@ -0,0 +1,132 @@
+/**
+ * Simplified SmartProxy with mandatory certificate provider
+ */
+import * as plugins from '../../plugins.js';
+import { NetworkProxy } from '../network-proxy/network-proxy.js';
+import { SimplifiedCertificateManager } from '../../certificate/simplified-certificate-manager.js';
+import { validateSmartProxyConfig } from './models/simplified-smartproxy-config.js';
+import { Port80Handler } from '../../http/port80/port80-handler.js';
+import { CertificateEvent } from '../../certificate/events/simplified-events.js';
+/**
+ * Simplified SmartProxy implementation
+ */
+export class SimplifiedSmartProxy extends plugins.EventEmitter {
+    constructor(options) {
+        super();
+        // Validate configuration
+        validateSmartProxyConfig(options);
+        this.options = options;
+        // Simple console logger
+        this.logger = {
+            info: (...args) => console.log('[INFO]', ...args),
+            warn: (...args) => console.warn('[WARN]', ...args),
+            error: (...args) => console.error('[ERROR]', ...args)
+        };
+        // Create NetworkProxy
+        this.networkProxy = new NetworkProxy({
+            port: options.port || 443,
+            logLevel: options.logLevel
+        });
+    }
+    /**
+     * Start the proxy
+     */
+    async start() {
+        this.logger.info('Starting SimplifiedSmartProxy...');
+        // Initialize certificate management if ACME is enabled
+        if (this.options.acme?.enabled !== false) {
+            await this.initializeCertificateManagement();
+        }
+        // Configure routes
+        await this.networkProxy.updateRouteConfigs(this.options.routes);
+        // Start NetworkProxy
+        await this.networkProxy.start();
+        this.logger.info(`SimplifiedSmartProxy started on port ${this.options.port || 443}`);
+    }
+    /**
+     * Stop the proxy
+     */
+    async stop() {
+        this.logger.info('Stopping SimplifiedSmartProxy...');
+        // Stop certificate manager
+        if (this.certificateManager) {
+            await this.certificateManager.stop();
+        }
+        // Stop Port80Handler  
+        if (this.port80Handler) {
+            await this.port80Handler.stop();
+        }
+        // Stop NetworkProxy
+        await this.networkProxy.stop();
+        this.logger.info('SimplifiedSmartProxy stopped');
+    }
+    /**
+     * Initialize certificate management
+     */
+    async initializeCertificateManagement() {
+        const acmeConfig = this.options.acme;
+        // Create certificate manager
+        this.certificateManager = new SimplifiedCertificateManager({
+            certProvider: acmeConfig.certProvider,
+            acmeEmail: acmeConfig.email,
+            acmeServer: acmeConfig.server,
+            storageDir: acmeConfig.storageDir,
+            renewBeforeDays: acmeConfig.renewBeforeDays
+        });
+        // Set up event forwarding
+        this.certificateManager.on(CertificateEvent.OBTAINED, (event) => {
+            this.logger.info(`Certificate ${event.type} for ${event.domain}`);
+            this.emit('certificate:obtained', event);
+        });
+        this.certificateManager.on(CertificateEvent.FAILED, (event) => {
+            this.logger.error(`Certificate failed for ${event.domain}: ${event.error.message}`);
+            this.emit('certificate:failed', event);
+        });
+        this.certificateManager.on(CertificateEvent.EXPIRING, (event) => {
+            this.logger.warn(`Certificate expiring in ${event.daysRemaining} days for ${event.domain}`);
+            this.emit('certificate:expiring', event);
+        });
+        // Create Port80Handler for HTTP-01 challenges
+        this.port80Handler = new Port80Handler({
+            port: 80,
+            enabled: true,
+            accountEmail: acmeConfig.email,
+            useProduction: acmeConfig.server === 'production',
+            certificateStore: acmeConfig.storageDir
+        });
+        // Connect certificate manager to Port80Handler
+        this.certificateManager.port80Handler = this.port80Handler;
+        // Start certificate manager
+        await this.certificateManager.start();
+        // Start Port80Handler
+        await this.port80Handler.start();
+        // Connect NetworkProxy to certificate manager
+        this.networkProxy.setExternalCertificateManager(this.certificateManager);
+        this.logger.info('Certificate management initialized');
+    }
+    /**
+     * Update route configurations dynamically
+     */
+    async updateRoutes(routes) {
+        this.options.routes = routes;
+        await this.networkProxy.updateRouteConfigs(routes);
+        // Update certificate manager if active
+        if (this.certificateManager) {
+            // Certificate manager will handle route-based certificates
+            await this.certificateManager.updateRoutes?.(routes);
+        }
+    }
+    /**
+     * Get listening port
+     */
+    getPort() {
+        return this.networkProxy.getListeningPort();
+    }
+}
+/**
+ * Factory function for creating SimplifiedSmartProxy
+ */
+export function createSimplifiedSmartProxy(options) {
+    return new SimplifiedSmartProxy(options);
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,5 +1,6 @@
 import * as plugins from '../../plugins.js';
 import { RouteManager } from './route-manager.js';
+import { type ICertStatus } from './certificate-manager.js';
 import type { ISmartProxyOptions } from './models/interfaces.js';
 import type { IRouteConfig } from './models/route-types.js';
 /**
@@ -27,8 +28,7 @@ export declare class SmartProxy extends plugins.EventEmitter {
     routeManager: RouteManager;
     private routeConnectionHandler;
     private nftablesManager;
-    private port80Handler;
-    private certProvisioner?;
+    private certManager;
     /**
      * Constructor for SmartProxy
      *
@@ -66,9 +66,13 @@ export declare class SmartProxy extends plugins.EventEmitter {
      */
     settings: ISmartProxyOptions;
     /**
-     * Initialize the Port80Handler for ACME certificate management
+     * Initialize certificate manager
      */
-    private initializePort80Handler;
+    private initializeCertificateManager;
+    /**
+     * Check if we have routes with static certificates
+     */
+    private hasStaticCertRoutes;
     /**
      * Start the proxy server with support for both configuration types
      */
@@ -113,12 +117,17 @@ export declare class SmartProxy extends plugins.EventEmitter {
      */
     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
+     * Manually provision a certificate for a route
+     */
+    provisionCertificate(routeName: string): Promise<void>;
+    /**
+     * Force renewal of a certificate
      */
-    requestCertificate(domain: string, routeName?: string): Promise<boolean>;
+    renewCertificate(routeName: string): Promise<void>;
+    /**
+     * Get certificate status for a route
+     */
+    getCertificateStatus(routeName: string): ICertStatus | undefined;
     /**
      * Validates if a domain name is valid for certificate issuance
      */
@@ -161,8 +170,4 @@ export declare class SmartProxy extends plugins.EventEmitter {
      * Get NFTables status
      */
     getNfTablesStatus(): Promise<Record<string, any>>;
-    /**
-     * Get status of certificates managed by Port80Handler
-     */
-    getCertificateStatus(): any;
 }