brave-real-browser-mcp-server 2.15.5 → 2.15.7

package/dist/index.js

@@ -22,21 +22,19 @@ import { setupProcessCleanup, } from "./core-infrastructure.js";
 console.error("🔍 [DEBUG] Loading handlers...");
 import { handleBrowserInit, handleBrowserClose, } from "./handlers/browser-handlers.js";
 import { handleNavigate, handleWait } from "./handlers/navigation-handlers.js";
-import { handleClick, handleType, handleSolveCaptcha, handleRandomScroll, } from "./handlers/interaction-handlers.js";
+import { handleClick, handleType, handleSolveCaptcha, handleRandomScroll, handlePressKey, } from "./handlers/interaction-handlers.js";
 import { handleGetContent, handleFindSelector, } from "./handlers/content-handlers.js";
 import { handleSaveContentAsMarkdown } from "./handlers/file-handlers.js";
 // Import new data extraction handlers
 import { handleExtractJSON, handleScrapeMetaTags, handleExtractSchema, } from "./handlers/data-extraction-handlers.js";
 // Import multi-element handlers
-import { handleBatchElementScraper, handleNestedDataExtraction, handleAttributeHarvester, handleLinkHarvester, handleMediaExtractor, } from "./handlers/multi-element-handlers.js";
+import { handleBatchElementScraper, handleAttributeHarvester, handleLinkHarvester, handleMediaExtractor, } from "./handlers/multi-element-handlers.js";
 // Import pagination handlers
-import { handleMultiPageScraper, handleBreadcrumbNavigator, } from "./handlers/pagination-handlers.js";
-// Import data processing handlers
-import { handleHTMLToText, } from "./handlers/data-processing-handlers.js";
+import { handleBreadcrumbNavigator, } from "./handlers/navigation-handlers.js";
 // Import AI-powered handlers
 import { handleSmartSelectorGenerator, handleContentClassification, } from "./handlers/ai-powered-handlers.js";
 // Import search & filter handlers
-import { handleKeywordSearch, handleRegexPatternMatcher, handleXPathSupport, handleAdvancedCSSSelectors, handleVisualElementFinder, } from "./handlers/search-filter-handlers.js";
+import { handleKeywordSearch, handleRegexPatternMatcher, handleXPathSupport, handleAdvancedCSSSelectors, } from "./handlers/search-filter-handlers.js";
 // Import data quality handlers
 import { handleDataTypeValidator, } from "./handlers/data-quality-handlers.js";
 // Import captcha handlers
