accessibility-server-mcp 1.0.0

package/dist/types/accessibility.d.ts

@@ -0,0 +1,172 @@
+/**
+ * Core types and interfaces for accessibility testing
+ */
+export type WCAGLevel = 'A' | 'AA' | 'AAA';
+export type WCAGVersion = '2.0' | '2.1' | '2.2';
+export type ViolationSeverity = 'minor' | 'moderate' | 'serious' | 'critical';
+export type AccessibilityCategory = 'color' | 'keyboard' | 'images' | 'headings' | 'landmarks' | 'forms' | 'links' | 'tables' | 'aria' | 'structure';
+/**
+ * Represents an accessibility violation found during testing
+ */
+export interface AccessibilityViolation {
+    /** Unique identifier for the violation rule */
+    id: string;
+    /** Impact level of the violation */
+    impact: ViolationSeverity;
+    /** Human-readable description of the violation */
+    description: string;
+    /** Help text explaining how to fix the violation */
+    help: string;
+    /** URL to detailed help documentation */
+    helpUrl: string;
+    /** DOM nodes where the violation was found */
+    nodes: ViolationNode[];
+    /** Tags categorizing this violation */
+    tags: string[];
+    /** WCAG conformance level this violation affects */
+    wcagLevel: WCAGLevel;
+    /** WCAG versions where this rule applies */
+    wcagVersions: WCAGVersion[];
+}
+/**
+ * Represents a DOM node where a violation occurred
+ */
+export interface ViolationNode {
+    /** HTML source of the failing element */
+    html: string;
+    /** CSS selector path to the element */
+    target: string[];
+    /** XPath to the element (if available) */
+    xpath?: string;
+    /** Ancestry chain of the element */
+    ancestry?: string[];
+    /** Summary of why this element failed */
+    failureSummary?: string;
+    /** Additional data about the failure */
+    any?: Array<{
+        id: string;
+        data: Record<string, unknown>;
+        relatedNodes?: Array<{
+            html: string;
+            target: string[];
+        }>;
+    }>;
+}
+/**
+ * Complete results of an accessibility test
+ */
+export interface AccessibilityTestResult {
+    /** URL that was tested (if applicable) */
+    url?: string;
+    /** Timestamp when the test was performed */
+    timestamp: string;
+    /** Duration of the test in milliseconds */
+    testDuration: number;
+    /** Violations found during testing */
+    violations: AccessibilityViolation[];
+    /** Rules that passed */
+    passes: AccessibilityRule[];
+    /** Summary statistics of the test */
+    summary: TestSummary;
+    /** Metadata about the test environment */
+    metadata: TestMetadata;
+}
+/**
+ * Represents an accessibility rule that was tested
+ */
+export interface AccessibilityRule {
+    /** Unique identifier for the rule */
+    id: string;
+    /** Human-readable description of the rule */
+    description: string;
+    /** Impact level if this rule fails */
+    impact?: ViolationSeverity;
+    /** Tags categorizing this rule */
+    tags: string[];
+    /** Nodes that were tested for this rule */
+    nodes: ViolationNode[];
+}
+/**
+ * Summary statistics of test results
+ */
+export interface TestSummary {
+    /** Total number of violations found */
+    totalViolations: number;
+    /** Violations grouped by severity */
+    violationsBySeverity: Record<ViolationSeverity, number>;
+    /** Number of rules that passed */
+    passedRules: number;
+    /** Overall accessibility score (0-100) */
+    score: number;
+    /** Compliance status for each WCAG level */
+    compliance: Record<WCAGLevel, boolean>;
+}
+/**
+ * Metadata about the test environment and configuration
+ */
+export interface TestMetadata {
+    /** User agent string used for testing */
+    userAgent: string;
+    /** Viewport dimensions */
+    viewport: {
+        width: number;
+        height: number;
+    };
+    /** WCAG level tested */
+    wcagLevel: WCAGLevel;
+}
+/**
+ * Color contrast analysis result
+ */
+export interface ColorContrastResult {
+    /** Foreground color value */
+    foreground: string;
+    /** Background color value */
+    background: string;
+    /** Calculated contrast ratio */
+    ratio: number;
+    /** WCAG AA compliance status */
+    wcagAA: {
+        /** Compliance for normal text */
+        normal: boolean;
+        /** Compliance for large text */
+        large: boolean;
+    };
+    /** WCAG AAA compliance status */
+    wcagAAA: {
+        /** Compliance for normal text */
+        normal: boolean;
+        /** Compliance for large text */
+        large: boolean;
+    };
+    /** Accessibility score for this color combination */
+    score: number;
+    /** Recommendations for improvement */
+    recommendations?: string[];
+}
+/**
+ * WCAG rule information
+ */
+export interface WCAGRule {
+    /** Unique rule identifier */
+    id: string;
+    /** Human-readable title */
+    title: string;
+    /** Detailed description */
+    description: string;
+    /** WCAG level this rule applies to */
+    level: WCAGLevel;
+    /** WCAG versions where this rule exists */
+    versions: WCAGVersion[];
+    /** Categories this rule belongs to */
+    categories: AccessibilityCategory[];
+    /** Tags for filtering */
+    tags: string[];
+    /** Link to official WCAG documentation */
+    wcagUrl: string;
+    /** Whether this rule is automated or manual */
+    testType: 'automated' | 'manual' | 'semi-automated';
+    /** Success criteria reference */
+    successCriteria: string;
+}
+//# sourceMappingURL=accessibility.d.ts.map

