@push.rocks/smartproxy 18.2.0 → 19.0.0

package/ts/proxies/network-proxy/models/types.ts

@@ -1,5 +1,17 @@
 import * as plugins from '../../../plugins.js';
-import type { IAcmeOptions } from '../../../certificate/models/certificate-types.js';
+// Certificate types removed - define IAcmeOptions locally
+export interface IAcmeOptions {
+  enabled: boolean;
+  email?: string;
+  accountEmail?: string;
+  port?: number;
+  certificateStore?: string;
+  environment?: 'production' | 'staging';
+  useProduction?: boolean;
+  renewThresholdDays?: number;
+  autoRenew?: boolean;
+  skipConfiguredCerts?: boolean;
+}
 import type { IRouteConfig } from '../../smart-proxy/models/route-types.js';
 import type { IRouteContext } from '../../../core/models/route-context.js';
 
@@ -22,7 +34,7 @@ export interface INetworkProxyOptions {
   // Settings for SmartProxy integration
   connectionPoolSize?: number; // Maximum connections to maintain in the pool to each backend
   portProxyIntegration?: boolean; // Flag to indicate this proxy is used by SmartProxy
-  useExternalPort80Handler?: boolean; // Flag to indicate using external Port80Handler
+  useExternalPort80Handler?: boolean; // @deprecated - use SmartCertManager instead
   // Protocol to use when proxying to backends: HTTP/1.x or HTTP/2
   backendProtocol?: 'http1' | 'http2';
 

package/ts/proxies/network-proxy/network-proxy.ts

@@ -18,7 +18,6 @@ import { RequestHandler, type IMetricsTracker } from './request-handler.js';
 import { WebSocketHandler } from './websocket-handler.js';
 import { ProxyRouter } from '../../http/router/index.js';
 import { RouteRouter } from '../../http/router/route-router.js';
-import { Port80Handler } from '../../http/port80/port80-handler.js';
 import { FunctionCache } from './function-cache.js';
 
 /**
@@ -221,15 +220,10 @@ export class NetworkProxy implements IMetricsTracker {
   }
 
   /**
-   * Sets an external Port80Handler for certificate management
-   * This allows the NetworkProxy to use a centrally managed Port80Handler
-   * instead of creating its own
-   * 
-   * @param handler The Port80Handler instance to use
+   * @deprecated Use SmartCertManager instead
    */
-  public setExternalPort80Handler(handler: Port80Handler): void {
-    // Connect it to the certificate manager
-    this.certificateManager.setExternalPort80Handler(handler);
+  public setExternalPort80Handler(handler: any): void {
+    this.logger.warn('Port80Handler is deprecated - use SmartCertManager instead');
   }
 
   /**
@@ -238,10 +232,7 @@ export class NetworkProxy implements IMetricsTracker {
   public async start(): Promise<void> {
     this.startTime = Date.now();
     
-    // Initialize Port80Handler if enabled and not using external handler
-    if (this.options.acme?.enabled && !this.options.useExternalPort80Handler) {
-      await this.certificateManager.initializePort80Handler();
-    }
+    // Certificate management is now handled by SmartCertManager
     
     // Create HTTP/2 server with HTTP/1 fallback
     this.httpsServer = plugins.http2.createSecureServer(
@@ -385,7 +376,7 @@ export class NetworkProxy implements IMetricsTracker {
 
     // Directly update the certificate manager with the new routes
     // This will extract domains and handle certificate provisioning
-    this.certificateManager.updateRouteConfigs(routes);
+    this.certificateManager.updateRoutes(routes);
 
     // Collect all domains and certificates for configuration
     const currentHostnames = new Set<string>();
@@ -425,7 +416,7 @@ export class NetworkProxy implements IMetricsTracker {
     // Update certificate cache with any static certificates
     for (const [domain, certData] of certificateUpdates.entries()) {
       try {
-        this.certificateManager.updateCertificateCache(
+        this.certificateManager.updateCertificate(
           domain,
           certData.cert,
           certData.key
@@ -547,8 +538,7 @@ export class NetworkProxy implements IMetricsTracker {
     // Close all connection pool connections
     this.connectionPool.closeAllConnections();
     
-    // Stop Port80Handler if internally managed
-    await this.certificateManager.stopPort80Handler();
+    // Certificate management cleanup is handled by SmartCertManager
     
     // Close the HTTPS server
     return new Promise((resolve) => {
@@ -566,7 +556,8 @@ export class NetworkProxy implements IMetricsTracker {
    * @returns A promise that resolves when the request is submitted (not when the certificate is issued)
    */
   public async requestCertificate(domain: string): Promise<boolean> {
-    return this.certificateManager.requestCertificate(domain);
+    this.logger.warn('requestCertificate is deprecated - use SmartCertManager instead');
+    return false;
   }
   
   /**
@@ -587,7 +578,7 @@ export class NetworkProxy implements IMetricsTracker {
     expiryDate?: Date
   ): void {
     this.logger.info(`Updating certificate for ${domain}`);
-    this.certificateManager.updateCertificateCache(domain, certificate, privateKey, expiryDate);
+    this.certificateManager.updateCertificate(domain, certificate, privateKey);
   }
 
   /**

package/ts/proxies/smart-proxy/models/index.ts

@@ -1,5 +1,6 @@
 /**
  * SmartProxy models
  */
-export * from './interfaces.js';
+// Export everything except IAcmeOptions from interfaces
+export type { ISmartProxyOptions, IConnectionRecord, TSmartProxyCertProvisionObject } from './interfaces.js';
 export * from './route-types.js';

package/ts/proxies/smart-proxy/models/interfaces.ts

@@ -1,5 +1,18 @@
 import * as plugins from '../../../plugins.js';
-import type { IAcmeOptions } from '../../../certificate/models/certificate-types.js';
+// Certificate types removed - define IAcmeOptions locally
+export interface IAcmeOptions {
+  enabled?: boolean;
+  email?: string;
+  environment?: 'production' | 'staging';
+  port?: number;
+  useProduction?: boolean;
+  renewThresholdDays?: number;
+  autoRenew?: boolean;
+  certificateStore?: string;
+  skipConfiguredCerts?: boolean;
+  renewCheckIntervalHours?: number;
+  routeForwards?: any[];
+}
 import type { IRouteConfig } from './route-types.js';
 import type { TForwardingType } from '../../../forwarding/config/forwarding-types.js';
 

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

@@ -1,5 +1,5 @@
 import * as plugins from '../../../plugins.js';
-import type { IAcmeOptions } from '../../../certificate/models/certificate-types.js';
+// Certificate types removed - use local definition
 import type { TForwardingType } from '../../../forwarding/config/forwarding-types.js';
 import type { PortRange } from '../../../proxies/nftables-proxy/models/interfaces.js';
 

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

@@ -121,13 +121,12 @@ export class SmartProxy extends plugins.EventEmitter {
       this.settings.acme = {
         enabled: false,
         port: 80,
-        accountEmail: 'admin@example.com',
+        email: 'admin@example.com',
         useProduction: false,
         renewThresholdDays: 30,
         autoRenew: true,
         certificateStore: './certs',
         skipConfiguredCerts: false,
-        httpsRedirectPort: 443,
         renewCheckIntervalHours: 24,
         routeForwards: []
       };

package/ts/certificate/acme/acme-factory.ts

@@ -1,48 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import type { IAcmeOptions } from '../models/certificate-types.js';
-import { ensureCertificateDirectory } from '../utils/certificate-helpers.js';
-// We'll need to update this import when we move the Port80Handler
-import { Port80Handler } from '../../http/port80/port80-handler.js';
-
-/**
- * Factory to create a Port80Handler with common setup.
- * Ensures the certificate store directory exists and instantiates the handler.
- * @param options Port80Handler configuration options
- * @returns A new Port80Handler instance
- */
-export function buildPort80Handler(
-  options: IAcmeOptions
-): Port80Handler {
-  if (options.certificateStore) {
-    ensureCertificateDirectory(options.certificateStore);
-    console.log(`Ensured certificate store directory: ${options.certificateStore}`);
-  }
-  return new Port80Handler(options);
-}
-
-/**
- * Creates default ACME options with sensible defaults
- * @param email Account email for ACME provider
- * @param certificateStore Path to store certificates
- * @param useProduction Whether to use production ACME servers
- * @returns Configured ACME options
- */
-export function createDefaultAcmeOptions(
-  email: string,
-  certificateStore: string,
-  useProduction: boolean = false
-): IAcmeOptions {
-  return {
-    accountEmail: email,
-    enabled: true,
-    port: 80,
-    useProduction,
-    httpsRedirectPort: 443,
-    renewThresholdDays: 30,
-    renewCheckIntervalHours: 24,
-    autoRenew: true,
-    certificateStore,
-    skipConfiguredCerts: false
-  };
-}

package/ts/certificate/acme/challenge-handler.ts

@@ -1,110 +0,0 @@
-import * as plugins from '../../plugins.js';
-import type { IAcmeOptions, ICertificateData } from '../models/certificate-types.js';
-import { CertificateEvents } from '../events/certificate-events.js';
-
-/**
- * Manages ACME challenges and certificate validation
- */
-export class AcmeChallengeHandler extends plugins.EventEmitter {
-  private options: IAcmeOptions;
-  private client: any; // ACME client from plugins
-  private pendingChallenges: Map<string, any>;
-
-  /**
-   * Creates a new ACME challenge handler
-   * @param options ACME configuration options
-   */
-  constructor(options: IAcmeOptions) {
-    super();
-    this.options = options;
-    this.pendingChallenges = new Map();
-
-    // Initialize ACME client if needed
-    // This is just a placeholder implementation since we don't use the actual
-    // client directly in this implementation - it's handled by Port80Handler
-    this.client = null;
-    console.log('Created challenge handler with options:',
-      options.accountEmail,
-      options.useProduction ? 'production' : 'staging'
-    );
-  }
-
-  /**
-   * Gets or creates the ACME account key
-   */
-  private getAccountKey(): Buffer {
-    // Implementation details would depend on plugin requirements
-    // This is a simplified version
-    if (!this.options.certificateStore) {
-      throw new Error('Certificate store is required for ACME challenges');
-    }
-    
-    // This is just a placeholder - actual implementation would check for
-    // existing account key and create one if needed
-    return Buffer.from('account-key-placeholder');
-  }
-
-  /**
-   * Validates a domain using HTTP-01 challenge
-   * @param domain Domain to validate
-   * @param challengeToken ACME challenge token
-   * @param keyAuthorization Key authorization for the challenge
-   */
-  public async handleHttpChallenge(
-    domain: string,
-    challengeToken: string,
-    keyAuthorization: string
-  ): Promise<void> {
-    // Store challenge for response
-    this.pendingChallenges.set(challengeToken, keyAuthorization);
-    
-    try {
-      // Wait for challenge validation - this would normally be handled by the ACME client
-      await new Promise(resolve => setTimeout(resolve, 1000));
-      this.emit(CertificateEvents.CERTIFICATE_ISSUED, {
-        domain,
-        success: true
-      });
-    } catch (error) {
-      this.emit(CertificateEvents.CERTIFICATE_FAILED, {
-        domain,
-        error: error instanceof Error ? error.message : String(error),
-        isRenewal: false
-      });
-      throw error;
-    } finally {
-      // Clean up the challenge
-      this.pendingChallenges.delete(challengeToken);
-    }
-  }
-
-  /**
-   * Responds to an HTTP-01 challenge request
-   * @param token Challenge token from the request path
-   * @returns The key authorization if found
-   */
-  public getChallengeResponse(token: string): string | null {
-    return this.pendingChallenges.get(token) || null;
-  }
-
-  /**
-   * Checks if a request path is an ACME challenge
-   * @param path Request path
-   * @returns True if this is an ACME challenge request
-   */
-  public isAcmeChallenge(path: string): boolean {
-    return path.startsWith('/.well-known/acme-challenge/');
-  }
-
-  /**
-   * Extracts the challenge token from an ACME challenge path
-   * @param path Request path
-   * @returns The challenge token if valid
-   */
-  public extractChallengeToken(path: string): string | null {
-    if (!this.isAcmeChallenge(path)) return null;
-    
-    const parts = path.split('/');
-    return parts[parts.length - 1] || null;
-  }
-}

package/ts/certificate/acme/index.ts

@@ -1,3 +0,0 @@
-/**
- * ACME certificate provisioning
- */

package/ts/certificate/events/certificate-events.ts

@@ -1,36 +0,0 @@
-/**
- * Certificate-related events emitted by certificate management components
- */
-export enum CertificateEvents {
-  CERTIFICATE_ISSUED = 'certificate-issued',
-  CERTIFICATE_RENEWED = 'certificate-renewed',
-  CERTIFICATE_FAILED = 'certificate-failed',
-  CERTIFICATE_EXPIRING = 'certificate-expiring',
-  CERTIFICATE_APPLIED = 'certificate-applied',
-  // Events moved from Port80Handler for compatibility
-  MANAGER_STARTED = 'manager-started',
-  MANAGER_STOPPED = 'manager-stopped',
-}
-
-/**
- * Port80Handler-specific events including certificate-related ones
- * @deprecated Use CertificateEvents and HttpEvents instead
- */
-export enum Port80HandlerEvents {
-  CERTIFICATE_ISSUED = 'certificate-issued',
-  CERTIFICATE_RENEWED = 'certificate-renewed',
-  CERTIFICATE_FAILED = 'certificate-failed',
-  CERTIFICATE_EXPIRING = 'certificate-expiring',
-  MANAGER_STARTED = 'manager-started',
-  MANAGER_STOPPED = 'manager-stopped',
-  REQUEST_FORWARDED = 'request-forwarded',
-}
-
-/**
- * Certificate provider events
- */
-export enum CertProvisionerEvents {
-  CERTIFICATE_ISSUED = 'certificate',
-  CERTIFICATE_RENEWED = 'certificate',
-  CERTIFICATE_FAILED = 'certificate-failed'
-}

package/ts/certificate/index.ts

@@ -1,75 +0,0 @@
-/**
- * Certificate management module for SmartProxy
- * Provides certificate provisioning, storage, and management capabilities
- */
-
-// Certificate types and models
-export * from './models/certificate-types.js';
-
-// Certificate events
-export * from './events/certificate-events.js';
-
-// Certificate providers
-export * from './providers/cert-provisioner.js';
-
-// ACME related exports
-export * from './acme/acme-factory.js';
-export * from './acme/challenge-handler.js';
-
-// Certificate utilities
-export * from './utils/certificate-helpers.js';
-
-// Certificate storage
-export * from './storage/file-storage.js';
-
-// Convenience function to create a certificate provisioner with common settings
-import { CertProvisioner } from './providers/cert-provisioner.js';
-import type { TCertProvisionObject } from './providers/cert-provisioner.js';
-import { buildPort80Handler } from './acme/acme-factory.js';
-import type { IAcmeOptions, IRouteForwardConfig } from './models/certificate-types.js';
-import type { IRouteConfig } from '../proxies/smart-proxy/models/route-types.js';
-
-/**
- * Interface for NetworkProxyBridge used by CertProvisioner
- */
-interface ICertNetworkProxyBridge {
-  applyExternalCertificate(certData: any): void;
-}
-
-/**
- * Creates a complete certificate provisioning system with default settings
- * @param routeConfigs Route configurations that may need certificates
- * @param acmeOptions ACME options for certificate provisioning
- * @param networkProxyBridge Bridge to apply certificates to network proxy
- * @param certProvider Optional custom certificate provider
- * @returns Configured CertProvisioner
- */
-export function createCertificateProvisioner(
-  routeConfigs: IRouteConfig[],
-  acmeOptions: IAcmeOptions,
-  networkProxyBridge: ICertNetworkProxyBridge,
-  certProvider?: (domain: string) => Promise<TCertProvisionObject>
-): CertProvisioner {
-  // Build the Port80Handler for ACME challenges
-  const port80Handler = buildPort80Handler(acmeOptions);
-
-  // Extract ACME-specific configuration
-  const {
-    renewThresholdDays = 30,
-    renewCheckIntervalHours = 24,
-    autoRenew = true,
-    routeForwards = []
-  } = acmeOptions;
-
-  // Create and return the certificate provisioner
-  return new CertProvisioner(
-    routeConfigs,
-    port80Handler,
-    networkProxyBridge,
-    certProvider,
-    renewThresholdDays,
-    renewCheckIntervalHours,
-    autoRenew,
-    routeForwards
-  );
-}

package/ts/certificate/models/certificate-types.ts

@@ -1,109 +0,0 @@
-import * as plugins from '../../plugins.js';
-import type { IRouteConfig } from '../../proxies/smart-proxy/models/route-types.js';
-
-/**
- * Certificate data structure containing all necessary information
- * about a certificate
- */
-export interface ICertificateData {
-  domain: string;
-  certificate: string;
-  privateKey: string;
-  expiryDate: Date;
-  // Optional source and renewal information for event emissions
-  source?: 'static' | 'http01' | 'dns01';
-  isRenewal?: boolean;
-  // Reference to the route that requested this certificate (if available)
-  routeReference?: {
-    routeId?: string;
-    routeName?: string;
-  };
-}
-
-/**
- * Certificates pair (private and public keys)
- */
-export interface ICertificates {
-  privateKey: string;
-  publicKey: string;
-}
-
-/**
- * Certificate failure payload type
- */
-export interface ICertificateFailure {
-  domain: string;
-  error: string;
-  isRenewal: boolean;
-  routeReference?: {
-    routeId?: string;
-    routeName?: string;
-  };
-}
-
-/**
- * Certificate expiry payload type
- */
-export interface ICertificateExpiring {
-  domain: string;
-  expiryDate: Date;
-  daysRemaining: number;
-  routeReference?: {
-    routeId?: string;
-    routeName?: string;
-  };
-}
-
-/**
- * Route-specific forwarding configuration for ACME challenges
- */
-export interface IRouteForwardConfig {
-  domain: string;
-  target: {
-    host: string;
-    port: number;
-  };
-  sslRedirect?: boolean;
-}
-
-/**
- * Domain configuration options for Port80Handler
- *
- * This is used internally by the Port80Handler to manage domains
- * but will eventually be replaced with route-based options.
- */
-export interface IDomainOptions {
-  domainName: string;
-  sslRedirect: boolean;   // if true redirects the request to port 443
-  acmeMaintenance: boolean; // tries to always have a valid cert for this domain
-  forward?: {
-    ip: string;
-    port: number;
-  }; // forwards all http requests to that target
-  acmeForward?: {
-    ip: string;
-    port: number;
-  }; // forwards letsencrypt requests to this config
-  routeReference?: {
-    routeId?: string;
-    routeName?: string;
-  };
-}
-
-/**
- * Unified ACME configuration options used across proxies and handlers
- */
-export interface IAcmeOptions {
-  accountEmail?: string;          // Email for Let's Encrypt account
-  enabled?: boolean;              // Whether ACME is enabled
-  port?: number;                  // Port to listen on for ACME challenges (default: 80)
-  useProduction?: boolean;        // Use production environment (default: staging)
-  httpsRedirectPort?: number;     // Port to redirect HTTP requests to HTTPS (default: 443)
-  renewThresholdDays?: number;    // Days before expiry to renew certificates
-  renewCheckIntervalHours?: number; // How often to check for renewals (in hours)
-  autoRenew?: boolean;            // Whether to automatically renew certificates
-  certificateStore?: string;      // Directory to store certificates
-  skipConfiguredCerts?: boolean;  // Skip domains with existing certificates
-  routeForwards?: IRouteForwardConfig[]; // Route-specific forwarding configs
-}
-