@@ -44,13 +42,13 @@ import { handleOCREngine, handleAudioCaptchaSolver, handlePuzzleCaptchaHandler,
 // Import visual tools handlers
 import { handleElementScreenshot, handleVideoRecording, } from "./handlers/visual-tools-handlers.js";
 // Import smart data extractors
-import { handleHtmlElementsExtractor, handleTagsFinder, handleLinksFinder, handleXpathLinks, handleAjaxExtractor, handleFetchXHR, handleNetworkRecorder, handleRegexPatternFinder, handleIframeExtractor, handleEmbedPageExtractor, handleImageExtractorAdvanced, handleVideoSourceExtractor, handleUrlRedirectTracer, handleUserAgentExtractor, } from "./handlers/smart-data-extractors.js";
+import { handleFetchXHR, handleNetworkRecorder, handleImageExtractorAdvanced, handleVideoSourceExtractor, handleUrlRedirectTracer, handleApiFinder, } from "./handlers/smart-data-extractors.js";
 // Import dynamic session handlers
-import { handleShadowDOMExtractor, handleFormAutoFill, handleAjaxContentWaiter, } from "./handlers/dynamic-session-handlers.js";
+import { handleAjaxContentWaiter, } from "./handlers/dynamic-session-handlers.js";
 // Import monitoring & reporting handlers
 import { handleProgressTracker, } from "./handlers/monitoring-reporting-handlers.js";
 // Import advanced video & media handlers
-import { handleVideoLinkFinder, handleVideoDownloadButton, handleVideoPlayPushSource, handleVideoPlayButtonClick, } from "./handlers/advanced-video-media-handlers.js";
+import { handleVideoPlayerFinder, handleStreamDetector, handleVideoDownloadLinkFinder, } from "./handlers/advanced-video-media-handlers.js";
 // Import advanced extraction handlers (Ad-bypass & Obfuscation)
 import { handleAdvancedVideoExtraction, handleDeobfuscateJS, handleMultiLayerRedirectTrace, handleAdProtectionDetector, } from "./handlers/advanced-extraction-handlers.js";
 console.error("🔍 [DEBUG] All modules loaded successfully");
@@ -132,6 +130,9 @@ export async function executeToolByName(name, args) {
             case TOOL_NAMES.RANDOM_SCROLL:
                 result = await handleRandomScroll();
                 break;
+            case TOOL_NAMES.PRESS_KEY:
+                result = await handlePressKey(args);
+                break;
             case TOOL_NAMES.FIND_SELECTOR:
                 result = await handleFindSelector(args);
                 break;
@@ -152,9 +153,6 @@ export async function executeToolByName(name, args) {
             case TOOL_NAMES.BATCH_ELEMENT_SCRAPER:
                 result = await handleBatchElementScraper(args);
                 break;
-            case TOOL_NAMES.NESTED_DATA_EXTRACTION:
-                result = await handleNestedDataExtraction(args);
-                break;
             case TOOL_NAMES.ATTRIBUTE_HARVESTER:
                 result = await handleAttributeHarvester(args);
                 break;
@@ -167,16 +165,12 @@ export async function executeToolByName(name, args) {
                 break;
             // Pagination Tools
             // Pagination Tools
-            case TOOL_NAMES.MULTI_PAGE_SCRAPER:
-                result = await handleMultiPageScraper(args);
-                break;
+            // Pagination Tools
             case TOOL_NAMES.BREADCRUMB_NAVIGATOR:
                 result = await handleBreadcrumbNavigator(args || {});
                 break;
             // Data Processing Tools
-            case TOOL_NAMES.HTML_TO_TEXT:
-                result = await handleHTMLToText(args);
-                break;
+            // Data Processing Tools
             // AI-Powered Features
             case TOOL_NAMES.SMART_SELECTOR_GENERATOR:
                 result = await handleSmartSelectorGenerator(args);
@@ -197,9 +191,6 @@ export async function executeToolByName(name, args) {
             case TOOL_NAMES.ADVANCED_CSS_SELECTORS:
                 result = await handleAdvancedCSSSelectors(args);
                 break;
-            case TOOL_NAMES.VISUAL_ELEMENT_FINDER:
-                result = await handleVisualElementFinder(args);
-                break;
             // Data Quality & Validation
             case TOOL_NAMES.DATA_TYPE_VALIDATOR:
                 result = await handleDataTypeValidator(args);
@@ -222,35 +213,14 @@ export async function executeToolByName(name, args) {
                 result = await handleVideoRecording(args);
                 break;
             // Smart Data Extractors (Advanced)
-            case "html_elements_extractor":
-                result = await handleHtmlElementsExtractor(args || {});
-                break;
-            case "tags_finder":
-                result = await handleTagsFinder(args || {});
-                break;
-            case "links_finder":
-                result = await handleLinksFinder(args || {});
-                break;
-            case "xpath_links":
-                result = await handleXpathLinks(args || {});
-                break;
-            case "ajax_extractor":
-                result = await handleAjaxExtractor(args || {});
-                break;
             case "fetch_xhr":
                 result = await handleFetchXHR(args || {});
                 break;
             case "network_recorder":
                 result = await handleNetworkRecorder(args || {});
                 break;
-            case "regex_pattern_finder":
-                result = await handleRegexPatternFinder(args);
-                break;
-            case "iframe_extractor":
-                result = await handleIframeExtractor(args || {});
-                break;
-            case "embed_page_extractor":
-                result = await handleEmbedPageExtractor(args || {});
+            case "api_finder":
+                result = await handleApiFinder(args || {});
                 break;
             case "image_extractor_advanced":
                 result = await handleImageExtractorAdvanced(args || {});
@@ -261,16 +231,7 @@ export async function executeToolByName(name, args) {
             case "url_redirect_tracer":
                 result = await handleUrlRedirectTracer(args);
                 break;
-            case "user_agent_extractor":
-                result = await handleUserAgentExtractor(args || {});
-                break;
             // Dynamic Content & Session Handling
-            case "shadow_dom_extractor":
-                result = await handleShadowDOMExtractor(args || {});
-                break;
-            case "form_auto_fill":
-                result = await handleFormAutoFill(args);
-                break;
             case "ajax_content_waiter":
                 result = await handleAjaxContentWaiter(args);
                 break;
@@ -279,17 +240,14 @@ export async function executeToolByName(name, args) {
                 result = await handleProgressTracker(args || {});
                 break;
             // Advanced Video & Media Download Tools
-            case "video_link_finder":
-                result = await handleVideoLinkFinder(args || {});
-                break;
-            case "video_download_button":
-                result = await handleVideoDownloadButton(args);
+            case "video_player_finder":
+                result = await handleVideoPlayerFinder(args || {});
                 break;
-            case "video_play_push_source":
-                result = await handleVideoPlayPushSource(args || {});
+            case "stream_detector":
+                result = await handleStreamDetector(args || {});
                 break;
-            case "video_play_button_click":
-                result = await handleVideoPlayButtonClick(args || {});
+            case "video_download_link_finder":
+                result = await handleVideoDownloadLinkFinder(args || {});
                 break;
             // Advanced Extraction Tools (Ad-Bypass & Obfuscation)
             case "advanced_video_extraction":

package/dist/tool-definitions.js

@@ -32,7 +32,11 @@ export const TOOLS = [
                 headless: {
                     type: 'boolean',
                     description: 'Run browser in headless mode',
-                    default: false,
+                },
+                autoInstall: {
+                    type: 'boolean',
+                    description: 'Automatically install Brave Browser if not found (Default: true)',
+                    default: true,
                 },
                 disableXvfb: {
                     type: 'boolean',
@@ -381,19 +385,6 @@ export const TOOLS = [
             required: ['selector'],
         },
     },
-    {
-        name: 'nested_data_extraction',
-        description: 'Extract data maintaining parent-child relationships',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                parentSelector: { type: 'string' },
-                childSelector: { type: 'string' },
-                maxParents: { type: 'number', default: 50 },
-            },
-            required: ['parentSelector', 'childSelector'],
-        },
-    },
     {
         name: 'attribute_harvester',
         description: 'Collect attributes (href, src, data-*) from elements',
@@ -432,19 +423,6 @@ export const TOOLS = [
         },
     },
     // Pagination Tools
-    {
-        name: 'multi_page_scraper',
-        description: 'Collect and merge data from multiple pages',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                urls: { type: 'array', items: { type: 'string' } },
-                dataSelector: { type: 'string' },
-                waitBetweenPages: { type: 'number', default: 1000 },
-            },
-            required: ['urls', 'dataSelector'],
-        },
-    },
     {
         name: 'breadcrumb_navigator',
         description: 'Extract navigation path by following site structure',
@@ -457,19 +435,7 @@ export const TOOLS = [
         },
     },
     // Data Processing Tools
-    {
-        name: 'html_to_text',
-        description: 'Convert HTML content to clean text',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                html: { type: 'string' },
-                preserveLinks: { type: 'boolean', default: false },
-                preserveFormatting: { type: 'boolean', default: false },
-            },
-            required: ['html'],
-        },
-    },
+    // Data Validation Tools
     // Data Validation Tools
     // AI-Powered Features (5 tools)
     {
@@ -553,21 +519,6 @@ export const TOOLS = [
             required: ['selector'],
         },
     },
-    {
-        name: 'visual_element_finder',
-        description: 'Find elements by visual properties',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                url: { type: 'string' },
-                criteria: {
-                    type: 'object',
-                    description: 'Visual criteria (color, size, position, etc.)'
-                },
-            },
-            required: ['criteria'],
-        },
-    },
     // Data Quality & Validation (5 tools)
     {
         name: 'data_type_validator',
@@ -652,60 +603,6 @@ export const TOOLS = [
         },
     },
     // Smart Data Extractors (Advanced)
-    {
-        name: 'html_elements_extractor',
-        description: 'Extract all HTML elements with complete details',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                selector: { type: 'string', default: '*' },
-                maxElements: { type: 'number', default: 100 },
-                includeStyles: { type: 'boolean', default: false },
-            },
-        },
-    },
-    {
-        name: 'tags_finder',
-        description: 'Find specific HTML tags',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                tags: { type: 'array', items: { type: 'string' }, default: ['div', 'span', 'p', 'a', 'img'] },
-            },
-        },
-    },
-    {
-        name: 'links_finder',
-        description: 'Extract all links from page',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                includeExternal: { type: 'boolean', default: true },
-                maxLinks: { type: 'number', default: 200 },
-            },
-        },
-    },
-    {
-        name: 'xpath_links',
-        description: 'Use XPath to find links',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                xpath: { type: 'string', default: '//a[@href]' },
-            },
-        },
-    },
-    {
-        name: 'ajax_extractor',
-        description: 'Extract AJAX/XHR request data',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                duration: { type: 'number', default: 15000 },
-                url: { type: 'string' },
-            },
-        },
-    },
     {
         name: 'fetch_xhr',
         description: 'Capture fetch and XHR requests with responses',
@@ -737,34 +634,6 @@ export const TOOLS = [
             },
         },
     },