package/dist/types/accessibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessibility.d.ts","sourceRoot":"","sources":["../../src/types/accessibility.ts"],"names":[],"mappings":"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"}

package/dist/types/accessibility.js

@@ -0,0 +1,5 @@
+/**
+ * Core types and interfaces for accessibility testing
+ */
+export {};
+//# sourceMappingURL=accessibility.js.map

package/dist/types/accessibility.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessibility.js","sourceRoot":"","sources":["../../src/types/accessibility.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Export all types for easy importing
+ */
+export * from './accessibility.js';
+export * from './mcp.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,cAAc,oBAAoB,CAAC;AAGnC,cAAc,UAAU,CAAC"}

package/dist/types/index.js

@@ -0,0 +1,8 @@
+/**
+ * Export all types for easy importing
+ */
+// Accessibility types
+export * from './accessibility.js';
+// MCP types
+export * from './mcp.js';
+//# sourceMappingURL=index.js.map

package/dist/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,sBAAsB;AACtB,cAAc,oBAAoB,CAAC;AAEnC,YAAY;AACZ,cAAc,UAAU,CAAC"}

package/dist/types/mcp.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Types for MCP server inputs and outputs
+ */
+import { WCAGLevel } from './accessibility.js';
+/**
+ * Input parameters for accessibility testing (unified URL/HTML)
+ */
+export interface TestAccessibilityInput {
+    /** Target to test - URL or HTML content */
+    target: string;
+    /** Type of target */
+    type: 'url' | 'html';
+    /** Testing depth level */
+    level: 'basic' | 'full';
+    /** WCAG compliance level to test against */
+    wcagLevel: WCAGLevel;
+}
+/**
+ * Input parameters for color contrast checking
+ */
+export interface ColorContrastInput {
+    /** Foreground color (hex, rgb, hsl, or named color) */
+    foreground: string;
+    /** Background color (hex, rgb, hsl, or named color) */
+    background: string;
+    /** Font size in pixels */
+    fontSize: number;
+    /** Whether the text is bold */
+    isBold: boolean;
+}
+/**
+ * Input parameters for getting WCAG rules information
+ */
+export interface GetWCAGRulesInput {
+    /** Filter by WCAG level */
+    wcagLevel?: WCAGLevel;
+    /** Filter by category */
+    category?: string;
+    /** Search term for rule titles/descriptions */
+    search?: string;
+    /** Maximum number of rules to return */
+    limit?: number;
+}
+/**
+ * Standard error response structure
+ */
+export interface ErrorResponse {
+    /** Error type */
+    type: 'validation' | 'network' | 'timeout' | 'parsing' | 'internal';
+    /** Error message */
+    message: string;
+    /** Additional error details */
+    details?: Record<string, unknown>;
+}
+/**
+ * Base response wrapper for all tool outputs
+ */
+export interface ToolResponse<T> {
+    /** Whether the operation was successful */
+    success: boolean;
+    /** Result data (if successful) */
+    data?: T;
+    /** Error information (if failed) */
+    error?: ErrorResponse;
+    /** Processing time in milliseconds */
+    processingTime: number;
+    /** Timestamp of the response */
+    timestamp: string;
+}
+//# sourceMappingURL=mcp.d.ts.map

