@push.rocks/smartproxy 19.5.4 → 19.5.5

package/dist_ts/core/utils/fs-utils.js

@@ -0,0 +1,252 @@
+/**
+ * Async filesystem utilities for SmartProxy
+ * Provides non-blocking alternatives to synchronous filesystem operations
+ */
+import * as plugins from '../../plugins.js';
+export class AsyncFileSystem {
+    /**
+     * Check if a file or directory exists
+     * @param path - Path to check
+     * @returns Promise resolving to true if exists, false otherwise
+     */
+    static async exists(path) {
+        try {
+            await plugins.fs.promises.access(path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Ensure a directory exists, creating it if necessary
+     * @param dirPath - Directory path to ensure
+     * @returns Promise that resolves when directory is ensured
+     */
+    static async ensureDir(dirPath) {
+        await plugins.fs.promises.mkdir(dirPath, { recursive: true });
+    }
+    /**
+     * Read a file as string
+     * @param filePath - Path to the file
+     * @param encoding - File encoding (default: utf8)
+     * @returns Promise resolving to file contents
+     */
+    static async readFile(filePath, encoding = 'utf8') {
+        return plugins.fs.promises.readFile(filePath, encoding);
+    }
+    /**
+     * Read a file as buffer
+     * @param filePath - Path to the file
+     * @returns Promise resolving to file buffer
+     */
+    static async readFileBuffer(filePath) {
+        return plugins.fs.promises.readFile(filePath);
+    }
+    /**
+     * Write string data to a file
+     * @param filePath - Path to the file
+     * @param data - String data to write
+     * @param encoding - File encoding (default: utf8)
+     * @returns Promise that resolves when file is written
+     */
+    static async writeFile(filePath, data, encoding = 'utf8') {
+        // Ensure directory exists
+        const dir = plugins.path.dirname(filePath);
+        await this.ensureDir(dir);
+        await plugins.fs.promises.writeFile(filePath, data, encoding);
+    }
+    /**
+     * Write buffer data to a file
+     * @param filePath - Path to the file
+     * @param data - Buffer data to write
+     * @returns Promise that resolves when file is written
+     */
+    static async writeFileBuffer(filePath, data) {
+        const dir = plugins.path.dirname(filePath);
+        await this.ensureDir(dir);
+        await plugins.fs.promises.writeFile(filePath, data);
+    }
+    /**
+     * Remove a file
+     * @param filePath - Path to the file
+     * @returns Promise that resolves when file is removed
+     */
+    static async remove(filePath) {
+        try {
+            await plugins.fs.promises.unlink(filePath);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+            // File doesn't exist, which is fine
+        }
+    }
+    /**
+     * Remove a directory and all its contents
+     * @param dirPath - Path to the directory
+     * @returns Promise that resolves when directory is removed
+     */
+    static async removeDir(dirPath) {
+        try {
+            await plugins.fs.promises.rm(dirPath, { recursive: true, force: true });
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+        }
+    }
+    /**
+     * Read JSON from a file
+     * @param filePath - Path to the JSON file
+     * @returns Promise resolving to parsed JSON
+     */
+    static async readJSON(filePath) {
+        const content = await this.readFile(filePath);
+        return JSON.parse(content);
+    }
+    /**
+     * Write JSON to a file
+     * @param filePath - Path to the file
+     * @param data - Data to write as JSON
+     * @param pretty - Whether to pretty-print JSON (default: true)
+     * @returns Promise that resolves when file is written
+     */
+    static async writeJSON(filePath, data, pretty = true) {
+        const jsonString = pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+        await this.writeFile(filePath, jsonString);
+    }
+    /**
+     * Copy a file from source to destination
+     * @param source - Source file path
+     * @param destination - Destination file path
+     * @returns Promise that resolves when file is copied
+     */
+    static async copyFile(source, destination) {
+        const destDir = plugins.path.dirname(destination);
+        await this.ensureDir(destDir);
+        await plugins.fs.promises.copyFile(source, destination);
+    }
+    /**
+     * Move/rename a file
+     * @param source - Source file path
+     * @param destination - Destination file path
+     * @returns Promise that resolves when file is moved
+     */
+    static async moveFile(source, destination) {
+        const destDir = plugins.path.dirname(destination);
+        await this.ensureDir(destDir);
+        await plugins.fs.promises.rename(source, destination);
+    }
+    /**
+     * Get file stats
+     * @param filePath - Path to the file
+     * @returns Promise resolving to file stats or null if doesn't exist
+     */
+    static async getStats(filePath) {
+        try {
+            return await plugins.fs.promises.stat(filePath);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return null;
+            }
+            throw error;
+        }
+    }
+    /**
+     * List files in a directory
+     * @param dirPath - Directory path
+     * @returns Promise resolving to array of filenames
+     */
+    static async listFiles(dirPath) {
+        try {
+            return await plugins.fs.promises.readdir(dirPath);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return [];
+            }
+            throw error;
+        }
+    }
+    /**
+     * List files in a directory with full paths
+     * @param dirPath - Directory path
+     * @returns Promise resolving to array of full file paths
+     */
+    static async listFilesFullPath(dirPath) {
+        const files = await this.listFiles(dirPath);
+        return files.map(file => plugins.path.join(dirPath, file));
+    }
+    /**
+     * Recursively list all files in a directory
+     * @param dirPath - Directory path
+     * @param fileList - Accumulator for file list (used internally)
+     * @returns Promise resolving to array of all file paths
+     */
+    static async listFilesRecursive(dirPath, fileList = []) {
+        const files = await this.listFiles(dirPath);
+        for (const file of files) {
+            const filePath = plugins.path.join(dirPath, file);
+            const stats = await this.getStats(filePath);
+            if (stats?.isDirectory()) {
+                await this.listFilesRecursive(filePath, fileList);
+            }
+            else if (stats?.isFile()) {
+                fileList.push(filePath);
+            }
+        }
+        return fileList;
+    }
+    /**
+     * Create a read stream for a file
+     * @param filePath - Path to the file
+     * @param options - Stream options
+     * @returns Read stream
+     */
+    static createReadStream(filePath, options) {
+        return plugins.fs.createReadStream(filePath, options);
+    }
+    /**
+     * Create a write stream for a file
+     * @param filePath - Path to the file
+     * @param options - Stream options
+     * @returns Write stream
+     */
+    static createWriteStream(filePath, options) {
+        return plugins.fs.createWriteStream(filePath, options);
+    }
+    /**
+     * Ensure a file exists, creating an empty file if necessary
+     * @param filePath - Path to the file
+     * @returns Promise that resolves when file is ensured
+     */
+    static async ensureFile(filePath) {
+        const exists = await this.exists(filePath);
+        if (!exists) {
+            await this.writeFile(filePath, '');
+        }
+    }
+    /**
+     * Check if a path is a directory
+     * @param path - Path to check
+     * @returns Promise resolving to true if directory, false otherwise
+     */
+    static async isDirectory(path) {
+        const stats = await this.getStats(path);
+        return stats?.isDirectory() ?? false;
+    }
+    /**
+     * Check if a path is a file
+     * @param path - Path to check
+     * @returns Promise resolving to true if file, false otherwise
+     */
+    static async isFile(path) {
+        const stats = await this.getStats(path);
+        return stats?.isFile() ?? false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,7 +1,6 @@
 /**
  * Core utility functions
  */
-export * from './event-utils.js';
 export * from './validation-utils.js';
 export * from './ip-utils.js';
 export * from './template-utils.js';
@@ -9,6 +8,10 @@ export * from './route-manager.js';
 export * from './route-utils.js';
 export * from './security-utils.js';
 export * from './shared-security-manager.js';
-export * from './event-system.js';
 export * from './websocket-utils.js';
 export * from './logger.js';
+export * from './async-utils.js';
+export * from './fs-utils.js';
+export * from './lifecycle-component.js';
+export * from './binary-heap.js';
+export * from './enhanced-connection-pool.js';

package/dist_ts/core/utils/index.js

@@ -1,7 +1,6 @@
 /**
  * Core utility functions
  */
-export * from './event-utils.js';
 export * from './validation-utils.js';
 export * from './ip-utils.js';
 export * from './template-utils.js';
@@ -9,7 +8,11 @@ export * from './route-manager.js';
 export * from './route-utils.js';
 export * from './security-utils.js';
 export * from './shared-security-manager.js';
-export * from './event-system.js';
 export * from './websocket-utils.js';
 export * from './logger.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9jb3JlL3V0aWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsc0JBQXNCLENBQUM7QUFDckMsY0FBYyxhQUFhLENBQUMifQ==
+export * from './async-utils.js';
+export * from './fs-utils.js';
+export * from './lifecycle-component.js';
+export * from './binary-heap.js';
+export * from './enhanced-connection-pool.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9jb3JlL3V0aWxzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLCtCQUErQixDQUFDIn0=

package/dist_ts/core/utils/lifecycle-component.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Base class for components that need proper resource lifecycle management
+ * Provides automatic cleanup of timers and event listeners to prevent memory leaks
+ */
+export declare abstract class LifecycleComponent {
+    private timers;
+    private intervals;
+    private listeners;
+    private childComponents;
+    protected isShuttingDown: boolean;
+    private cleanupPromise?;
+    /**
+     * Create a managed setTimeout that will be automatically cleaned up
+     */
+    protected setTimeout(handler: Function, timeout: number): NodeJS.Timeout;
+    /**
+     * Create a managed setInterval that will be automatically cleaned up
+     */
+    protected setInterval(handler: Function, interval: number): NodeJS.Timeout;
+    /**
+     * Clear a managed timeout
+     */
+    protected clearTimeout(timer: NodeJS.Timeout): void;
+    /**
+     * Clear a managed interval
+     */
+    protected clearInterval(timer: NodeJS.Timeout): void;
+    /**
+     * Add a managed event listener that will be automatically removed on cleanup
+     */
+    protected addEventListener(target: any, event: string, handler: Function, options?: {
+        once?: boolean;
+    }): void;
+    /**
+     * Remove a specific event listener
+     */
+    protected removeEventListener(target: any, event: string, handler: Function): void;
+    /**
+     * Register a child component that should be cleaned up when this component is cleaned up
+     */
+    protected registerChildComponent(component: LifecycleComponent): void;
+    /**
+     * Unregister a child component
+     */
+    protected unregisterChildComponent(component: LifecycleComponent): void;
+    /**
+     * Override this method to implement component-specific cleanup logic
+     */
+    protected onCleanup(): Promise<void>;
+    /**
+     * Clean up all managed resources
+     */
+    cleanup(): Promise<void>;
+    private performCleanup;
+    /**
+     * Check if the component is shutting down
+     */
+    protected isShuttingDownState(): boolean;
+}

package/dist_ts/core/utils/lifecycle-component.js

@@ -0,0 +1,195 @@
+/**
+ * Base class for components that need proper resource lifecycle management
+ * Provides automatic cleanup of timers and event listeners to prevent memory leaks
+ */
+export class LifecycleComponent {
+    constructor() {
+        this.timers = new Set();
+        this.intervals = new Set();
+        this.listeners = [];
+        this.childComponents = new Set();
+        this.isShuttingDown = false;
+    }
+    /**
+     * Create a managed setTimeout that will be automatically cleaned up
+     */
+    setTimeout(handler, timeout) {
+        if (this.isShuttingDown) {
+            // Return a dummy timer if shutting down
+            return setTimeout(() => { }, 0);
+        }
+        const wrappedHandler = () => {
+            this.timers.delete(timer);
+            if (!this.isShuttingDown) {
+                handler();
+            }
+        };
+        const timer = setTimeout(wrappedHandler, timeout);
+        this.timers.add(timer);
+        return timer;
+    }
+    /**
+     * Create a managed setInterval that will be automatically cleaned up
+     */
+    setInterval(handler, interval) {
+        if (this.isShuttingDown) {
+            // Return a dummy timer if shutting down
+            return setInterval(() => { }, interval);
+        }
+        const wrappedHandler = () => {
+            if (!this.isShuttingDown) {
+                handler();
+            }
+        };
+        const timer = setInterval(wrappedHandler, interval);
+        this.intervals.add(timer);
+        // Allow process to exit even with timer
+        if (typeof timer.unref === 'function') {
+            timer.unref();
+        }
+        return timer;
+    }
+    /**
+     * Clear a managed timeout
+     */
+    clearTimeout(timer) {
+        clearTimeout(timer);
+        this.timers.delete(timer);
+    }
+    /**
+     * Clear a managed interval
+     */
+    clearInterval(timer) {
+        clearInterval(timer);
+        this.intervals.delete(timer);
+    }
+    /**
+     * Add a managed event listener that will be automatically removed on cleanup
+     */
+    addEventListener(target, event, handler, options) {
+        if (this.isShuttingDown) {
+            return;
+        }
+        // For 'once' listeners, we need to wrap the handler to remove it from our tracking
+        let actualHandler = handler;
+        if (options?.once) {
+            actualHandler = (...args) => {
+                // Call the original handler
+                handler(...args);
+                // Remove from our internal tracking
+                const index = this.listeners.findIndex(l => l.target === target && l.event === event && l.handler === handler);
+                if (index !== -1) {
+                    this.listeners.splice(index, 1);
+                }
+            };
+        }
+        // Support both EventEmitter and DOM-style event targets
+        if (typeof target.on === 'function') {
+            if (options?.once) {
+                target.once(event, actualHandler);
+            }
+            else {
+                target.on(event, actualHandler);
+            }
+        }
+        else if (typeof target.addEventListener === 'function') {
+            target.addEventListener(event, actualHandler, options);
+        }
+        else {
+            throw new Error('Target must support on() or addEventListener()');
+        }
+        // Store the original handler in our tracking (not the wrapped one)
+        this.listeners.push({
+            target,
+            event,
+            handler,
+            once: options?.once
+        });
+    }
+    /**
+     * Remove a specific event listener
+     */
+    removeEventListener(target, event, handler) {
+        // Remove from target
+        if (typeof target.removeListener === 'function') {
+            target.removeListener(event, handler);
+        }
+        else if (typeof target.removeEventListener === 'function') {
+            target.removeEventListener(event, handler);
+        }
+        // Remove from our tracking
+        const index = this.listeners.findIndex(l => l.target === target && l.event === event && l.handler === handler);
+        if (index !== -1) {
+            this.listeners.splice(index, 1);
+        }
+    }
+    /**
+     * Register a child component that should be cleaned up when this component is cleaned up
+     */
+    registerChildComponent(component) {
+        this.childComponents.add(component);
+    }
+    /**
+     * Unregister a child component
+     */
+    unregisterChildComponent(component) {
+        this.childComponents.delete(component);
+    }
+    /**
+     * Override this method to implement component-specific cleanup logic
+     */
+    async onCleanup() {
+        // Override in subclasses
+    }
+    /**
+     * Clean up all managed resources
+     */
+    async cleanup() {
+        // Return existing cleanup promise if already cleaning up
+        if (this.cleanupPromise) {
+            return this.cleanupPromise;
+        }
+        this.cleanupPromise = this.performCleanup();
+        return this.cleanupPromise;
+    }
+    async performCleanup() {
+        this.isShuttingDown = true;
+        // First, clean up child components
+        const childCleanupPromises = [];
+        for (const child of this.childComponents) {
+            childCleanupPromises.push(child.cleanup());
+        }
+        await Promise.all(childCleanupPromises);
+        this.childComponents.clear();
+        // Clear all timers
+        for (const timer of this.timers) {
+            clearTimeout(timer);
+        }
+        this.timers.clear();
+        // Clear all intervals
+        for (const timer of this.intervals) {
+            clearInterval(timer);
+        }
+        this.intervals.clear();
+        // Remove all event listeners
+        for (const { target, event, handler } of this.listeners) {
+            // All listeners need to be removed, including 'once' listeners that might not have fired
+            if (typeof target.removeListener === 'function') {
+                target.removeListener(event, handler);
+            }
+            else if (typeof target.removeEventListener === 'function') {
+                target.removeEventListener(event, handler);
+            }
+        }
+        this.listeners = [];
+        // Call subclass cleanup
+        await this.onCleanup();
+    }
+    /**
+     * Check if the component is shutting down
+     */
+    isShuttingDownState() {
+        return this.isShuttingDown;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/plugins.d.ts

@@ -3,10 +3,11 @@ import * as fs from 'fs';
 import * as http from 'http';
 import * as https from 'https';
 import * as net from 'net';
+import * as path from 'path';
 import * as tls from 'tls';
 import * as url from 'url';
 import * as http2 from 'http2';
-export { EventEmitter, fs, http, https, net, tls, url, http2 };
+export { EventEmitter, fs, http, https, net, path, tls, url, http2 };
 import * as tsclass from '@tsclass/tsclass';
 export { tsclass };
 import * as lik from '@push.rocks/lik';

package/dist_ts/plugins.js

@@ -4,10 +4,11 @@ import * as fs from 'fs';
 import * as http from 'http';
 import * as https from 'https';
 import * as net from 'net';
+import * as path from 'path';
 import * as tls from 'tls';
 import * as url from 'url';
 import * as http2 from 'http2';
-export { EventEmitter, fs, http, https, net, tls, url, http2 };
+export { EventEmitter, fs, http, https, net, path, tls, url, http2 };
 // tsclass scope
 import * as tsclass from '@tsclass/tsclass';
 export { tsclass };
@@ -32,4 +33,4 @@ import * as ws from 'ws';
 import wsDefault from 'ws';
 import { minimatch } from 'minimatch';
 export { prettyMs, ws, wsDefault, minimatch };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxRQUFRLENBQUM7QUFDdEMsT0FBTyxLQUFLLEVBQUUsTUFBTSxJQUFJLENBQUM7QUFDekIsT0FBTyxLQUFLLElBQUksTUFBTSxNQUFNLENBQUM7QUFDN0IsT0FBTyxLQUFLLEtBQUssTUFBTSxPQUFPLENBQUM7QUFDL0IsT0FBTyxLQUFLLEdBQUcsTUFBTSxLQUFLLENBQUM7QUFDM0IsT0FBTyxLQUFLLEdBQUcsTUFBTSxLQUFLLENBQUM7QUFDM0IsT0FBTyxLQUFLLEdBQUcsTUFBTSxLQUFLLENBQUM7QUFDM0IsT0FBTyxLQUFLLEtBQUssTUFBTSxPQUFPLENBQUM7QUFFL0IsT0FBTyxFQUFFLFlBQVksRUFBRSxFQUFFLEVBQUUsSUFBSSxFQUFFLEtBQUssRUFBRSxHQUFHLEVBQUUsR0FBRyxFQUFFLEdBQUcsRUFBRSxLQUFLLEVBQUUsQ0FBQztBQUUvRCxnQkFBZ0I7QUFDaEIsT0FBTyxLQUFLLE9BQU8sTUFBTSxrQkFBa0IsQ0FBQztBQUU1QyxPQUFPLEVBQUUsT0FBTyxFQUFFLENBQUM7QUFFbkIsa0JBQWtCO0FBQ2xCLE9BQU8sS0FBSyxHQUFHLE1BQU0saUJBQWlCLENBQUM7QUFDdkMsT0FBTyxLQUFLLFVBQVUsTUFBTSx3QkFBd0IsQ0FBQztBQUNyRCxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxLQUFLLFdBQVcsTUFBTSx5QkFBeUIsQ0FBQztBQUN2RCxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBQ25ELE9BQU8sS0FBSyxXQUFXLE1BQU0seUJBQXlCLENBQUM7QUFDdkQsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssZ0JBQWdCLE1BQU0sb0RBQW9ELENBQUM7QUFDdkYsT0FBTyxLQUFLLGlCQUFpQixNQUFNLGlEQUFpRCxDQUFDO0FBQ3JGLE9BQU8sS0FBSyxRQUFRLE1BQU0sc0JBQXNCLENBQUM7QUFDakQsT0FBTyxLQUFLLHdCQUF3QixNQUFNLHdDQUF3QyxDQUFDO0FBQ25GLE9BQU8sS0FBSyxVQUFVLE1BQU0sd0JBQXdCLENBQUM7QUFFckQsT0FBTyxFQUNMLEdBQUcsRUFDSCxVQUFVLEVBQ1YsWUFBWSxFQUNaLFlBQVksRUFDWixXQUFXLEVBQ1gsU0FBUyxFQUNULFdBQVcsRUFDWCxTQUFTLEVBQ1QsZ0JBQWdCLEVBQ2hCLGlCQUFpQixFQUNqQixRQUFRLEVBQ1Isd0JBQXdCLEVBQ3hCLFVBQVUsR0FDWCxDQUFDO0FBRUYsb0JBQW9CO0FBQ3BCLE9BQU8sUUFBUSxNQUFNLFdBQVcsQ0FBQztBQUNqQyxPQUFPLEtBQUssRUFBRSxNQUFNLElBQUksQ0FBQztBQUN6QixPQUFPLFNBQVMsTUFBTSxJQUFJLENBQUM7QUFDM0IsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLFdBQVcsQ0FBQztBQUV0QyxPQUFPLEVBQUUsUUFBUSxFQUFFLEVBQUUsRUFBRSxTQUFTLEVBQUUsU0FBUyxFQUFFLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxRQUFRLENBQUM7QUFDdEMsT0FBTyxLQUFLLEVBQUUsTUFBTSxJQUFJLENBQUM7QUFDekIsT0FBTyxLQUFLLElBQUksTUFBTSxNQUFNLENBQUM7QUFDN0IsT0FBTyxLQUFLLEtBQUssTUFBTSxPQUFPLENBQUM7QUFDL0IsT0FBTyxLQUFLLEdBQUcsTUFBTSxLQUFLLENBQUM7QUFDM0IsT0FBTyxLQUFLLElBQUksTUFBTSxNQUFNLENBQUM7QUFDN0IsT0FBTyxLQUFLLEdBQUcsTUFBTSxLQUFLLENBQUM7QUFDM0IsT0FBTyxLQUFLLEdBQUcsTUFBTSxLQUFLLENBQUM7QUFDM0IsT0FBTyxLQUFLLEtBQUssTUFBTSxPQUFPLENBQUM7QUFFL0IsT0FBTyxFQUFFLFlBQVksRUFBRSxFQUFFLEVBQUUsSUFBSSxFQUFFLEtBQUssRUFBRSxHQUFHLEVBQUUsSUFBSSxFQUFFLEdBQUcsRUFBRSxHQUFHLEVBQUUsS0FBSyxFQUFFLENBQUM7QUFFckUsZ0JBQWdCO0FBQ2hCLE9BQU8sS0FBSyxPQUFPLE1BQU0sa0JBQWtCLENBQUM7QUFFNUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxDQUFDO0FBRW5CLGtCQUFrQjtBQUNsQixPQUFPLEtBQUssR0FBRyxNQUFNLGlCQUFpQixDQUFDO0FBQ3ZDLE9BQU8sS0FBSyxVQUFVLE1BQU0sd0JBQXdCLENBQUM7QUFDckQsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxXQUFXLE1BQU0seUJBQXlCLENBQUM7QUFDdkQsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssV0FBVyxNQUFNLHlCQUF5QixDQUFDO0FBQ3ZELE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFDbkQsT0FBTyxLQUFLLGdCQUFnQixNQUFNLG9EQUFvRCxDQUFDO0FBQ3ZGLE9BQU8sS0FBSyxpQkFBaUIsTUFBTSxpREFBaUQsQ0FBQztBQUNyRixPQUFPLEtBQUssUUFBUSxNQUFNLHNCQUFzQixDQUFDO0FBQ2pELE9BQU8sS0FBSyx3QkFBd0IsTUFBTSx3Q0FBd0MsQ0FBQztBQUNuRixPQUFPLEtBQUssVUFBVSxNQUFNLHdCQUF3QixDQUFDO0FBRXJELE9BQU8sRUFDTCxHQUFHLEVBQ0gsVUFBVSxFQUNWLFlBQVksRUFDWixZQUFZLEVBQ1osV0FBVyxFQUNYLFNBQVMsRUFDVCxXQUFXLEVBQ1gsU0FBUyxFQUNULGdCQUFnQixFQUNoQixpQkFBaUIsRUFDakIsUUFBUSxFQUNSLHdCQUF3QixFQUN4QixVQUFVLEdBQ1gsQ0FBQztBQUVGLG9CQUFvQjtBQUNwQixPQUFPLFFBQVEsTUFBTSxXQUFXLENBQUM7QUFDakMsT0FBTyxLQUFLLEVBQUUsTUFBTSxJQUFJLENBQUM7QUFDekIsT0FBTyxTQUFTLE1BQU0sSUFBSSxDQUFDO0FBQzNCLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFFdEMsT0FBTyxFQUFFLFFBQVEsRUFBRSxFQUFFLEVBQUUsU0FBUyxFQUFFLFNBQVMsRUFBRSxDQUFDIn0=

package/dist_ts/proxies/http-proxy/certificate-manager.d.ts

@@ -14,11 +14,26 @@ export declare class CertificateManager {
     private certificateStoreDir;
     private logger;
     private httpsServer;
+    private initialized;
     constructor(options: IHttpProxyOptions);
+    /**
+     * Synchronous initialization for backward compatibility
+     * @deprecated This uses sync filesystem operations which block the event loop
+     */
+    private initializeSync;
+    /**
+     * Async initialization - preferred method
+     */
+    initialize(): Promise<void>;
     /**
      * Loads default certificates from the filesystem
+     * @deprecated This uses sync filesystem operations which block the event loop
      */
     loadDefaultCertificates(): void;
+    /**
+     * Loads default certificates from the filesystem asynchronously
+     */
+    loadDefaultCertificatesAsync(): Promise<void>;
     /**
      * Generates self-signed certificates as fallback
      */