brave-real-browser-mcp-server 2.40.2 → 2.41.1

package/lib/ocr-captcha-solver.js

@@ -0,0 +1,525 @@
+/**
+ * OCR Text Captcha Solver (Enhanced Version)
+ * 
+ * Simple text-based captcha solver using Tesseract.js OCR
+ * Works with captchas like: CCA23E, actukd, hf4kvf (eCourts India style)
+ * 
+ * Features:
+ * - Advanced image preprocessing (grayscale, threshold, denoise, remove lines)
+ * - Multiple OCR attempts with different settings
+ * - Auto-retry with captcha refresh
+ * - Hindi + English language support
+ * - Works offline (no API needed)
+ */
+
+const Tesseract = require('tesseract.js');
+const path = require('path');
+const fs = require('fs');
+
+// Colors for console
+const colors = {
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    red: '\x1b[31m',
+    cyan: '\x1b[36m',
+    reset: '\x1b[0m'
+};
+
+const log = {
+    info: (msg) => console.log(`${colors.blue}[ocr-captcha]${colors.reset} ${msg}`),
+    success: (msg) => console.log(`${colors.green}[ocr-captcha]${colors.reset} ✅ ${msg}`),
+    warn: (msg) => console.log(`${colors.yellow}[ocr-captcha]${colors.reset} ⚠️ ${msg}`),
+    error: (msg) => console.log(`${colors.red}[ocr-captcha]${colors.reset} ❌ ${msg}`),
+    debug: (msg) => console.log(`${colors.cyan}[ocr-captcha]${colors.reset} 🔍 ${msg}`)
+};
+
+// Common captcha character substitutions for correction
+const CHAR_SUBSTITUTIONS = {
+    '0': ['O', 'o', 'Q', 'D'],
+    'O': ['0', 'o', 'Q', 'D'],
+    '1': ['l', 'I', 'i', '|', '!'],
+    'l': ['1', 'I', 'i', '|'],
+    'I': ['1', 'l', 'i', '|'],
+    '5': ['S', 's', '$'],
+    'S': ['5', 's', '$'],
+    '8': ['B', '&'],
+    'B': ['8', '&'],
+    '2': ['Z', 'z'],
+    'Z': ['2', 'z'],
+    '6': ['G', 'b'],
+    'G': ['6', 'C'],
+    '9': ['g', 'q'],
+    'g': ['9', 'q'],
+    'C': ['G', 'c', '('],
+    'E': ['3', 'e'],
+    '3': ['E', 'e'],
+    'A': ['4', 'a'],
+    '4': ['A', 'a'],
+};
+
+// Default OCR settings optimized for captchas
+const DEFAULT_OCR_CONFIG = {
+    lang: 'eng',
+    tessedit_char_whitelist: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789',
+    tessedit_pageseg_mode: '7', // Single line
+    preserve_interword_spaces: '0',
+};
+
+// Preprocessing configurations for different captcha types
+const PREPROCESS_CONFIGS = [
+    { name: 'standard', threshold: 128, invert: false, removeLines: true },
+    { name: 'high-contrast', threshold: 100, invert: false, removeLines: true },
+    { name: 'low-contrast', threshold: 160, invert: false, removeLines: true },
+    { name: 'inverted', threshold: 128, invert: true, removeLines: true },
+    { name: 'no-line-removal', threshold: 128, invert: false, removeLines: false },
+];
+
+/**
+ * Advanced image preprocessing in browser
+ * Removes noise, lines, and enhances text
+ */
+async function preprocessImageAdvanced(page, selector, config = {}) {
+    const { threshold = 128, invert = false, removeLines = true } = config;
+    
+    return await page.evaluate(({ sel, threshold, invert, removeLines }) => {
+        const img = document.querySelector(sel);
+        if (!img) return null;
+
+        const canvas = document.createElement('canvas');
+        const ctx = canvas.getContext('2d');
+        
+        // Use natural dimensions for better quality
+        const width = img.naturalWidth || img.width || 200;
+        const height = img.naturalHeight || img.height || 50;
+        
+        canvas.width = width;
+        canvas.height = height;
+        
+        // Draw original image
+        ctx.drawImage(img, 0, 0, width, height);
+        
+        // Get image data
+        const imageData = ctx.getImageData(0, 0, width, height);
+        const data = imageData.data;
+        
+        // Step 1: Convert to grayscale
+        for (let i = 0; i < data.length; i += 4) {
+            const gray = 0.299 * data[i] + 0.587 * data[i + 1] + 0.114 * data[i + 2];
+            data[i] = gray;
+            data[i + 1] = gray;
+            data[i + 2] = gray;
+        }
+        
+        // Step 2: Remove diagonal lines (common in captchas)
+        if (removeLines) {
+            // Detect and remove thin lines
+            for (let y = 1; y < height - 1; y++) {
+                for (let x = 1; x < width - 1; x++) {
+                    const idx = (y * width + x) * 4;
+                    const pixel = data[idx];
+                    
+                    // Check if this is a dark pixel
+                    if (pixel < threshold) {
+                        // Get surrounding pixels
+                        const top = data[((y - 1) * width + x) * 4];
+                        const bottom = data[((y + 1) * width + x) * 4];
+                        const left = data[(y * width + (x - 1)) * 4];
+                        const right = data[(y * width + (x + 1)) * 4];
+                        
+                        // Count dark neighbors
+                        let darkNeighbors = 0;
+                        if (top < threshold) darkNeighbors++;
+                        if (bottom < threshold) darkNeighbors++;
+                        if (left < threshold) darkNeighbors++;
+                        if (right < threshold) darkNeighbors++;
+                        
+                        // If isolated or thin line (≤2 dark neighbors), might be noise
+                        if (darkNeighbors <= 1) {
+                            // Make it white (remove noise)
+                            data[idx] = 255;
+                            data[idx + 1] = 255;
+                            data[idx + 2] = 255;
+                        }
+                    }
+                }
+            }
+        }
+        
+        // Step 3: Apply threshold (binarization)
+        for (let i = 0; i < data.length; i += 4) {
+            const gray = data[i];
+            let bw = gray > threshold ? 255 : 0;
+            
+            // Invert if needed
+            if (invert) bw = 255 - bw;
+            
+            data[i] = bw;
+            data[i + 1] = bw;
+            data[i + 2] = bw;
+        }
+        
+        ctx.putImageData(imageData, 0, 0);
+        
+        return canvas.toDataURL('image/png');
+    }, { sel: selector, threshold, invert, removeLines });
+}
+
+/**
+ * Get captcha image with optional preprocessing
+ */
+async function getCaptchaImage(page, selector, preprocess = true, preprocessConfig = {}) {
+    try {
+        if (preprocess) {
+            // Try preprocessing first
+            const processed = await preprocessImageAdvanced(page, selector, preprocessConfig);
+            if (processed) {
+                log.debug('Image preprocessed successfully');
+                return processed;
+            }
+        }
+        
+        // Fallback: Screenshot of element
+        const element = await page.$(selector);
+        if (element) {
+            const screenshot = await element.screenshot({ encoding: 'base64' });
+            return `data:image/png;base64,${screenshot}`;
+        }
+
+        // Fallback 2: Get image src
+        const imgSrc = await page.$eval(selector, (img) => {
+            if (img.tagName === 'IMG') {
+                const canvas = document.createElement('canvas');
+                canvas.width = img.naturalWidth || img.width;
+                canvas.height = img.naturalHeight || img.height;
+                const ctx = canvas.getContext('2d');
+                ctx.drawImage(img, 0, 0);
+                return canvas.toDataURL('image/png');
+            }
+            return img.src || null;
+        });
+
+        return imgSrc;
+    } catch (error) {
+        log.warn(`Image capture error: ${error.message}`);
+        return null;
+    }
+}
+
+/**
+ * Recognize text using Tesseract with multiple attempts
+ */
+async function recognizeText(imageData, config = {}) {
+    const worker = await Tesseract.createWorker(config.lang || 'eng');
+    
+    try {
+        await worker.setParameters({
+            tessedit_char_whitelist: config.tessedit_char_whitelist || DEFAULT_OCR_CONFIG.tessedit_char_whitelist,
+            tessedit_pageseg_mode: config.tessedit_pageseg_mode || '7',
+        });
+
+        const { data } = await worker.recognize(imageData);
+        
+        // Clean up recognized text
+        let text = data.text
+            .replace(/\s+/g, '')           // Remove whitespace
+            .replace(/[^a-zA-Z0-9]/g, ''); // Keep only alphanumeric
+        
+        return {
+            text,
+            confidence: data.confidence,
+            rawText: data.text,
+        };
+    } finally {
+        await worker.terminate();
+    }
+}
+
+/**
+ * Solve text captcha with multiple preprocessing attempts
+ */
+async function solveTextCaptcha(page, selector, options = {}) {
+    const {
+        lang = 'eng',
+        retries = 3,
+        confidence = 50,        // Lowered for better success rate
+        allowedChars = null,
+        expectedLength = null,
+        tryAllPreprocess = true,  // Try all preprocessing configs
+    } = options;
+
+    log.info(`Solving text captcha: ${selector}`);
+
+    try {
+        let bestResult = null;
+        let allAttempts = [];
+
+        // Determine which preprocessing configs to try
+        const configsToTry = tryAllPreprocess ? PREPROCESS_CONFIGS : [PREPROCESS_CONFIGS[0]];
+
+        for (const preprocessConfig of configsToTry) {
+            log.debug(`Trying preprocess config: ${preprocessConfig.name}`);
+            
+            // Get preprocessed image
+            const imageData = await getCaptchaImage(page, selector, true, preprocessConfig);
+            
+            if (!imageData) {
+                continue;
+            }
+
+            // Try different PSM modes
+            const psmModes = ['7', '8', '13', '6']; // 7=single line, 8=word, 13=raw, 6=block
+            
+            for (let i = 0; i < Math.min(retries, psmModes.length); i++) {
+                const config = {
+                    ...DEFAULT_OCR_CONFIG,
+                    lang,
+                    tessedit_pageseg_mode: psmModes[i],
+                    ...(allowedChars && { tessedit_char_whitelist: allowedChars }),
+                };
+
+                try {
+                    const result = await recognizeText(imageData, config);
+                    result.preprocessConfig = preprocessConfig.name;
+                    result.psmMode = psmModes[i];
+                    allAttempts.push(result);
+
+                    log.debug(`  PSM ${psmModes[i]}: "${result.text}" (${result.confidence.toFixed(1)}%)`);
+
+                    // Check if result meets criteria
+                    const meetsConfidence = result.confidence >= confidence;
+                    const meetsLength = !expectedLength || result.text.length === expectedLength;
+                    const hasText = result.text.length > 0;
+
+                    if (meetsConfidence && meetsLength && hasText) {
+                        bestResult = result;
+                        break;
+                    }
+
+                    // Keep best result so far (prioritize correct length)
+                    if (hasText) {
+                        if (!bestResult) {
+                            bestResult = result;
+                        } else if (expectedLength) {
+                            // Prefer correct length
+                            if (result.text.length === expectedLength && bestResult.text.length !== expectedLength) {
+                                bestResult = result;
+                            } else if (result.confidence > bestResult.confidence) {
+                                bestResult = result;
+                            }
+                        } else if (result.confidence > bestResult.confidence) {
+                            bestResult = result;
+                        }
+                    }
+                } catch (err) {
+                    log.debug(`  OCR error: ${err.message}`);
+                }
+            }
+
+            // Stop if we found a good result
+            if (bestResult && bestResult.confidence >= confidence) {
+                break;
+            }
+        }
+
+        if (bestResult && bestResult.text) {
+            log.success(`Solved: "${bestResult.text}" (confidence: ${bestResult.confidence.toFixed(1)}%, config: ${bestResult.preprocessConfig})`);
+            return {
+                success: true,
+                text: bestResult.text,
+                confidence: bestResult.confidence,
+                attempts: allAttempts.length,
+                allAttempts,
+            };
+        }
+
+        log.warn('OCR could not recognize text');
+        return {
+            success: false,
+            text: bestResult?.text || '',
+            confidence: bestResult?.confidence || 0,
+            attempts: allAttempts.length,
+            allAttempts,
+        };
+
+    } catch (error) {
+        log.error(`Failed to solve captcha: ${error.message}`);
+        return {
+            success: false,
+            text: '',
+            confidence: 0,
+            error: error.message,
+        };
+    }
+}
+
+/**
+ * Solve captcha and fill input field with auto-retry
+ */
+async function solveCaptchaAndFill(page, captchaSelector, inputSelector, options = {}) {
+    const {
+        humanLike = true,
+        submitAfter = false,
+        submitSelector = 'button[type="submit"], input[type="submit"], button.btn-primary, input.btn',
+        refreshSelector = null,
+        maxRefreshAttempts = 5,       // Increased retries
+        minConfidence = 40,           // Minimum confidence to try
+        expectedLength = null,
+        lang = 'eng',
+        allowedChars = null,
+        waitAfterRefresh = 1500,      // Wait after refresh
+        waitBeforeType = 500,         // Wait before typing
+    } = options;
+
+    let attempts = 0;
+    let lastResult = null;
+    
+    log.info(`Starting captcha solve with ${maxRefreshAttempts} max attempts`);
+
+    while (attempts < maxRefreshAttempts) {
+        attempts++;
+        log.info(`Attempt ${attempts}/${maxRefreshAttempts}`);
+
+        // Wait for image to load properly
+        await new Promise(r => setTimeout(r, waitBeforeType));
+
+        // Solve captcha
+        const result = await solveTextCaptcha(page, captchaSelector, {
+            lang,
+            expectedLength,
+            allowedChars,
+            confidence: minConfidence,
+            tryAllPreprocess: attempts <= 2, // Only try all configs on first 2 attempts
+        });
+        
+        lastResult = result;
+
+        // Check if we got a usable result
+        if (!result.text || result.text.length === 0) {
+            log.warn('No text recognized');
+            if (refreshSelector) {
+                log.info('Refreshing captcha...');
+                try {
+                    await page.click(refreshSelector);
+                    await new Promise(r => setTimeout(r, waitAfterRefresh));
+                } catch (e) {
+                    log.warn(`Refresh failed: ${e.message}`);
+                }
+            }
+            continue;
+        }
+
+        // If expected length specified and doesn't match, refresh
+        if (expectedLength && result.text.length !== expectedLength) {
+            log.warn(`Length mismatch: got ${result.text.length}, expected ${expectedLength}`);
+            if (refreshSelector && attempts < maxRefreshAttempts) {
+                log.info('Refreshing captcha for better result...');
+                await page.click(refreshSelector);
+                await new Promise(r => setTimeout(r, waitAfterRefresh));
+                continue;
+            }
+        }
+
+        // Fill the input
+        const input = await page.$(inputSelector);
+        if (!input) {
+            return { success: false, error: 'Input field not found', attempts };
+        }
+
+        // Clear field
+        await page.click(inputSelector, { clickCount: 3 });
+        await page.keyboard.press('Backspace');
+        await new Promise(r => setTimeout(r, 100));
+
+        // Type the captcha
+        if (humanLike) {
+            for (const char of result.text) {
+                await page.keyboard.type(char);
+                await new Promise(r => setTimeout(r, 30 + Math.random() * 80));
+            }
+        } else {
+            await page.type(inputSelector, result.text);
+        }
+
+        log.success(`Filled captcha: "${result.text}"`);
+
+        // Submit if requested
+        if (submitAfter) {
+            try {
+                await page.click(submitSelector);
+                await new Promise(r => setTimeout(r, 2000));
+                
+                // Check if captcha was wrong
+                const stillOnPage = await page.$(captchaSelector);
+                const errorVisible = await page.evaluate(() => {
+                    const errorSelectors = ['.error', '.alert-danger', '.captcha-error', '#captchaError'];
+                    return errorSelectors.some(sel => {
+                        const el = document.querySelector(sel);
+                        return el && el.offsetParent !== null;
+                    });
+                });
+
+                if ((stillOnPage || errorVisible) && refreshSelector) {
+                    log.warn('Captcha might be wrong, retrying...');
+                    await page.click(refreshSelector);
+                    await new Promise(r => setTimeout(r, waitAfterRefresh));
+                    continue;
+                }
+            } catch (e) {
+                log.warn(`Submit error: ${e.message}`);
+            }
+        }
+
+        return {
+            success: true,
+            text: result.text,
+            confidence: result.confidence,
+            attempts,
+        };
+    }
+
+    return {
+        success: false,
+        error: 'Max attempts reached',
+        attempts,
+        lastResult,
+    };
+}
+
+/**
+ * Solve captcha from URL directly
+ */
+async function solveCaptchaFromUrl(imageUrl, options = {}) {
+    log.info(`Solving captcha from URL: ${imageUrl}`);
+    
+    try {
+        const result = await recognizeText(imageUrl, {
+            ...DEFAULT_OCR_CONFIG,
+            ...options,
+        });
+
+        return {
+            success: result.confidence > 40 && result.text.length > 0,
+            text: result.text,
+            confidence: result.confidence,
+        };
+    } catch (error) {
+        return {
+            success: false,
+            error: error.message,
+        };
+    }
+}
+
+// Export functions
+module.exports = {
+    solveTextCaptcha,
+    solveCaptchaAndFill,
+    solveCaptchaFromUrl,
+    getCaptchaImage,
+    recognizeText,
+    preprocessImageAdvanced,
+    CHAR_SUBSTITUTIONS,
+    DEFAULT_OCR_CONFIG,
+    PREPROCESS_CONFIGS,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser-mcp-server",
-  "version": "2.40.2",
+  "version": "2.41.1",
   "description": "MCP Server for Brave Real Browser - Puppeteer with Brave Browser, Stealth Mode, Ad Blocker, and Turnstile Auto-Solver for undetectable web automation.",
   "main": "lib/cjs/index.js",
   "module": "lib/esm/index.mjs",
@@ -43,7 +43,10 @@
     "lint": "echo 'No linting configured'",
     "build:all": "npm run build --workspaces --if-present",
     "clean:all": "npm run clean --workspaces --if-present",
-    "test:all": "npm run test --workspaces --if-present"
+    "test:all": "npm run test --workspaces --if-present",
+    "postinstall": "node scripts/auto-update-deps.js || true",
+    "update-deps": "node scripts/auto-update-deps.js",
+    "upstream-patch": "node scripts/upstream-patcher.js"
   },
   "keywords": [
     "mcp-server",
@@ -76,6 +79,7 @@
     "ghost-cursor": "^1.4.2",
     "puppeteer-extra": "^3.3.6",
     "puppeteer-extra-plugin-stealth": "^2.11.2",
+    "tesseract.js": "^5.1.1",
     "tree-kill": "^1.2.2",
     "vscode-languageserver": "^9.0.1",
     "vscode-languageserver-textdocument": "^1.0.12",

package/packages/brave-real-blocker/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-blocker",
-  "version": "1.16.2",
+  "version": "1.17.1",
   "description": "Advanced uBlock Origin management and stealth features for Brave Real Browser",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -66,7 +66,7 @@
     "@types/node": "^20.0.0",
     "brave-real-puppeteer-core": "^24.36.NaN.1",
     "mocha": "^10.4.0",
-    "puppeteer-core": "^24.36.1",
+    "puppeteer-core": ">=24.0.0",
     "sinon": "^17.0.1",
     "ts-node": "^10.9.2",
     "tsup": "^8.0.0",

package/packages/brave-real-launcher/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-launcher",
-  "version": "1.22.2",
+  "version": "1.23.1",
   "description": "Launch Brave Browser with ease from node. Based on chrome-launcher with Brave-specific support.",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -54,7 +54,7 @@
     "typescript": "^5.0.0"
   },
   "dependencies": {
-    "brave-real-blocker": "^1.16.2",
+    "brave-real-blocker": "^1.17.1",
     "escape-string-regexp": "^5.0.0",
     "is-wsl": "^3.1.0",
     "which": "^6.0.0"

package/packages/brave-real-playwright-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-playwright-core",
-  "version": "1.58.NaN.1",
+  "version": "1.59.1.1",
   "description": "Brave-optimized Playwright Core (v1.57.0) with comprehensive stealth patches and error stack sanitization",
   "keywords": [
     "playwright",

package/packages/brave-real-puppeteer-core/package.json

@@ -134,13 +134,13 @@
     "test-version": "node ./scripts/test-version-management.js"
   },
   "dependencies": {
-    "brave-real-launcher": "^1.22.2",
+    "brave-real-launcher": "^1.23.1",
     "get-east-asian-width": "^1.4.0",
     "yargs": "^18.0.0"
   },
   "optionalDependencies": {
-    "playwright-core": "^1.58.1",
-    "puppeteer-core": "^24.36.1"
+    "playwright-core": ">=1.40.0",
+    "puppeteer-core": ">=24.0.0"
   },
   "devDependencies": {
     "test": "^3.3.0"

package/scripts/auto-update-deps.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+/**
+ * Auto-Update Dependencies Script
+ * 
+ * यह script npm install के बाद automatically चलता है और:
+ * 1. सभी external dependencies को latest version पर update करता है
+ * 2. Internal workspace packages को sync रखता है
+ * 3. puppeteer-core और playwright-core को latest पर रखता है
+ * 
+ * Usage: Automatically runs via postinstall hook
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+// Colors for console
+const colors = {
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    red: '\x1b[31m',
+    reset: '\x1b[0m',
+    bold: '\x1b[1m'
+};
+
+const log = {
+    info: (msg) => console.log(`${colors.blue}[auto-update]${colors.reset} ${msg}`),
+    success: (msg) => console.log(`${colors.green}[auto-update]${colors.reset} ${msg}`),
+    warn: (msg) => console.log(`${colors.yellow}[auto-update]${colors.reset} ${msg}`),
+    error: (msg) => console.log(`${colors.red}[auto-update]${colors.reset} ${msg}`)
+};
+
+// Skip if CI environment and SKIP_AUTO_UPDATE is set
+if (process.env.SKIP_AUTO_UPDATE === 'true') {
+    log.info('Skipping auto-update (SKIP_AUTO_UPDATE=true)');
+    process.exit(0);
+}
+
+// Skip during npm publish
+if (process.env.npm_command === 'publish') {
+    log.info('Skipping auto-update during publish');
+    process.exit(0);
+}
+
+// Critical dependencies to always keep updated
+const CRITICAL_DEPS = [
+    'puppeteer-core',
+    'playwright-core',
+    '@modelcontextprotocol/sdk'
+];
+
+// Packages to update (external dependencies)
+const PACKAGES_TO_UPDATE = [
+    'ghost-cursor',
+    'puppeteer-extra',
+    'puppeteer-extra-plugin-stealth',
+    'puppeteer-extra-plugin-adblocker',
+    '@ghostery/adblocker-puppeteer'
+];
+
+async function getLatestVersion(packageName) {
+    try {
+        const result = execSync(`npm view ${packageName} version`, { 
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe']
+        }).trim();
+        return result;
+    } catch (e) {
+        return null;
+    }
+}
+
+async function getCurrentVersion(packageName) {
+    try {
+        const result = execSync(`npm list ${packageName} --depth=0 --json`, {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+        const data = JSON.parse(result);
+        return data.dependencies?.[packageName]?.version || null;
+    } catch (e) {
+        return null;
+    }
+}
+
+async function updateDependencies() {
+    log.info('Checking for dependency updates...');
+    
+    const updates = [];
+    
+    // Check critical dependencies
+    for (const pkg of CRITICAL_DEPS) {
+        const latest = await getLatestVersion(pkg);
+        const current = await getCurrentVersion(pkg);
+        
+        if (latest && current && latest !== current) {
+            updates.push({ name: pkg, current, latest, critical: true });
+        }
+    }
+    
+    // Check other packages
+    for (const pkg of PACKAGES_TO_UPDATE) {
+        const latest = await getLatestVersion(pkg);
+        const current = await getCurrentVersion(pkg);
+        
+        if (latest && current && latest !== current) {
+            updates.push({ name: pkg, current, latest, critical: false });
+        }
+    }
+    
+    if (updates.length === 0) {
+        log.success('All dependencies are up to date!');
+        return;
+    }
+    
+    // Show what will be updated
+    log.info(`Found ${updates.length} packages to update:`);
+    updates.forEach(u => {
+        const icon = u.critical ? '🔴' : '🔵';
+        console.log(`  ${icon} ${u.name}: ${u.current} → ${u.latest}`);
+    });
+    
+    log.info('Run "npm update" to update these packages.');
+}
+
+async function updateBasedOnField() {
+    log.info('Checking basedOn field updates...');
+    
+    const packagesDir = path.join(__dirname, '..', 'packages');
+    const updates = [];
+    
+    // Check brave-real-puppeteer-core
+    const puppeteerPkgPath = path.join(packagesDir, 'brave-real-puppeteer-core', 'package.json');
+    if (fs.existsSync(puppeteerPkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(puppeteerPkgPath, 'utf8'));
+        const basedOn = pkg.brave?.basedOn?.['puppeteer-core'];
+        const latestPuppeteer = await getLatestVersion('puppeteer-core');
+        
+        if (basedOn && latestPuppeteer && basedOn !== latestPuppeteer) {
+            updates.push({
+                package: 'brave-real-puppeteer-core',
+                basedOn,
+                latest: latestPuppeteer,
+                upstream: 'puppeteer-core'
+            });
+        }
+    }
+    
+    // Check brave-real-playwright-core
+    const playwrightPkgPath = path.join(packagesDir, 'brave-real-playwright-core', 'package.json');
+    if (fs.existsSync(playwrightPkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(playwrightPkgPath, 'utf8'));
+        const basedOn = pkg.brave?.basedOn?.['playwright-core'];
+        const latestPlaywright = await getLatestVersion('playwright-core');
+        
+        if (basedOn && latestPlaywright && basedOn !== latestPlaywright) {
+            updates.push({
+                package: 'brave-real-playwright-core',
+                basedOn,
+                latest: latestPlaywright,
+                upstream: 'playwright-core'
+            });
+        }
+    }
+    
+    if (updates.length > 0) {
+        log.warn('Upstream updates available:');
+        updates.forEach(u => {
+            console.log(`  ⬆️  ${u.package}: ${u.upstream} ${u.basedOn} → ${u.latest}`);
+        });
+        log.info('Run "npm run upstream-patch" to update to latest upstream');
+    } else {
+        log.success('All packages are based on latest upstream versions!');
+    }
+}
+
+// Main execution
+async function main() {
+    console.log(`\n${colors.bold}🔄 Auto-Update Dependencies${colors.reset}\n`);
+    
+    try {
+        await updateDependencies();
+        await updateBasedOnField();
+        console.log('');
+    } catch (e) {
+        log.error('Auto-update failed: ' + e.message);
+        // Don't fail the install
+        process.exit(0);
+    }
+}
+
+main();

package/src/mcp/handlers.js

@@ -506,13 +506,105 @@ const handlers = {
     return { success: true, message: 'Browser closed' };
   },
 
-  // 8. Solve Captcha
+// 8. Solve Captcha (Enhanced with OCR for text captchas)
   async solve_captcha(params = {}) {
     const { page } = requireBrowser();
-    const { type = 'auto', timeout = 30000 } = params;
+    const { 
+      type = 'auto', 
+      timeout = 30000,
+      // OCR-specific options
+      captchaSelector,
+      inputSelector,
+      refreshSelector,
+      lang = 'eng',
+      expectedLength,
+      allowedChars,
+      maxRetries = 3
+    } = params;
     
     notifyProgress('solve_captcha', 'started', `Solving ${type} captcha...`);
     
+    // Handle text/image captcha with OCR
+    if (type === 'text' || type === 'image') {
+      if (!captchaSelector) {
+        return { success: false, error: 'captchaSelector is required for text/image captcha' };
+      }
+      
+      try {
+        // Dynamic import for OCR solver
+        const ocrSolver = require('../../lib/ocr-captcha-solver');
+        
+        if (inputSelector) {
+          // Solve and fill
+          const result = await ocrSolver.solveCaptchaAndFill(page, captchaSelector, inputSelector, {
+            lang,
+            expectedLength,
+            allowedChars,
+            refreshSelector,
+            maxRefreshAttempts: maxRetries,
+            humanLike: true
+          });
+          
+          notifyProgress('solve_captcha', result.success ? 'completed' : 'error', 
+            result.success ? `OCR solved: "${result.text}"` : `OCR failed: ${result.error}`);
+          
+          return {
+            success: result.success,
+            type: 'ocr',
+            text: result.text,
+            confidence: result.confidence,
+            attempts: result.attempts,
+            filled: true
+          };
+        } else {
+          // Just solve (don't fill)
+          const result = await ocrSolver.solveTextCaptcha(page, captchaSelector, {
+            lang,
+            expectedLength,
+            allowedChars,
+            retries: maxRetries
+          });
+          
+          notifyProgress('solve_captcha', result.success ? 'completed' : 'error',
+            result.success ? `OCR result: "${result.text}"` : 'OCR failed');
+          
+          return {
+            success: result.success,
+            type: 'ocr',
+            text: result.text,
+            confidence: result.confidence,
+            attempts: result.attempts,
+            filled: false
+          };
+        }
+      } catch (err) {
+        notifyProgress('solve_captcha', 'error', `OCR error: ${err.message}`);
+        return { success: false, error: err.message, type: 'ocr' };
+      }
+    }
+    
+    // Auto-detect captcha type
+    if (type === 'auto') {
+      // Check for text/image captcha first
+      const hasTextCaptcha = await page.evaluate(() => {
+        const captchaIndicators = [
+          'img[src*="captcha"]',
+          'img[alt*="captcha"]',
+          'img[id*="captcha"]',
+          '.captcha-image',
+          '#captcha-image',
+          'img[src*="Captcha"]'
+        ];
+        return captchaIndicators.some(sel => document.querySelector(sel));
+      });
+      
+      if (hasTextCaptcha && captchaSelector) {
+        // Recursively call with text type
+        return this.solve_captcha({ ...params, type: 'text' });
+      }
+    }
+    
+    // Original Turnstile/reCAPTCHA/hCaptcha handling
     const start = Date.now();
     let attempts = 0;
     

package/src/shared/tools.js

@@ -173,21 +173,34 @@ const TOOLS = [
     }
   },
 
-  // 8. Solve Captcha
+  // 8. Solve Captcha (Enhanced with OCR for text captchas)
   {
     name: 'solve_captcha',
     emoji: '🔓',
-    description: 'Auto-solve CAPTCHA with AI (Turnstile, reCAPTCHA, hCaptcha)',
-    descriptionHindi: 'CAPTCHA हल करना (AI-powered)',
+    description: 'Auto-solve CAPTCHA with AI (Turnstile, reCAPTCHA, hCaptcha, Text/Image OCR)',
+    descriptionHindi: 'CAPTCHA हल करना (AI + OCR powered)',
     category: 'interaction',
     requiresBrowser: true,
     requiresPage: true,
     inputSchema: {
       type: 'object',
       properties: {
-        type: { type: 'string', enum: ['turnstile', 'recaptcha', 'hcaptcha', 'auto'], default: 'auto' },
+        type: { 
+          type: 'string', 
+          enum: ['turnstile', 'recaptcha', 'hcaptcha', 'text', 'image', 'auto'], 
+          default: 'auto',
+          description: 'Captcha type: turnstile/recaptcha/hcaptcha (JS-based), text/image (OCR-based), auto (detect)'
+        },
         timeout: { type: 'number', default: 30000 },
-        aiMode: { type: 'boolean', default: true, description: 'Use AI vision for complex CAPTCHAs' }
+        aiMode: { type: 'boolean', default: true, description: 'Use AI vision for complex CAPTCHAs' },
+        // OCR-specific options for text/image captchas
+        captchaSelector: { type: 'string', description: 'CSS selector for captcha image (required for text/image type)' },
+        inputSelector: { type: 'string', description: 'CSS selector for input field to fill result' },
+        refreshSelector: { type: 'string', description: 'CSS selector for captcha refresh button' },
+        lang: { type: 'string', default: 'eng', description: 'OCR language: eng, hin, eng+hin' },
+        expectedLength: { type: 'number', description: 'Expected captcha text length' },
+        allowedChars: { type: 'string', description: 'Allowed characters in captcha' },
+        maxRetries: { type: 'number', default: 3, description: 'Max refresh attempts for OCR' }
       }
     }
   },