brave-real-browser-mcp-server 2.8.5 → 2.8.7

package/dist/handlers/api-integration-handlers.js

@@ -88,27 +88,31 @@ export async function handleRESTAPIEndpointFinder(args) {
             });
             return apis;
         });
+        let summary = `REST API Discovery Results:\n\nSummary:\n- Total APIs Found: ${apiEndpoints.length + discoveredAPIs.length}\n- Network APIs: ${apiEndpoints.length}\n- Discovered in Content: ${discoveredAPIs.length}`;
+        if (apiEndpoints.length > 0) {
+            summary += `\n\nNetwork API Endpoints (Top 10):\n${apiEndpoints.slice(0, 10).map((ep, i) => `${i + 1}. ${ep.method} ${ep.url}\n   Type: ${ep.resourceType}${ep.hasBody ? ' (with body)' : ''}`).join('\n')}`;
+        }
+        if (discoveredAPIs.length > 0) {
+            summary += `\n\nDiscovered APIs (Top 10):\n${discoveredAPIs.slice(0, 10).map((api, i) => `${i + 1}. ${api.url}\n   Source: ${api.source}`).join('\n')}`;
+        }
         return {
-            success: true,
-            networkRequests: {
-                count: apiEndpoints.length,
-                endpoints: apiEndpoints
-            },
-            discoveredInContent: {
-                count: discoveredAPIs.length,
-                endpoints: discoveredAPIs.slice(0, 20) // Limit to 20
-            },
-            summary: {
-                totalFound: apiEndpoints.length + discoveredAPIs.length,
-                uniqueNetworkAPIs: apiEndpoints.length,
-                discoveredAPIs: discoveredAPIs.length
-            }
+            content: [
+                {
+                    type: "text",
+                    text: summary
+                }
+            ]
         };
     }
     catch (error) {
         return {
-            success: false,
-            error: error.message
+            content: [
+                {
+                    type: "text",
+                    text: `REST API Endpoint Finder Error: ${error.message}`
+                }
+            ],
+            isError: true
         };
     }
 }
@@ -138,48 +142,47 @@ export async function handleWebhookSupport(args) {
                     timeout: 10000
                 });
                 return {
-                    success: true,
-                    webhookUrl,
-                    method,
-                    testMode: true,
-                    response: {
-                        status: response.status,
-                        statusText: response.statusText,
-                        headers: response.headers,
-                        data: response.data
-                    }
+                    content: [
+                        {
+                            type: "text",
+                            text: `Webhook Test Successful:\n- URL: ${webhookUrl}\n- Method: ${method}\n- Status: ${response.status} ${response.statusText}\n- Response Headers: ${JSON.stringify(response.headers, null, 2)}\n- Response Data: ${JSON.stringify(response.data, null, 2)}`
+                        }
+                    ]
                 };
             }
             catch (webhookError) {
                 return {
-                    success: false,
-                    webhookUrl,
-                    testMode: true,
-                    error: webhookError.message,
-                    details: {
-                        status: webhookError.response?.status,
-                        statusText: webhookError.response?.statusText,
-                        data: webhookError.response?.data
-                    }
+                    content: [
+                        {
+                            type: "text",
+                            text: `Webhook Test Failed:\n- URL: ${webhookUrl}\n- Error: ${webhookError.message}${webhookError.response ? `\n- Status: ${webhookError.response.status} ${webhookError.response.statusText}\n- Response: ${JSON.stringify(webhookError.response.data, null, 2)}` : ''}`
+                        }
+                    ],
+                    isError: true
                 };
             }
         }
         else {
             // Production mode - set up webhook listener
             return {
-                success: true,
-                webhookUrl,
-                method,
-                testMode: false,
-                status: 'configured',
-                note: 'Webhook configured. Send data using separate call or integrate with scraping workflow'
+                content: [
+                    {
+                        type: "text",
+                        text: `Webhook Configured:\n- URL: ${webhookUrl}\n- Method: ${method}\n- Test Mode: No\n- Status: Configured\n\nNote: Webhook configured. Send data using separate call or integrate with scraping workflow`
+                    }
+                ]
             };
         }
     }
     catch (error) {
         return {
-            success: false,
-            error: error.message
+            content: [
+                {
+                    type: "text",
+                    text: `Webhook Support Error: ${error.message}`
+                }
+            ],
+            isError: true
         };
     }
 }
@@ -291,24 +294,41 @@ export async function handleAllWebsiteAPIFinder(args) {
         }, deepScan, includeExternal);
         // Deduplicate APIs
         const uniqueAPIs = [...new Set(apiDiscovery.apis.map((api) => api.url))];
