brave-real-browser-mcp-server 2.14.7 → 2.14.8

package/dist/browser-manager.js

@@ -5,7 +5,12 @@ import * as net from 'net';
 import { execSync, spawn } from 'child_process';
 import { config as dotenvConfig } from 'dotenv';
 // Load environment variables from .env file
+// Silence dotenv output
+const originalWrite = process.stdout.write;
+// @ts-ignore
+process.stdout.write = () => true;
 dotenvConfig();
+process.stdout.write = originalWrite;
 // Browser error categorization
 export var BrowserErrorType;
 (function (BrowserErrorType) {

package/dist/handlers/APPLY_OPTIMIZATION_PATTERN.js

@@ -32,7 +32,7 @@ export async function handleUNIVERSAL_TOOL_TEMPLATE(args) {
         if (shouldCache) {
             const cached = globalCache.get(cacheKey);
             if (cached) {
-                console.log(`[${toolName}] Cache hit for key: ${cacheKey}`);
+                console.error(`[${toolName}] Cache hit for key: ${cacheKey}`);
                 return {
                     content: [
                         {
@@ -87,7 +87,7 @@ export async function handleUNIVERSAL_TOOL_TEMPLATE(args) {
         // Cleanup and metrics
         const duration = globalMetrics.end(toolName);
         globalToolStatus.recordExecution(toolName, duration);
-        console.log(`[${toolName}] Execution time: ${duration}ms`);
+        console.error(`[${toolName}] Execution time: ${duration}ms`);
     }
 }
 // ============================================================================

package/dist/handlers/advanced-video-media-handlers.js

@@ -580,7 +580,7 @@ export async function handleNetworkRecordingFinder(args) {
                 const contentType = response.headers()['content-type'] || '';
                 const resourceType = response.request().resourceType();
                 if (verbose && totalResponses % 10 === 0) {
-                    console.log(`[Network Recording] Processed ${totalResponses} responses, ${matchedResponses} matched`);
+                    console.error(`[Network Recording] Processed ${totalResponses} responses, ${matchedResponses} matched`);
                 }
                 let shouldRecord = false;
                 const urlLower = url.toLowerCase();
@@ -603,7 +603,7 @@ export async function handleNetworkRecordingFinder(args) {
                 if (shouldRecord) {
                     matchedResponses++;
                     if (verbose) {
-                        console.log(`[Network Recording] ✅ Matched ${filterType}: ${url.substring(0, 100)}`);
+                        console.error(`[Network Recording] ✅ Matched ${filterType}: ${url.substring(0, 100)}`);
                     }
                     try {
                         const buffer = await response.buffer();
@@ -629,21 +629,21 @@ export async function handleNetworkRecordingFinder(args) {
                 // Ignore individual response errors
             }
         };
-        console.log(`[Network Recording] 🎬 Starting monitoring for ${filterType} (${duration}ms)${navigateTo ? ` + navigating to ${navigateTo}` : ''}`);
+        console.error(`[Network Recording] 🎬 Starting monitoring for ${filterType} (${duration}ms)${navigateTo ? ` + navigating to ${navigateTo}` : ''}`);
         page.on('response', responseHandler);
         // If navigateTo is provided, navigate first, then wait
         if (navigateTo) {
             try {
                 await page.goto(navigateTo, { waitUntil: 'networkidle2', timeout: 30000 });
-                console.log(`[Network Recording] ✅ Navigation complete, continuing monitoring...`);
+                console.error(`[Network Recording] ✅ Navigation complete, continuing monitoring...`);
             }
             catch (e) {
-                console.log(`[Network Recording] ⚠️ Navigation error (continuing anyway): ${e}`);
+                console.error(`[Network Recording] ⚠️ Navigation error (continuing anyway): ${e}`);
             }
         }
         await sleep(duration);
         page.off('response', responseHandler);
-        console.log(`[Network Recording] 🛑 Monitoring stopped. Total: ${totalResponses}, Matched: ${matchedResponses}, Recorded: ${recordings.length}`);
+        console.error(`[Network Recording] 🛑 Monitoring stopped. Total: ${totalResponses}, Matched: ${matchedResponses}, Recorded: ${recordings.length}`);
         if (recordings.length === 0) {
             return {
                 content: [{
@@ -717,7 +717,7 @@ export async function handleNetworkRecordingExtractors(args) {
                     (contentType.includes('application/octet-stream') && url.includes('video'));
                 if (isVideoFile || isVideoAPI) {
                     if (verbose)
-                        console.log(`[Extractor] 🎥 Video found: ${url.substring(0, 80)}`);
+                        console.error(`[Extractor] 🎥 Video found: ${url.substring(0, 80)}`);
                     extractedData.videos.push({
                         url,
                         contentType,

package/dist/handlers/data-processing-handlers.js

@@ -3,7 +3,6 @@
 // @ts-nocheck
 import { withErrorHandling } from '../system-utils.js';
 import { parsePhoneNumber } from 'libphonenumber-js';
-import * as chrono from 'chrono-node';
 import Ajv from 'ajv/dist/2020.js';
 /**
  * Extra whitespace और special characters remove करता है
@@ -85,107 +84,6 @@ export async function handleHTMLToText(args) {
         };
     }, 'Failed to convert HTML to text');
 }
-/**
- * Currency symbols और formatting से actual numbers निकालता है
- */
-export async function handlePriceParser(args) {
-    return await withErrorHandling(async () => {
-        const text = args.text;
-        const currency = args.currency;
-        // Regular expressions for price patterns
-        const pricePatterns = [
-            /\$\s?(\d{1,3}(?:,\d{3})*(?:\.\d{2})?)/g, // $1,234.56
-            /(\d{1,3}(?:,\d{3})*(?:\.\d{2})?)\s?USD/gi, // 1234.56 USD
-            /€\s?(\d{1,3}(?:,\d{3})*(?:\.\d{2})?)/g, // €1,234.56
-            /£\s?(\d{1,3}(?:,\d{3})*(?:\.\d{2})?)/g, // £1,234.56
-            /₹\s?(\d{1,3}(?:,\d{3})*(?:\.\d{2})?)/g, // ₹1,234.56
-            /(\d{1,3}(?:,\d{3})*(?:\.\d{2})?)/g, // 1,234.56
-        ];
-        const prices = [];
-        pricePatterns.forEach((pattern) => {
-            let match;
-            while ((match = pattern.exec(text)) !== null) {
-                const priceStr = match[1] || match[0];
-                const numericValue = parseFloat(priceStr.replace(/,/g, ''));
-                if (!isNaN(numericValue)) {
-                    // Detect currency symbol
-                    let detectedCurrency = currency || 'Unknown';
-                    if (match[0].includes('$'))
-                        detectedCurrency = 'USD';
-                    else if (match[0].includes('€'))
-                        detectedCurrency = 'EUR';
-                    else if (match[0].includes('£'))
-                        detectedCurrency = 'GBP';
-                    else if (match[0].includes('₹'))
-                        detectedCurrency = 'INR';
-                    prices.push({
-                        original: match[0],
-                        value: numericValue,
-                        currency: detectedCurrency,
-                        formatted: `${detectedCurrency} ${numericValue.toFixed(2)}`,
-                    });
-                }
-            }
-        });
-        // Remove duplicates
-        const uniquePrices = prices.filter((price, index, self) => index === self.findIndex((p) => p.value === price.value && p.currency === price.currency));
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `✅ Parsed ${uniquePrices.length} price(s)\n\n${JSON.stringify(uniquePrices, null, 2)}`,
-                },
-            ],
-        };
-    }, 'Failed to parse prices');
-}
-/**
- * Different date formats को standard format में convert करता है
- */
-export async function handleDateNormalizer(args) {
-    return await withErrorHandling(async () => {
-        const text = args.text;
-        const outputFormat = args.outputFormat || 'iso';
-        // Parse dates using chrono-node
-        const parsedDates = chrono.parse(text);
-        const dates = [];
-        parsedDates.forEach((parsed) => {
-            const date = parsed.start.date();
-            let formatted;
-            if (outputFormat === 'iso') {
-                formatted = date.toISOString();
-            }
-            else if (outputFormat === 'locale') {
-                formatted = date.toLocaleString();
-            }
-            else if (outputFormat === 'unix') {
-                formatted = Math.floor(date.getTime() / 1000);
-            }
-            else {
-                formatted = date.toISOString();
-            }
-            dates.push({
-                original: parsed.text,
-                parsed: formatted,
-                components: {
-                    year: date.getFullYear(),
-                    month: date.getMonth() + 1,
-                    day: date.getDate(),
-                    hour: date.getHours(),
-                    minute: date.getMinutes(),
-                },
-            });
-        });
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `✅ Normalized ${dates.length} date(s)\n\n${JSON.stringify(dates, null, 2)}`,
-                },
-            ],
-        };
-    }, 'Failed to normalize dates');
-}
 /**
  * Contact information automatically detect करता है
  */

package/dist/handlers/monitoring-reporting-handlers.js

@@ -110,91 +110,9 @@ export async function handleProgressTracker(args) {
         throw new Error(`Unknown action: ${action}`);
     }, 'Failed progress tracker');
 }
-/**
- * Error Logger - Log and track errors
- */
-export async function handleErrorLogger(args) {
-    return await withErrorHandling(async () => {
-        const action = args.action || 'log'; // log, get, clear
-        if (action === 'log') {
-            const error = {
-                id: `err_${Date.now()}`,
-                message: args.message || 'Unknown error',
-                type: args.type || 'error',
-                timestamp: new Date().toISOString(),
-                context: args.context || {},
-                stackTrace: args.stackTrace || null,
-            };
-            monitoringState.errors.push(error);
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Error logged: ${error.message}\n\n${JSON.stringify(error, null, 2)}`,
-                    }],
-            };
-        }
-        if (action === 'get') {
-            const limit = args.limit || 10;
-            const errorType = args.type;
-            let filteredErrors = monitoringState.errors;
-            if (errorType) {
-                filteredErrors = filteredErrors.filter((err) => err.type === errorType);
-            }
-            const recentErrors = filteredErrors.slice(-limit);
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Retrieved ${recentErrors.length} error(s)\n\nTotal Errors: ${monitoringState.errors.length}\n\n${JSON.stringify(recentErrors, null, 2)}`,
-                    }],
-            };
-        }
-        if (action === 'clear') {
-            const count = monitoringState.errors.length;
-            monitoringState.errors = [];
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Cleared ${count} error(s)`,
-                    }],
-            };
-        }
-        throw new Error(`Unknown action: ${action}`);
-    }, 'Failed error logger');
-}
 /**
  * Success Rate Reporter - Report success metrics
  */
-export async function handleSuccessRateReporter(args) {
-    return await withErrorHandling(async () => {
-        const timeRange = args.timeRange || 'all'; // all, last_hour, last_day
-        let operations = monitoringState.operations;
-        if (timeRange === 'last_hour') {
-            const hourAgo = Date.now() - (60 * 60 * 1000);
-            operations = operations.filter((op) => op.startTime >= hourAgo);
-        }
-        else if (timeRange === 'last_day') {
-            const dayAgo = Date.now() - (24 * 60 * 60 * 1000);
-            operations = operations.filter((op) => op.startTime >= dayAgo);
-        }
-        const total = operations.length;
-        const completed = operations.filter((op) => op.status === 'completed').length;
-        const failed = operations.filter((op) => op.status === 'failed').length;
-        const inProgress = operations.filter((op) => op.status === 'in_progress').length;
-        const successRate = total > 0 ? ((completed / total) * 100).toFixed(2) : 0;
-        const failureRate = total > 0 ? ((failed / total) * 100).toFixed(2) : 0;
-        // Calculate average duration
-        const completedOps = operations.filter((op) => op.duration !== undefined);
-        const avgDuration = completedOps.length > 0
-            ? (completedOps.reduce((sum, op) => sum + op.duration, 0) / completedOps.length).toFixed(2)
-            : 0;
-        return {
-            content: [{
-                    type: 'text',
-                    text: `✅ Success Rate Report (${timeRange})\n\nTotal Operations: ${total}\nCompleted: ${completed}\nFailed: ${failed}\nIn Progress: ${inProgress}\n\nSuccess Rate: ${successRate}%\nFailure Rate: ${failureRate}%\nAverage Duration: ${avgDuration}ms\n\nUptime: ${((Date.now() - monitoringState.startTime) / 1000 / 60).toFixed(2)} minutes`,
-                }],
-        };
-    }, 'Failed success rate reporter');
-}
 /**
  * Data Quality Metrics - Report data quality metrics
  */
@@ -282,94 +200,6 @@ export async function handleDataQualityMetrics(args) {
 /**
  * Performance Monitor - Monitor browser and page performance
  */
-export async function handlePerformanceMonitor(args) {
-    return await withErrorHandling(async () => {
-        validateWorkflow('performance_monitor', {
-            requireBrowser: true,
-            requirePage: true,
-        });
-        const page = getCurrentPage();
-        const performanceData = await page.evaluate(() => {
-            const perfData = {
-                navigation: {},
-                resources: [],
-                memory: {},
-                timing: {},
-            };
-            // Navigation timing
-            if (performance.timing) {
-                const timing = performance.timing;
-                perfData.navigation = {
-                    domContentLoaded: timing.domContentLoadedEventEnd - timing.navigationStart,
-                    loadComplete: timing.loadEventEnd - timing.navigationStart,
-                    domInteractive: timing.domInteractive - timing.navigationStart,
-                    firstPaint: timing.responseEnd - timing.requestStart,
-                };
-            }
-            // Resource timing
-            if (performance.getEntriesByType) {
-                const resources = performance.getEntriesByType('resource');
-                perfData.resources = resources.slice(0, 20).map((resource) => ({
-                    name: resource.name.substring(0, 100),
-                    type: resource.initiatorType,
-                    duration: Math.round(resource.duration),
-                    size: resource.transferSize || 0,
-                }));
-            }
-            // Memory (if available)
-            if (performance.memory) {
-                const memory = performance.memory;
-                perfData.memory = {
-                    usedJSHeapSize: Math.round(memory.usedJSHeapSize / 1024 / 1024) + ' MB',
-                    totalJSHeapSize: Math.round(memory.totalJSHeapSize / 1024 / 1024) + ' MB',
-                    jsHeapSizeLimit: Math.round(memory.jsHeapSizeLimit / 1024 / 1024) + ' MB',
-                };
-            }
-            // Performance marks and measures
-            if (performance.getEntriesByType) {
-                const marks = performance.getEntriesByType('mark');
-                const measures = performance.getEntriesByType('measure');
-                perfData.timing.marks = marks.length;
-                perfData.timing.measures = measures.length;
-            }
-            return perfData;
-        });
-        // Calculate summary
-        const resourceCount = performanceData.resources.length;
-        const totalResourceDuration = performanceData.resources.reduce((sum, r) => sum + r.duration, 0);
-        const avgResourceDuration = resourceCount > 0 ? (totalResourceDuration / resourceCount).toFixed(2) : 0;
-        return {
-            content: [{
-                    type: 'text',
-                    text: `✅ Performance Monitor\n\nPage Load Metrics:\n${JSON.stringify(performanceData.navigation, null, 2)}\n\nResources (showing ${resourceCount}):\nAverage Load Time: ${avgResourceDuration}ms\n\nMemory Usage:\n${JSON.stringify(performanceData.memory, null, 2)}\n\nTop Resources:\n${JSON.stringify(performanceData.resources.slice(0, 10), null, 2)}`,
-                }],
-        };
-    }, 'Failed performance monitor');
-}
 /**
  * Get Monitoring Summary - Get overall monitoring summary
  */
-export async function handleGetMonitoringSummary(args) {
-    return await withErrorHandling(async () => {
-        const summary = {
-            uptime: ((Date.now() - monitoringState.startTime) / 1000 / 60).toFixed(2) + ' minutes',
-            operations: {
-                total: monitoringState.operations.length,
-                completed: monitoringState.operations.filter((op) => op.status === 'completed').length,
-                failed: monitoringState.operations.filter((op) => op.status === 'failed').length,
-                inProgress: monitoringState.operations.filter((op) => op.status === 'in_progress').length,
-            },
-            errors: {
-                total: monitoringState.errors.length,
-                recent: monitoringState.errors.slice(-5),
-            },
-            metrics: monitoringState.metrics,
-        };
-        return {
-            content: [{
-                    type: 'text',
-                    text: `✅ Monitoring Summary\n\n${JSON.stringify(summary, null, 2)}`,
-                }],
-        };
-    }, 'Failed to get monitoring summary');
-}

package/dist/handlers/multi-element-handlers.js

@@ -441,92 +441,3 @@ export async function handleMediaExtractor(args) {
         };
     }, 'Failed to extract media');
 }
-/**
- * Downloadable files (PDF, DOC, etc.) detect करता है
- */
-export async function handlePDFLinkFinder(args) {
-    return await withErrorHandling(async () => {
-        validateWorkflow('pdf_link_finder', {
-            requireBrowser: true,
-            requirePage: true,
-        });
-        const page = getCurrentPage();
-        const selector = args.selector || 'a[href]';
-        const includeOtherFiles = args.includeOtherFiles !== false;
-        const fileData = await page.evaluate(({ selector, includeOtherFiles }) => {
-            const links = document.querySelectorAll(selector);
-            const results = {
-                pdfs: [],
-                documents: [],
-                archives: [],
-                others: [],
-            };
-            const fileExtensions = {
-                pdf: ['pdf'],
-                documents: ['doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'odt', 'ods', 'odp'],
-                archives: ['zip', 'rar', '7z', 'tar', 'gz', 'bz2'],
-                others: ['txt', 'csv', 'json', 'xml'],
-            };
-            links.forEach((link, index) => {
-                const href = link.href;
-                const text = link.textContent?.trim() || '';
-                // Check file extension
-                const url = href.toLowerCase();
-                let fileType = '';
-                let category = '';
-                for (const [cat, exts] of Object.entries(fileExtensions)) {
-                    for (const ext of exts) {
-                        if (url.endsWith(`.${ext}`) || url.includes(`.${ext}?`) || url.includes(`.${ext}#`)) {
-                            fileType = ext;
-                            category = cat;
-                            break;
-                        }
-                    }
-                    if (fileType)
-                        break;
-                }
-                if (!fileType && !includeOtherFiles) {
-                    return;
-                }
-                const fileInfo = {
-                    index,
-                    href,
-                    text,
-                    fileType,
-                    fileName: href.split('/').pop()?.split('?')[0] || '',
-                };
-                // Get file size if available
-                const sizeAttr = link.getAttribute('data-size') || link.getAttribute('title');
-                if (sizeAttr) {
-                    fileInfo.size = sizeAttr;
-                }
-                // Categorize
-                if (category === 'pdf') {
-                    results.pdfs.push(fileInfo);
-                }
-                else if (category === 'documents') {
-                    results.documents.push(fileInfo);
-                }
-                else if (category === 'archives') {
-                    results.archives.push(fileInfo);
-                }
-                else if (includeOtherFiles) {
-                    results.others.push(fileInfo);
-                }
-            });
-            return results;
-        }, { selector, includeOtherFiles });
-        const totalFiles = fileData.pdfs.length +
-            fileData.documents.length +
-            fileData.archives.length +
-            fileData.others.length;
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `✅ Found ${totalFiles} downloadable files\n\n${JSON.stringify(fileData, null, 2)}`,
-                },
-            ],
-        };
-    }, 'Failed to find PDF links');
-}

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

