@push.rocks/smartproxy 19.3.2 → 19.3.3

package/dist_ts/certificate/events/simplified-events.js

@@ -1,13 +0,0 @@
-/**
- * Simplified certificate event system
- */
-/**
- * Certificate event types - only the essentials
- */
-export var CertificateEvent;
-(function (CertificateEvent) {
-    CertificateEvent["OBTAINED"] = "certificate:obtained";
-    CertificateEvent["FAILED"] = "certificate:failed";
-    CertificateEvent["EXPIRING"] = "certificate:expiring";
-})(CertificateEvent || (CertificateEvent = {}));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2ltcGxpZmllZC1ldmVudHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9jZXJ0aWZpY2F0ZS9ldmVudHMvc2ltcGxpZmllZC1ldmVudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFJSDs7R0FFRztBQUNILE1BQU0sQ0FBTixJQUFZLGdCQUlYO0FBSkQsV0FBWSxnQkFBZ0I7SUFDMUIscURBQWlDLENBQUE7SUFDakMsaURBQTZCLENBQUE7SUFDN0IscURBQWlDLENBQUE7QUFDbkMsQ0FBQyxFQUpXLGdCQUFnQixLQUFoQixnQkFBZ0IsUUFJM0IifQ==

package/dist_ts/certificate/index.d.ts

@@ -1,30 +0,0 @@
-/**
- * Certificate management module for SmartProxy
- * Provides certificate provisioning, storage, and management capabilities
- */
-export * from './models/certificate-types.js';
-export * from './events/certificate-events.js';
-export * from './providers/cert-provisioner.js';
-export * from './acme/acme-factory.js';
-export * from './acme/challenge-handler.js';
-export * from './utils/certificate-helpers.js';
-export * from './storage/file-storage.js';
-import { CertProvisioner } from './providers/cert-provisioner.js';
-import type { TCertProvisionObject } from './providers/cert-provisioner.js';
-import type { IAcmeOptions } 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 declare function createCertificateProvisioner(routeConfigs: IRouteConfig[], acmeOptions: IAcmeOptions, networkProxyBridge: ICertNetworkProxyBridge, certProvider?: (domain: string) => Promise<TCertProvisionObject>): CertProvisioner;

package/dist_ts/certificate/index.js

