brave-real-browser-mcp-server 2.16.0 → 2.17.0

package/dist/browser-manager.js

@@ -1,5 +1,6 @@
 import { connect } from 'brave-real-browser';
 import * as fs from 'fs';
+import { ExtensionManager } from './extension-manager.js';
 import * as path from 'path';
 import * as net from 'net';
 import { execSync, spawn } from 'child_process';
@@ -455,6 +456,13 @@ export async function initializeBrowser(options) {
         }
         const customConfig = options?.customConfig ?? {};
         const platform = process.platform;
+        // Auto-install/update uBlock Origin
+        const extensionPath = await ExtensionManager.ensureUBlockOrigin();
+        const uBlockArgs = [];
+        if (extensionPath) {
+            console.error(`🔌 Loading uBlock Origin from: ${extensionPath}`);
+            uBlockArgs.push(`--disable-extensions-except=${extensionPath}`, `--load-extension=${extensionPath}`);
+        }
         const getOptimalBraveFlags = (isWindows, isRetry = false) => {
             // 2025 best practices: Minimal, secure, performance-focused flags
             const baseFlags = [
@@ -544,7 +552,8 @@ export async function initializeBrowser(options) {
                 headless: options?.headless ?? (process.env.HEADLESS === 'true'),
                 turnstile: true,
                 args: [
-                    "--start-maximized"
+                    "--start-maximized",
+                    ...uBlockArgs // Add uBlock args to primary strategy
                 ],
                 disableXvfb: true,
                 // CRITICAL: Must be false to allow brave-real-browser to process DEFAULT_FLAGS

package/dist/extension-manager.js

@@ -0,0 +1,135 @@
+import fs from 'fs';
+import path from 'path';
+import axios from 'axios';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+const EXTENSIONS_DIR = path.resolve(process.cwd(), 'extensions');
+const UBLOCK_DIR = path.join(EXTENSIONS_DIR, 'ublock');
+export class ExtensionManager {
+    static GITHUB_API_URL = 'https://api.github.com/repos/gorhill/uBlock/releases/latest';
+    static FALLBACK_VERSION_URL = 'https://github.com/gorhill/uBlock/releases/download/1.68.1rc1/uBlock0_1.68.1rc1.chromium.zip';
+    /**
+     * Ensures uBlock Origin is installed and up-to-date.
+     * Returns the path to the unzipped extension.
+     */
+    static async ensureUBlockOrigin() {
+        try {
+            if (!fs.existsSync(UBLOCK_DIR)) {
+                console.error('🚀 [Auto-Update] uBlock Origin not found. Installing...');
+                await this.installUBlock();
+            }
+            else {
+                // Optional: Check for updates (Skipped for now to avoid Github API rate limits on every startup, 
+                // using existence check primarily. A real-world app might check once a day.)
+                // For now, if it exists, use it.
+                console.error('✅ [Auto-Update] uBlock Origin is already installed.');
+            }
+            return UBLOCK_DIR;
+        }
+        catch (error) {
+            console.error('❌ [Auto-Update] Failed to install/update uBlock:', error);
+            // Fallback: Return empty string or throw? If fails, browser opens without adblock.
+            // Better to log and continue without extension than crash.
+            return '';
+        }
+    }
+    static async installUBlock() {
+        // 1. Create directory
+        if (!fs.existsSync(EXTENSIONS_DIR)) {
+            fs.mkdirSync(EXTENSIONS_DIR, { recursive: true });
+        }
+        // 2. Get Download URL
+        let downloadUrl = this.FALLBACK_VERSION_URL;
+        try {
+            const release = await axios.get(this.GITHUB_API_URL);
+            const assets = release.data.assets;
+            const chromiumAsset = assets.find((a) => a.name.includes('.chromium.zip'));
+            if (chromiumAsset) {
+                downloadUrl = chromiumAsset.browser_download_url;
+                console.error(`⬇️ [Auto-Update] Found latest version: ${release.data.tag_name}`);
+            }
+        }
+        catch (e) {
+            console.warn('⚠️ [Auto-Update] Failed to fetch latest release from GitHub (Rate limit?), using fallback.');
+        }
+        // 3. Download Zip
+        const zipPath = path.join(EXTENSIONS_DIR, 'ublock.zip');
+        console.error(`⬇️ [Auto-Update] Downloading ${downloadUrl}...`);
+        const response = await axios({
+            method: 'GET',
+            url: downloadUrl,
+            responseType: 'stream',
+        });
+        const writer = fs.createWriteStream(zipPath);
+        response.data.pipe(writer);
+        await new Promise((resolve, reject) => {
+            writer.on('finish', resolve);
+            writer.on('error', reject);
+        });
+        // 4. Extract
+        console.error('📦 [Auto-Update] Extracting uBlock Origin...');
+        // Clean previous install if any partial
+        if (fs.existsSync(UBLOCK_DIR)) {
+            fs.rmSync(UBLOCK_DIR, { recursive: true, force: true });
+        }
+        // Also clean potential extraction artifacts
+        const preChildren = fs.readdirSync(EXTENSIONS_DIR);
+        preChildren.forEach(c => {
+            if (c.startsWith('uBlock0') && c.endsWith('.chromium')) {
+                fs.rmSync(path.join(EXTENSIONS_DIR, c), { recursive: true, force: true });
+            }
+        });
+        await this.extractZip(zipPath, EXTENSIONS_DIR);
+        // Wait for file locks to release
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        // Rename extracted folder to 'ublock'
+        const children = fs.readdirSync(EXTENSIONS_DIR);
+        const extractedFolder = children.find(c => c.startsWith('uBlock0') && c.endsWith('.chromium'));
+        if (extractedFolder) {
+            const fullPath = path.join(EXTENSIONS_DIR, extractedFolder);
+            try {
+                fs.renameSync(fullPath, UBLOCK_DIR);
+            }
+            catch (renameError) {
+                console.warn('⚠️ [Auto-Update] Rename failed, trying copy...', renameError);
+                fs.cpSync(fullPath, UBLOCK_DIR, { recursive: true, force: true });
+                fs.rmSync(fullPath, { recursive: true, force: true });
+            }
+        }
+        else {
+            // If extracted directly or structure is different, we might already be good or failed.
+            // Let's assume if ublock dir doesn't exist, something went wrong, OR unzip worked differently.
+            if (!fs.existsSync(UBLOCK_DIR)) {
+                // Try to handle case where it unzipped contents directly (unlikely for uBlock release)
+                // or maybe check if there is another folder.
+                console.warn('⚠️ [Auto-Update] setup: Could not determine extracted folder name. Checking extensions dir content.');
+            }
+        }
+        // 5. Cleanup
+        if (fs.existsSync(zipPath)) {
+            fs.unlinkSync(zipPath);
+        }
+        console.error('✅ [Auto-Update] uBlock Origin installed successfully!');
+    }
+    static async extractZip(zipPath, destDir) {
+        // Cross-platform unzip without adding dependencies
+        if (process.platform === 'win32') {
+            // Use PowerShell Expand-Archive
+            const command = `powershell -Command "Expand-Archive -Path '${zipPath}' -DestinationPath '${destDir}' -Force"`;
+            await execAsync(command);
+        }
+        else {
+            // Use unzip command on Linux/Mac
+            try {
+                await execAsync(`unzip -o "${zipPath}" -d "${destDir}"`);
+            }
+            catch (e) {
+                // Fallback or specific error handling (e.g., install unzip?)
+                // Most distros have unzip. If not:
+                console.error('❌ [Auto-Update] `unzip` command failed. Please install unzip (sudo apt install unzip).');
+                throw e;
+            }
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser-mcp-server",
-  "version": "2.16.0",
+  "version": "2.17.0",
   "description": "Universal AI IDE MCP Server - Auto-detects and supports all AI IDEs (Claude Desktop, Cursor, Windsurf, Cline, Zed, VSCode, Qoder AI, etc.) with Brave browser automation",
   "type": "module",
   "main": "dist/index.js",

package/scripts/verify-ublock.ts

@@ -0,0 +1,58 @@
+
+import { ExtensionManager } from '../src/extension-manager.js';
+import { initializeBrowser, closeBrowser } from '../src/browser-manager.js';
+import * as fs from 'fs';
+import * as path from 'path';
+
+async function verifyUBlock() {
+    console.log('🚀 Starting uBlock Origin Verification...');
+
+    // 1. Verify Download & Extraction
+    console.log('\nSTEP 1: Checking ExtensionManager...');
+    const extPath = await ExtensionManager.ensureUBlockOrigin();
+    console.log(`📂 Extension Path: ${extPath}`);
+
+    if (!extPath || !fs.existsSync(extPath)) {
+        console.error('❌ Failed: Extension path does not exist!');
+        process.exit(1);
+    }
+
+    const manifestPath = path.join(extPath, 'manifest.json');
+    if (fs.existsSync(manifestPath)) {
+        console.log('✅ Manifest.json found! Extension extracted correctly.');
+    } else {
+        console.error('❌ Failed: manifest.json missing in extension folder!');
+        process.exit(1);
+    }
+
+    // 2. Verify Browser Launch with Extension
+    console.log('\nSTEP 2: Launching Browser with uBlock...');
+    try {
+        const { browser } = await initializeBrowser({
+            headless: false, // Must be false or 'new' for extensions usually, but let's test our default config
+            autoInstall: true
+        });
+
+        // Check if arguments were passed
+        const spawnArgs = browser.process()?.spawnargs || [];
+        const loadArg = spawnArgs.find(arg => arg.includes('--load-extension'));
+
+        if (loadArg && loadArg.includes(extPath)) {
+            console.log('✅ Browser launched with --load-extension argument pointing to uBlock!');
+        } else {
+            console.error('❌ Failed: Browser launched but --load-extension arg missing or incorrect.');
+            console.error('Spawn Args:', spawnArgs);
+            await closeBrowser();
+            process.exit(1);
+        }
+
+        await closeBrowser();
+        console.log('\n✨ VERIFICATION SUCCESSFUL: uBlock Origin is integrated!');
+
+    } catch (error) {
+        console.error('❌ Browser Launch Failed:', error);
+        process.exit(1);
+    }
+}
+
+verifyUBlock();