@dorothywebb/any-browser-mcp/dist/utils/ResourceManager.d.ts

Any Browser MCP - Launch Chrome with your actual data in debug mode for comprehensive browser automation

/**
 * Resource Manager for Any Browser MCP
 *
 * @fileoverview Manages system resources including memory usage, connection limits,
 * and performance monitoring. Provides automatic resource cleanup and optimization.
 *
 * @example
 * ```typescript
 * import { ResourceManager } from './ResourceManager.js';
 *
 * const resourceManager = ResourceManager.getInstance();
 *
 * // Monitor resource usage
 * const usage = resourceManager.getResourceUsage();
 * console.log(`Memory usage: ${usage.memoryUsage.heapUsed / 1024 / 1024} MB`);
 *
 * // Register a resource for cleanup
 * resourceManager.registerResource('connection-1', async () => {
 *   await connection.close();
 * });
 * ```
 *
 * @category Utilities
 */
/// <reference types="node" resolution-mode="require"/>
/// <reference types="node" resolution-mode="require"/>
import { EventEmitter } from 'events';
/**
 * Resource usage information.
 */
export interface ResourceUsage {
    /** Memory usage statistics */
    memoryUsage: NodeJS.MemoryUsage;
    /** CPU usage percentage (if available) */
    cpuUsage?: number;
    /** Number of active connections */
    activeConnections: number;
    /** Number of registered resources */
    registeredResources: number;
    /** Uptime in milliseconds */
    uptime: number;
    /** Timestamp of measurement */
    timestamp: Date;
}
/**
 * Resource limits configuration.
 */
export interface ResourceLimits {
    /** Maximum memory usage in bytes */
    maxMemoryUsage?: number;
    /** Maximum number of connections */
    maxConnections?: number;
    /** Maximum CPU usage percentage */
    maxCpuUsage?: number;
    /** Memory cleanup threshold percentage */
    memoryCleanupThreshold?: number;
}
/**
 * Resource cleanup function.
 */
export type CleanupFunction = () => Promise<void> | void;
/**
 * Registered resource information.
 */
interface RegisteredResource {
    /** Unique identifier for the resource */
    id: string;
    /** Cleanup function for the resource */
    cleanup: CleanupFunction;
    /** When the resource was registered */
    registeredAt: Date;
    /** Resource type/category */
    type: string;
    /** Resource metadata */
    metadata?: Record<string, any>;
}
/**
 * Resource manager events.
 */
export interface ResourceManagerEvents {
    /** Emitted when resource usage exceeds limits */
    'resource-limit-exceeded': (usage: ResourceUsage, limit: keyof ResourceLimits) => void;
    /** Emitted when resources are cleaned up */
    'resources-cleaned': (count: number) => void;
    /** Emitted when memory cleanup is triggered */
    'memory-cleanup': (beforeUsage: number, afterUsage: number) => void;
    /** Emitted when resource monitoring detects issues */
    'resource-warning': (message: string, usage: ResourceUsage) => void;
}
/**
 * Resource manager for monitoring and managing system resources.
 *
 * @description This class provides centralized resource management including
 * memory monitoring, connection tracking, automatic cleanup, and performance
 * optimization. It helps prevent resource leaks and maintains system stability.
 */
export declare class ResourceManager extends EventEmitter {
    private static instance;
    private resources;
    private limits;
    private config;
    private monitoringInterval?;
    private startTime;
    private activeConnections;
    /**
     * Private constructor to enforce singleton pattern.
     */
    private constructor();
    /**
     * Gets the singleton instance of ResourceManager.
     *
     * @returns The singleton ResourceManager instance
     */
    static getInstance(): ResourceManager;
    /**
     * Registers a resource for automatic cleanup.
     *
     * @param id - Unique identifier for the resource
     * @param cleanup - Function to call when cleaning up the resource
     * @param type - Type/category of the resource
     * @param metadata - Optional metadata about the resource
     *
     * @example
     * ```typescript
     * resourceManager.registerResource(
     *   'browser-connection-1',
     *   async () => await connection.close(),
     *   'connection',
     *   { port: 9223, pid: 12345 }
     * );
     * ```
     */
    registerResource(id: string, cleanup: CleanupFunction, type?: string, metadata?: Record<string, any>): void;
    /**
     * Unregisters a resource.
     *
     * @param id - Unique identifier of the resource to unregister
     * @param cleanup - Whether to run cleanup function before unregistering
     *
     * @example
     * ```typescript
     * await resourceManager.unregisterResource('browser-connection-1', true);
     * ```
     */
    unregisterResource(id: string, cleanup?: boolean): Promise<void>;
    /**
     * Gets current resource usage information.
     *
     * @returns Current resource usage statistics
     */
    getResourceUsage(): ResourceUsage;
    /**
     * Sets resource limits.
     *
     * @param limits - New resource limits to apply
     *
     * @example
     * ```typescript
     * resourceManager.setLimits({
     *   maxMemoryUsage: 1024 * 1024 * 1024, // 1 GB
     *   maxConnections: 10
     * });
     * ```
     */
    setLimits(limits: Partial<ResourceLimits>): void;
    /**
     * Gets current resource limits.
     *
     * @returns Current resource limits
     */
    getLimits(): ResourceLimits;
    /**
     * Increments the active connection count.
     */
    incrementConnections(): void;
    /**
     * Decrements the active connection count.
     */
    decrementConnections(): void;
    /**
     * Forces garbage collection if available.
     *
     * @returns Whether garbage collection was triggered
     */
    forceGarbageCollection(): boolean;
    /**
     * Cleans up all registered resources.
     *
     * @param type - Optional type filter for cleanup
     *
     * @example
     * ```typescript
     * // Clean up all resources
     * await resourceManager.cleanupResources();
     *
     * // Clean up only connection resources
     * await resourceManager.cleanupResources('connection');
     * ```
     */
    cleanupResources(type?: string): Promise<void>;
    /**
     * Shuts down the resource manager and cleans up all resources.
     */
    shutdown(): Promise<void>;
    /**
     * Gets a list of all registered resources.
     *
     * @param type - Optional type filter
     * @returns Array of registered resources
     */
    getRegisteredResources(type?: string): RegisteredResource[];
    /**
     * Starts resource monitoring.
     */
    private startMonitoring;
    /**
     * Checks current resource usage against limits.
     */
    private checkResourceUsage;
    /**
     * Sets up process event handlers for cleanup.
     */
    private setupProcessHandlers;
}
/**
 * Global resource manager instance.
 */
export declare const globalResourceManager: ResourceManager;
export {};
//# sourceMappingURL=ResourceManager.d.ts.map