@@ -1,37 +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 { buildPort80Handler } from './acme/acme-factory.js';
-/**
- * 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, acmeOptions, networkProxyBridge, certProvider) {
-    // 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);
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9jZXJ0aWZpY2F0ZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFFSCwrQkFBK0I7QUFDL0IsY0FBYywrQkFBK0IsQ0FBQztBQUU5QyxxQkFBcUI7QUFDckIsY0FBYyxnQ0FBZ0MsQ0FBQztBQUUvQyx3QkFBd0I7QUFDeEIsY0FBYyxpQ0FBaUMsQ0FBQztBQUVoRCx1QkFBdUI7QUFDdkIsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLDZCQUE2QixDQUFDO0FBRTVDLHdCQUF3QjtBQUN4QixjQUFjLGdDQUFnQyxDQUFDO0FBRS9DLHNCQUFzQjtBQUN0QixjQUFjLDJCQUEyQixDQUFDO0FBRTFDLGdGQUFnRjtBQUNoRixPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFFbEUsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFXNUQ7Ozs7Ozs7R0FPRztBQUNILE1BQU0sVUFBVSw0QkFBNEIsQ0FDMUMsWUFBNEIsRUFDNUIsV0FBeUIsRUFDekIsa0JBQTJDLEVBQzNDLFlBQWdFO0lBRWhFLDhDQUE4QztJQUM5QyxNQUFNLGFBQWEsR0FBRyxrQkFBa0IsQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUV0RCxzQ0FBc0M7SUFDdEMsTUFBTSxFQUNKLGtCQUFrQixHQUFHLEVBQUUsRUFDdkIsdUJBQXVCLEdBQUcsRUFBRSxFQUM1QixTQUFTLEdBQUcsSUFBSSxFQUNoQixhQUFhLEdBQUcsRUFBRSxFQUNuQixHQUFHLFdBQVcsQ0FBQztJQUVoQixnREFBZ0Q7SUFDaEQsT0FBTyxJQUFJLGVBQWUsQ0FDeEIsWUFBWSxFQUNaLGFBQWEsRUFDYixrQkFBa0IsRUFDbEIsWUFBWSxFQUNaLGtCQUFrQixFQUNsQix1QkFBdUIsRUFDdkIsU0FBUyxFQUNULGFBQWEsQ0FDZCxDQUFDO0FBQ0osQ0FBQyJ9

package/dist_ts/certificate/models/certificate-errors.d.ts

@@ -1,69 +0,0 @@
-/**
- * Structured error types for certificate management
- */
-export interface CertificateErrorDetails {
-    code: string;
-    message: string;
-    solution?: string;
-    domain?: string;
-    challengeType?: 'http' | 'dns';
-    details?: Record<string, any>;
-    cause?: Error;
-}
-/**
- * Certificate-specific error class with structured information
- */
-export declare class CertificateError extends Error {
-    readonly code: string;
-    readonly solution?: string;
-    readonly domain?: string;
-    readonly challengeType?: 'http' | 'dns';
-    readonly details?: Record<string, any>;
-    readonly cause?: Error;
-    constructor(details: CertificateErrorDetails);
-    /**
-     * Convert error to JSON for logging
-     */
-    toJSON(): Record<string, any>;
-}
-/**
- * Common certificate error codes
- */
-export declare const CertificateErrorCodes: {
-    readonly NO_CERT_PROVIDER: "NO_CERT_PROVIDER";
-    readonly INVALID_CERT_PROVIDER: "INVALID_CERT_PROVIDER";
-    readonly MISSING_ACME_EMAIL: "MISSING_ACME_EMAIL";
-    readonly ACME_HTTP_CHALLENGE_FAILED: "ACME_HTTP_CHALLENGE_FAILED";
-    readonly ACME_DNS_CHALLENGE_FAILED: "ACME_DNS_CHALLENGE_FAILED";
-    readonly ACME_RATE_LIMITED: "ACME_RATE_LIMITED";
-    readonly ACME_ACCOUNT_ERROR: "ACME_ACCOUNT_ERROR";
-    readonly ACME_VALIDATION_ERROR: "ACME_VALIDATION_ERROR";
-    readonly CERTIFICATE_EXPIRED: "CERTIFICATE_EXPIRED";
-    readonly CERTIFICATE_INVALID: "CERTIFICATE_INVALID";
-    readonly CERTIFICATE_NOT_FOUND: "CERTIFICATE_NOT_FOUND";
-    readonly CERTIFICATE_PARSE_ERROR: "CERTIFICATE_PARSE_ERROR";
-    readonly STORAGE_READ_ERROR: "STORAGE_READ_ERROR";
-    readonly STORAGE_WRITE_ERROR: "STORAGE_WRITE_ERROR";
-    readonly STORAGE_PERMISSION_ERROR: "STORAGE_PERMISSION_ERROR";
-    readonly NETWORK_TIMEOUT: "NETWORK_TIMEOUT";
-    readonly NETWORK_UNREACHABLE: "NETWORK_UNREACHABLE";
-    readonly DNS_RESOLUTION_FAILED: "DNS_RESOLUTION_FAILED";
-    readonly INVALID_DOMAIN: "INVALID_DOMAIN";
-    readonly WILDCARD_NOT_SUPPORTED: "WILDCARD_NOT_SUPPORTED";
-    readonly DOMAIN_NOT_CONFIGURED: "DOMAIN_NOT_CONFIGURED";
-};
-/**
- * Helper functions for creating common certificate errors
- */
-export declare const CertificateErrors: {
-    noCertProvider: () => CertificateError;
-    invalidCertProvider: (error: Error) => CertificateError;
-    missingAcmeEmail: () => CertificateError;
-    acmeHttpChallengeFailed: (domain: string, details?: any) => CertificateError;
-    acmeDnsChallengeFailed: (domain: string, details?: any) => CertificateError;
-    acmeRateLimited: (domain: string, resetTime?: Date) => CertificateError;
-    certificateExpired: (domain: string, expiredAt: Date) => CertificateError;
-    certificateNotFound: (domain: string) => CertificateError;
-    wildcardNotSupported: (domain: string) => CertificateError;
-    storageError: (operation: "read" | "write", path: string, error: Error) => CertificateError;
-};

