@dorothywebb/any-browser-mcp/dist/core/ConfigManager.d.ts

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

/**
 * Configuration Manager for Any Browser MCP
 *
 * @fileoverview Handles loading, validation, and access to configuration settings.
 * Enforces safety policies to prevent auto-launching browsers during VS Code startup.
 *
 * @example
 * ```typescript
 * import { getConfigManager } from './ConfigManager.js';
 *
 * const config = getConfigManager();
 * const debugPort = config.getDebugPort();
 * const browserConfig = config.getBrowserConfig();
 * ```
 *
 * @category Core Components
 */
import { ValidatedAppConfig } from './ConfigValidator.js';
export interface BrowserConfig {
    type: 'chrome' | 'edge' | 'firefox';
    debugPort: number;
    autoLaunch: boolean;
    allowLaunch: boolean;
    useExistingOnly: boolean;
    endpoint?: string;
    connectionTimeout: number;
    retryAttempts: number;
    retryDelay: number;
    useSeparateInstance: boolean;
    mcpProfilePath: string;
    launchTimeout: number;
    confirmDestructiveActions: boolean;
    copyUserData: boolean;
    sourceProfilePath?: string;
}
export interface ServerConfig {
    strategy: 'direct-cdp' | 'playwright' | 'hybrid' | 'separate-instance';
    lazyInitialization: boolean;
    initializeOnStartup: boolean;
    connectOnFirstUse: boolean;
    verbose: boolean;
    maxConcurrentConnections: number;
}
export interface SafetyConfig {
    neverLaunchBrowser: boolean;
    requireExistingBrowser: boolean;
    validateConnection: boolean;
    timeoutConnections: boolean;
}
export interface AppConfig {
    browser: BrowserConfig;
    server: ServerConfig;
    safety: SafetyConfig;
    features: {
        preventAutoStart: boolean;
        useExistingTabs: boolean;
        preserveUserData: boolean;
        respectUserBrowser: boolean;
        errorRetry: boolean;
        gracefulFailure: boolean;
    };
    paths: {
        chrome: Record<string, string>;
    };
}
/**
 * Singleton configuration manager that handles all configuration-related operations.
 *
 * @description This class provides centralized access to application configuration,
 * enforces safety policies, and ensures configuration validation. It implements
 * the singleton pattern to maintain consistency across the application.
 *
 * @example
 * ```typescript
 * const configManager = ConfigManager.getInstance();
 * configManager.setVerbose(true);
 *
 * const browserConfig = configManager.getBrowserConfig();
 * console.log(`Debug port: ${browserConfig.debugPort}`);
 * ```
 */
export declare class ConfigManager {
    private config;
    private static instance;
    private verbose;
    /**
     * Private constructor to enforce singleton pattern.
     * Loads and validates configuration, then enforces safety policies.
     */
    private constructor();
    /**
     * Gets the singleton instance of ConfigManager.
     *
     * @returns The singleton ConfigManager instance
     *
     * @example
     * ```typescript
     * const config = ConfigManager.getInstance();
     * ```
     */
    static getInstance(): ConfigManager;
    private loadAndValidateConfig;
    private getDefaultConfig;
    /**
     * Enforce safe browser policy - allow separate instance launching but maintain safety
     */
    private enforceNeverLaunchPolicy;
    /**
     * Gets the browser configuration section.
     *
     * @returns Browser configuration including debug port, timeouts, and launch settings
     *
     * @example
     * ```typescript
     * const browserConfig = config.getBrowserConfig();
     * console.log(`Debug port: ${browserConfig.debugPort}`);
     * console.log(`Auto launch: ${browserConfig.autoLaunch}`);
     * ```
     */
    getBrowserConfig(): BrowserConfig;
    /**
     * Gets the server configuration section.
     *
     * @returns Server configuration including strategy and connection settings
     *
     * @example
     * ```typescript
     * const serverConfig = config.getServerConfig();
     * console.log(`Strategy: ${serverConfig.strategy}`);
     * console.log(`Lazy init: ${serverConfig.lazyInitialization}`);
     * ```
     */
    getServerConfig(): ServerConfig;
    /**
     * Gets the safety configuration section.
     *
     * @returns Safety configuration including validation and timeout settings
     *
     * @example
     * ```typescript
     * const safetyConfig = config.getSafetyConfig();
     * console.log(`Validate connection: ${safetyConfig.validateConnection}`);
     * ```
     */
    getSafetyConfig(): SafetyConfig;
    getFullConfig(): ValidatedAppConfig;
    shouldNeverLaunch(): boolean;
    shouldUseExistingOnly(): boolean;
    shouldInitializeOnStartup(): boolean;
    isLazyInitializationEnabled(): boolean;
    getDebugEndpoint(): string;
    getDebugPort(): number;
    isVerbose(): boolean;
    setVerbose(verbose: boolean): void;
    /**
     * Validate current configuration
     */
    validateCurrentConfig(): void;
    /**
     * Update configuration with validation
     */
    updateConfig(newConfig: Partial<ValidatedAppConfig>): void;
    /**
     * Get configuration validation report
     */
    getValidationReport(): any;
}
export declare function getConfigManager(): ConfigManager;
//# sourceMappingURL=ConfigManager.d.ts.map