@@ -150,62 +150,6 @@ export async function handleElementScreenshot(args) {
         };
     }
 }
-/**
- * PDF Generation - Convert page to PDF
- */
-export async function handlePDFGeneration(args) {
-    const { url, outputPath, format = 'A4', landscape = false, printBackground = true, margin } = args;
-    try {
-        const page = getPageInstance();
-        if (!page) {
-            throw new Error('Browser not initialized. Call browser_init first.');
-        }
-        if (url && page.url() !== url) {
-            await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });
-        }
-        // Ensure output directory exists
-        if (outputPath) {
-            const dir = path.dirname(outputPath);
-            await fs.mkdir(dir, { recursive: true });
-        }
-        const pdfOptions = {
-            path: outputPath,
-            format,
-            landscape,
-            printBackground
-        };
-        if (margin) {
-            pdfOptions.margin = margin;
-        }
-        await page.pdf(pdfOptions);
-        // Get file stats
-        let fileSize = 0;
-        if (outputPath) {
-            const stats = await fs.stat(outputPath);
-            fileSize = stats.size;
-        }
-        const resultText = `✅ PDF generated successfully\n\nPath: ${outputPath}\nFormat: ${format}\nLandscape: ${landscape}\nFile Size: ${(fileSize / 1024).toFixed(2)} KB (${(fileSize / (1024 * 1024)).toFixed(2)} MB)\nTimestamp: ${new Date().toISOString()}`;
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: resultText,
-                },
-            ],
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `❌ PDF generation failed: ${error.message}`,
-                },
-            ],
-            isError: true,
-        };
-    }
-}
 /**
  * Video Recording - Record browser session (basic implementation)
  */

