@push.rocks/smartproxy 12.0.0 → 13.1.2

package/dist_ts/certificate/providers/cert-provisioner.js

@@ -0,0 +1,262 @@
+import * as plugins from '../../plugins.js';
+import { Port80HandlerEvents, CertProvisionerEvents } from '../events/certificate-events.js';
+import { Port80Handler } from '../../http/port80/port80-handler.js';
+/**
+ * CertProvisioner manages certificate provisioning and renewal workflows,
+ * unifying static certificates and HTTP-01 challenges via Port80Handler.
+ */
+export class CertProvisioner extends plugins.EventEmitter {
+    /**
+     * @param domainConfigs Array of domain configuration objects
+     * @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 forwardConfigs Domain forwarding configurations for ACME challenges
+     */
+    constructor(domainConfigs, port80Handler, networkProxyBridge, certProvider, renewThresholdDays = 30, renewCheckIntervalHours = 24, autoRenew = true, forwardConfigs = []) {
+        super();
+        this.domainConfigs = domainConfigs;
+        this.port80Handler = port80Handler;
+        this.networkProxyBridge = networkProxyBridge;
+        this.certProvisionFunction = certProvider;
+        this.renewThresholdDays = renewThresholdDays;
+        this.renewCheckIntervalHours = renewCheckIntervalHours;
+        this.autoRenew = autoRenew;
+        this.provisionMap = new Map();
+        this.forwardConfigs = forwardConfigs;
+    }
+    /**
+     * Start initial provisioning and schedule renewals.
+     */
+    async start() {
+        // Subscribe to Port80Handler certificate events
+        this.setupEventSubscriptions();
+        // Apply external forwarding for ACME challenges
+        this.setupForwardingConfigs();
+        // Initial provisioning for all domains
+        await this.provisionAllDomains();
+        // Schedule renewals if enabled
+        if (this.autoRenew) {
+            this.scheduleRenewals();
+        }
+    }
+    /**
+     * Set up event subscriptions for certificate events
+     */
+    setupEventSubscriptions() {
+        // We need to reimplement subscribeToPort80Handler here
+        this.port80Handler.on(Port80HandlerEvents.CERTIFICATE_ISSUED, (data) => {
+            this.emit(CertProvisionerEvents.CERTIFICATE_ISSUED, { ...data, source: 'http01', isRenewal: false });
+        });
+        this.port80Handler.on(Port80HandlerEvents.CERTIFICATE_RENEWED, (data) => {
+            this.emit(CertProvisionerEvents.CERTIFICATE_RENEWED, { ...data, source: 'http01', isRenewal: true });
+        });
+        this.port80Handler.on(Port80HandlerEvents.CERTIFICATE_FAILED, (error) => {
+            this.emit(CertProvisionerEvents.CERTIFICATE_FAILED, error);
+        });
+    }
+    /**
+     * Set up forwarding configurations for the Port80Handler
+     */
+    setupForwardingConfigs() {
+        for (const config of this.forwardConfigs) {
+            const domainOptions = {
+                domainName: config.domain,
+                sslRedirect: config.sslRedirect || false,
+                acmeMaintenance: false,
+                forward: config.forwardConfig,
+                acmeForward: config.acmeForwardConfig
+            };
+            this.port80Handler.addDomain(domainOptions);
+        }
+    }
+    /**
+     * Provision certificates for all configured domains
+     */
+    async provisionAllDomains() {
+        const domains = this.domainConfigs.flatMap(cfg => cfg.domains);
+        for (const domain of domains) {
+            await this.provisionDomain(domain);
+        }
+    }
+    /**
+     * Provision a certificate for a single domain
+     * @param domain Domain to provision
+     */
+    async provisionDomain(domain) {
+        const isWildcard = domain.includes('*');
+        let provision = 'http01';
+        // Try to get a certificate from the provision function
+        if (this.certProvisionFunction) {
+            try {
+                provision = await this.certProvisionFunction(domain);
+            }
+            catch (err) {
+                console.error(`certProvider error for ${domain}:`, err);
+            }
+        }
+        else if (isWildcard) {
+            // No certProvider: cannot handle wildcard without DNS-01 support
+            console.warn(`Skipping wildcard domain without certProvisionFunction: ${domain}`);
+            return;
+        }
+        // Handle different provisioning methods
+        if (provision === 'http01') {
+            if (isWildcard) {
+                console.warn(`Skipping HTTP-01 for wildcard domain: ${domain}`);
+                return;
+            }
+            this.provisionMap.set(domain, 'http01');
+            this.port80Handler.addDomain({
+                domainName: domain,
+                sslRedirect: true,
+                acmeMaintenance: true
+            });
+        }
+        else if (provision === 'dns01') {
+            // DNS-01 challenges would be handled by the certProvisionFunction
+            this.provisionMap.set(domain, 'dns01');
+            // DNS-01 handling would go here if implemented
+        }
+        else {
+            // Static certificate (e.g., DNS-01 provisioned or user-provided)
+            this.provisionMap.set(domain, 'static');
+            const certObj = provision;
+            const certData = {
+                domain: certObj.domainName,
+                certificate: certObj.publicKey,
+                privateKey: certObj.privateKey,
+                expiryDate: new Date(certObj.validUntil),
+                source: 'static',
+                isRenewal: false
+            };
+            this.networkProxyBridge.applyExternalCertificate(certData);
+            this.emit(CertProvisionerEvents.CERTIFICATE_ISSUED, certData);
+        }
+    }
+    /**
+     * Schedule certificate renewals using a task manager
+     */
+    scheduleRenewals() {
+        this.renewManager = new plugins.taskbuffer.TaskManager();
+        const renewTask = new plugins.taskbuffer.Task({
+            name: 'CertificateRenewals',
+            taskFunction: async () => await this.performRenewals()
+        });
+        const hours = this.renewCheckIntervalHours;
+        const cronExpr = `0 0 */${hours} * * *`;
+        this.renewManager.addAndScheduleTask(renewTask, cronExpr);
+        this.renewManager.start();
+    }
+    /**
+     * Perform renewals for all domains that need it
+     */
+    async performRenewals() {
+        for (const [domain, type] of this.provisionMap.entries()) {
+            // Skip wildcard domains for HTTP-01 challenges
+            if (domain.includes('*') && type === 'http01')
+                continue;
+            try {
+                await this.renewDomain(domain, type);
+            }
+            catch (err) {
+                console.error(`Renewal error for ${domain}:`, err);
+            }
+        }
+    }
+    /**
+     * Renew a certificate for a specific domain
+     * @param domain Domain to renew
+     * @param provisionType Type of provisioning for this domain
+     */
+    async renewDomain(domain, provisionType) {
+        if (provisionType === 'http01') {
+            await this.port80Handler.renewCertificate(domain);
+        }
+        else if ((provisionType === 'static' || provisionType === 'dns01') && this.certProvisionFunction) {
+            const provision = await this.certProvisionFunction(domain);
+            if (provision !== 'http01' && provision !== 'dns01') {
+                const certObj = provision;
+                const certData = {
+                    domain: certObj.domainName,
+                    certificate: certObj.publicKey,
+                    privateKey: certObj.privateKey,
+                    expiryDate: new Date(certObj.validUntil),
+                    source: 'static',
+                    isRenewal: true
+                };
+                this.networkProxyBridge.applyExternalCertificate(certData);
+                this.emit(CertProvisionerEvents.CERTIFICATE_RENEWED, certData);
+            }
+        }
+    }
+    /**
+     * Stop all scheduled renewal tasks.
+     */
+    async stop() {
+        if (this.renewManager) {
+            this.renewManager.stop();
+        }
+    }
+    /**
+     * Request a certificate on-demand for the given domain.
+     * @param domain Domain name to provision
+     */
+    async requestCertificate(domain) {
+        const isWildcard = domain.includes('*');
+        // Determine provisioning method
+        let provision = 'http01';
+        if (this.certProvisionFunction) {
+            provision = await this.certProvisionFunction(domain);
+        }
+        else if (isWildcard) {
+            // Cannot perform HTTP-01 on wildcard without certProvider
+            throw new Error(`Cannot request certificate for wildcard domain without certProvisionFunction: ${domain}`);
+        }
+        if (provision === 'http01') {
+            if (isWildcard) {
+                throw new Error(`Cannot request HTTP-01 certificate for wildcard domain: ${domain}`);
+            }
+            await this.port80Handler.renewCertificate(domain);
+        }
+        else if (provision === 'dns01') {
+            // DNS-01 challenges would be handled by external mechanisms
+            // This is a placeholder for future implementation
+            console.log(`DNS-01 challenge requested for ${domain}`);
+        }
+        else {
+            // Static certificate (e.g., DNS-01 provisioned) supports wildcards
+            const certObj = provision;
+            const certData = {
+                domain: certObj.domainName,
+                certificate: certObj.publicKey,
+                privateKey: certObj.privateKey,
+                expiryDate: new Date(certObj.validUntil),
+                source: 'static',
+                isRenewal: false
+            };
+            this.networkProxyBridge.applyExternalCertificate(certData);
+            this.emit(CertProvisionerEvents.CERTIFICATE_ISSUED, certData);
+        }
+    }
+    /**
+     * Add a new domain for certificate provisioning
+     * @param domain Domain to add
+     * @param options Domain configuration options
+     */
+    async addDomain(domain, options) {
+        const domainOptions = {
+            domainName: domain,
+            sslRedirect: options?.sslRedirect || true,
+            acmeMaintenance: options?.acmeMaintenance || true
+        };
+        this.port80Handler.addDomain(domainOptions);
+        await this.provisionDomain(domain);
+    }
+}
+// For backward compatibility
+export { CertProvisioner as CertificateProvisioner };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cert-provisioner.js","sourceRoot":"","sources":["../../../ts/certificate/providers/cert-provisioner.ts"],"names":[],"mappings":"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"}

