brave-real-browser-mcp-server 2.5.1 → 2.7.0

package/README.md

@@ -93,7 +93,7 @@ Once set up, you can ask Claude to:
 - **Fill forms**: "Fill out this contact form with my details"
 - **Extract data**: "Get all the product prices from this page"
 - **Automate tasks**: "Log into my account and download my invoice"
-- **Solve captchas automatically**: "Detect and solve any CAPTCHAs on this page" - 🆕 Zero configuration required!
+- **Solve captchas**: "Handle any captchas that appear"
 
 ### Safety Notes
 - Claude will show you what it's doing - you can see the browser window
@@ -124,7 +124,6 @@ assistants to control a real browser, extract content, and more.
 - **Comprehensive toolset**: 11 tools covering all browser automation needs
 - **Proxy support**: Built-in proxy configuration for enhanced privacy
 - **Captcha handling**: Support for solving reCAPTCHA, hCaptcha, and Turnstile
-- **🆕 Auto CAPTCHA Solver**: 🤖 Automatically detects and solves text CAPTCHAs with 100% accuracy - no selectors needed! [Learn more](docs/AUTO_CAPTCHA_SOLVER.md)
 - **Robust error handling**: Advanced error recovery with circuit breaker pattern
 - **Stack overflow protection**: Comprehensive protection against infinite recursion
 - **Timeout controls**: Automatic timeout mechanisms prevent hanging operations
@@ -539,10 +538,8 @@ AI: I'll set up the browser with your proxy configuration.
 ### Anti-Detection Tools
 
 | Tool Name | Description | Required Parameters | Optional Parameters |
-|-----------|-------------|---------------------|---------------------|
+|-----------|-------------|---------------------|-------------------|
 | `solve_captcha` | Attempt to solve captchas | `type` | None |
-| `solve_text_captcha` | Solve text-based image CAPTCHAs using OCR | `imageSelector` | `inputSelector`, `config` |
-| `auto_solve_captcha` | 🆕 **Automatically detect and solve CAPTCHAs** (no selectors needed!) | None | `config` |
 
 ## Advanced Features
 

package/dist/advanced/advanced-scraping.js