package/dist/index.js

@@ -27,11 +27,11 @@ import { handleSaveContentAsMarkdown } from "./handlers/file-handlers.js";
 // Import new data extraction handlers
 import { handleScrapeTable, handleExtractList, handleExtractJSON, handleScrapeMetaTags, handleExtractSchema, } from "./handlers/data-extraction-handlers.js";
 // Import multi-element handlers
-import { handleBatchElementScraper, handleNestedDataExtraction, handleAttributeHarvester, handleImageScraper, handleLinkHarvester, handleMediaExtractor, handlePDFLinkFinder, } from "./handlers/multi-element-handlers.js";
+import { handleBatchElementScraper, handleNestedDataExtraction, handleAttributeHarvester, handleImageScraper, handleLinkHarvester, handleMediaExtractor, } from "./handlers/multi-element-handlers.js";
 // Import pagination handlers
 import { handleAutoPagination, handleInfiniteScroll, handleMultiPageScraper, handleSitemapParser, handleBreadcrumbNavigator, } from "./handlers/pagination-handlers.js";
 // Import data processing handlers
-import { handleSmartTextCleaner, handleHTMLToText, handlePriceParser, handleDateNormalizer, handleContactExtractor, handleSchemaValidator, handleRequiredFieldsChecker, handleDuplicateRemover, } from "./handlers/data-processing-handlers.js";
+import { handleSmartTextCleaner, handleHTMLToText, handleContactExtractor, handleSchemaValidator, handleRequiredFieldsChecker, handleDuplicateRemover, } from "./handlers/data-processing-handlers.js";
 // Import AI-powered handlers
 import { handleSmartSelectorGenerator, handleContentClassification, handleSentimentAnalysis, handleSummaryGenerator, handleTranslationSupport, } from "./handlers/ai-powered-handlers.js";
 // Import search & filter handlers