package/dist_ts/certificate/providers/index.d.ts

@@ -0,0 +1,4 @@
+export {};
+/**
+ * Certificate providers
+ */

package/dist_ts/certificate/providers/index.js

@@ -0,0 +1,5 @@
+export {};
+/**
+ * Certificate providers
+ */
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9jZXJ0aWZpY2F0ZS9wcm92aWRlcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOztHQUVHIn0=

package/dist_ts/certificate/storage/file-storage.d.ts

@@ -0,0 +1,66 @@
+import type { ICertificateData } from '../models/certificate-types.js';
+/**
+ * FileStorage provides file system storage for certificates
+ */
+export declare class FileStorage {
+    private storageDir;
+    /**
+     * Creates a new file storage provider
+     * @param storageDir Directory to store certificates
+     */
+    constructor(storageDir: string);
+    /**
+     * Save a certificate to the file system
+     * @param domain Domain name
+     * @param certData Certificate data to save
+     */
+    saveCertificate(domain: string, certData: ICertificateData): Promise<void>;
+    /**
+     * Load a certificate from the file system
+     * @param domain Domain name
+     * @returns Certificate data if found, null otherwise
+     */
+    loadCertificate(domain: string): Promise<ICertificateData | null>;
+    /**
+     * Delete a certificate from the file system
+     * @param domain Domain name
+     */
+    deleteCertificate(domain: string): Promise<boolean>;
+    /**
+     * List all domains with stored certificates
+     * @returns Array of domain names
+     */
+    listCertificates(): Promise<string[]>;
+    /**
+     * Check if a certificate is expiring soon
+     * @param domain Domain name
+     * @param thresholdDays Days threshold to consider expiring
+     * @returns Information about expiring certificate or null
+     */
+    isExpiringSoon(domain: string, thresholdDays?: number): Promise<{
+        domain: string;
+        expiryDate: Date;
+        daysRemaining: number;
+    } | null>;
+    /**
+     * Check all certificates for expiration
+     * @param thresholdDays Days threshold to consider expiring
+     * @returns List of expiring certificates
+     */
+    getExpiringCertificates(thresholdDays?: number): Promise<Array<{
+        domain: string;
+        expiryDate: Date;
+        daysRemaining: number;
+    }>>;
+    /**
+     * Delete a directory recursively
+     * @param directoryPath Directory to delete
+     */
+    private deleteDirectory;
+    /**
+     * Sanitize a domain name for use as a directory name
+     * @param domain Domain name
+     * @returns Sanitized domain name
+     */
+    private sanitizeDomain;
+}

