brave-real-browser-mcp-server 2.27.8 → 2.27.9

package/dist/handlers/advanced-tools.js

@@ -364,10 +364,221 @@ export async function handleFindElementAdvanced(page, args) {
     };
 }
 /**
- * Extract embedded JSON/API data from page
+ * Extract embedded JSON/API data from page + Advanced Decode capabilities
+ * Supports: base64, URL encoding, hex, rot13, reverse - with multi-layer decoding
  */
+// ============================================================
+// DECODE HELPER FUNCTIONS
+// ============================================================
+function decodeBase64(input) {
+    try {
+        // Handle URL-safe base64
+        const normalized = input.replace(/-/g, '+').replace(/_/g, '/');
+        const padded = normalized + '='.repeat((4 - normalized.length % 4) % 4);
+        return Buffer.from(padded, 'base64').toString('utf-8');
+    }
+    catch {
+        return input;
+    }
+}
+function decodeUrl(input) {
+    try {
+        return decodeURIComponent(input);
+    }
+    catch {
+        return input;
+    }
+}
+function decodeHex(input) {
+    try {
+        // Remove 0x prefix if present
+        const hex = input.replace(/^0x/i, '').replace(/\s/g, '');
+        return Buffer.from(hex, 'hex').toString('utf-8');
+    }
+    catch {
+        return input;
+    }
+}
+function decodeRot13(input) {
+    return input.replace(/[a-zA-Z]/g, (char) => {
+        const base = char <= 'Z' ? 65 : 97;
+        return String.fromCharCode(((char.charCodeAt(0) - base + 13) % 26) + base);
+    });
+}
+function reverseString(input) {
+    return input.split('').reverse().join('');
+}
+function applyDecodeLayer(input, layer) {
+    switch (layer) {
+        case 'base64': return decodeBase64(input);
+        case 'url': return decodeUrl(input);
+        case 'hex': return decodeHex(input);
+        case 'rot13': return decodeRot13(input);
+        case 'reverse': return reverseString(input);
+        default: return input;
+    }
+}
+function multiLayerDecode(input, layers) {
+    let result = input;
+    for (const layer of layers) {
+        result = applyDecodeLayer(result, layer);
+    }
+    return result;
+}
+function extractUrlParam(url, param = 'id') {
+    try {
+        const urlObj = new URL(url);
+        return urlObj.searchParams.get(param);
+    }
+    catch {
+        // Try regex fallback for malformed URLs
+        const match = url.match(new RegExp(`[?&]${param}=([^&]+)`));
+        return match ? match[1] : null;
+    }
+}
+function findBase64InText(text, pattern) {
+    const results = [];
+    // Use custom pattern or default base64 pattern
+    const regex = pattern
+        ? new RegExp(pattern, 'g')
+        : /[A-Za-z0-9+/=_-]{20,}/g; // Match potential base64 strings
+    let match;
+    while ((match = regex.exec(text)) !== null) {
+        // Validate it looks like base64
+        const candidate = match[0];
+        if (candidate.length >= 20 && /^[A-Za-z0-9+/=_-]+$/.test(candidate)) {
+            try {
+                const decoded = decodeBase64(candidate);
+                // Only include if it decoded to something meaningful
+                if (decoded && decoded.length > 0 && /^[\x20-\x7E\s]+$/.test(decoded)) {
+                    results.push(decoded);
+                }
+            }
+            catch {
+                // Skip invalid base64
+            }
+        }
+        if (results.length >= 50)
+            break; // Limit results
+    }
+    return results;
+}
+// ============================================================
+// MAIN HANDLER
+// ============================================================
 export async function handleExtractJson(page, args) {
     const data = [];
+    let decoded = null;
+    // ============================================================
+    // 1. DECODE FROM DIRECT BASE64 STRING
+    // ============================================================
+    if (args.decodeBase64) {
+        try {
+            const result = decodeBase64(args.decodeBase64);
+            decoded = {
+                source: 'decodeBase64',
+                input: args.decodeBase64.substring(0, 50) + '...',
+                output: result,
+                isUrl: result.startsWith('http'),
+            };
+            data.push(decoded);
+        }
+        catch (e) {
+            decoded = { source: 'decodeBase64', error: String(e) };
+        }
+    }
+    // ============================================================
+    // 2. DECODE FROM URL PARAMETER
+    // ============================================================
+    if (args.decodeFromUrl) {
+        try {
+            const paramName = args.decodeUrlParam || 'id';
+            const encoded = extractUrlParam(args.decodeFromUrl, paramName);
+            if (encoded) {
+                const result = decodeBase64(encoded);
+                decoded = {
+                    source: 'decodeFromUrl',
+                    url: args.decodeFromUrl.substring(0, 80) + '...',
+                    param: paramName,
+                    encoded: encoded.substring(0, 50) + '...',
+                    decoded: result,
+                    isUrl: result.startsWith('http'),
+                };
+                data.push(decoded);
+            }
+            else {
+                decoded = { source: 'decodeFromUrl', error: `Parameter '${paramName}' not found in URL` };
+            }
+        }
+        catch (e) {
+            decoded = { source: 'decodeFromUrl', error: String(e) };
+        }
+    }
+    // ============================================================
+    // 3. ADVANCED MULTI-LAYER DECODE
+    // ============================================================
+    if (args.advancedDecode) {
+        try {
+            let input = args.advancedDecode.input || '';
+            // Extract from page if requested
+            if (args.advancedDecode.extractFromPage) {
+                const pageContent = await page.evaluate((selector) => {
+                    if (selector) {
+                        const el = document.querySelector(selector);
+                        return el?.textContent || '';
+                    }
+                    return document.body?.textContent || '';
+                }, args.advancedDecode.pageSelector);
+                input = pageContent;
+            }
+            if (input) {
+                const result = multiLayerDecode(input, args.advancedDecode.layers);
+                decoded = {
+                    source: 'advancedDecode',
+                    layers: args.advancedDecode.layers,
+                    inputLength: input.length,
+                    inputPreview: input.substring(0, 100) + (input.length > 100 ? '...' : ''),
+                    output: result,
+                    outputLength: result.length,
+                    isUrl: result.startsWith('http'),
+                };
+                data.push(decoded);
+            }
+        }
+        catch (e) {
+            decoded = { source: 'advancedDecode', error: String(e) };
+        }
+    }
+    // ============================================================
+    // 4. FIND AND DECODE BASE64 PATTERNS IN PAGE
+    // ============================================================
+    if (args.decodePattern) {
+        try {
+            const pageText = await page.evaluate(() => {
+                // Get all script contents + page text
+                const scripts = Array.from(document.querySelectorAll('script'))
+                    .map(s => s.textContent || '')
+                    .join('\n');
+                const bodyText = document.body?.textContent || '';
+                return scripts + '\n' + bodyText;
+            });
+            const found = findBase64InText(pageText, args.decodePattern);
+            decoded = {
+                source: 'decodePattern',
+                pattern: args.decodePattern,
+                foundCount: found.length,
+                results: found.slice(0, 20), // Limit to first 20
+                urls: found.filter(f => f.startsWith('http')),
+            };
+            data.push(decoded);
+        }
+        catch (e) {
+            decoded = { source: 'decodePattern', error: String(e) };
+        }
+    }
+    // ============================================================
+    // 5. ORIGINAL JSON EXTRACTION (preserved)
+    // ============================================================
     // Extract from script tags with type="application/json" or type="application/ld+json"
     const scriptData = await page.evaluate((selector) => {
         const scripts = selector
@@ -415,6 +626,7 @@ export async function handleExtractJson(page, args) {
         found: data.length > 0,
         data,
         count: data.length,
+        decoded,
     };
 }
 /**

package/dist/tool-definitions.js

@@ -470,14 +470,34 @@ export const TOOLS = [
     },
     {
         name: 'extract_json',
-        description: 'Extract embedded JSON/API data from page (LD+JSON, __NEXT_DATA__, etc.)',
+        description: 'Extract embedded JSON/API data from page (LD+JSON, __NEXT_DATA__, etc.) + Advanced Decode capabilities for complex websites (base64, URL, hex, rot13, multi-layer)',
         inputSchema: {
             type: 'object',
             additionalProperties: false,
             properties: {
+                // Original JSON extraction
                 selector: { type: 'string', description: 'CSS selector for script tags' },
                 scriptIndex: { type: 'number', description: 'Index of script to extract' },
                 variableName: { type: 'string', description: 'Window variable name to extract' },
+                // Advanced Decode capabilities
+                decodeBase64: { type: 'string', description: 'Direct base64 string to decode' },
+                decodeFromUrl: { type: 'string', description: 'URL to extract and decode encoded parameter from (e.g., gadgetsweb.xyz/?id=xxx)' },
+                decodeUrlParam: { type: 'string', description: 'URL parameter name to decode (default: id)', default: 'id' },
+                decodePattern: { type: 'string', description: 'Regex pattern to find and decode base64 strings in page content' },
+                advancedDecode: {
+                    type: 'object',
+                    description: 'Multi-layer decode for complex obfuscation (supports base64, url, hex, rot13, reverse)',
+                    properties: {
+                        input: { type: 'string', description: 'Input string to decode (if not using page content)' },
+                        layers: {
+                            type: 'array',
+                            items: { type: 'string', enum: ['base64', 'url', 'hex', 'rot13', 'reverse'] },
+                            description: 'Decode layers to apply in order (e.g., ["base64", "url"])'
+                        },
+                        extractFromPage: { type: 'boolean', description: 'Extract input from current page content', default: false },
+                        pageSelector: { type: 'string', description: 'CSS selector to extract from (for extractFromPage)' },
+                    },
+                },
             },
         },
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser-mcp-server",
-  "version": "2.27.8",
+  "version": "2.27.9",
   "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.8",
+    "brave-real-browser": "^2.8.9",
     "puppeteer-core": "^24.35.0",
     "turndown": "latest",
     "vscode-languageserver": "^9.0.1",