@@ -41,13 +41,13 @@ import { handleDataDeduplication, handleMissingDataHandler, handleDataTypeValida
 // Import captcha handlers
 import { handleOCREngine, handleAudioCaptchaSolver, handlePuzzleCaptchaHandler, } from "./handlers/captcha-handlers.js";
 // Import visual tools handlers
-import { handleFullPageScreenshot, handleElementScreenshot, handlePDFGeneration, handleVideoRecording, handleVisualComparison, } from "./handlers/visual-tools-handlers.js";
+import { handleFullPageScreenshot, handleElementScreenshot, handleVideoRecording, handleVisualComparison, } from "./handlers/visual-tools-handlers.js";
 // Import smart data extractors
 import { handleHtmlElementsExtractor, handleTagsFinder, handleLinksFinder, handleXpathLinks, handleAjaxExtractor, handleFetchXHR, handleNetworkRecorder, handleRegexPatternFinder, handleIframeExtractor, handleEmbedPageExtractor, handleImageExtractorAdvanced, handleVideoSourceExtractor, handleVideoPlayerExtractor, handleVideoPlayerHosterFinder, handleOriginalVideoHosterFinder, handleUrlRedirectTracer, handleUserAgentExtractor, } from "./handlers/smart-data-extractors.js";
 // Import dynamic session handlers
 import { handleShadowDOMExtractor, handleCookieManager, handleSessionPersistence, handleFormAutoFill, handleAjaxContentWaiter, handleModalPopupHandler, handleLoginSessionManager, } from "./handlers/dynamic-session-handlers.js";
 // Import monitoring & reporting handlers
-import { handleProgressTracker, handleErrorLogger, handleSuccessRateReporter, handleDataQualityMetrics, handlePerformanceMonitor, handleGetMonitoringSummary, } from "./handlers/monitoring-reporting-handlers.js";
+import { handleProgressTracker, handleDataQualityMetrics, } from "./handlers/monitoring-reporting-handlers.js";
 // Import advanced video & media handlers
 import { handleVideoLinkFinder, handleVideoDownloadPage, handleVideoDownloadButton, handleVideoPlayPushSource, handleVideoPlayButtonClick, handleUrlRedirectTraceEndpoints, handleNetworkRecordingFinder, handleNetworkRecordingExtractors, handleVideoLinksFinders, handleVideosSelectors, handleLinkProcessExtracts, handleVideoLinkFindersExtracts, handleVideoDownloadButtonFinders, } from "./handlers/advanced-video-media-handlers.js";
 // Import advanced extraction handlers (Ad-bypass & Obfuscation)
@@ -173,9 +173,6 @@ export async function executeToolByName(name, args) {
             case TOOL_NAMES.MEDIA_EXTRACTOR:
                 result = await handleMediaExtractor(args || {});
                 break;
-            case TOOL_NAMES.PDF_LINK_FINDER:
-                result = await handlePDFLinkFinder(args || {});
-                break;
             // Pagination Tools
             case TOOL_NAMES.AUTO_PAGINATION:
                 result = await handleAutoPagination(args || {});
@@ -199,12 +196,6 @@ export async function executeToolByName(name, args) {
             case TOOL_NAMES.HTML_TO_TEXT:
                 result = await handleHTMLToText(args);
                 break;
-            case TOOL_NAMES.PRICE_PARSER:
-                result = await handlePriceParser(args);
-                break;
-            case TOOL_NAMES.DATE_NORMALIZER:
-                result = await handleDateNormalizer(args);
-                break;
             case TOOL_NAMES.CONTACT_EXTRACTOR:
                 result = await handleContactExtractor(args);
                 break;
@@ -283,9 +274,6 @@ export async function executeToolByName(name, args) {
             case TOOL_NAMES.ELEMENT_SCREENSHOT:
                 result = await handleElementScreenshot(args);
                 break;
-            case TOOL_NAMES.PDF_GENERATION:
-                result = await handlePDFGeneration(args);
-                break;
             case TOOL_NAMES.VIDEO_RECORDING:
                 result = await handleVideoRecording(args);
                 break;
@@ -370,21 +358,9 @@ export async function executeToolByName(name, args) {
             case "progress_tracker":
                 result = await handleProgressTracker(args || {});
                 break;
-            case "error_logger":
-                result = await handleErrorLogger(args || {});
-                break;
-            case "success_rate_reporter":
-                result = await handleSuccessRateReporter(args || {});
-                break;
             case "data_quality_metrics":
                 result = await handleDataQualityMetrics(args || {});
                 break;
-            case "performance_monitor":
-                result = await handlePerformanceMonitor(args || {});
-                break;
-            case "monitoring_summary":
-                result = await handleGetMonitoringSummary(args || {});
-                break;
             // Advanced Video & Media Download Tools
             case "video_link_finder":
                 result = await handleVideoLinkFinder(args || {});

package/dist/mcp-server.js

@@ -9,7 +9,7 @@ import { handleClick, handleType, handlePressKey, handleSolveCaptcha, handleRand
 import { handleGetContent, handleFindSelector } from './handlers/content-handlers.js';
 import { handleSaveContentAsMarkdown } from './handlers/file-handlers.js';
 import { handleScrapeTable, handleExtractList, handleExtractJSON, handleScrapeMetaTags, handleExtractSchema } from './handlers/data-extraction-handlers.js';
-import { handleBatchElementScraper, handleNestedDataExtraction, handleAttributeHarvester, handleImageScraper, handleLinkHarvester, handleMediaExtractor, handlePDFLinkFinder } from './handlers/multi-element-handlers.js';
+import { handleBatchElementScraper, handleNestedDataExtraction, handleAttributeHarvester, handleImageScraper, handleLinkHarvester, handleMediaExtractor, } from './handlers/multi-element-handlers.js';
 export async function createMcpServer() {
     const server = new Server(SERVER_INFO, { capabilities: CAPABILITIES });
     // Register initialize handler
@@ -111,9 +111,6 @@ export async function createMcpServer() {
                 case TOOL_NAMES.MEDIA_EXTRACTOR:
                     result = await handleMediaExtractor(args || {});
                     break;
-                case TOOL_NAMES.PDF_LINK_FINDER:
-                    result = await handlePDFLinkFinder(args || {});
-                    break;
                 default:
                     throw new Error(`Unknown tool: ${name}`);
             }

package/dist/optimization-utils.js

@@ -207,7 +207,7 @@ export async function executeToolWithOptimizations(toolName, toolFn, options = {
     if (cacheKey && shouldCache) {
         const cached = globalCache.get(cacheKey);
         if (cached) {
-            console.log(`[${toolName}] Cache hit for key: ${cacheKey}`);
+            console.error(`[${toolName}] Cache hit for key: ${cacheKey}`);
             return cached;
         }
     }
@@ -226,7 +226,7 @@ export async function executeToolWithOptimizations(toolName, toolFn, options = {
     catch (error) {
         // Retry on failure for network tools
         if (retryAttempts > 0) {
-            console.log(`[${toolName}] Retrying after error: ${error instanceof Error ? error.message : String(error)}`);
+            console.error(`[${toolName}] Retrying after error: ${error instanceof Error ? error.message : String(error)}`);
             return retryWithBackoff(toolFn, retryAttempts, retryDelay);
         }
         throw error;
@@ -253,7 +253,7 @@ export async function cleanupToolResources(page, context) {
         // Clear cache periodically
         const cacheStats = globalCache.getStats();
         if (cacheStats.size > 100) {
-            console.log('[Cleanup] Clearing cache - size exceeded 100 items');
+            console.error('[Cleanup] Clearing cache - size exceeded 100 items');
             globalCache.clear();
         }
     }

package/dist/tool-definitions.js

@@ -468,17 +468,6 @@ export const TOOLS = [
             },
         },
     },
-    {
-        name: 'pdf_link_finder',
-        description: 'Downloadable files (PDF, DOC, etc.) detect करता है',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                selector: { type: 'string', default: 'a[href]' },
-                includeOtherFiles: { type: 'boolean', default: true },
-            },
-        },
-    },
     // Pagination Tools
     {
         name: 'auto_pagination',
@@ -570,31 +559,6 @@ export const TOOLS = [
             required: ['html'],
         },
     },
-    {
-        name: 'price_parser',
-        description: 'Currency symbols से actual numbers extract करता है',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                text: { type: 'string' },
-                currency: { type: 'string' },
-            },
-            required: ['text'],
-        },
-    },
-    {
-        name: 'date_normalizer',
-        description: 'Different date formats को standard format में convert करता है',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                text: { type: 'string' },
-                outputFormat: { type: 'string', enum: ['iso', 'locale', 'unix'], default: 'iso' },
-                timezone: { type: 'string' },
-            },
-            required: ['text'],
-        },
-    },
     {
         name: 'contact_extractor',
         description: 'Phone numbers और email addresses automatically detect करता है',
@@ -917,22 +881,6 @@ export const TOOLS = [
             required: ['selector', 'outputPath'],
         },
     },
-    {
-        name: 'pdf_generation',
-        description: 'Convert page to PDF',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                url: { type: 'string' },
-                outputPath: { type: 'string' },
-                format: { type: 'string', default: 'A4' },
-                landscape: { type: 'boolean', default: false },
-                printBackground: { type: 'boolean', default: true },
-                margin: { type: 'object' },
-            },
-            required: ['outputPath'],
-        },
-    },
     {
         name: 'video_recording',
         description: 'Record browser session',
@@ -1235,31 +1183,6 @@ export const TOOLS = [
             },
         },
     },
-    {
-        name: 'error_logger',
-        description: 'Log and track errors',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                action: { type: 'string', enum: ['log', 'get', 'clear'], default: 'log' },
-                message: { type: 'string' },
-                type: { type: 'string' },
-                context: { type: 'object' },
-                stackTrace: { type: 'string' },
-                limit: { type: 'number', default: 10 },
-            },
-        },
-    },
-    {
-        name: 'success_rate_reporter',
-        description: 'Report success metrics',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                timeRange: { type: 'string', enum: ['all', 'last_hour', 'last_day'], default: 'all' },
-            },
-        },
-    },
     {
         name: 'data_quality_metrics',
         description: 'Report data quality metrics',
@@ -1270,22 +1193,6 @@ export const TOOLS = [
             },
         },
     },