package/dist_ts/certificate/models/certificate-errors.js

@@ -1,141 +0,0 @@
-/**
- * Structured error types for certificate management
- */
-/**
- * Certificate-specific error class with structured information
- */
-export class CertificateError extends Error {
-    constructor(details) {
-        super(details.message);
-        this.name = 'CertificateError';
-        this.code = details.code;
-        this.solution = details.solution;
-        this.domain = details.domain;
-        this.challengeType = details.challengeType;
-        this.details = details.details;
-        this.cause = details.cause;
-    }
-    /**
-     * Convert error to JSON for logging
-     */
-    toJSON() {
-        return {
-            name: this.name,
-            code: this.code,
-            message: this.message,
-            solution: this.solution,
-            domain: this.domain,
-            challengeType: this.challengeType,
-            details: this.details,
-            cause: this.cause?.message,
-            stack: this.stack
-        };
-    }
-}
-/**
- * Common certificate error codes
- */
-export const CertificateErrorCodes = {
-    // Configuration errors
-    NO_CERT_PROVIDER: 'NO_CERT_PROVIDER',
-    INVALID_CERT_PROVIDER: 'INVALID_CERT_PROVIDER',
-    MISSING_ACME_EMAIL: 'MISSING_ACME_EMAIL',
-    // ACME errors
-    ACME_HTTP_CHALLENGE_FAILED: 'ACME_HTTP_CHALLENGE_FAILED',
-    ACME_DNS_CHALLENGE_FAILED: 'ACME_DNS_CHALLENGE_FAILED',
-    ACME_RATE_LIMITED: 'ACME_RATE_LIMITED',
-    ACME_ACCOUNT_ERROR: 'ACME_ACCOUNT_ERROR',
-    ACME_VALIDATION_ERROR: 'ACME_VALIDATION_ERROR',
-    // Certificate errors
-    CERTIFICATE_EXPIRED: 'CERTIFICATE_EXPIRED',
-    CERTIFICATE_INVALID: 'CERTIFICATE_INVALID',
-    CERTIFICATE_NOT_FOUND: 'CERTIFICATE_NOT_FOUND',
-    CERTIFICATE_PARSE_ERROR: 'CERTIFICATE_PARSE_ERROR',
-    // Storage errors
-    STORAGE_READ_ERROR: 'STORAGE_READ_ERROR',
-    STORAGE_WRITE_ERROR: 'STORAGE_WRITE_ERROR',
-    STORAGE_PERMISSION_ERROR: 'STORAGE_PERMISSION_ERROR',
-    // Network errors
-    NETWORK_TIMEOUT: 'NETWORK_TIMEOUT',
-    NETWORK_UNREACHABLE: 'NETWORK_UNREACHABLE',
-    DNS_RESOLUTION_FAILED: 'DNS_RESOLUTION_FAILED',
-    // Domain errors
-    INVALID_DOMAIN: 'INVALID_DOMAIN',
-    WILDCARD_NOT_SUPPORTED: 'WILDCARD_NOT_SUPPORTED',
-    DOMAIN_NOT_CONFIGURED: 'DOMAIN_NOT_CONFIGURED'
-};
-/**
- * Helper functions for creating common certificate errors
- */
-export const CertificateErrors = {
-    noCertProvider: () => new CertificateError({
-        code: CertificateErrorCodes.NO_CERT_PROVIDER,
-        message: 'Certificate provider is required when ACME is enabled',
-        solution: 'Configure a certProvider in your SmartProxy options'
-    }),
-    invalidCertProvider: (error) => new CertificateError({
-        code: CertificateErrorCodes.INVALID_CERT_PROVIDER,
-        message: 'Certificate provider returned invalid response',
-        solution: 'Ensure your certProvider returns a valid CertificateStrategy',
-        cause: error
-    }),
-    missingAcmeEmail: () => new CertificateError({
-        code: CertificateErrorCodes.MISSING_ACME_EMAIL,
-        message: 'ACME email is required for certificate provisioning',
-        solution: 'Configure acme.email in your SmartProxy options'
-    }),
-    acmeHttpChallengeFailed: (domain, details) => new CertificateError({
-        code: CertificateErrorCodes.ACME_HTTP_CHALLENGE_FAILED,
-        message: `HTTP-01 challenge failed for ${domain}`,
-        solution: 'Ensure port 80 is accessible and DNS points to this server',
-        domain,
-        challengeType: 'http',
-        details
-    }),
-    acmeDnsChallengeFailed: (domain, details) => new CertificateError({
-        code: CertificateErrorCodes.ACME_DNS_CHALLENGE_FAILED,
-        message: `DNS-01 challenge failed for ${domain}`,
-        solution: 'Verify DNS TXT record is correctly set for the domain',
-        domain,
-        challengeType: 'dns',
-        details
-    }),
-    acmeRateLimited: (domain, resetTime) => new CertificateError({
-        code: CertificateErrorCodes.ACME_RATE_LIMITED,
-        message: `ACME rate limit exceeded for ${domain}`,
-        solution: resetTime
-            ? `Wait until ${resetTime.toISOString()} before retrying`
-            : 'Wait before retrying or use staging environment for testing',
-        domain,
-        details: { resetTime }
-    }),
-    certificateExpired: (domain, expiredAt) => new CertificateError({
-        code: CertificateErrorCodes.CERTIFICATE_EXPIRED,
-        message: `Certificate for ${domain} expired at ${expiredAt.toISOString()}`,
-        solution: 'Renew the certificate or configure automatic renewal',
-        domain,
-        details: { expiredAt }
-    }),
-    certificateNotFound: (domain) => new CertificateError({
-        code: CertificateErrorCodes.CERTIFICATE_NOT_FOUND,
-        message: `No certificate found for ${domain}`,
-        solution: 'Request a new certificate or provide a static certificate',
-        domain
-    }),
-    wildcardNotSupported: (domain) => new CertificateError({
-        code: CertificateErrorCodes.WILDCARD_NOT_SUPPORTED,
-        message: `Wildcard domain ${domain} requires DNS-01 challenge`,
-        solution: 'Configure your certProvider to return acme-dns strategy for wildcards',
-        domain
-    }),
-    storageError: (operation, path, error) => new CertificateError({
-        code: operation === 'read'
-            ? CertificateErrorCodes.STORAGE_READ_ERROR
-            : CertificateErrorCodes.STORAGE_WRITE_ERROR,
-        message: `Failed to ${operation} certificate at ${path}`,
-        solution: `Check file permissions and ensure directory exists`,
-        details: { path },
-        cause: error
-    })
-};
-//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/certificate/models/certificate-strategy.d.ts