-    {
-        name: 'regex_pattern_finder',
-        description: 'Find patterns using regex',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                pattern: { type: 'string' },
-                flags: { type: 'string', default: 'gi' },
-            },
-            required: ['pattern'],
-        },
-    },
-    {
-        name: 'iframe_extractor',
-        description: 'Extract all iframes and their content',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'embed_page_extractor',
-        description: 'Extract embedded content (iframes, objects, embeds)',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
     {
         name: 'image_extractor_advanced',
         description: 'Advanced image extraction with metadata',
@@ -786,37 +655,7 @@ export const TOOLS = [
             required: ['url'],
         },
     },
-    {
-        name: 'user_agent_extractor',
-        description: 'Extract user agent information',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
     // Dynamic Content & Session Handling
-    {
-        name: 'shadow_dom_extractor',
-        description: 'Extract content from Shadow DOM',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                selector: { type: 'string', default: '*' },
-            },
-        },
-    },
-    {
-        name: 'form_auto_fill',
-        description: 'Automatically fill form fields',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                formData: { type: 'object' },
-                submitAfterFill: { type: 'boolean', default: false },
-                submitButtonSelector: { type: 'string' },
-            },
-        },
-    },
     {
         name: 'ajax_content_waiter',
         description: 'Wait for dynamic content to load',
@@ -846,45 +685,6 @@ export const TOOLS = [
         },
     },
     // Advanced Video & Media Download Tools