package/dist/types/mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../src/types/mcp.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAE/C;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,2CAA2C;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,qBAAqB;IACrB,IAAI,EAAE,KAAK,GAAG,MAAM,CAAC;IACrB,0BAA0B;IAC1B,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC;IACxB,4CAA4C;IAC5C,SAAS,EAAE,SAAS,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,uDAAuD;IACvD,UAAU,EAAE,MAAM,CAAC;IACnB,uDAAuD;IACvD,UAAU,EAAE,MAAM,CAAC;IACnB,0BAA0B;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,+BAA+B;IAC/B,MAAM,EAAE,OAAO,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,2BAA2B;IAC3B,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,yBAAyB;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,+CAA+C;IAC/C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,wCAAwC;IACxC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,iBAAiB;IACjB,IAAI,EAAE,YAAY,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG,UAAU,CAAC;IACpE,oBAAoB;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,+BAA+B;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,2CAA2C;IAC3C,OAAO,EAAE,OAAO,CAAC;IACjB,kCAAkC;IAClC,IAAI,CAAC,EAAE,CAAC,CAAC;IACT,oCAAoC;IACpC,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,sCAAsC;IACtC,cAAc,EAAE,MAAM,CAAC;IACvB,gCAAgC;IAChC,SAAS,EAAE,MAAM,CAAC;CACnB"}

package/dist/types/mcp.js

@@ -0,0 +1,5 @@
+/**
+ * Types for MCP server inputs and outputs
+ */
+export {};
+//# sourceMappingURL=mcp.js.map

package/dist/types/mcp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.js","sourceRoot":"","sources":["../../src/types/mcp.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/utils/browser-manager.d.ts

@@ -0,0 +1,83 @@
+import { Browser, Page, PuppeteerLaunchOptions } from 'puppeteer';
+/**
+ * Browser manager for handling Puppeteer browser instances
+ * Provides connection pooling, error handling, and resource cleanup
+ */
+export declare class BrowserManager {
+    private readonly logger;
+    private readonly browserPool;
+    private readonly maxBrowsers;
+    private isLaunching;
+    private readonly launchOptions;
+    constructor(options?: Partial<PuppeteerLaunchOptions & {
+        maxBrowsers?: number;
+    }>);
+    /**
+     * Get or create a browser instance from the pool
+     */
+    getBrowser(): Promise<Browser>;
+    /**
+     * Create a new browser and add it to the pool
+     */
+    private createNewBrowser;
+    /**
+     * Wait for browser launch to complete
+     */
+    private waitForLaunch;
+    /**
+     * Wait for an available browser in the pool
+     */
+    private waitForAvailableBrowser;
+    /**
+     * Remove disconnected browsers from pool
+     */
+    private cleanupDisconnectedBrowsers;
+    /**
+     * Remove a specific browser from the pool
+     */
+    private removeBrowserFromPool;
+    /**
+     * Create a new page with standard configuration
+     */
+    createPage(options?: {
+        viewport?: {
+            width: number;
+            height: number;
+        };
+        userAgent?: string;
+        timeout?: number;
+    }): Promise<Page>;
+    /**
+     * Navigate to a URL with retry logic
+     */
+    navigateToURL(page: Page, url: string, options?: {
+        waitUntil?: 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2';
+        timeout?: number;
+        retries?: number;
+    }): Promise<void>;
+    /**
+     * Close a page safely
+     */
+    closePage(page: Page): Promise<void>;
+    /**
+     * Clean up all browser resources
+     */
+    cleanup(): Promise<void>;
+    /**
+     * Get browser pool status
+     */
+    getPoolStatus(): {
+        total: number;
+        connected: number;
+        available: number;
+    };
+    /**
+     * Get browser information
+     */
+    getBrowserInfo(): Promise<{
+        version: string;
+        userAgent: string;
+        poolStatus: any;
+    } | null>;
+}
+//# sourceMappingURL=browser-manager.d.ts.map