@@ -1,60 +0,0 @@
-/**
- * Certificate strategy types for SmartProxy
- */
-/**
- * Certificate strategy types
- */
-export type CertificateStrategy = {
-    type: 'acme-http';
-} | {
-    type: 'acme-dns';
-} | {
-    type: 'static';
-    cert: string;
-    key: string;
-    expiresAt?: Date;
-} | {
-    type: 'skip';
-};
-/**
- * Certificate provider function type
- */
-export type CertProvider = (domain: string) => Promise<CertificateStrategy>;
-/**
- * Helper functions for creating certificate strategies
- */
-export declare const CertStrategies: {
-    /**
-     * Use ACME HTTP-01 challenge
-     */
-    acmeHttp: () => CertificateStrategy;
-    /**
-     * Use ACME DNS-01 challenge (required for wildcards)
-     */
-    acmeDns: () => CertificateStrategy;
-    /**
-     * Use static certificate
-     */
-    static: (cert: string, key: string, expiresAt?: Date) => CertificateStrategy;
-    /**
-     * Skip certificate provisioning for this domain
-     */
-    skip: () => CertificateStrategy;
-};
-/**
- * Built-in certificate providers
- */
-export declare const defaultCertProviders: {
-    /**
-     * Standard ACME provider: HTTP-01 for regular domains, DNS-01 for wildcards
-     */
-    standard: (domain: string) => Promise<CertificateStrategy>;
-    /**
-     * Use static certificates from disk if available, fallback to ACME
-     */
-    withStaticFallback: (certDir: string) => (domain: string) => Promise<CertificateStrategy>;
-    /**
-     * Always skip certificate provisioning
-     */
-    skip: () => Promise<CertificateStrategy>;
-};