-    {
-        name: 'video_link_finder',
-        description: 'Find all video links on page',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                includeEmbedded: { type: 'boolean', default: true },
-            },
-        },
-    },
-    {
-        name: 'video_download_button',
-        description: 'Find and interact with video download buttons',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                action: { type: 'string', enum: ['find', 'click'], default: 'find' },
-                selector: { type: 'string' },
-            },
-        },
-    },
-    {
-        name: 'video_play_push_source',
-        description: 'Capture video sources when play button is clicked',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'video_play_button_click',
-        description: 'Click video play button',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                selector: { type: 'string' },
-            },
-        },
-    },
     // Advanced Extraction Tools (Ad-Bypass & Obfuscation)
     {
         name: 'advanced_video_extraction',
@@ -1001,29 +801,18 @@ export const TOOL_NAMES = {
     EXTRACT_SCHEMA: 'extract_schema',
     // Multi-Element Extractors
     BATCH_ELEMENT_SCRAPER: 'batch_element_scraper',
-    NESTED_DATA_EXTRACTION: 'nested_data_extraction',
     ATTRIBUTE_HARVESTER: 'attribute_harvester',
     // Content Type Specific
     LINK_HARVESTER: 'link_harvester',
     MEDIA_EXTRACTOR: 'media_extractor',
     // DOM & HTML Extraction (Phase 1)
-    HTML_ELEMENTS_EXTRACTOR: 'html_elements_extractor',
-    TAGS_FINDER: 'tags_finder',
-    LINKS_FINDER: 'links_finder',
-    XPATH_LINKS: 'xpath_links',
-    SHADOW_DOM_EXTRACTOR: 'shadow_dom_extractor',
-    IFRAME_EXTRACTOR: 'iframe_extractor',
-    EMBED_PAGE_EXTRACTOR: 'embed_page_extractor',
     // Network Tools (Phase 1)
-    AJAX_EXTRACTOR: 'ajax_extractor',
     FETCH_XHR: 'fetch_xhr',
     NETWORK_RECORDER: 'network_recorder',
     API_FINDER: 'api_finder',
     // Pagination Tools
-    MULTI_PAGE_SCRAPER: 'multi_page_scraper',
     BREADCRUMB_NAVIGATOR: 'breadcrumb_navigator',
     // Data Processing
-    HTML_TO_TEXT: 'html_to_text',
     // AI-Powered Features
     SMART_SELECTOR_GENERATOR: 'smart_selector_generator',
     CONTENT_CLASSIFICATION: 'content_classification',
@@ -1036,7 +825,6 @@ export const TOOL_NAMES = {
     REGEX_PATTERN_MATCHER: 'regex_pattern_matcher',
     XPATH_SUPPORT: 'xpath_support',
     ADVANCED_CSS_SELECTORS: 'advanced_css_selectors',
-    VISUAL_ELEMENT_FINDER: 'visual_element_finder',
     // Data Quality & Validation
     DATA_TYPE_VALIDATOR: 'data_type_validator',
     // Advanced Captcha Handling

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser-mcp-server",
-  "version": "2.15.5",
+  "version": "2.15.7",
   "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",
@@ -34,7 +34,7 @@
     "test:brave:cleanup": "taskkill /F /IM brave.exe || pkill -f brave || true"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.25.0",
+    "@modelcontextprotocol/sdk": "^1.25.1",
     "@types/turndown": "^5.0.6",
     "ajv": "^8.12.0",
     "axios": "^1.6.5",

package/scripts/check-tool-registration.ts

@@ -0,0 +1,66 @@
+
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Simple regex parser since we can't easily import the typescript modules directly in a node script without compilation steps
+function checkRegistration() {
+    const rootDir = path.resolve(__dirname, '..');
+    const toolDefsPath = path.join(rootDir, 'src', 'tool-definitions.ts');
+    const indexPath = path.join(rootDir, 'src', 'index.ts');
+
+    console.log(`Checking definitions in: ${toolDefsPath}`);
+    console.log(`Checking registration in: ${indexPath}`);
+
+    const toolDefsContent = fs.readFileSync(toolDefsPath, 'utf8');
+    const indexContent = fs.readFileSync(indexPath, 'utf8');
+
+    // Extract TOOL_NAMES constants
+    // Looks like:   BROWSER_INIT: 'browser_init',
+    const toolNameRegex = /([A-Z_]+):\s*'([^']+)'/g;
+    const definedTools = new Map();
+    let match;
+
+    // We only want the ones inside "export const TOOL_NAMES = {" block
+    // So let's isolate that block roughly
+    const toolsBlockMatch = toolDefsContent.match(/export const TOOL_NAMES = \{([\s\S]*?)\}/);
+    if (!toolsBlockMatch) {
+        console.error("Could not find TOOL_NAMES block in definitions!");
+        return;
+    }
+    const toolsBlock = toolsBlockMatch[1];
+
+    while ((match = toolNameRegex.exec(toolsBlock)) !== null) {
+        // match[1] is Key (BROWSER_INIT), match[2] is Value (browser_init)
+        const key = match[1];
+        const value = match[2];
+        definedTools.set(key, value);
+    }
+
+    console.log(`Found ${definedTools.size} defined tools.`);
+
+    // Check index.ts for cases
+    // We look for `case TOOL_NAMES.KEY:` or `case "value":`
+    const missingTools = [];
+
+    for (const [key, value] of definedTools.entries()) {
+        const keyPattern = `case TOOL_NAMES.${key}`;
+        const valuePattern = `case "${value}"`;
+        const valuePatternSingle = `case '${value}'`;
+
+        if (!indexContent.includes(keyPattern) &&
+            !indexContent.includes(valuePattern) &&
+            !indexContent.includes(valuePatternSingle)) {
+            missingTools.push({ key, value });
+        }
+    }
+
+    if (missingTools.length > 0) {
+        console.error("❌ The following tools are MISSING in index.ts:");
+        missingTools.forEach(t => console.error(`   - ${t.key} (${t.value})`));
+        process.exit(1);
+    } else {
+        console.log("✅ All tools appear to be registered in index.ts!");
+    }
+}
+
+checkRegistration();

package/scripts/full-verification.ts

@@ -0,0 +1,98 @@
+
+import { handleBrowserInit, handleBrowserClose } from '../src/handlers/browser-handlers.js';
+import { handleNavigate, handleWait } from '../src/handlers/navigation-handlers.js';
+import { handleGetContent, handleFindSelector } from '../src/handlers/content-handlers.js';
+import { handleBreadcrumbNavigator } from '../src/handlers/navigation-handlers.js';
+import {
+    handleBatchElementScraper,
+    handleAttributeHarvester,
+    handleLinkHarvester,
+    handleMediaExtractor
+} from '../src/handlers/multi-element-handlers.js';
+import {
+    handleKeywordSearch,
+    handleRegexPatternMatcher,
+    handleXPathSupport,
+    handleAdvancedCSSSelectors
+} from '../src/handlers/search-filter-handlers.js';
+import { handleRandomScroll } from '../src/handlers/interaction-handlers.js';
+import { handleScrapeMetaTags, handleExtractSchema } from '../src/handlers/data-extraction-handlers.js';
+
+async function runFullVerification() {
+    console.log('🚀 Starting Comprehensive Tool Verification...');
+
+    try {
+        await handleBrowserInit({ headless: true });
+
+        // Testing on one site primarily to save time, then brief check on second
+        const url = 'https://moviesdrive.forum/';
+        console.log(`\n--------------------------------------------------`);
+        console.log(`🔍 Targeting: ${url}`);
+        console.log(`--------------------------------------------------`);
+
+        // --- Navigation & Basic ---
+        console.log(`\n[1/12] 🟢 Testing Navigation & Wait...`);
+        await handleNavigate({ url });
+        await handleWait({ type: 'timeout', value: '2000' });
+        console.log('   ✅ Navigation complete.');
+
+        // --- Interaction ---
+        console.log(`\n[2/12] 🟢 Testing Random Scroll...`);
+        await handleRandomScroll({});
+        console.log('   ✅ Scroll complete.');
+
+        // --- Content Handlers ---
+        console.log(`\n[3/12] 🟢 Testing Find Selector (Text search)...`);
+        const findRes = await handleFindSelector({ text: 'Movie' }); // Assuming "Movie" exists
+        console.log(`   Result: Found ${findRes.content[0].text.length > 50 ? 'matches' : 'no matches'} (Length: ${findRes.content[0].text.length})`);
+
+        // --- Multi-Element Handlers (The file we kept) ---
+        console.log(`\n[4/12] 🟢 Testing Batch Element Scraper...`);
+        const batchRes = await handleBatchElementScraper({ selector: 'a', maxElements: 3 });
+        console.log(`   Result: ${batchRes.content[0].text.substring(0, 100)}...`);
+
+        console.log(`\n[5/12] 🟢 Testing Attribute Harvester...`);
+        const attrRes = await handleAttributeHarvester({ selector: 'img', attributes: ['src'], maxElements: 3 });
+        console.log(`   Result: ${attrRes.content[0].text.substring(0, 100)}...`);
+
+        console.log(`\n[6/12] 🟢 Testing Media Extractor...`); // Might be empty on home page but runs logic
+        const mediaRes = await handleMediaExtractor({ types: ['video', 'iframe'] });
+        console.log(`   Result: ${mediaRes.content[0].text.substring(0, 100)}...`);
+
+        // --- Search & Filter Handlers (The file we kept) ---
+        console.log(`\n[7/12] 🟢 Testing Keyword Search...`);
+        const keyRes = await handleKeywordSearch({ keywords: ['Bollywood', 'Hollywood'] });
+        console.log(`   Result: ${keyRes.content[0].text.substring(0, 100)}...`);
+
+        console.log(`\n[8/12] 🟢 Testing Regex Pattern Matcher...`);
+        const regexRes = await handleRegexPatternMatcher({ pattern: 'https?://[^\\s"\']+' });
+        console.log(`   Result: ${regexRes.content[0].text.substring(0, 100)}...`);
+
+        console.log(`\n[9/12] 🟢 Testing XPath Support...`);
+        const xpathRes = await handleXPathSupport({ xpath: '//body//div' });
+        console.log(`   Result: ${xpathRes.content[0].text.substring(0, 100)}...`);
+
+        console.log(`\n[10/12] 🟢 Testing Advanced CSS Selectors...`);
+        const cssRes = await handleAdvancedCSSSelectors({ selector: 'div > a', operation: 'query' });
+        console.log(`   Result: ${cssRes.content[0].text.substring(0, 100)}...`);
+
+        // --- Data Extraction ---
+        console.log(`\n[11/12] 🟢 Testing Schema Extraction...`);
+        const schemaRes = await handleExtractSchema({});
+        console.log(`   Result: ${schemaRes.content[0].text.substring(0, 100)}...`);
+
+        // --- Pagination (Refactored) ---
+        console.log(`\n[12/12] 🟢 Testing Breadcrumb Navigator...`);
+        const breadRes = await handleBreadcrumbNavigator({});
+        console.log(`   Result: ${breadRes.content[0].text.substring(0, 100)}...`);
+
+        console.log('\n✅ All primary handler categories verified successfully.');
+
+    } catch (error) {
+        console.error('\n❌ Verification Failed:', error);
+    } finally {
+        await handleBrowserClose({});
+    }
+}
+
+runFullVerification();