@@ -0,0 +1,301 @@
+// Advanced Scraping Features Module
+// Dynamic Content Handling, Authentication, Rate Limiting, Session Management
+/**
+ * Wait for Dynamic Content to Load
+ * AJAX/dynamic content के लिए intelligent waiting
+ */
+export async function waitForDynamicContent(page, options) {
+    const startTime = Date.now();
+    const timeout = options?.timeout || 30000;
+    const networkIdleTime = options?.networkIdleTime || 500;
+    try {
+        if (options?.selector) {
+            // Wait for specific selector
+            await page.waitForSelector(options.selector, { timeout });
+            return {
+                success: true,
+                waitTime: Date.now() - startTime,
+                method: 'selector'
+            };
+        }
+        // Wait for network idle
+        await page.waitForNetworkIdle({ timeout, idleTime: networkIdleTime });
+        return {
+            success: true,
+            waitTime: Date.now() - startTime,
+            method: 'networkIdle'
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            waitTime: Date.now() - startTime,
+            method: 'timeout'
+        };
+    }
+}
+/**
+ * Handle Shadow DOM Content
+ * Shadow DOM elements को access करना
+ */
+export async function extractFromShadowDOM(page, hostSelector, innerSelector) {
+    return await page.evaluate((host, inner) => {
+        const hostElement = document.querySelector(host);
+        if (!hostElement || !hostElement.shadowRoot) {
+            return null;
+        }
+        const innerElement = hostElement.shadowRoot.querySelector(inner);
+        return innerElement ? innerElement.textContent?.trim() : null;
+    }, hostSelector, innerSelector);
+}
+/**
+ * Handle iFrame Content
+ * iFrames के अंदर का content extract करना
+ */
+export async function extractFromIframe(page, iframeSelector, contentSelector) {
+    const frames = page.frames();
+    for (const frame of frames) {
+        try {
+            const frameElement = await frame.$(iframeSelector);
+            if (frameElement) {
+                if (contentSelector) {
+                    return await frame.$eval(contentSelector, (el) => el.textContent?.trim());
+                }
+                else {
+                    return await frame.content();
+                }
+            }
+        }
+        catch (error) {
+            continue;
+        }
+    }
+    return null;
+}
+/**
+ * Cookie Manager
+ * Cookies को save और reuse करना
+ */
+export class CookieManager {
+    cookies = [];
+    async saveCookies(page) {
+        this.cookies = await page.cookies();
+    }
+    async loadCookies(page) {
+        if (this.cookies.length > 0) {
+            await page.setCookie(...this.cookies);
+        }
+    }
+    getCookies() {
+        return this.cookies;
+    }
+    clearCookies() {
+        this.cookies = [];
+    }
+    async exportCookies() {
+        return JSON.stringify(this.cookies, null, 2);
+    }
+    async importCookies(cookiesJson) {
+        this.cookies = JSON.parse(cookiesJson);
+    }
+}
+/**
+ * Session Manager
+ * Multiple requests में session maintain करना
+ */
+export class SessionManager {
+    sessionData = new Map();
+    cookieManager = new CookieManager();
+    async saveSession(page, sessionId) {
+        await this.cookieManager.saveCookies(page);
+        const localStorage = await page.evaluate(() => {
+            return JSON.stringify(localStorage);
+        });
+        const sessionStorage = await page.evaluate(() => {
+            return JSON.stringify(sessionStorage);
+        });
+        this.sessionData.set(sessionId, {
+            cookies: this.cookieManager.getCookies(),
+            localStorage,
+            sessionStorage,
+            timestamp: Date.now()
+        });
+    }
+    async restoreSession(page, sessionId) {
+        const session = this.sessionData.get(sessionId);
+        if (!session) {
+            return false;
+        }
+        // Restore cookies
+        await this.cookieManager.loadCookies(page);
+        // Restore localStorage
+        if (session.localStorage) {
+            await page.evaluate((data) => {
+                const parsed = JSON.parse(data);
+                for (const key in parsed) {
+                    localStorage.setItem(key, parsed[key]);
+                }
+            }, session.localStorage);
+        }
+        // Restore sessionStorage
+        if (session.sessionStorage) {
+            await page.evaluate((data) => {
+                const parsed = JSON.parse(data);
+                for (const key in parsed) {
+                    sessionStorage.setItem(key, parsed[key]);
+                }
+            }, session.sessionStorage);
+        }
+        return true;
+    }
+    deleteSession(sessionId) {
+        this.sessionData.delete(sessionId);
+    }
+    listSessions() {
+        return Array.from(this.sessionData.keys());
+    }
+}
+/**
+ * Rate Limiter
+ * Requests के बीच delays और throttling
+ */
+export class RateLimiter {
+    minDelay;
+    maxRequestsPerWindow;
+    windowDuration;
+    lastRequestTime = 0;
+    requestCount = 0;
+    windowStart = Date.now();
+    constructor(minDelay = 1000, maxRequestsPerWindow = 10, windowDuration = 60000) {
+        this.minDelay = minDelay;
+        this.maxRequestsPerWindow = maxRequestsPerWindow;
+        this.windowDuration = windowDuration;
+    }
+    async waitForNextRequest() {
+        const now = Date.now();
+        // Reset window if needed
+        if (now - this.windowStart > this.windowDuration) {
+            this.requestCount = 0;
+            this.windowStart = now;
+        }
+        // Check rate limit
+        if (this.requestCount >= this.maxRequestsPerWindow) {
+            const waitTime = this.windowDuration - (now - this.windowStart);
+            await this.sleep(waitTime);
+            this.requestCount = 0;
+            this.windowStart = Date.now();
+        }
+        // Enforce minimum delay
+        const timeSinceLastRequest = now - this.lastRequestTime;
+        if (timeSinceLastRequest < this.minDelay) {
+            await this.sleep(this.minDelay - timeSinceLastRequest);
+        }
+        this.lastRequestTime = Date.now();
+        this.requestCount++;
+    }
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    getStats() {
+        return {
+            requestCount: this.requestCount,
+            windowRemaining: this.maxRequestsPerWindow - this.requestCount
+        };
+    }
+}
+/**
+ * Random Delay Generator
+ * Human-like delays के लिए
+ */
+export function getRandomDelay(min = 500, max = 2000) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+/**
+ * User Agent Rotator
+ * Different user agents use करना
+ */
+export class UserAgentRotator {
+    userAgents = [
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0',
+        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15',
+        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+    ];
+    currentIndex = 0;
+    getNext() {
+        const ua = this.userAgents[this.currentIndex];
+        this.currentIndex = (this.currentIndex + 1) % this.userAgents.length;
+        return ua;
+    }
+    getRandom() {
+        return this.userAgents[Math.floor(Math.random() * this.userAgents.length)];
+    }
+    addUserAgent(ua) {
+        this.userAgents.push(ua);
+    }
+}
+/**
+ * Auto Login Handler
+ * Automatic login form filling
+ */
+export async function autoLogin(page, credentials) {
+    try {
+        // Wait for form
+        await page.waitForSelector(credentials.usernameSelector, { timeout: 10000 });
+        // Fill username
+        await page.type(credentials.usernameSelector, credentials.username, { delay: 100 });
+        // Fill password
+        await page.type(credentials.passwordSelector, credentials.password, { delay: 100 });
+        // Random delay before submit
+        await page.waitForTimeout(getRandomDelay(500, 1500));
+        // Click submit
+        await page.click(credentials.submitSelector);
+        // Wait for navigation
+        await page.waitForNavigation({ waitUntil: 'networkidle0', timeout: 15000 });
+        return {
+            success: true,
+            message: 'Login successful'
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Login failed: ${error.message}`
+        };
+    }
+}
+/**
+ * Robots.txt Checker
+ * Website की scraping permissions check करना
+ */
+export async function checkRobotsTxt(page, baseUrl, userAgent = '*') {
+    try {
+        const robotsUrl = new URL('/robots.txt', baseUrl).href;
+        await page.goto(robotsUrl, { waitUntil: 'networkidle0' });
+        const content = await page.content();
+        const rules = [];
+        let allowed = true;
+        const lines = content.split('\n');
+        let currentUserAgent = '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith('User-agent:')) {
+                currentUserAgent = trimmed.split(':')[1].trim();
+            }
+            else if (trimmed.startsWith('Disallow:') &&
+                (currentUserAgent === userAgent || currentUserAgent === '*')) {
+                const disallowedPath = trimmed.split(':')[1].trim();
+                rules.push(disallowedPath);
+                if (disallowedPath === '/') {
+                    allowed = false;
+                }
+            }
+        }
+        return { allowed, rules };
+    }
+    catch (error) {
+        // If robots.txt doesn't exist, assume allowed
+        return { allowed: true, rules: [] };
+    }
+}