brave-real-browser-mcp-server 2.14.8 → 2.14.10

package/dist/handlers/dynamic-session-handlers.js

@@ -127,85 +127,6 @@ export async function handleCookieManager(args) {
 /**
  * Session Persistence - Save and restore browser session
  */
-export async function handleSessionPersistence(args) {
-    return await withErrorHandling(async () => {
-        validateWorkflow('session_persistence', {
-            requireBrowser: true,
-            requirePage: true,
-        });
-        const page = getCurrentPage();
-        const action = args.action || 'save'; // save, restore
-        if (action === 'save') {
-            const cookies = await page.cookies();
-            const localStorage = await page.evaluate(() => {
-                const items = {};
-                for (let i = 0; i < window.localStorage.length; i++) {
-                    const key = window.localStorage.key(i);
-                    if (key) {
-                        items[key] = window.localStorage.getItem(key);
-                    }
-                }
-                return items;
-            });
-            const sessionStorage = await page.evaluate(() => {
-                const items = {};
-                for (let i = 0; i < window.sessionStorage.length; i++) {
-                    const key = window.sessionStorage.key(i);
-                    if (key) {
-                        items[key] = window.sessionStorage.getItem(key);
-                    }
-                }
-                return items;
-            });
-            const sessionData = {
-                url: page.url(),
-                cookies,
-                localStorage,
-                sessionStorage,
-                timestamp: new Date().toISOString(),
-            };
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Session saved\n\n${JSON.stringify(sessionData, null, 2)}`,
-                    }],
-            };
-        }
-        if (action === 'restore') {
-            const sessionData = args.sessionData;
-            if (!sessionData) {
-                throw new Error('Session data is required for restore');
-            }
-            // Restore cookies
-            if (sessionData.cookies) {
-                await Promise.all(sessionData.cookies.map((cookie) => page.setCookie(cookie)));
-            }
-            // Restore localStorage
-            if (sessionData.localStorage) {
-                await page.evaluate((items) => {
-                    for (const [key, value] of Object.entries(items)) {
-                        window.localStorage.setItem(key, value);
-                    }
-                }, sessionData.localStorage);
-            }
-            // Restore sessionStorage
-            if (sessionData.sessionStorage) {
-                await page.evaluate((items) => {
-                    for (const [key, value] of Object.entries(items)) {
-                        window.sessionStorage.setItem(key, value);
-                    }
-                }, sessionData.sessionStorage);
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Session restored from ${sessionData.timestamp}`,
-                    }],
-            };
-        }
-        throw new Error(`Unknown action: ${action}`);
-    }, 'Failed session persistence');
-}
 /**
  * Form Auto Fill - Automatically fill form fields
  */
