insite-mcp/dist/browser-manager.d.ts

MCP server for browser automation with 52 tools using Playwright

/**
 * Browser Manager - Singleton class for managing Playwright browser lifecycle
 */
import { type Browser, type BrowserContext, type Page } from 'playwright';
import { type WaitCondition } from './types.js';
/**
 * Console log entry interface
 */
interface ConsoleLogEntry {
    timestamp: Date;
    level: string;
    text: string;
    location?: string;
}
/**
 * Network request log entry interface
 */
interface NetworkLogEntry {
    timestamp: Date;
    method: string;
    url: string;
    status?: number;
    statusText?: string;
    requestHeaders: Record<string, string>;
    responseHeaders?: Record<string, string>;
    size?: number;
    duration?: number;
}
/**
 * Supported browser engines
 */
export type BrowserEngine = 'chromium' | 'firefox' | 'webkit';
/**
 * Configuration options for browser initialization
 */
interface BrowserConfig {
    headless?: boolean;
    engine?: BrowserEngine;
    viewport?: {
        width: number;
        height: number;
    };
    userAgent?: string;
    timeout?: number;
}
/**
 * Singleton class managing browser lifecycle and page operations
 */
export declare class BrowserManager {
    private static instance;
    private browser;
    private context;
    private page;
    private config;
    private consoleLogs;
    private networkLogs;
    private pendingRequests;
    private constructor();
    /**
     * Get singleton instance of BrowserManager
     */
    static getInstance(config?: BrowserConfig): BrowserManager;
    /**
     * Initialize browser and create default context/page
     */
    initialize(): Promise<void>;
    /**
     * Get browser type based on engine configuration
     */
    private getBrowserType;
    /**
     * Get browser-specific launch options
     */
    private getBrowserLaunchOptions;
    /**
     * Get current page instance
     */
    getPage(): Page;
    /**
     * Get current browser instance
     */
    getBrowser(): Browser;
    /**
     * Get current browser context
     */
    getContext(): BrowserContext;
    /**
     * Navigate to URL with proper error handling
     */
    navigateToUrl(url: string, waitUntil?: WaitCondition): Promise<void>;
    /**
     * Take screenshot and save to temp directory
     */
    takeScreenshot(options: {
        fullPage?: boolean;
        quality?: number;
        format?: 'png' | 'jpeg';
        filePath: string;
    }): Promise<string>;
    /**
     * Scroll to an element and take a screenshot of it
     */
    scrollToElementAndScreenshot(selector: string, options: {
        filePath: string;
        quality?: number;
        format?: 'png' | 'jpeg';
        padding?: number;
        timeout?: number;
    }): Promise<string>;
    /**
     * Capture the entire scrollable page height in one long image
     */
    captureFullScrollablePage(options: {
        filePath: string;
        quality?: number;
        format?: 'png' | 'jpeg';
        timeout?: number;
    }): Promise<string>;
    /**
     * Get current URL
     */
    getCurrentUrl(): string;
    /**
     * Get page title
     */
    getPageTitle(): Promise<string>;
    /**
     * Get viewport information
     */
    getViewportInfo(): {
        width: number;
        height: number;
        devicePixelRatio: number;
    };
    /**
     * Get DOM content
     */
    getDOMContent(selector?: string): Promise<string>;
    /**
     * Click element by selector
     */
    clickElement(selector: string, options?: {
        timeout?: number;
        force?: boolean;
    }): Promise<void>;
    /**
     * Type text into an element
     */
    typeText(selector: string, text: string, options?: {
        delay?: number;
        timeout?: number;
        clear?: boolean;
    }): Promise<void>;
    /**
     * Hover over an element
     */
    hoverElement(selector: string, options?: {
        timeout?: number;
        force?: boolean;
    }): Promise<void>;
    /**
     * Scroll the page or an element
     */
    scrollPage(options?: {
        direction?: 'up' | 'down' | 'left' | 'right';
        amount?: number;
        selector?: string;
    }): Promise<void>;
    /**
     * Press a keyboard key or key combination
     */
    pressKey(key: string, options?: {
        selector?: string;
        timeout?: number;
    }): Promise<void>;
    /**
     * Wait for an element to be in a specific state
     */
    waitForElement(selector: string, options?: {
        state?: 'visible' | 'hidden' | 'attached' | 'detached';
        timeout?: number;
    }): Promise<void>;
    /**
     * Wait for navigation to complete
     */
    waitForNavigation(options?: {
        url?: string | RegExp;
        timeout?: number;
        waitUntil?: WaitCondition;
    }): Promise<void>;
    /**
     * Navigate back in browser history
     */
    goBack(options?: {
        timeout?: number;
        waitUntil?: WaitCondition;
    }): Promise<void>;
    /**
     * Navigate forward in browser history
     */
    goForward(options?: {
        timeout?: number;
        waitUntil?: WaitCondition;
    }): Promise<void>;
    /**
     * Reload the current page
     */
    reloadPage(options?: {
        ignoreCache?: boolean;
        timeout?: number;
        waitUntil?: WaitCondition;
    }): Promise<void>;
    /**
     * Execute JavaScript code in the page context
     */
    evaluateJavaScript(code: string, options?: {
        timeout?: number;
    }): Promise<unknown>;
    /**
     * Execute JavaScript code on a specific element
     */
    evaluateJavaScriptOnElement(selector: string, code: string, options?: {
        timeout?: number;
    }): Promise<unknown>;
    /**
     * Get element information using JavaScript evaluation
     */
    getElementInfo(selector: string, options?: {
        timeout?: number;
    }): Promise<{
        tagName: string;
        id?: string;
        className?: string;
        textContent?: string;
        innerHTML?: string;
        attributes: Record<string, string>;
        computedStyle: Record<string, string>;
        boundingRect: {
            x: number;
            y: number;
            width: number;
            height: number;
            top: number;
            left: number;
            right: number;
            bottom: number;
        };
        visible: boolean;
        enabled: boolean;
    }>;
    /**
     * Get console logs with optional filtering
     */
    getConsoleLogs(options?: {
        level?: string;
        limit?: number;
    }): ConsoleLogEntry[];
    /**
     * Clear stored console logs
     */
    clearConsoleLogs(): void;
    /**
     * Get network logs with optional filtering
     */
    getNetworkLogs(options?: {
        method?: string;
        status?: number;
        urlPattern?: string;
        limit?: number;
    }): NetworkLogEntry[];
    /**
     * Clear stored network logs
     */
    clearNetworkLogs(): void;
    /**
     * Set viewport size
     */
    setViewportSize(width: number, height: number): Promise<void>;
    /**
     * Set user agent string
     */
    setUserAgent(userAgent: string): Promise<void>;
    /**
     * Set geolocation
     */
    setGeolocation(latitude: number, longitude: number, accuracy?: number): Promise<void>;
    /**
     * Close browser and cleanup resources
     */
    close(): Promise<void>;
    /**
     * Switch to a different browser engine
     */
    switchBrowserEngine(engine: BrowserEngine): Promise<void>;
    /**
     * Get current browser information
     */
    getBrowserInfo(): {
        engine: BrowserEngine;
        version?: string;
        isInitialized: boolean;
    };
    /**
     * Get list of available browser engines
     */
    static getAvailableEngines(): BrowserEngine[];
    /**
     * Check if browser is initialized and ready
     */
    isInitialized(): boolean;
    /**
     * Highlight elements on the page for debugging
     */
    highlightElement(selector: string, options?: {
        style?: {
            border?: string;
            backgroundColor?: string;
            outline?: string;
        };
        duration?: number;
        showInfo?: boolean;
        timeout?: number;
    }): Promise<{
        highlightedCount: number;
        elementInfo?: Array<{
            tagName: string;
            id?: string;
            classes: string[];
            text?: string;
            bounds: {
                x: number;
                y: number;
                width: number;
                height: number;
            };
        }>;
    }>;
    /**
     * Private property to track debug state
     */
    private debugState;
    /**
     * Enable/disable debug mode with enhanced logging
     */
    enableDebugMode(options: {
        enabled: boolean;
        level?: 'verbose' | 'info' | 'warn' | 'error';
        features?: {
            consoleLogging?: boolean;
            networkLogging?: boolean;
            performanceMonitoring?: boolean;
            elementInspection?: boolean;
            errorTracking?: boolean;
        };
        outputPath?: string;
    }): Promise<{
        status: string;
        features: string[];
    }>;
    /**
     * Enable execution tracing for debugging
     */
    enableTracing(options?: {
        enabled?: boolean;
        screenshots?: boolean;
        snapshots?: boolean;
        sources?: boolean;
        network?: boolean;
        console?: boolean;
        path?: string;
    }): Promise<{
        status: string;
        tracePath?: string;
    }>;
    /**
     * Capture performance timeline data
     */
    capturePerformanceTimeline(options?: {
        categories?: string[];
        duration?: number;
        includeMetrics?: boolean;
        format?: 'json' | 'timeline' | 'summary';
    }): Promise<{
        format: string;
        data: any;
        metrics?: Record<string, number>;
        timestamp: Date;
    }>;
    /**
     * Handle Content Security Policy configuration and checking
     */
    handleCSP(options: {
        action: 'bypass' | 'enforce' | 'report' | 'check';
        policies?: string[];
        bypassUnsafe?: boolean;
        reportOnly?: boolean;
        violationCallback?: string;
    }): Promise<{
        action: string;
        status: string;
        policies?: string[];
        violations?: Array<{
            directive: string;
            blockedURI: string;
            violatedDirective: string;
            originalPolicy: string;
        }>;
        message: string;
    }>;
    /**
     * Manage SSL certificates and validation
     */
    manageCertificates(options: {
        action: 'validate' | 'ignore' | 'add_trusted' | 'check_chain' | 'get_info';
        url?: string;
        certificatePath?: string;
        ignoreHTTPSErrors?: boolean;
        checkExpiry?: boolean;
        validateChain?: boolean;
    }): Promise<{
        action: string;
        status: string;
        certificateInfo?: {
            subject: string;
            issuer: string;
            validFrom: string;
            validTo: string;
            serialNumber: string;
            fingerprint: string;
            isValid: boolean;
            isExpired: boolean;
            daysUntilExpiry: number;
        };
        chain?: Array<{
            subject: string;
            issuer: string;
            validFrom: string;
            validTo: string;
        }>;
        message: string;
    }>;
    /**
     * Validate security aspects of the current page
     */
    validateSecurity(options?: {
        checks?: string[];
        level?: 'basic' | 'intermediate' | 'advanced';
        includeHeaders?: boolean;
        scanContent?: boolean;
        reportFormat?: 'summary' | 'detailed' | 'json';
    }): Promise<{
        level: string;
        overallScore: number;
        results: Array<{
            check: string;
            status: 'pass' | 'fail' | 'warn' | 'info';
            message: string;
            details?: any;
        }>;
        headers?: Record<string, string>;
        recommendations?: string[];
        summary: {
            passed: number;
            failed: number;
            warnings: number;
            total: number;
        };
    }>;
    /**
     * Private property to track analytics state
     */
    private analyticsState;
    /**
     * Usage analytics management
     */
    manageUsageAnalytics(options: {
        action: 'start_tracking' | 'stop_tracking' | 'get_report' | 'reset_data' | 'configure';
        trackingConfig?: {
            trackPageViews?: boolean;
            trackUserInteractions?: boolean;
            trackPerformance?: boolean;
            trackErrors?: boolean;
            sessionTimeout?: number;
        };
        reportFormat?: 'summary' | 'detailed' | 'json' | 'csv';
        timeRange?: {
            start?: string;
            end?: string;
            preset?: 'last_hour' | 'last_day' | 'last_week' | 'last_month' | 'all_time';
        };
    }): Promise<{
        action: string;
        status: string;
        data?: any;
        message: string;
    }>;
    /**
     * Error tracking management
     */
    manageErrorTracking(options: {
        action: 'start_monitoring' | 'stop_monitoring' | 'get_errors' | 'clear_errors' | 'configure_alerts';
        errorTypes?: string[];
        alertConfig?: {
            enableAlerts?: boolean;
            threshold?: number;
            timeWindow?: number;
            notificationMethod?: 'console' | 'file' | 'webhook';
        };
        filters?: {
            severity?: 'all' | 'critical' | 'error' | 'warning' | 'info';
            source?: string;
            limit?: number;
        };
    }): Promise<{
        action: string;
        status: string;
        data?: any;
        message: string;
    }>;
    /**
     * Performance monitoring management
     */
    managePerformanceMonitoring(options: {
        action: 'start_monitoring' | 'stop_monitoring' | 'get_metrics' | 'analyze_performance' | 'set_thresholds';
        metrics?: string[];
        thresholds?: {
            pageLoadTime?: number;
            firstContentfulPaint?: number;
            largestContentfulPaint?: number;
            cumulativeLayoutShift?: number;
            memoryUsage?: number;
        };
        samplingInterval?: number;
        reportFormat?: 'realtime' | 'summary' | 'detailed' | 'chart_data';
    }): Promise<{
        action: string;
        status: string;
        data?: any;
        message: string;
    }>;
    /**
     * Session analytics management
     */
    manageSessionAnalytics(options: {
        action: 'start_session' | 'end_session' | 'get_session_data' | 'analyze_journey' | 'export_sessions';
        sessionConfig?: {
            trackPageFlow?: boolean;
            trackInteractionSequence?: boolean;
            trackTimings?: boolean;
            trackFormInteractions?: boolean;
            captureScreenshots?: boolean;
        };
        analysisType?: 'funnel_analysis' | 'path_analysis' | 'interaction_heatmap' | 'time_analysis' | 'conversion_analysis';
        filters?: {
            minDuration?: number;
            maxDuration?: number;
            browserEngine?: string;
            dateRange?: {
                start: string;
                end: string;
            };
        };
        exportFormat?: 'json' | 'csv' | 'timeline' | 'report';
    }): Promise<{
        action: string;
        status: string;
        data?: any;
        message: string;
    }>;
    private getTopPages;
    private getErrorBreakdown;
    private analyzePerformanceMetrics;
    private calculateAvgSessionDuration;
    private getBrowserEngineDistribution;
    private performJourneyAnalysis;
    private exportSessionData;
    /**
     * Playwright Test adapter for seamless integration
     */
    playwrightTestAdapter(action: string, config?: any, testPath?: string, _reportFormat?: string, outputDir?: string): Promise<any>;
    /**
     * Jest adapter for browser automation testing
     */
    jestAdapter(action: string, config?: any, testPath?: string, watchMode?: boolean, bail?: number, verbose?: boolean): Promise<any>;
    /**
     * Mocha adapter for browser automation testing
     */
    mochaAdapter(action: string, config?: any, testPath?: string, bail?: boolean, watch?: boolean, require?: string[]): Promise<any>;
    /**
     * Advanced test reporting and result aggregation
     */
    testReporter(action: string, sources?: Array<{
        framework: string;
        resultsPath: string;
        format: string;
    }>, outputFormat?: string, outputPath?: string, includeScreenshots?: boolean, includeVideos?: boolean, analytics?: any, _filters?: any, compareWith?: string, threshold?: any): Promise<any>;
}
export {};
//# sourceMappingURL=browser-manager.d.ts.map