package/dist/utils/browser-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-manager.d.ts","sourceRoot":"","sources":["../../src/utils/browser-manager.ts"],"names":[],"mappings":"AAAA,OAAkB,EAAE,OAAO,EAAE,IAAI,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AAG7E;;;GAGG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAiB;IAC7C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAa;IACzC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAyB;gBAE3C,OAAO,CAAC,EAAE,OAAO,CAAC,sBAAsB,GAAG;QAAE,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAuBhF;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,OAAO,CAAC;IAwBpC;;OAEG;YACW,gBAAgB;IA8B9B;;OAEG;YACW,aAAa;IAe3B;;OAEG;YACW,uBAAuB;IAqBrC;;OAEG;IACH,OAAO,CAAC,2BAA2B;IAcnC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAQ7B;;OAEG;IACG,UAAU,CAAC,OAAO,CAAC,EAAE;QACzB,QAAQ,CAAC,EAAE;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,CAAC;QAC7C,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,GAAG,OAAO,CAAC,IAAI,CAAC;IAmDjB;;OAEG;IACG,aAAa,CACjB,IAAI,EAAE,IAAI,EACV,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE;QACR,SAAS,CAAC,EAAE,MAAM,GAAG,kBAAkB,GAAG,cAAc,GAAG,cAAc,CAAC;QAC1E,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,GACA,OAAO,CAAC,IAAI,CAAC;IAqChB;;OAEG;IACG,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAW1C;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAmB9B;;OAEG;IACH,aAAa,IAAI;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE;IAWxE;;OAEG;IACG,cAAc,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,GAAG,CAAA;KAAE,GAAG,IAAI,CAAC;CAkBhG"}

package/dist/utils/browser-manager.js