@@ -385,131 +306,6 @@ export async function handleAjaxContentWaiter(args) {
 /**
  * Modal Popup Handler - Handle modal popups
  */
-export async function handleModalPopupHandler(args) {
-    return await withErrorHandling(async () => {
-        validateWorkflow('modal_popup_handler', {
-            requireBrowser: true,
-            requirePage: true,
-        });
-        const page = getCurrentPage();
-        const action = args.action || 'detect'; // detect, close, interact
-        if (action === 'detect') {
-            const modals = await page.evaluate(() => {
-                const results = [];
-                const modalSelectors = [
-                    '.modal',
-                    '[role="dialog"]',
-                    '[class*="popup"]',
-                    '[class*="overlay"]',
-                    '.dialog',
-                ];
-                modalSelectors.forEach(selector => {
-                    const elements = document.querySelectorAll(selector);
-                    elements.forEach((el) => {
-                        const isVisible = el.offsetWidth > 0 && el.offsetHeight > 0;
-                        if (isVisible) {
-                            results.push({
-                                selector,
-                                id: el.id || null,
-                                className: el.className,
-                                text: el.textContent?.trim().substring(0, 200) || '',
-                            });
-                        }
-                    });
-                });
-                return results;
-            });
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Found ${modals.length} visible modals\n\n${JSON.stringify(modals, null, 2)}`,
-                    }],
-            };
-        }
-        if (action === 'close') {
-            const closeSelector = args.closeSelector || '.close, [aria-label="Close"], button[class*="close"]';
-            try {
-                await page.click(closeSelector);
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `✅ Modal closed`,
-                        }],
-                };
-            }
-            catch (e) {
-                // Try pressing Escape
-                await page.keyboard.press('Escape');
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `✅ Pressed Escape key to close modal`,
-                        }],
-                };
-            }
-        }
-        throw new Error(`Unknown action: ${action}`);
-    }, 'Failed modal popup handler');
-}
 /**
  * Login Session Manager - Manage login sessions
  */
-export async function handleLoginSessionManager(args) {
-    return await withErrorHandling(async () => {
-        validateWorkflow('login_session_manager', {
-            requireBrowser: true,
-            requirePage: true,
-        });
-        const page = getCurrentPage();
-        const action = args.action || 'check'; // check, login, logout
-        if (action === 'check') {
-            const isLoggedIn = await page.evaluate(() => {
-                // Check common indicators of logged-in state
-                const indicators = [
-                    document.querySelector('[class*="logout"]'),
-                    document.querySelector('[class*="profile"]'),
-                    document.querySelector('[class*="account"]'),
-                    document.cookie.includes('session') || document.cookie.includes('token'),
-                    localStorage.getItem('token') !== null,
-                ];
-                return indicators.some(indicator => Boolean(indicator));
-            });
-            const cookies = await page.cookies();
-            const sessionCookies = cookies.filter(c => c.name.toLowerCase().includes('session') ||
-                c.name.toLowerCase().includes('token') ||
-                c.name.toLowerCase().includes('auth'));
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Login Status Check\n\nLikely Logged In: ${isLoggedIn}\nSession Cookies: ${sessionCookies.length}\n\n${JSON.stringify(sessionCookies.map(c => ({ name: c.name, domain: c.domain })), null, 2)}`,
-                    }],
-            };
-        }
-        if (action === 'login') {
-            const username = args.username;
-            const password = args.password;
-            const usernameSelector = args.usernameSelector || 'input[type="email"], input[type="text"], input[name*="user"], input[name*="email"]';
-            const passwordSelector = args.passwordSelector || 'input[type="password"]';
-            const submitSelector = args.submitSelector || 'button[type="submit"], input[type="submit"]';
-            if (!username || !password) {
-                throw new Error('Username and password are required');
-            }
-            // Fill username
-            await page.waitForSelector(usernameSelector, { timeout: 5000 });
-            await page.type(usernameSelector, username);
-            // Fill password
-            await page.waitForSelector(passwordSelector, { timeout: 5000 });
-            await page.type(passwordSelector, password);
-            // Submit
-            await page.click(submitSelector);
-            await page.waitForNavigation({ waitUntil: 'networkidle2', timeout: 10000 }).catch(() => { });
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Login attempted\n\nUsername: ${username}\nCurrent URL: ${page.url()}`,
-                    }],
-            };
-        }
-        throw new Error(`Unknown action: ${action}`);
-    }, 'Failed login session manager');
-}

package/dist/handlers/multi-element-handlers.js

@@ -194,61 +194,6 @@ export async function handleAttributeHarvester(args) {
         };
     }, 'Failed to harvest attributes');
 }
-/**
- * सभी images URLs, alt text, dimensions के साथ extract करता है
- */
-export async function handleImageScraper(args) {
-    return await withErrorHandling(async () => {
-        validateWorkflow('image_scraper', {
-            requireBrowser: true,
-            requirePage: true,
-        });
-        const page = getCurrentPage();
-        const selector = args.selector || 'img';
-        const includeDataUrls = args.includeDataUrls || false;
-        const includeDimensions = args.includeDimensions !== false;
-        const imageData = await page.evaluate(({ selector, includeDataUrls, includeDimensions }) => {
-            const images = document.querySelectorAll(selector);
-            const results = [];
-            images.forEach((img, index) => {
-                const src = img.src || img.getAttribute('data-src') || '';
-                // Skip data URLs if not included
-                if (!includeDataUrls && src.startsWith('data:')) {
-                    return;
-                }
-                const imageInfo = {
-                    index,
-                    src,
-                    alt: img.alt || '',
-                    title: img.title || '',
-                };
-                if (includeDimensions) {
-                    imageInfo.width = img.naturalWidth || img.width || 0;
-                    imageInfo.height = img.naturalHeight || img.height || 0;
-                }
-                // Additional attributes
-                const srcset = img.srcset || img.getAttribute('data-srcset');
-                if (srcset) {
-                    imageInfo.srcset = srcset;
-                }
-                const loading = img.loading;
-                if (loading) {
-                    imageInfo.loading = loading;
-                }
-                results.push(imageInfo);
-            });
-            return results;
-        }, { selector, includeDataUrls, includeDimensions });
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `✅ Scraped ${imageData.length} images\n\n${JSON.stringify(imageData, null, 2)}`,
-                },
-            ],
-        };
-    }, 'Failed to scrape images');
-}
 /**
  * Internal/external links classification के साथ collect करता है
  */

package/dist/handlers/network-handlers.js

@@ -0,0 +1,111 @@
+import { getPageInstance } from '../browser-manager.js';
+async function captureNetwork(page, duration, filter) {
+    const captured = [];
+    const responseHandler = async (response) => {
+        try {
+            const request = response.request();
+            if (filter(request, response)) {
+                let body = '[Binary or Too Large]';
+                try {
+                    const type = response.headers()['content-type'] || '';
+                    if (type.includes('text') || type.includes('json') || type.includes('xml')) {
+                        body = await response.text();
+                    }
+                }
+                catch (e) {
+                    // Ignore
+                }
+                captured.push({
+                    url: response.url(),
+                    method: request.method(),
+                    type: request.resourceType(),
+                    status: response.status(),
+                    headers: response.headers(),
+                    body: body.slice(0, 5000)
+                });
+            }
+        }
+        catch (e) {
+            // ignore
+        }
+    };
+    page.on('response', responseHandler);
+    await new Promise(resolve => setTimeout(resolve, duration));
+    page.off('response', responseHandler);
+    return captured;
+}
+export async function handleNetworkRecorder(args) {
+    const page = getPageInstance();
+    if (!page)
+        throw new Error('Browser not initialized');
+    const duration = args.duration || 10000;
+    const results = await captureNetwork(page, duration, (req, res) => {
+        if (!args.filterTypes || args.filterTypes.length === 0)
+            return true;
+        const type = req.resourceType().toLowerCase();
+        return args.filterTypes.includes(type);
+    });
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(results, null, 2)
+            }]
+    };
+}
+export async function handleAjaxExtractor(args) {
+    const page = getPageInstance();
+    if (!page)
+        throw new Error('Browser not initialized');
+    const duration = args.duration || 15000;
+    const results = await captureNetwork(page, duration, (req, res) => {
+        const type = req.resourceType();
+        const isXhr = type === 'xhr' || type === 'fetch';
+        if (!isXhr)
+            return false;
+        if (args.url && !req.url().includes(args.url))
+            return false;
+        return true;
+    });
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(results, null, 2)
+            }]
+    };
+}
+export async function handleFetchXhr(args) {
+    return handleAjaxExtractor({ duration: args.duration });
+}
+export async function handleApiFinder(args) {
+    const page = getPageInstance();
+    if (!page)
+        throw new Error('Browser not initialized');
+    // 1. Static Analysis
+    const staticApis = await page.evaluate(() => {
+        const patterns = [/\/api\//, /\/v\d+\//, /graphql/, /\.json$/];
+        const candidates = new Set();
+        document.querySelectorAll('script').forEach(s => {
+            if (s.src)
+                candidates.add(s.src);
+        });
+        document.querySelectorAll('a').forEach(a => {
+            candidates.add(a.href);
+        });
+        return Array.from(candidates).filter(url => patterns.some(p => p.test(url)));
+    });
+    // 2. Dynamic Analysis
+    const dynamicApis = await captureNetwork(page, 5000, (req, res) => {
+        const type = req.resourceType();
+        const contentType = res.headers()['content-type'] || '';
+        return (type === 'xhr' || type === 'fetch') && contentType.includes('json');
+    });
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    staticAnalysis: staticApis,
+                    dynamicCapture: dynamicApis.map(d => d.url)
+                }, null, 2)
+            }]
+    };
+}

package/dist/handlers/pagination-handlers.js

@@ -4,129 +4,6 @@
 import { getCurrentPage } from '../browser-manager.js';
 import { validateWorkflow } from '../workflow-validation.js';
 import { withErrorHandling, sleep } from '../system-utils.js';
-import * as xml2js from 'xml2js';
-/**
- * "Next" button automatically detect और click करके सभी pages से data collect करता है
- */
-export async function handleAutoPagination(args) {
-    return await withErrorHandling(async () => {
-        validateWorkflow('auto_pagination', {
-            requireBrowser: true,
-            requirePage: true,
-        });
-        const page = getCurrentPage();
-        const nextButtonSelector = args.nextButtonSelector || 'a[rel="next"], button:contains("Next"), .next, .pagination-next';
-        const maxPages = args.maxPages || 10;
-        const dataSelector = args.dataSelector;
-        const waitBetweenPages = args.waitBetweenPages || 1000;
-        const allData = [];
-        let currentPage = 1;
-        let hasMore = true;
-        while (currentPage <= maxPages && hasMore) {
-            // Extract data from current page
-            if (dataSelector) {
-                const pageData = await page.evaluate((selector) => {
-                    const elements = document.querySelectorAll(selector);
-                    return Array.from(elements).map((el) => ({
-                        text: el.textContent?.trim() || '',
-                        html: el.innerHTML,
-                    }));
-                }, dataSelector);
-                allData.push(...pageData);
-            }
-            // Check for next button
-            const nextButton = await page.$(nextButtonSelector);
-            if (!nextButton) {
-                hasMore = false;
-                break;
-            }
-            // Check if button is disabled
-            const isDisabled = await page.evaluate((selector) => {
-                const btn = document.querySelector(selector);
-                return btn?.hasAttribute('disabled') || btn?.classList.contains('disabled');
-            }, nextButtonSelector);
-            if (isDisabled) {
-                hasMore = false;
-                break;
-            }
-            // Click next button
-            await nextButton.click();
-            await sleep(waitBetweenPages);
-            // Wait for navigation or content load
-            try {
-                await page.waitForNavigation({ timeout: 5000, waitUntil: 'domcontentloaded' });
-            }
-            catch (e) {
-                // No navigation occurred, content loaded dynamically
-                await sleep(1000);
-            }
-            currentPage++;
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `✅ Auto-paginated through ${currentPage} pages\n\nCollected ${allData.length} items\n\n${JSON.stringify(allData.slice(0, 10), null, 2)}${allData.length > 10 ? '\n\n... (showing first 10 items)' : ''}`,
-                },
-            ],
-        };
-    }, 'Failed to auto-paginate');
-}
-/**
- * Lazy-loading pages के लिए auto-scroll करता है
- */
-export async function handleInfiniteScroll(args) {
-    return await withErrorHandling(async () => {
-        validateWorkflow('infinite_scroll', {
-            requireBrowser: true,
-            requirePage: true,
-        });
-        const page = getCurrentPage();
-        const maxScrolls = args.maxScrolls || 10;
-        const scrollDelay = args.scrollDelay || 1000;
-        const dataSelector = args.dataSelector;
-        const allData = [];
-        let scrollCount = 0;
-        let previousHeight = 0;
-        while (scrollCount < maxScrolls) {
-            // Get current scroll height
-            const currentHeight = await page.evaluate(() => document.body.scrollHeight);
-            // If height hasn't changed, we've reached the end
-            if (currentHeight === previousHeight && scrollCount > 0) {
-                break;
-            }
-            previousHeight = currentHeight;
-            // Collect data if selector provided
-            if (dataSelector) {
-                const pageData = await page.evaluate((selector) => {
-                    const elements = document.querySelectorAll(selector);
-                    return Array.from(elements).map((el, idx) => ({
-                        index: idx,
-                        text: el.textContent?.trim() || '',
-                    }));
-                }, dataSelector);
-                // Add only new items (avoid duplicates)
-                const newItems = pageData.filter((item) => !allData.some((existing) => existing.text === item.text));
-                allData.push(...newItems);
-            }
-            // Scroll to bottom
-            await page.evaluate(() => {
-                window.scrollTo(0, document.body.scrollHeight);
-            });
-            // Wait for new content to load
-            await sleep(scrollDelay);
-            scrollCount++;
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `✅ Infinite scroll completed (${scrollCount} scrolls)\n\nCollected ${allData.length} items\n\n${JSON.stringify(allData.slice(0, 10), null, 2)}${allData.length > 10 ? '\n\n... (showing first 10 items)' : ''}`,
-                },
-            ],
-        };
-    }, 'Failed to handle infinite scroll');
-}
 /**
  * Multiple pages से data collect और merge करता है
  */
@@ -178,74 +55,6 @@ export async function handleMultiPageScraper(args) {
         };
     }, 'Failed to scrape multiple pages');
 }
-/**
- * sitemap.xml से URLs automatically extract करता है
- */
-export async function handleSitemapParser(args) {
-    return await withErrorHandling(async () => {
-        validateWorkflow('sitemap_parser', {
-            requireBrowser: true,
-            requirePage: true,
-        });
-        const page = getCurrentPage();
-        const currentUrl = page.url();
-        const baseUrl = new URL(currentUrl).origin;
-        const sitemapUrl = args.sitemapUrl || `${baseUrl}/sitemap.xml`;
-        const maxUrls = args.maxUrls || 100;
-        const filterPattern = args.filterPattern;
-        // Fetch sitemap
-        await page.goto(sitemapUrl, { waitUntil: 'domcontentloaded' });
-        // Get sitemap XML content
-        const sitemapContent = await page.evaluate(() => {
-            return document.body.textContent || document.documentElement.innerHTML;
-        });
-        // Parse XML
-        const parser = new xml2js.Parser();
-        const result = await parser.parseStringPromise(sitemapContent);
-        const urls = [];
-        // Extract URLs from sitemap
-        if (result.urlset && result.urlset.url) {
-            for (const urlEntry of result.urlset.url) {
-                if (urls.length >= maxUrls)
-                    break;
-                const loc = urlEntry.loc?.[0];
-                if (!loc)
-                    continue;
-                // Apply filter if specified
-                if (filterPattern && !loc.includes(filterPattern)) {
-                    continue;
-                }
-                urls.push({
-                    url: loc,
-                    lastmod: urlEntry.lastmod?.[0],
-                    changefreq: urlEntry.changefreq?.[0],
-                    priority: urlEntry.priority?.[0],
-                });
-            }
-        }
-        // Handle sitemap index
-        else if (result.sitemapindex && result.sitemapindex.sitemap) {
-            for (const sitemapEntry of result.sitemapindex.sitemap) {
-                const loc = sitemapEntry.loc?.[0];
-                if (loc) {
-                    urls.push({
-                        url: loc,
-                        type: 'sitemap',
-                        lastmod: sitemapEntry.lastmod?.[0],
-                    });
-                }
-            }
-        }
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `✅ Parsed sitemap: ${urls.length} URLs found\n\n${JSON.stringify(urls, null, 2)}`,
-                },
-            ],
-        };
-    }, 'Failed to parse sitemap');
-}
 /**
  * Site structure follow करके pages scrape करता है
  */