package/dist_ts/certificate/storage/file-storage.js

@@ -0,0 +1,194 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as plugins from '../../plugins.js';
+import { ensureCertificateDirectory } from '../utils/certificate-helpers.js';
+/**
+ * FileStorage provides file system storage for certificates
+ */
+export class FileStorage {
+    /**
+     * Creates a new file storage provider
+     * @param storageDir Directory to store certificates
+     */
+    constructor(storageDir) {
+        this.storageDir = path.resolve(storageDir);
+        ensureCertificateDirectory(this.storageDir);
+    }
+    /**
+     * Save a certificate to the file system
+     * @param domain Domain name
+     * @param certData Certificate data to save
+     */
+    async saveCertificate(domain, certData) {
+        const sanitizedDomain = this.sanitizeDomain(domain);
+        const certDir = path.join(this.storageDir, sanitizedDomain);
+        ensureCertificateDirectory(certDir);
+        const certPath = path.join(certDir, 'fullchain.pem');
+        const keyPath = path.join(certDir, 'privkey.pem');
+        const metaPath = path.join(certDir, 'metadata.json');
+        // Write certificate and private key
+        await fs.promises.writeFile(certPath, certData.certificate, 'utf8');
+        await fs.promises.writeFile(keyPath, certData.privateKey, 'utf8');
+        // Write metadata
+        const metadata = {
+            domain: certData.domain,
+            expiryDate: certData.expiryDate.toISOString(),
+            source: certData.source || 'unknown',
+            issuedAt: new Date().toISOString()
+        };
+        await fs.promises.writeFile(metaPath, JSON.stringify(metadata, null, 2), 'utf8');
+    }
+    /**
+     * Load a certificate from the file system
+     * @param domain Domain name
+     * @returns Certificate data if found, null otherwise
+     */
+    async loadCertificate(domain) {
+        const sanitizedDomain = this.sanitizeDomain(domain);
+        const certDir = path.join(this.storageDir, sanitizedDomain);
+        if (!fs.existsSync(certDir)) {
+            return null;
+        }
+        const certPath = path.join(certDir, 'fullchain.pem');
+        const keyPath = path.join(certDir, 'privkey.pem');
+        const metaPath = path.join(certDir, 'metadata.json');
+        try {
+            // Check if all required files exist
+            if (!fs.existsSync(certPath) || !fs.existsSync(keyPath)) {
+                return null;
+            }
+            // Read certificate and private key
+            const certificate = await fs.promises.readFile(certPath, 'utf8');
+            const privateKey = await fs.promises.readFile(keyPath, 'utf8');
+            // Try to read metadata if available
+            let expiryDate = new Date();
+            let source;
+            if (fs.existsSync(metaPath)) {
+                const metaContent = await fs.promises.readFile(metaPath, 'utf8');
+                const metadata = JSON.parse(metaContent);
+                if (metadata.expiryDate) {
+                    expiryDate = new Date(metadata.expiryDate);
+                }
+                if (metadata.source) {
+                    source = metadata.source;
+                }
+            }
+            return {
+                domain,
+                certificate,
+                privateKey,
+                expiryDate,
+                source
+            };
+        }
+        catch (error) {
+            console.error(`Error loading certificate for ${domain}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Delete a certificate from the file system
+     * @param domain Domain name
+     */
+    async deleteCertificate(domain) {
+        const sanitizedDomain = this.sanitizeDomain(domain);
+        const certDir = path.join(this.storageDir, sanitizedDomain);
+        if (!fs.existsSync(certDir)) {
+            return false;
+        }
+        try {
+            // Recursively delete the certificate directory
+            await this.deleteDirectory(certDir);
+            return true;
+        }
+        catch (error) {
+            console.error(`Error deleting certificate for ${domain}:`, error);
+            return false;
+        }
+    }
+    /**
+     * List all domains with stored certificates
+     * @returns Array of domain names
+     */
+    async listCertificates() {
+        try {
+            const entries = await fs.promises.readdir(this.storageDir, { withFileTypes: true });
+            return entries
+                .filter(entry => entry.isDirectory())
+                .map(entry => entry.name);
+        }
+        catch (error) {
+            console.error('Error listing certificates:', error);
+            return [];
+        }
+    }
+    /**
+     * Check if a certificate is expiring soon
+     * @param domain Domain name
+     * @param thresholdDays Days threshold to consider expiring
+     * @returns Information about expiring certificate or null
+     */
+    async isExpiringSoon(domain, thresholdDays = 30) {
+        const certData = await this.loadCertificate(domain);
+        if (!certData) {
+            return null;
+        }
+        const now = new Date();
+        const expiryDate = certData.expiryDate;
+        const timeRemaining = expiryDate.getTime() - now.getTime();
+        const daysRemaining = Math.floor(timeRemaining / (1000 * 60 * 60 * 24));
+        if (daysRemaining <= thresholdDays) {
+            return {
+                domain,
+                expiryDate,
+                daysRemaining
+            };
+        }
+        return null;
+    }
+    /**
+     * Check all certificates for expiration
+     * @param thresholdDays Days threshold to consider expiring
+     * @returns List of expiring certificates
+     */
+    async getExpiringCertificates(thresholdDays = 30) {
+        const domains = await this.listCertificates();
+        const expiringCerts = [];
+        for (const domain of domains) {
+            const expiring = await this.isExpiringSoon(domain, thresholdDays);
+            if (expiring) {
+                expiringCerts.push(expiring);
+            }
+        }
+        return expiringCerts;
+    }
+    /**
+     * Delete a directory recursively
+     * @param directoryPath Directory to delete
+     */
+    async deleteDirectory(directoryPath) {
+        if (fs.existsSync(directoryPath)) {
+            const entries = await fs.promises.readdir(directoryPath, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(directoryPath, entry.name);
+                if (entry.isDirectory()) {
+                    await this.deleteDirectory(fullPath);
+                }
+                else {
+                    await fs.promises.unlink(fullPath);
+                }
+            }
+            await fs.promises.rmdir(directoryPath);
+        }
+    }
+    /**
+     * Sanitize a domain name for use as a directory name
+     * @param domain Domain name
+     * @returns Sanitized domain name
+     */
+    sanitizeDomain(domain) {
+        // Replace wildcard and any invalid filesystem characters
+        return domain.replace(/\*/g, '_wildcard_').replace(/[/\\:*?"<>|]/g, '_');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/certificate/storage/index.d.ts

@@ -0,0 +1,4 @@
+export {};
+/**
+ * Certificate storage mechanisms
+ */

package/dist_ts/certificate/storage/index.js

@@ -0,0 +1,5 @@
+export {};
+/**
+ * Certificate storage mechanisms
+ */
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9jZXJ0aWZpY2F0ZS9zdG9yYWdlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7R0FFRyJ9

package/dist_ts/certificate/utils/certificate-helpers.d.ts

@@ -0,0 +1,17 @@
+import type { ICertificates } from '../models/certificate-types.js';
+/**
+ * Loads the default SSL certificates from the assets directory
+ * @returns The certificate key pair
+ */
+export declare function loadDefaultCertificates(): ICertificates;
+/**
+ * Checks if a certificate file exists at the specified path
+ * @param certPath Path to check for certificate
+ * @returns True if the certificate exists, false otherwise
+ */
+export declare function certificateExists(certPath: string): boolean;
+/**
+ * Ensures the certificate directory exists
+ * @param dirPath Path to the certificate directory
+ */
+export declare function ensureCertificateDirectory(dirPath: string): void;

package/dist_ts/certificate/utils/certificate-helpers.js

@@ -0,0 +1,45 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+/**
+ * Loads the default SSL certificates from the assets directory
+ * @returns The certificate key pair
+ */
+export function loadDefaultCertificates() {
+    try {
+        // Need to adjust path from /ts/certificate/utils to /assets/certs
+        const certPath = path.join(__dirname, '..', '..', '..', 'assets', 'certs');
+        const privateKey = fs.readFileSync(path.join(certPath, 'key.pem'), 'utf8');
+        const publicKey = fs.readFileSync(path.join(certPath, 'cert.pem'), 'utf8');
+        if (!privateKey || !publicKey) {
+            throw new Error('Failed to load default certificates');
+        }
+        return {
+            privateKey,
+            publicKey
+        };
+    }
+    catch (error) {
+        console.error('Error loading default certificates:', error);
+        throw error;
+    }
+}
+/**
+ * Checks if a certificate file exists at the specified path
+ * @param certPath Path to check for certificate
+ * @returns True if the certificate exists, false otherwise
+ */
+export function certificateExists(certPath) {
+    return fs.existsSync(certPath);
+}
+/**
+ * Ensures the certificate directory exists
+ * @param dirPath Path to the certificate directory
+ */
+export function ensureCertificateDirectory(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2VydGlmaWNhdGUtaGVscGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL2NlcnRpZmljYXRlL3V0aWxzL2NlcnRpZmljYXRlLWhlbHBlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsTUFBTSxJQUFJLENBQUM7QUFDekIsT0FBTyxLQUFLLElBQUksTUFBTSxNQUFNLENBQUM7QUFDN0IsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLEtBQUssQ0FBQztBQUdwQyxNQUFNLFNBQVMsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLGFBQWEsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUM7QUFFL0Q7OztHQUdHO0FBQ0gsTUFBTSxVQUFVLHVCQUF1QjtJQUNyQyxJQUFJLENBQUM7UUFDSCxrRUFBa0U7UUFDbEUsTUFBTSxRQUFRLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsSUFBSSxFQUFFLElBQUksRUFBRSxJQUFJLEVBQUUsUUFBUSxFQUFFLE9BQU8sQ0FBQyxDQUFDO1FBQzNFLE1BQU0sVUFBVSxHQUFHLEVBQUUsQ0FBQyxZQUFZLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLEVBQUUsU0FBUyxDQUFDLEVBQUUsTUFBTSxDQUFDLENBQUM7UUFDM0UsTUFBTSxTQUFTLEdBQUcsRUFBRSxDQUFDLFlBQVksQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLFFBQVEsRUFBRSxVQUFVLENBQUMsRUFBRSxNQUFNLENBQUMsQ0FBQztRQUUzRSxJQUFJLENBQUMsVUFBVSxJQUFJLENBQUMsU0FBUyxFQUFFLENBQUM7WUFDOUIsTUFBTSxJQUFJLEtBQUssQ0FBQyxxQ0FBcUMsQ0FBQyxDQUFDO1FBQ3pELENBQUM7UUFFRCxPQUFPO1lBQ0wsVUFBVTtZQUNWLFNBQVM7U0FDVixDQUFDO0lBQ0osQ0FBQztJQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7UUFDZixPQUFPLENBQUMsS0FBSyxDQUFDLHFDQUFxQyxFQUFFLEtBQUssQ0FBQyxDQUFDO1FBQzVELE1BQU0sS0FBSyxDQUFDO0lBQ2QsQ0FBQztBQUNILENBQUM7QUFFRDs7OztHQUlHO0FBQ0gsTUFBTSxVQUFVLGlCQUFpQixDQUFDLFFBQWdCO0lBQ2hELE9BQU8sRUFBRSxDQUFDLFVBQVUsQ0FBQyxRQUFRLENBQUMsQ0FBQztBQUNqQyxDQUFDO0FBRUQ7OztHQUdHO0FBQ0gsTUFBTSxVQUFVLDBCQUEwQixDQUFDLE9BQWU7SUFDeEQsSUFBSSxDQUFDLEVBQUUsQ0FBQyxVQUFVLENBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQztRQUM1QixFQUFFLENBQUMsU0FBUyxDQUFDLE9BQU8sRUFBRSxFQUFFLFNBQVMsRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDO0lBQzdDLENBQUM7QUFDSCxDQUFDIn0=

package/dist_ts/common/eventUtils.d.ts

@@ -1,4 +1,4 @@
-import type { Port80Handler } from '../port80handler/classes.port80handler.js';
+import type { Port80Handler } from '../http/port80/port80-handler.js';
 import type { ICertificateData, ICertificateFailure, ICertificateExpiring } from './types.js';
 /**
  * Subscribers callback definitions for Port80Handler events

package/dist_ts/common/port80-adapter.d.ts

@@ -1,5 +1,5 @@
 import type { IForwardConfig as ILegacyForwardConfig, IDomainOptions } from './types.js';
-import type { IForwardConfig } from '../smartproxy/types/forwarding.types.js';
+import type { IForwardConfig } from '../forwarding/config/forwarding-types.js';
 /**
  * Converts a forwarding configuration target to the legacy format
  * for Port80Handler

package/dist_ts/core/events/index.d.ts

@@ -0,0 +1,4 @@
+export {};
+/**
+ * Common event definitions
+ */