+        const restFound = apiDiscovery.rest.filter((r) => r.found).length;
+        let summary = `Comprehensive API Discovery:\n\nSummary:\n- Total Unique APIs: ${uniqueAPIs.length}\n- GraphQL Detected: ${apiDiscovery.graphql.length > 0 ? 'Yes' : 'No'}\n- REST Endpoints: ${restFound}\n- WebSockets: ${apiDiscovery.websockets.length}\n- Documentation Links: ${apiDiscovery.documentationLinks?.length || 0}`;
+        if (apiDiscovery.graphql.length > 0) {
+            summary += `\n\nGraphQL:\n- Indicators Found: ${apiDiscovery.graphql[0].indicators}\n- Possible Endpoints: ${apiDiscovery.graphql[0].possibleEndpoints.join(', ')}`;
+        }
+        if (uniqueAPIs.length > 0) {
+            summary += `\n\nUnique APIs (Top 10):\n${uniqueAPIs.slice(0, 10).map((api, i) => `${i + 1}. ${api}`).join('\n')}`;
+        }
+        if (apiDiscovery.websockets.length > 0) {
+            summary += `\n\nWebSockets:\n${apiDiscovery.websockets.map((ws, i) => `${i + 1}. ${ws.url} (${ws.protocol})`).join('\n')}`;
+        }
+        if (apiDiscovery.documentationLinks?.length > 0) {
+            summary += `\n\nDocumentation Links:\n${apiDiscovery.documentationLinks.slice(0, 5).map((link, i) => `${i + 1}. ${link.text}: ${link.href}`).join('\n')}`;
+        }
+        if (apiDiscovery.swagger?.length > 0) {
+            summary += `\n\nSwagger/OpenAPI:\n${apiDiscovery.swagger.map((s, i) => `${i + 1}. ${s.href}`).join('\n')}`;
+        }
         return {
-            success: true,
-            summary: {
-                totalAPIsFound: uniqueAPIs.length,
-                graphqlDetected: apiDiscovery.graphql.length > 0,
-                restEndpointsFound: apiDiscovery.rest.filter((r) => r.found).length,
-                websocketsFound: apiDiscovery.websockets.length,
-                documentationLinks: apiDiscovery.documentationLinks?.length || 0
-            },
-            details: apiDiscovery,
-            uniqueAPIs: uniqueAPIs.slice(0, 20),
-            recommendations: []
+            content: [
+                {
+                    type: "text",
+                    text: summary
+                }
+            ]
         };
     }
     catch (error) {
         return {
-            success: false,
-            error: error.message
+            content: [
+                {
+                    type: "text",
+                    text: `All Website API Finder Error: ${error.message}`
+                }
+            ],
+            isError: true
         };
     }
 }

package/dist/handlers/captcha-handlers.js

@@ -47,18 +47,23 @@ export async function handleOCREngine(args) {
             bbox: word.bbox
         }));
         return {
-            success: true,
-            text,
-            confidence,
-            words,
-            lines: result.data.lines.length,
-            language
+            content: [
+                {
+                    type: "text",
+                    text: `OCR Results:\n- Extracted Text: ${text}\n- Confidence: ${confidence.toFixed(2)}%\n- Words Found: ${words.length}\n- Lines: ${result.data.lines.length}\n- Language: ${language}\n\nWords Detail:\n${words.map((w) => `  "${w.text}" (confidence: ${w.confidence.toFixed(2)}%)`).join('\n')}`
+                }
+            ]
         };
     }
     catch (error) {
         return {
-            success: false,
-            error: error.message
+            content: [
+                {
+                    type: "text",
+                    text: `OCR Engine Error: ${error.message}`
+                }
+            ],
+            isError: true
         };
     }
 }
@@ -106,17 +111,23 @@ export async function handleAudioCaptchaSolver(args) {
             }
         }
         return {
-            success: true,
-            audioUrl: audioSource,
-            downloaded,
-            downloadPath: downloaded ? downloadPath : null,
-            note: 'Audio captcha solving requires external speech-to-text API (Google Speech, AWS Transcribe, etc.)'
+            content: [
+                {
+                    type: "text",
+                    text: `Audio Captcha Analysis:\n- Audio URL: ${audioSource}\n- Downloaded: ${downloaded ? 'Yes' : 'No'}${downloaded ? `\n- Download Path: ${downloadPath}` : ''}\n\nNote: Audio captcha solving requires external speech-to-text API (Google Speech, AWS Transcribe, etc.)`
+                }
+            ]
         };
     }
     catch (error) {
         return {
-            success: false,
-            error: error.message
+            content: [
+                {
+                    type: "text",
+                    text: `Audio Captcha Solver Error: ${error.message}`
+                }
+            ],
+            isError: true
         };
     }
 }
@@ -208,16 +219,38 @@ export async function handlePuzzleCaptchaHandler(args) {
                 result.solveError = solveError.message;
             }
         }