package/dist_ts/certificate/models/certificate-strategy.js

@@ -1,73 +0,0 @@
-/**
- * Certificate strategy types for SmartProxy
- */
-/**
- * Helper functions for creating certificate strategies
- */
-export const CertStrategies = {
-    /**
-     * Use ACME HTTP-01 challenge
-     */
-    acmeHttp: () => ({ type: 'acme-http' }),
-    /**
-     * Use ACME DNS-01 challenge (required for wildcards)
-     */
-    acmeDns: () => ({ type: 'acme-dns' }),
-    /**
-     * Use static certificate
-     */
-    static: (cert, key, expiresAt) => ({
-        type: 'static',
-        cert,
-        key,
-        expiresAt
-    }),
-    /**
-     * Skip certificate provisioning for this domain
-     */
-    skip: () => ({ type: 'skip' })
-};
-/**
- * Built-in certificate providers
- */
-export const defaultCertProviders = {
-    /**
-     * Standard ACME provider: HTTP-01 for regular domains, DNS-01 for wildcards
-     */
-    standard: (domain) => {
-        return Promise.resolve(domain.includes('*')
-            ? CertStrategies.acmeDns()
-            : CertStrategies.acmeHttp());
-    },
-    /**
-     * Use static certificates from disk if available, fallback to ACME
-     */
-    withStaticFallback: (certDir) => {
-        return async (domain) => {
-            const fs = await import('fs/promises');
-            const path = await import('path');
-            const certPath = path.join(certDir, `${domain}.crt`);
-            const keyPath = path.join(certDir, `${domain}.key`);
-            try {
-                const [cert, key] = await Promise.all([
-                    fs.readFile(certPath, 'utf-8'),
-                    fs.readFile(keyPath, 'utf-8')
-                ]);
-                return CertStrategies.static(cert, key);
-            }
-            catch {
-                // File not found, fallback to ACME
-                return domain.includes('*')
-                    ? CertStrategies.acmeDns()
-                    : CertStrategies.acmeHttp();
-            }
-        };
-    },
-    /**
-     * Always skip certificate provisioning
-     */
-    skip: () => {
-        return Promise.resolve(CertStrategies.skip());
-    }
-};
-//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,97 +0,0 @@
-/**
- * Certificate data structure containing all necessary information
- * about a certificate
- */
-export interface ICertificateData {
-    domain: string;
-    certificate: string;
-    privateKey: string;
-    expiryDate: Date;
-    source?: 'static' | 'http01' | 'dns01';
-    isRenewal?: boolean;
-    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;
-    acmeMaintenance: boolean;
-    forward?: {
-        ip: string;
-        port: number;
-    };
-    acmeForward?: {
-        ip: string;
-        port: number;
-    };
-    routeReference?: {
-        routeId?: string;
-        routeName?: string;
-    };
-}
-/**
- * Unified ACME configuration options used across proxies and handlers
- */
-export interface IAcmeOptions {
-    accountEmail?: string;
-    enabled?: boolean;
-    port?: number;
-    useProduction?: boolean;
-    httpsRedirectPort?: number;
-    renewThresholdDays?: number;
-    renewCheckIntervalHours?: number;
-    autoRenew?: boolean;
-    certificateStore?: string;
-    skipConfiguredCerts?: boolean;
-    routeForwards?: IRouteForwardConfig[];
-}

package/dist_ts/certificate/models/certificate-types.js

@@ -1,2 +0,0 @@
-import * as plugins from '../../plugins.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2VydGlmaWNhdGUtdHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9jZXJ0aWZpY2F0ZS9tb2RlbHMvY2VydGlmaWNhdGUtdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxrQkFBa0IsQ0FBQyJ9

package/dist_ts/certificate/providers/cert-provisioner.d.ts

