brave-real-browser-mcp-server 2.27.32 → 2.28.1

package/dist/handlers/advanced-tools.js

@@ -1707,6 +1707,7 @@ export async function handleExtractJson(page, args) {
         try {
             const key = args.decryptAES.key || "kiemtienmua911ca";
             const ivList = args.decryptAES.ivList || ["1234567890oiuytr", "0123456789abcdef"];
+            const autoIV = args.decryptAES.autoIV !== false; // Default to true for hubstream-style encryption
             let input = args.decryptAES.input || "";
             // Option: Fetch encrypted data from API URL directly (recommended for hubstream)
             if (!input && args.decryptAES.fetchUrl) {
@@ -1733,24 +1734,43 @@ export async function handleExtractJson(page, args) {
                             }
                             return bytes;
                         };
-                        for (const iv of params.ivList) {
+                        // Build IV list - if autoIV, try extracting from first 16 bytes first
+                        const ivsToTry = [];
+                        if (params.autoIV && encryptedHex.length >= 32) {
+                            // First 32 hex chars = first 16 bytes = IV (hubstream style)
+                            const ivHex = encryptedHex.substring(0, 32);
+                            ivsToTry.push({ iv: hexToBytes(ivHex), label: 'autoIV (first 16 bytes)' });
+                        }
+                        // Add manual IV list
+                        for (const ivStr of params.ivList) {
+                            ivsToTry.push({ iv: new TextEncoder().encode(ivStr), label: ivStr });
+                        }
+                        for (const { iv: ivData, label: ivLabel } of ivsToTry) {
                             try {
                                 const keyData = new TextEncoder().encode(params.key);
-                                const ivData = new TextEncoder().encode(iv);
-                                const encryptedData = hexToBytes(encryptedHex);
+                                // If using autoIV, encrypted data starts after first 32 hex chars (16 bytes)
+                                const isAutoIV = ivLabel.startsWith('autoIV');
+                                const dataHex = isAutoIV ? encryptedHex.substring(32) : encryptedHex;
+                                const encryptedData = hexToBytes(dataHex);
                                 const cryptoKey = await crypto.subtle.importKey("raw", keyData, "AES-CBC", false, ["decrypt"]);
                                 const decrypted = await crypto.subtle.decrypt({ name: "AES-CBC", iv: ivData }, cryptoKey, encryptedData);
                                 const decryptedText = new TextDecoder().decode(decrypted);
-                                // Extract source URL from decrypted JSON
+                                // Extract URLs from decrypted JSON
                                 const sourceMatch = /"source":"([^"]+)"/.exec(decryptedText);
+                                const mp4Match = /"mp4":"([^"]+)"/.exec(decryptedText);
+                                const hlsMatch = /"hls":"([^"]+)"/.exec(decryptedText);
                                 const streamUrl = sourceMatch ? sourceMatch[1].replace(/\\\//g, '/') : null;
+                                const mp4Url = mp4Match ? mp4Match[1].replace(/\\\//g, '/') : null;
+                                const hlsUrl = hlsMatch ? hlsMatch[1].replace(/\\\//g, '/') : null;
                                 return {
                                     success: true,
-                                    iv: iv,
+                                    iv: ivLabel,
                                     decrypted: decryptedText,
                                     decryptedLength: decryptedText.length,
                                     extractedStreamUrl: streamUrl,
-                                    isStreamUrl: streamUrl ? (streamUrl.includes('m3u8') || streamUrl.includes('.mp4')) : false,
+                                    extractedMp4Url: mp4Url,
+                                    extractedHlsUrl: hlsUrl,
+                                    isStreamUrl: (streamUrl && (streamUrl.includes('m3u8') || streamUrl.includes('.mp4'))) || !!mp4Url,
                                     inputLength: encryptedHex.length
                                 };
                             }
@@ -1763,7 +1783,7 @@ export async function handleExtractJson(page, args) {
                     catch (e) {
                         return { success: false, error: String(e) };
                     }
-                }, { input, key, ivList, fetchUrl: args.decryptAES.fetchUrl });
+                }, { input, key, ivList, autoIV, fetchUrl: args.decryptAES.fetchUrl });
                 decoded = {
                     source: 'decryptAES',
                     ...result,
@@ -4801,9 +4821,16 @@ export async function handleExecuteJs(page, args) {
     const waitTime = args.waitForResult || 5000;
     try {
         let result;
+        // Auto-detect if code contains await and wrap with async IIFE
+        const hasAwait = /\bawait\b/.test(args.code);
+        const isAlreadyAsync = /^\s*\(async\s+function|\(\s*async\s*\(|\(async\s*\(\)\s*=>/.test(args.code.trim());
+        // Wrap code with async IIFE if it contains await but isn't already async
+        const codeToExecute = (hasAwait && !isAlreadyAsync)
+            ? `(async () => { ${args.code} })()`
+            : args.code;
         if (args.context === 'isolated') {
             // Execute in isolated context (sandboxed)
-            result = await page.evaluate(args.code);
+            result = await page.evaluate(codeToExecute);
         }
         else {
             // Execute in page context with full access
@@ -4815,7 +4842,7 @@ export async function handleExecuteJs(page, args) {
                 catch (e) {
                     return { error: String(e) };
                 }
-            }, args.code);
+            }, codeToExecute);
         }
         // Handle async results
         if (result instanceof Promise) {

package/dist/handlers/navigation-handlers.js

@@ -5,6 +5,10 @@ import { getProgressNotifier } from '../transport/progress-notifier.js';
 import { getSharedEventBus } from '../transport/index.js';
 // Get event bus instance
 const eventBus = getSharedEventBus();
+// Helper to detect API endpoints
+function isApiEndpoint(url) {
+    return /\/api\/|\.json(\?|$)|\?.*=.*&|\/v\d+\//.test(url);
+}
 // Navigation handler with real-time progress
 export async function handleNavigate(args) {
     const progressNotifier = getProgressNotifier();
@@ -42,6 +46,37 @@ export async function handleNavigate(args) {
                 }
                 catch (error) {
                     lastError = error instanceof Error ? error : new Error(String(error));
+                    // Check if this is an API endpoint that failed with ERR_ABORTED
+                    const isAborted = lastError.message.includes('ERR_ABORTED') ||
+                        lastError.message.includes('net::ERR_');
+                    if (isAborted && isApiEndpoint(url)) {
+                        // Fallback: Use fetch to get API response directly
+                        tracker.setProgress(50, '📡 Detected API endpoint, using fetch fallback...');
+                        try {
+                            const apiResponse = await pageInstance.evaluate(async (apiUrl) => {
+                                const response = await fetch(apiUrl);
+                                const text = await response.text();
+                                return {
+                                    status: response.status,
+                                    contentType: response.headers.get('content-type'),
+                                    data: text
+                                };
+                            }, url);
+                            tracker.complete('📡 API endpoint fetched successfully');
+                            return {
+                                content: [
+                                    {
+                                        type: 'text',
+                                        text: `API Response from ${url}\n\nStatus: ${apiResponse.status}\nContent-Type: ${apiResponse.contentType}\n\nData:\n${apiResponse.data}`,
+                                    },
+                                ],
+                            };
+                        }
+                        catch (fetchError) {
+                            // Fetch also failed, continue with normal retry
+                            tracker.setProgress(55, '❌ Fetch fallback failed, retrying navigation...');
+                        }
+                    }
                     tracker.setProgress(20 + attempt * 20, `❌ Attempt ${attempt} failed: ${lastError.message}`);
                     if (attempt < maxRetries) {
                         const delay = 1000 * Math.pow(2, attempt - 1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser-mcp-server",
-  "version": "2.27.32",
+  "version": "2.28.1",
   "description": "🦁 MCP server for Brave Real Browser - NPM Workspaces Monorepo with anti-detection features, SSE streaming, and LSP compatibility",
   "type": "module",
   "main": "dist/index.js",
@@ -50,7 +50,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "latest",
     "@types/turndown": "latest",
-    "brave-real-browser": "^2.8.32",
+    "brave-real-browser": "^2.8.33",
     "puppeteer-core": "^24.35.0",
     "turndown": "latest",
     "vscode-languageserver": "^9.0.1",