real-browser-mcp-server 1.1.7 → 1.1.8

package/dist/src/mcp/handlers/browser.js

@@ -0,0 +1,230 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.browserHandlers = void 0;
+const state_1 = require("./state");
+// Auto-generated browser handlers
+exports.browserHandlers = {
+    async browser_init(params = {}) {
+        (0, state_1.notifyProgress)('browser_init', 'started', 'Initializing browser...');
+        const { connect } = require('../../../lib/cjs/index.js');
+        // Get headless from params OR environment variable
+        const envHeadless = (0, state_1.getHeadlessFromEnv)();
+        const headless = params.headless !== undefined ? params.headless : envHeadless;
+        const { proxy = {}, turnstile = false, enableBlocker = true } = params;
+        (0, state_1.notifyProgress)('browser_init', 'progress', `Mode: ${headless ? 'Headless' : 'GUI (Visible)'}`, { headless });
+        const result = await connect({
+            headless,
+            proxy,
+            turnstile,
+            enableBlocker,
+        });
+        state_1.state.browserInstance = result.browser;
+        state_1.state.pageInstance = result.page;
+        state_1.state.blockerInstance = result.blocker;
+        state_1.state.setupPageFn = result.setupPage; // Store CDP early injection function
+        // ═══════════════════════════════════════════════════════════════
+        // GLOBAL DIALOG HANDLER - Auto-handle dialogs
+        // Logic: BLOCK redirects to external sites, ACCEPT everything else
+        // ═══════════════════════════════════════════════════════════════
+        state_1.state.pageInstance.on('dialog', async (dialog) => {
+            const dialogType = dialog.type();
+            const msg = dialog.message().toLowerCase();
+            (0, state_1.notifyProgress)('browser_init', 'progress', `🔔 Handling dialog: ${dialogType} - ${dialog.message().substring(0, 100)}...`);
+            try {
+                // Critical Fix: BLOCK redirects to external sites (e.g., eCommittee)
+                // These redirects take the user away from the search page
+                if (msg.includes('redirect') || msg.includes('external') || msg.includes('leaving')) {
+                    console.error('🚫 Blocking redirect dialog (Dismiss)');
+                    await dialog.dismiss(); // Simulate clicking 'Cancel'
+                }
+                else {
+                    // Auto-accept other dialogs (like alerts or simple confirmations)
+                    await dialog.accept(); // Simulate clicking 'OK'
+                }
+            }
+            catch (e) {
+                // Ignore errors (dialog might be closed by injected script)
+            }
+        });
+        // ═══════════════════════════════════════════════════════════════
+        // INJECTED SCRIPT - Silent Handling of Popups
+        // Override window.confirm/alert to handle them inside the page context
+        // Note: Using addInitScript (Playwright) to intercept popups early
+        // ═══════════════════════════════════════════════════════════════
+        await state_1.state.pageInstance.addInitScript(() => {
+            window.originalConfirm = window.confirm;
+            window.originalAlert = window.alert;
+            // Smart Confirm Handler
+            window.confirm = (msg) => {
+                console.log('Intercepted Confirm Dialog:', msg);
+                if (msg && (msg.toLowerCase().includes('redirect') || msg.toLowerCase().includes('external'))) {
+                    console.log('🚫 Blocking redirect confirmation inside page');
+                    return false; // Return FALSE = Click Cancel
+                }
+                return true; // Return TRUE = Click OK
+            };
+            // Silently ignore alerts (always OK)
+            window.alert = (msg) => {
+                console.log('Blocked Alert Dialog:', msg);
+                return true;
+            };
+            // Silently return null for prompts
+            window.prompt = (msg) => {
+                console.log('Blocked Prompt Dialog:', msg);
+                return null;
+            };
+        });
+        const pid = (typeof state_1.state.browserInstance.process === 'function') ? state_1.state.browserInstance.process()?.pid : null;
+        (0, state_1.notifyProgress)('browser_init', 'completed', `Browser started (PID: ${pid})`, {
+            headless,
+            pid,
+            blockerEnabled: enableBlocker
+        });
+        return {
+            success: true,
+            message: `Browser initialized in ${headless ? 'headless' : 'GUI'} mode`,
+            pid,
+            headless,
+            blockerEnabled: enableBlocker
+        };
+    },
+    async navigate(params) {
+        const { page } = (0, state_1.requireBrowser)();
+        let { url, waitUntil = 'networkidle', timeout = 30000, retries = 2 } = params;
+        // Playwright/Patchright wait states: load | domcontentloaded | networkidle | commit
+        waitUntil = (0, state_1.resolveWaitUntil)(waitUntil);
+        (0, state_1.notifyProgress)('navigate', 'started', `Navigating to: ${url}`);
+        // ═══════════════════════════════════════════════════════════════
+        // CDP EARLY INJECTION - Setup BEFORE navigation for better ad blocking
+        // This ensures CSS and scripts are injected before page scripts run
+        // ═══════════════════════════════════════════════════════════════
+        console.error('[Navigate] state.setupPageFn available:', !!state_1.state.setupPageFn);
+        if (state_1.state.setupPageFn) {
+            try {
+                await state_1.state.setupPageFn(page);
+                (0, state_1.notifyProgress)('navigate', 'progress', 'CDP early injection setup complete');
+                console.error('[Navigate] CDP early injection SUCCESS');
+            }
+            catch (e) {
+                // Non-critical error, continue navigation
+                console.error('[Navigate] CDP early injection failed:', e.message);
+            }
+        }
+        else {
+            console.error('[Navigate] No state.setupPageFn available - CDP early injection skipped');
+        }
+        let lastError = null;
+        for (let attempt = 0; attempt <= retries; attempt++) {
+            try {
+                // Wait a bit if this is a retry
+                if (attempt > 0) {
+                    (0, state_1.notifyProgress)('navigate', 'progress', `Retry attempt ${attempt}...`);
+                    await new Promise(r => setTimeout(r, 1000));
+                }
+                await page.goto(url, { waitUntil, timeout });
+                // Wait for page to stabilize after navigation
+                await new Promise(r => setTimeout(r, 500));
+                // Try to get title with error handling
+                let title = '';
+                try {
+                    title = await page.title();
+                }
+                catch (e) {
+                    // Title might fail if page is still loading
+                    title = 'Loading...';
+                }
+                (0, state_1.notifyProgress)('navigate', 'completed', `Loaded: ${title}`, { url: page.url(), title });
+                return {
+                    success: true,
+                    url: page.url(),
+                    title
+                };
+            }
+            catch (error) {
+                lastError = error;
+                // Handle specific errors that might be recoverable
+                if (error.message?.includes('Execution context was destroyed') ||
+                    error.message?.includes('context') ||
+                    error.message?.includes('Target closed')) {
+                    (0, state_1.notifyProgress)('navigate', 'progress', `Navigation interrupted (${error.message.substring(0, 50)}...), waiting for page...`);
+                    // Wait for any ongoing navigation to complete
+                    try {
+                        await page.waitForNavigation({ timeout: 5000, waitUntil: 'domcontentloaded' }).catch(() => { });
+                    }
+                    catch (e) {
+                        // Ignore timeout
+                    }
+                    // Check if we actually landed on the page
+                    try {
+                        const currentUrl = page.url();
+                        if (currentUrl && currentUrl !== 'about:blank') {
+                            const title = await page.title().catch(() => 'Unknown');
+                            (0, state_1.notifyProgress)('navigate', 'completed', `Loaded after recovery: ${title}`, { url: currentUrl, title });
+                            return {
+                                success: true,
+                                url: currentUrl,
+                                title,
+                                recovered: true
+                            };
+                        }
+                    }
+                    catch (e) {
+                        // Continue to retry
+                    }
+                }
+                else {
+                    // Non-recoverable error, throw immediately
+                    throw error;
+                }
+            }
+        }
+        // All retries failed
+        (0, state_1.notifyProgress)('navigate', 'error', `Navigation failed after ${retries + 1} attempts: ${lastError?.message}`);
+        throw lastError || new Error('Navigation failed');
+    },
+    async wait(params) {
+        const { page } = (0, state_1.requireBrowser)();
+        const { type = 'timeout', value, timeout = 30000 } = params;
+        (0, state_1.notifyProgress)('wait', 'started', `Waiting for ${type}: ${value}`);
+        switch (type) {
+            case 'selector':
+                await page.waitForSelector(value, { timeout });
+                break;
+            case 'navigation':
+                await page.waitForNavigation({ timeout });
+                break;
+            case 'networkidle':
+                await page.waitForLoadState('networkidle', { timeout });
+                break;
+            case 'timeout':
+            default:
+                await new Promise(r => setTimeout(r, parseInt(value) || 1000));
+        }
+        (0, state_1.notifyProgress)('wait', 'completed', `Wait completed: ${type}`, { type, value });
+        return { success: true, type, value };
+    },
+    async browser_close(params = {}) {
+        const { force = false } = params;
+        (0, state_1.notifyProgress)('browser_close', 'started', 'Closing browser...');
+        if (state_1.state.browserInstance) {
+            try {
+                await state_1.state.browserInstance.close();
+                (0, state_1.notifyProgress)('browser_close', 'progress', 'Browser closed gracefully');
+            }
+            catch (e) {
+                if (force) {
+                    if (typeof state_1.state.browserInstance.process === 'function') {
+                        state_1.state.browserInstance.process()?.kill('SIGKILL');
+                    }
+                    (0, state_1.notifyProgress)('browser_close', 'progress', 'Browser force killed');
+                }
+            }
+            state_1.state.browserInstance = null;
+            state_1.state.pageInstance = null;
+            state_1.state.blockerInstance = null;
+            state_1.state.setupPageFn = null;
+        }
+        (0, state_1.notifyProgress)('browser_close', 'completed', 'Browser closed');
+        return { success: true, message: 'Browser closed' };
+    }
+};