@@ -1,119 +0,0 @@
-import * as plugins from '../../plugins.js';
-import type { IRouteConfig } from '../../proxies/smart-proxy/models/route-types.js';
-import type { ICertificateData, IRouteForwardConfig } from '../models/certificate-types.js';
-import { Port80Handler } from '../../http/port80/port80-handler.js';
-interface INetworkProxyBridge {
-    applyExternalCertificate(certData: ICertificateData): void;
-}
-/**
- * Type for static certificate provisioning
- */
-export type TCertProvisionObject = plugins.tsclass.network.ICert | 'http01' | 'dns01';
-/**
- * CertProvisioner manages certificate provisioning and renewal workflows,
- * unifying static certificates and HTTP-01 challenges via Port80Handler.
- *
- * This class directly works with route configurations instead of converting to domain configs.
- */
-export declare class CertProvisioner extends plugins.EventEmitter {
-    private routeConfigs;
-    private certRoutes;
-    private port80Handler;
-    private networkProxyBridge;
-    private certProvisionFunction?;
-    private routeForwards;
-    private renewThresholdDays;
-    private renewCheckIntervalHours;
-    private autoRenew;
-    private renewManager?;
-    private provisionMap;
-    /**
-     * Extract routes that need certificates
-     * @param routes Route configurations
-     */
-    private extractCertificateRoutesFromRoutes;
-    /**
-     * Constructor for CertProvisioner
-     *
-     * @param routeConfigs Array of route configurations
-     * @param port80Handler HTTP-01 challenge handler instance
-     * @param networkProxyBridge Bridge for applying external certificates
-     * @param certProvider Optional callback returning a static cert or 'http01'
-     * @param renewThresholdDays Days before expiry to trigger renewals
-     * @param renewCheckIntervalHours Interval in hours to check for renewals
-     * @param autoRenew Whether to automatically schedule renewals
-     * @param routeForwards Route-specific forwarding configs for ACME challenges
-     */
-    constructor(routeConfigs: IRouteConfig[], port80Handler: Port80Handler, networkProxyBridge: INetworkProxyBridge, certProvider?: (domain: string) => Promise<TCertProvisionObject>, renewThresholdDays?: number, renewCheckIntervalHours?: number, autoRenew?: boolean, routeForwards?: IRouteForwardConfig[]);
-    /**
-     * Start initial provisioning and schedule renewals.
-     */
-    start(): Promise<void>;
-    /**
-     * Set up event subscriptions for certificate events
-     */
-    private setupEventSubscriptions;
-    /**
-     * Find a route for a given domain
-     */
-    private findRouteForDomain;
-    /**
-     * Set up forwarding configurations for the Port80Handler
-     */
-    private setupForwardingConfigs;
-    /**
-     * Provision certificates for all routes that need them
-     */
-    private provisionAllCertificates;
-    /**
-     * Provision a certificate for a route
-     */
-    private provisionCertificateForRoute;
-    /**
-     * Schedule certificate renewals using a task manager
-     */
-    private scheduleRenewals;
-    /**
-     * Perform renewals for all domains that need it
-     */
-    private performRenewals;
-    /**
-     * Renew a certificate for a specific domain
-     * @param domain Domain to renew
-     * @param provisionType Type of provisioning for this domain
-     * @param certRoute The route reference for this domain
-     */
-    private renewCertificateForDomain;
-    /**
-     * Stop all scheduled renewal tasks.
-     */
-    stop(): Promise<void>;
-    /**
-     * Request a certificate on-demand for the given domain.
-     * This will look for a matching route configuration and provision accordingly.
-     *
-     * @param domain Domain name to provision
-     */
-    requestCertificate(domain: string): Promise<void>;
-    /**
-     * Add a new domain for certificate provisioning
-     *
-     * @param domain Domain to add
-     * @param options Domain configuration options
-     */
-    addDomain(domain: string, options?: {
-        sslRedirect?: boolean;
-        acmeMaintenance?: boolean;
-        routeId?: string;
-        routeName?: string;
-    }): Promise<void>;
-    /**
-     * Update routes with new configurations
-     * This replaces all existing routes with new ones and re-provisions certificates as needed
-     *
-     * @param newRoutes New route configurations to use
-     */
-    updateRoutes(newRoutes: IRouteConfig[]): Promise<void>;
-}
-export type TSmartProxyCertProvisionObject = TCertProvisionObject;
-export {};