brave-real-browser-mcp-server 2.27.0 → 2.27.1

package/dist/tool-definitions.js

@@ -7,9 +7,103 @@ export const SERVER_INFO = {
 // MCP capabilities with LSP-compatible streaming support
 export const CAPABILITIES = {
     tools: {},
-    resources: {},
-    prompts: {},
+    resources: { subscribe: true, listChanged: true },
+    prompts: { listChanged: true },
 };
+// MCP Resources - Dynamic browser state resources
+export const RESOURCES = [
+    {
+        uri: 'browser://state',
+        name: 'Browser State',
+        description: 'Current browser instance state including page URL, title, and session info',
+        mimeType: 'application/json',
+    },
+    {
+        uri: 'browser://page/content',
+        name: 'Page Content',
+        description: 'Current page HTML content',
+        mimeType: 'text/html',
+    },
+    {
+        uri: 'browser://page/text',
+        name: 'Page Text',
+        description: 'Current page text content (no HTML)',
+        mimeType: 'text/plain',
+    },
+    {
+        uri: 'browser://cookies',
+        name: 'Browser Cookies',
+        description: 'All cookies in current browser session',
+        mimeType: 'application/json',
+    },
+    {
+        uri: 'browser://network/requests',
+        name: 'Network Requests',
+        description: 'Recent network requests captured during browsing',
+        mimeType: 'application/json',
+    },
+    {
+        uri: 'browser://console/logs',
+        name: 'Console Logs',
+        description: 'Browser console log messages',
+        mimeType: 'application/json',
+    },
+];
+// MCP Prompts - Reusable automation workflows
+export const PROMPTS = [
+    {
+        name: 'scrape_website',
+        description: 'Scrape content from a website with automatic navigation and extraction',
+        arguments: [
+            { name: 'url', description: 'URL to scrape', required: true },
+            { name: 'selector', description: 'CSS selector for target content', required: false },
+            { name: 'outputFormat', description: 'Output format (json, markdown, text)', required: false },
+        ],
+    },
+    {
+        name: 'extract_download_links',
+        description: 'Extract all download links from a page with quality and size info',
+        arguments: [
+            { name: 'url', description: 'Page URL to extract from', required: true },
+            { name: 'fileTypes', description: 'File types to extract (mp4, mkv, pdf, etc.)', required: false },
+        ],
+    },
+    {
+        name: 'monitor_page_changes',
+        description: 'Monitor a page for changes and notify when content updates',
+        arguments: [
+            { name: 'url', description: 'URL to monitor', required: true },
+            { name: 'selector', description: 'Element to watch for changes', required: true },
+            { name: 'interval', description: 'Check interval in seconds', required: false },
+        ],
+    },
+    {
+        name: 'automate_login',
+        description: 'Automate login to a website with credentials',
+        arguments: [
+            { name: 'url', description: 'Login page URL', required: true },
+            { name: 'usernameSelector', description: 'Username field selector', required: true },
+            { name: 'passwordSelector', description: 'Password field selector', required: true },
+            { name: 'submitSelector', description: 'Submit button selector', required: true },
+        ],
+    },
+    {
+        name: 'batch_screenshot',
+        description: 'Take screenshots of multiple URLs',
+        arguments: [
+            { name: 'urls', description: 'Comma-separated list of URLs', required: true },
+            { name: 'outputDir', description: 'Directory to save screenshots', required: true },
+        ],
+    },
+    {
+        name: 'extract_video_stream',
+        description: 'Extract video streaming URL from a page (m3u8, mp4)',
+        arguments: [
+            { name: 'url', description: 'Video page URL', required: true },
+            { name: 'quality', description: 'Preferred quality (highest, 1080p, 720p)', required: false },
+        ],
+    },
+];
 // Extended capabilities for streaming and auto-sync (for documentation/client info)
 export const EXTENDED_CAPABILITIES = {
     streaming: true,

package/dist/unified-server.js

@@ -17,10 +17,10 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ListPromptsRequestSchema, InitializeRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, InitializeRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { randomUUID } from 'crypto';
 // Import core modules
-import { TOOLS, SERVER_INFO, CAPABILITIES, TOOL_NAMES } from './tool-definitions.js';
+import { TOOLS, SERVER_INFO, CAPABILITIES, TOOL_NAMES, RESOURCES, PROMPTS } from './tool-definitions.js';
 import { getSharedEventBus } from './shared/event-bus.js';
 import { getProgressNotifier } from './transport/progress-notifier.js';
 import { getSessionManager } from './transport/session-manager.js';
@@ -69,8 +69,109 @@ mcpServer.setRequestHandler(InitializeRequestSchema, async (request) => {
     };
 });
 mcpServer.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
-mcpServer.setRequestHandler(ListResourcesRequestSchema, async () => ({ resources: [] }));
-mcpServer.setRequestHandler(ListPromptsRequestSchema, async () => ({ prompts: [] }));
+mcpServer.setRequestHandler(ListResourcesRequestSchema, async () => ({ resources: RESOURCES }));
+mcpServer.setRequestHandler(ListPromptsRequestSchema, async () => ({ prompts: PROMPTS }));
+// Read Resource Handler
+mcpServer.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    const page = getPageInstance();
+    debug(`ReadResource: ${uri}`);
+    try {
+        switch (uri) {
+            case 'browser://state': {
+                const state = page ? {
+                    url: page.url(),
+                    title: await page.title(),
+                    isConnected: page.browser()?.connected ?? false,
+                    viewport: page.viewport(),
+                } : { status: 'Browser not initialized' };
+                return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(state, null, 2) }] };
+            }
+            case 'browser://page/content': {
+                if (!page)
+                    throw new Error('Browser not initialized');
+                const html = await page.content();
+                return { contents: [{ uri, mimeType: 'text/html', text: html }] };
+            }
+            case 'browser://page/text': {
+                if (!page)
+                    throw new Error('Browser not initialized');
+                const text = await page.evaluate(() => document.body.innerText);
+                return { contents: [{ uri, mimeType: 'text/plain', text }] };
+            }
+            case 'browser://cookies': {
+                if (!page)
+                    throw new Error('Browser not initialized');
+                const cookies = await page.cookies();
+                return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(cookies, null, 2) }] };
+            }
+            case 'browser://network/requests': {
+                // Return cached network requests from event bus
+                const history = eventBus.getHistory().filter(e => e.type.includes('network'));
+                return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(history.slice(-50), null, 2) }] };
+            }
+            case 'browser://console/logs': {
+                const logs = eventBus.getHistory().filter(e => e.type.includes('console'));
+                return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(logs.slice(-100), null, 2) }] };
+            }
+            default:
+                throw new Error(`Unknown resource: ${uri}`);
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return { contents: [{ uri, mimeType: 'text/plain', text: `Error: ${errorMessage}` }] };
+    }
+});
+// Get Prompt Handler
+mcpServer.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    debug(`GetPrompt: ${name}`);
+    const prompt = PROMPTS.find(p => p.name === name);
+    if (!prompt) {
+        throw new Error(`Unknown prompt: ${name}`);
+    }
+    // Generate prompt messages based on template
+    let messages = [];
+    switch (name) {
+        case 'scrape_website':
+            messages = [
+                { role: 'user', content: { type: 'text', text: `Scrape the website at ${args?.url || '[URL]'}. ${args?.selector ? `Focus on elements matching: ${args.selector}` : 'Extract main content.'}` } },
+            ];
+            break;
+        case 'extract_download_links':
+            messages = [
+                { role: 'user', content: { type: 'text', text: `Extract all download links from ${args?.url || '[URL]'}. ${args?.fileTypes ? `Filter for: ${args.fileTypes}` : 'Include all file types.'}` } },
+            ];
+            break;
+        case 'monitor_page_changes':
+            messages = [
+                { role: 'user', content: { type: 'text', text: `Monitor ${args?.url || '[URL]'} for changes in element: ${args?.selector || '[SELECTOR]'}. Check every ${args?.interval || 60} seconds.` } },
+            ];
+            break;
+        case 'automate_login':
+            messages = [
+                { role: 'user', content: { type: 'text', text: `Automate login to ${args?.url || '[URL]'}. Use ${args?.usernameSelector || '#username'} for username, ${args?.passwordSelector || '#password'} for password, and ${args?.submitSelector || 'button[type=submit]'} to submit.` } },
+            ];
+            break;
+        case 'batch_screenshot':
+            messages = [
+                { role: 'user', content: { type: 'text', text: `Take screenshots of: ${args?.urls || '[URLs]'}. Save to: ${args?.outputDir || './screenshots'}` } },
+            ];
+            break;
+        case 'extract_video_stream':
+            messages = [
+                { role: 'user', content: { type: 'text', text: `Extract video streaming URL from ${args?.url || '[URL]'}. Prefer quality: ${args?.quality || 'highest'}` } },
+            ];
+            break;
+        default:
+            messages = [{ role: 'user', content: { type: 'text', text: `Execute prompt: ${name}` } }];
+    }
+    return {
+        description: prompt.description,
+        messages,
+    };
+});
 mcpServer.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     debug(`Tool call: ${name}`);

package/package.json

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