+        let summary = `Puzzle Captcha Analysis:\n- Puzzle Found: ${result.puzzleFound ? 'Yes' : 'No'}\n- Slider Found: ${result.sliderFound ? 'Yes' : 'No'}`;
+        if (result.puzzle) {
+            summary += `\n\nPuzzle Details:\n- Dimensions: ${result.puzzle.width}x${result.puzzle.height}\n- Position: (${result.puzzle.left}, ${result.puzzle.top})\n- Visible: ${result.puzzle.visible ? 'Yes' : 'No'}`;
+        }
+        if (result.puzzlePiece) {
+            summary += `\n\nPuzzle Piece:\n- Dimensions: ${result.puzzlePiece.width}x${result.puzzlePiece.height}\n- Position: (${result.puzzlePiece.left}, ${result.puzzlePiece.top})`;
+        }
+        if (result.slider) {
+            summary += `\n\nSlider Details:\n- Dimensions: ${result.slider.width}x${result.slider.height}\n- Position: (${result.slider.left}, ${result.slider.top})\n- Visible: ${result.slider.visible ? 'Yes' : 'No'}\n- Tag: ${result.slider.tagName}`;
+        }
+        if (result.attemptedSolve) {
+            summary += `\n\nSolve Attempt:\n- Method: ${result.method}\n- Status: ${result.solveError ? 'Failed' : 'Completed'}${result.solveError ? `\n- Error: ${result.solveError}` : ''}`;
+        }
+        summary += `\n\nNote: Advanced puzzle solving requires computer vision libraries (OpenCV, TensorFlow)`;
         return {
-            success: true,
-            ...result,
-            note: 'Advanced puzzle solving requires computer vision libraries (OpenCV, TensorFlow)'
+            content: [
+                {
+                    type: "text",
+                    text: summary
+                }
+            ]
         };
     }
     catch (error) {
         return {
-            success: false,
-            error: error.message
+            content: [
+                {
+                    type: "text",
+                    text: `Puzzle Captcha Handler Error: ${error.message}`
+                }
+            ],
+            isError: true
         };
     }
 }

package/dist/handlers/visual-tools-handlers.js

@@ -240,19 +240,23 @@ export async function handleVideoRecording(args) {
             }
         }
         return {
-            success: true,
-            duration,
-            fps,
-            frameCount: frames.length,
-            frames: frames.slice(0, 5), // Show first 5 frames
-            outputPath,
-            note: 'For actual video file, use ffmpeg or puppeteer-screen-recorder library to combine frames'
+            content: [
+                {
+                    type: "text",
+                    text: `Video Recording Complete:\n- Duration: ${duration} seconds\n- FPS: ${fps}\n- Frames Captured: ${frames.length}\n- Output Path: ${outputPath}\n- Sample Frames:\n${frames.slice(0, 5).map((f, i) => `  ${i + 1}. ${f}`).join('\n')}\n\nNote: For actual video file, use ffmpeg or puppeteer-screen-recorder library to combine frames`
+                }
+            ]
         };
     }
     catch (error) {
         return {
-            success: false,
-            error: error.message
+            content: [
+                {
+                    type: "text",
+                    text: `Video Recording Error: ${error.message}`
+                }
+            ],
+            isError: true
         };
     }
 }
@@ -273,10 +277,13 @@ export async function handleVisualComparison(args) {
         // Check if dimensions match
         if (img1.width !== img2.width || img1.height !== img2.height) {
             return {
-                success: false,
-                error: 'Image dimensions do not match',
-                image1: { width: img1.width, height: img1.height },
-                image2: { width: img2.width, height: img2.height }
+                content: [
+                    {
+                        type: "text",
+                        text: `Image dimensions do not match:\n- Image 1: ${img1.width}x${img1.height}\n- Image 2: ${img2.width}x${img2.height}`
+                    }
+                ],
+                isError: true
             };
         }
         // Create diff image
@@ -291,27 +298,25 @@ export async function handleVisualComparison(args) {
         }
         const totalPixels = img1.width * img1.height;
         const diffPercentage = (numDiffPixels / totalPixels) * 100;
+        const similarity = ((1 - (numDiffPixels / totalPixels)) * 100).toFixed(2);
         return {
-            success: true,
-            identical: numDiffPixels === 0,
-            differences: {
-                pixels: numDiffPixels,
-                percentage: diffPercentage.toFixed(2) + '%',
-                totalPixels
-            },
-            dimensions: {
-                width: img1.width,
-                height: img1.height
-            },
-            threshold,
-            diffImagePath: diffOutputPath,
-            similarity: ((1 - (numDiffPixels / totalPixels)) * 100).toFixed(2) + '%'
+            content: [
+                {
+                    type: "text",
+                    text: `Visual Comparison Results:\n- Identical: ${numDiffPixels === 0 ? 'Yes' : 'No'}\n- Similarity: ${similarity}%\n- Different Pixels: ${numDiffPixels} (${diffPercentage.toFixed(2)}%)\n- Total Pixels: ${totalPixels}\n- Image Dimensions: ${img1.width}x${img1.height}\n- Threshold: ${threshold}${diffOutputPath ? `\n- Diff Image Saved: ${diffOutputPath}` : ''}`
+                }
+            ]
         };
     }
     catch (error) {
         return {
-            success: false,
-            error: error.message
+            content: [
+                {
+                    type: "text",
+                    text: `Visual Comparison Error: ${error.message}`
+                }
+            ],
+            isError: true
         };
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser-mcp-server",
-  "version": "2.8.5",
+  "version": "2.8.7",
   "description": "MCP server for brave-real-browser",
   "type": "module",
   "main": "dist/index.js",