@@ -0,0 +1,292 @@
+import puppeteer from 'puppeteer';
+import { Logger } from './logger.js';
+/**
+ * Browser manager for handling Puppeteer browser instances
+ * Provides connection pooling, error handling, and resource cleanup
+ */
+export class BrowserManager {
+    logger;
+    browserPool = [];
+    maxBrowsers = 3;
+    isLaunching = false;
+    launchOptions;
+    constructor(options) {
+        this.logger = new Logger().child({ component: 'BrowserManager' });
+        this.maxBrowsers = options?.maxBrowsers ?? 3;
+        this.launchOptions = {
+            headless: 'new',
+            args: [
+                '--no-sandbox',
+                '--disable-setuid-sandbox',
+                '--disable-dev-shm-usage',
+                '--disable-gpu',
+                '--no-first-run',
+                '--disable-extensions',
+                '--disable-default-apps',
+                '--disable-background-timer-throttling',
+                '--disable-backgrounding-occluded-windows',
+                '--disable-renderer-backgrounding'
+            ],
+            timeout: 30000,
+            ...options
+        };
+    }
+    /**
+     * Get or create a browser instance from the pool
+     */
+    async getBrowser() {
+        // Try to find an available browser in the pool
+        const availableBrowser = this.browserPool.find(browser => browser.connected);
+        if (availableBrowser) {
+            this.logger.debug('Reusing browser from pool');
+            return availableBrowser;
+        }
+        // Remove disconnected browsers from pool
+        this.cleanupDisconnectedBrowsers();
+        // Create new browser if pool is not full
+        if (this.browserPool.length < this.maxBrowsers) {
+            return this.createNewBrowser();
+        }
+        // Wait for a browser to become available if pool is full
+        this.logger.warn('Browser pool is full, waiting for available browser');
+        return this.waitForAvailableBrowser();
+    }
+    /**
+     * Create a new browser and add it to the pool
+     */
+    async createNewBrowser() {
+        // Prevent multiple launch attempts
+        if (this.isLaunching) {
+            await this.waitForLaunch();
+            return this.getBrowser();
+        }
+        this.isLaunching = true;
+        try {
+            this.logger.info('Creating new browser instance');
+            const browser = await puppeteer.launch(this.launchOptions);
+            // Set up error handlers
+            browser.on('disconnected', () => {
+                this.logger.warn('Browser disconnected');
+                this.removeBrowserFromPool(browser);
+            });
+            this.browserPool.push(browser);
+            this.logger.info(`Browser created successfully. Pool size: ${this.browserPool.length}`);
+            return browser;
+        }
+        catch (error) {
+            this.logger.error('Failed to launch browser', error instanceof Error ? error : new Error(String(error)));
+            throw new Error(`Browser launch failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+        finally {
+            this.isLaunching = false;
+        }
+    }
+    /**
+     * Wait for browser launch to complete
+     */
+    async waitForLaunch() {
+        const maxWait = 30000; // 30 seconds
+        const checkInterval = 100; // 100ms
+        let waited = 0;
+        while (this.isLaunching && waited < maxWait) {
+            await new Promise(resolve => setTimeout(resolve, checkInterval));
+            waited += checkInterval;
+        }
+        if (waited >= maxWait) {
+            throw new Error('Timeout waiting for browser to launch');
+        }
+    }
+    /**
+     * Wait for an available browser in the pool
+     */
+    async waitForAvailableBrowser() {
+        const maxWait = 10000; // 10 seconds
+        const checkInterval = 500; // 500ms
+        let waited = 0;
+        while (waited < maxWait) {
+            const availableBrowser = this.browserPool.find(browser => browser.connected);
+            if (availableBrowser) {
+                return availableBrowser;
+            }
+            await new Promise(resolve => setTimeout(resolve, checkInterval));
+            waited += checkInterval;
+        }
+        throw new Error('Timeout waiting for available browser in pool');
+    }
+    /**
+     * Remove disconnected browsers from pool
+     */
+    cleanupDisconnectedBrowsers() {
+        const initialSize = this.browserPool.length;
+        for (let i = this.browserPool.length - 1; i >= 0; i--) {
+            const browser = this.browserPool[i];
+            if (browser && !browser.connected) {
+                this.browserPool.splice(i, 1);
+            }
+        }
+        if (this.browserPool.length !== initialSize) {
+            this.logger.debug(`Cleaned up ${initialSize - this.browserPool.length} disconnected browsers`);
+        }
+    }
+    /**
+     * Remove a specific browser from the pool
+     */
+    removeBrowserFromPool(browser) {
+        const index = this.browserPool.indexOf(browser);
+        if (index > -1) {
+            this.browserPool.splice(index, 1);
+            this.logger.debug(`Removed browser from pool. Pool size: ${this.browserPool.length}`);
+        }
+    }
+    /**
+     * Create a new page with standard configuration
+     */
+    async createPage(options) {
+        const browser = await this.getBrowser();
+        const page = await browser.newPage();
+        try {
+            // Set viewport
+            if (options?.viewport) {
+                await page.setViewport(options.viewport);
+            }
+            else {
+                await page.setViewport({ width: 1920, height: 1080 });
+            }
+            // Set user agent if provided
+            if (options?.userAgent) {
+                await page.setUserAgent(options.userAgent);
+            }
+            // Set timeouts
+            const timeout = options?.timeout ?? 30000;
+            page.setDefaultTimeout(timeout);
+            page.setDefaultNavigationTimeout(timeout);
+            // Block only heavy media to speed up loading but keep essential resources
+            await page.setRequestInterception(true);
+            page.on('request', (req) => {
+                const resourceType = req.resourceType();
+                // Only block heavy media files, keep CSS and fonts for proper accessibility testing
+                if (['image', 'media'].includes(resourceType)) {
+                    req.abort();
+                }
+                else {
+                    req.continue();
+                }
+            });
+            // Add error handling
+            page.on('error', (error) => {
+                this.logger.error('Page error occurred', error);
+            });
+            page.on('pageerror', (error) => {
+                this.logger.error('Page script error', error);
+            });
+            this.logger.debug('Created new page');
+            return page;
+        }
+        catch (error) {
+            await page.close();
+            throw error;
+        }
+    }
+    /**
+     * Navigate to a URL with retry logic
+     */
+    async navigateToURL(page, url, options) {
+        const maxRetries = options?.retries ?? 3;
+        const waitUntil = options?.waitUntil ?? 'networkidle2';
+        const timeout = options?.timeout ?? 30000;
+        let lastError = null;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                this.logger.debug(`Navigating to URL (attempt ${attempt}/${maxRetries})`, { url });
+                await page.goto(url, {
+                    waitUntil,
+                    timeout
+                });
+                this.logger.debug('Successfully navigated to URL', { url });
+                return;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                this.logger.warn(`Navigation attempt ${attempt} failed`, {
+                    url,
+                    error: lastError.message,
+                    attempt,
+                    maxRetries
+                });
+                if (attempt < maxRetries) {
+                    // Wait before retrying
+                    await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
+                }
+            }
+        }
+        throw new Error(`Failed to navigate to ${url} after ${maxRetries} attempts: ${lastError?.message ?? 'Unknown error'}`);
+    }
+    /**
+     * Close a page safely
+     */
+    async closePage(page) {
+        try {
+            if (!page.isClosed()) {
+                await page.close();
+                this.logger.debug('Page closed successfully');
+            }
+        }
+        catch (error) {
+            this.logger.warn('Error closing page', { error: String(error) });
+        }
+    }
+    /**
+     * Clean up all browser resources
+     */
+    async cleanup() {
+        this.logger.info(`Cleaning up ${this.browserPool.length} browsers`);
+        const cleanupPromises = this.browserPool.map(async (browser, index) => {
+            try {
+                if (browser.connected) {
+                    await browser.close();
+                    this.logger.debug(`Browser ${index} closed successfully`);
+                }
+            }
+            catch (error) {
+                this.logger.warn(`Error closing browser ${index}`, { error: String(error) });
+            }
+        });
+        await Promise.allSettled(cleanupPromises);
+        this.browserPool.length = 0; // Clear the pool
+        this.logger.info('All browsers cleaned up');
+    }
+    /**
+     * Get browser pool status
+     */
+    getPoolStatus() {
+        const total = this.browserPool.length;
+        const connected = this.browserPool.filter(browser => browser.connected).length;
+        return {
+            total,
+            connected,
+            available: this.maxBrowsers - total
+        };
+    }
+    /**
+     * Get browser information
+     */
+    async getBrowserInfo() {
+        try {
+            const browser = await this.getBrowser();
+            const version = await browser.version();
+            const page = await this.createPage();
+            const userAgent = await page.evaluate(() => navigator.userAgent);
+            await this.closePage(page);
+            return {
+                version,
+                userAgent,
+                poolStatus: this.getPoolStatus()
+            };
+        }
+        catch (error) {
+            this.logger.error('Failed to get browser info', error instanceof Error ? error : new Error(String(error)));
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=browser-manager.js.map