-    {
-        name: 'performance_monitor',
-        description: 'Monitor browser and page performance',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'monitoring_summary',
-        description: 'Get overall monitoring summary',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
     // Advanced Video & Media Download Tools
     {
         name: 'video_link_finder',
@@ -1487,7 +1394,6 @@ export const TOOL_NAMES = {
     IMAGE_SCRAPER: 'image_scraper',
     LINK_HARVESTER: 'link_harvester',
     MEDIA_EXTRACTOR: 'media_extractor',
-    PDF_LINK_FINDER: 'pdf_link_finder',
     // Pagination Tools
     AUTO_PAGINATION: 'auto_pagination',
     INFINITE_SCROLL: 'infinite_scroll',
@@ -1497,8 +1403,6 @@ export const TOOL_NAMES = {
     // Data Processing
     SMART_TEXT_CLEANER: 'smart_text_cleaner',
     HTML_TO_TEXT: 'html_to_text',
-    PRICE_PARSER: 'price_parser',
-    DATE_NORMALIZER: 'date_normalizer',
     CONTACT_EXTRACTOR: 'contact_extractor',
     // Data Validation
     SCHEMA_VALIDATOR: 'schema_validator',
@@ -1529,7 +1433,6 @@ export const TOOL_NAMES = {
     // Screenshot & Visual Tools
     FULL_PAGE_SCREENSHOT: 'full_page_screenshot',
     ELEMENT_SCREENSHOT: 'element_screenshot',
-    PDF_GENERATION: 'pdf_generation',
     VIDEO_RECORDING: 'video_recording',
     VISUAL_COMPARISON: 'visual_comparison',
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser-mcp-server",
-  "version": "2.14.7",
+  "version": "2.14.8",
   "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",
@@ -39,7 +39,7 @@
     "ajv": "^8.12.0",
     "axios": "^1.6.5",
     "brave-real-browser": "^1.5.105",
-    "brave-real-launcher": "^1.2.28",
+    "brave-real-launcher": "^1.2.29",
     "brave-real-puppeteer-core": "^24.33.0-patch.1",
     "cheerio": "^1.0.0-rc.12",
     "chrono-node": "^2.7.0",