mcpbrowser 0.3.18 → 0.3.20

package/README.md

@@ -7,7 +7,7 @@
 
 > ⚠️ **Security Notice:** MCPBrowser extracts webpage content and provides it to your AI agent (e.g., GitHub Copilot, Claude), which then sends it to the LLM provider it uses (e.g., Anthropic, OpenAI, GitHub) for processing. Make sure you trust both your agent and the LLM provider — especially when accessing pages with sensitive or private data.
 
-**MCPBrowser is an MCP browser server that gives AI assistants the ability to browse web pages using a real Chrome or Edge browser.** This browser-based MCP server fetches any web page — especially those protected by authentication, CAPTCHAs, anti-bot protection, or requiring JavaScript rendering. Uses your real Chrome/Edge browser for web automation so you can log in normally, then automatically extracts content. Works with corporate SSO, login forms, Cloudflare, and JavaScript-heavy sites (SPAs, dashboards).
+**MCPBrowser is an MCP browser server that gives AI assistants the ability to browse web pages using a real Chrome, Edge, or Brave browser.** This browser-based MCP server fetches any web page — especially those protected by authentication, CAPTCHAs, anti-bot protection, or requiring JavaScript rendering. Uses your real browser for web automation so you can log in normally, then automatically extracts content. Works with corporate SSO, login forms, Cloudflare, and JavaScript-heavy sites (SPAs, dashboards).
 
 This is an [MCP (Model Context Protocol)](https://modelcontextprotocol.io/) server using [stdio transport](https://modelcontextprotocol.io/docs/concepts/transports#stdio). Your AI assistant uses this web browser MCP server when standard HTTP requests fail — pages requiring authentication, CAPTCHA protection, or heavy JavaScript (SPAs). Once connected, the browser MCP server can navigate through websites, interact with elements, and send HTML back to the AI assistant. This gives your AI the ability to browse the web just like you do.
 
@@ -15,10 +15,9 @@ Example workflow for AI assistant to use MCPBrowser
 
 ```
 1. fetch_webpage    → Load the login page
-2. type_text        → Enter username
-3. type_text        → Enter password
-4. click_element    → Click "Sign In"
-5. get_current_html → Extract the content after login
+2. type_text        → Enter username and password (multiple fields at once)
+3. click_element    → Click "Sign In"
+4. get_current_html → Extract the content after login
 ```
 
 
@@ -35,6 +34,7 @@ Example workflow for AI assistant to use MCPBrowser
   - [click_element](#click_element)
   - [type_text](#type_text)
   - [get_current_html](#get_current_html)
+  - [scroll_page](#scroll_page)
   - [take_screenshot](#take_screenshot)
   - [close_tab](#close_tab)
 - [Configuration](#configuration-optional)
@@ -43,7 +43,7 @@ Example workflow for AI assistant to use MCPBrowser
 
 ## Requirements
 
-- Chrome or Edge browser
+- Chrome, Edge, or Brave browser
 - [Node.js 18+](https://nodejs.org/) (includes npm)
 
 > **Note:** Node.js must be installed on your system. The VS Code extension and npm package both require Node.js to run the MCP server. Download from [nodejs.org](https://nodejs.org/) if not already installed.
@@ -54,8 +54,9 @@ Example workflow for AI assistant to use MCPBrowser
 |---|----------|------------|
 | 1 | [VS Code Extension](#option-1-vs-code-extension) | One Click |
 | 2 | [Claude Code](#option-2-claude-code) | One Command |
-| 3 | [Claude Desktop](#option-3-claude-desktop) | Manual |
-| 4 | [npm Package](#option-4-npm-package) | Manual |
+| 3 | [OpenClaw](#option-3-openclaw) | One Command |
+| 4 | [Claude Desktop](#option-4-claude-desktop) | Manual |
+| 5 | [npm Package](#option-5-npm-package) | Manual |
 
 ### Option 1: VS Code Extension
 
@@ -85,7 +86,22 @@ mcpbrowser: npx -y mcpbrowser@latest - ✓ Connected
 That's it! Ask Claude to fetch any protected page:
 > "Fetch https://portal.azure.com using mcpbrowser"
 
-### Option 3: Claude Desktop
+### Option 3: OpenClaw
+
+[OpenClaw](https://openclaw.ai/) is a personal AI assistant that runs on your devices. Add MCPBrowser to give it browser automation capabilities:
+
+```bash
+openclaw mcp add mcpbrowser -- npx -y mcpbrowser@latest
+```
+
+Verify it's working:
+```bash
+openclaw mcp list
+```
+
+Now OpenClaw can browse authenticated pages, fill forms, and interact with web apps using your existing browser sessions.
+
+### Option 4: Claude Desktop
 
 Add to your config file:
 
@@ -105,7 +121,7 @@ Add to your config file:
 
 Restart Claude Desktop after saving.
 
-### Option 4: npm Package
+### Option 5: npm Package
 
 For VS Code (GitHub Copilot) manual setup, add to your `mcp.json`:
 
@@ -183,36 +199,55 @@ Clicks on any clickable element (buttons, links, divs with onclick handlers, etc
 
 ### `type_text`
 
-Types text into an input field, textarea, or other editable element. Simulates human-like typing with configurable delay between keystrokes. Automatically clears existing text by default.
+Types text into one or more input fields in a single call. Supports filling entire forms at once for efficient automation. Automatically clears existing text by default.
 
 **⚠️ Note:** Page must be already loaded via `fetch_webpage` first.
 
 **Parameters:**
 - `url` (string, required) - The URL of the page (must match a previously fetched page)
-- `selector` (string, required) - CSS selector for the input element (e.g., `#username`, `input[name="email"]`)
-- `text` (string, required) - Text to type into the field
-- `clear` (boolean, optional, default: `true`) - Whether to clear existing text first
-- `typeDelay` (number, optional, default: `50`) - Delay between keystrokes in milliseconds (simulates human typing)
+- `fields` (array, required) - Array of fields to fill. Each field object contains:
+  - `selector` (string, required) - CSS selector for the input element (e.g., `#username`, `input[name="email"]`)
+  - `text` (string, required) - Text to type into the field
+  - `clear` (boolean, optional, default: `true`) - Whether to clear existing text first
+  - `waitForElementTimeout` (number, optional, default: `5000`) - Maximum time to wait for element in milliseconds
 - `returnHtml` (boolean, optional, default: `true`) - Whether to wait for stability and return HTML after typing
 - `removeUnnecessaryHTML` (boolean, optional, default: `true`) - Remove unnecessary HTML for size reduction. Only used when `returnHtml` is `true`
 - `postTypeWait` (number, optional, default: `1000`) - Milliseconds to wait after typing for SPAs to render dynamic content
-- `waitForElementTimeout` (number, optional, default: `5000`) - Maximum time to wait for element in milliseconds
 
 **Examples:**
 ```javascript
-// Basic text input
-{ url: "https://example.com", selector: "#email", text: "user@example.com" }
-
-// Append text without clearing
-{ url: "https://example.com", selector: "#search", text: " advanced", clear: false }
+// Fill multiple fields at once (login form)
+{ 
+  url: "https://example.com/login", 
+  fields: [
+    { selector: "#username", text: "john@example.com" },
+    { selector: "#password", text: "secretpass123" }
+  ]
+}
 
-// Fast typing without human simulation
-{ url: "https://example.com", selector: "#username", text: "john", typeDelay: 0 }
+// Single field input
+{ url: "https://example.com", fields: [{ selector: "#search", text: "query" }] }
 
-// Type without waiting for HTML return (faster)
-{ url: "https://example.com", selector: "#field", text: "value", returnHtml: false }
+// Append text without clearing
+{ url: "https://example.com", fields: [{ selector: "#notes", text: " additional text", clear: false }] }
+
+// Fast form fill without HTML return
+{ 
+  url: "https://example.com/signup", 
+  fields: [
+    { selector: "#firstName", text: "John" },
+    { selector: "#lastName", text: "Doe" },
+    { selector: "#email", text: "john@example.com" }
+  ],
+  returnHtml: false 
+}
 ```
 
+**Error handling:** If a field fails, the response indicates:
+- Which field number failed (e.g., "Failed on field 2 of 3")
+- Which fields were successfully filled
+- Clear guidance to NOT re-type already filled fields
+
 ---
 
 ### `get_current_html`
@@ -240,6 +275,46 @@ Gets the current HTML from an already-loaded page **WITHOUT** navigating or relo
 
 ---
 
+### `scroll_page`
+
+Scrolls within an already-loaded page. Use before `take_screenshot` to capture different parts of the page, or to bring elements into view before interaction. Supports multiple scroll modes:
+
+- **By direction**: Scroll up/down/left/right by pixel amount
+- **To element**: Scroll until a specific element is visible
+- **To position**: Scroll to absolute coordinates
+
+**⚠️ Note:** Page must be already loaded via `fetch_webpage` first.
+
+**Parameters:**
+- `url` (string, required) - The URL of the page (must match a previously fetched page)
+- `direction` (string, optional) - Direction to scroll: `up`, `down`, `left`, `right`. Use with `amount`.
+- `amount` (number, optional, default: `500`) - Pixels to scroll in the specified direction (~half a viewport)
+- `selector` (string, optional) - CSS selector of element to scroll into view. Ignores direction/amount.
+- `x` (number, optional) - Absolute horizontal scroll position. Use with `y`.
+- `y` (number, optional) - Absolute vertical scroll position. Use with `x`.
+
+**Examples:**
+```javascript
+// Scroll down by 500px (default)
+{ url: "https://example.com", direction: "down" }
+
+// Scroll down by 1000px
+{ url: "https://example.com", direction: "down", amount: 1000 }
+
+// Scroll an element into view
+{ url: "https://example.com", selector: "#footer" }
+
+// Scroll to specific position
+{ url: "https://example.com", x: 0, y: 2000 }
+
+// Scroll to top of page
+{ url: "https://example.com", x: 0, y: 0 }
+```
+
+**Returns:** Current scroll position, page dimensions, and viewport size — useful for understanding where you are on the page.
+
+---
+
 ### `take_screenshot`
 
 Takes a screenshot of an already-loaded page for visual analysis. **Useful when HTML parsing is insufficient** — for example, pages with charts, images, complex layouts, popups, or visual content that's hard to understand from HTML alone. Returns a PNG image.
@@ -328,7 +403,7 @@ Logs go to `stderr` so they don't interfere with MCP protocol on `stdout`.
 ## Troubleshooting
 
 **Browser doesn't open?**
-- Make sure Chrome or Edge is installed
+- Make sure Chrome, Edge, or Brave is installed
 - Try setting `CHROME_PATH` explicitly
 
 **Can't connect to browser?**

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "mcpbrowser",
-  "version": "0.3.18",
+  "version": "0.3.20",
   "mcpName": "io.github.cherchyk/mcpbrowser",
   "type": "module",
-  "description": "MCP browser server - fetch web pages using real Chrome/Edge browser. Handles authentication, SSO, CAPTCHAs, and anti-bot protection. Browser automation for AI assistants.",
+  "description": "MCP browser server - fetch web pages using real Chrome/Edge/Brave browser. Handles authentication, SSO, CAPTCHAs, and anti-bot protection. Browser automation for AI assistants.",
   "main": "src/mcp-browser.js",
   "bin": {
     "mcpbrowser": "src/mcp-browser.js"

package/src/actions/accept-eula.js

@@ -0,0 +1,188 @@
+/**
+ * accept-eula.js - Accept the End User License Agreement
+ * This tool must be called before any other MCPBrowser tools can be used.
+ */
+
+import { MCPResponse } from '../core/responses.js';
+import { acceptEula, isEulaAccepted, EULA_URL } from '../core/eula.js';
+import logger from '../core/logger.js';
+
+/**
+ * @typedef {import('@modelcontextprotocol/sdk/types.js').Tool} Tool
+ */
+
+// ============================================================================
+// EULA CHECK HELPER
+// ============================================================================
+
+/**
+ * Check if EULA acceptance is required before executing a tool.
+ * @param {string} toolName - The name of the tool being called
+ * @returns {Object|null} MCP-formatted response if EULA not accepted, null if OK to proceed
+ */
+export function requireEulaAcceptance(toolName) {
+  if (isEulaAccepted()) {
+    return null;
+  }
+  
+  logger.info(`Tool ${toolName} requested - EULA acceptance required`);
+  return new EulaPendingResponse(
+    EULA_URL,
+    [],
+    toolName
+  ).toMcpFormat();
+}
+
+// ============================================================================
+// RESPONSE CLASSES
+// ============================================================================
+
+/**
+ * Response when EULA needs to be accepted (shown before acceptance)
+ */
+export class EulaPendingResponse extends MCPResponse {
+  /**
+   * @param {string} eulaUrl - URL to the EULA
+   * @param {string[]} nextSteps - Suggested next actions
+   * @param {string} [attemptedAction] - The tool the user tried to use (optional)
+   */
+  constructor(eulaUrl, nextSteps, attemptedAction = null) {
+    super(nextSteps);
+    
+    if (typeof eulaUrl !== 'string') {
+      throw new TypeError('eulaUrl must be a string');
+    }
+    
+    this.eulaUrl = eulaUrl;
+    this.accepted = false;
+    this.attemptedAction = attemptedAction;
+    this.requiresUserConfirmation = true;
+  }
+
+  _getAdditionalFields() {
+    return {
+      accepted: this.accepted,
+      eulaUrl: this.eulaUrl,
+      requiresUserConfirmation: this.requiresUserConfirmation,
+      ...(this.attemptedAction && { attemptedAction: this.attemptedAction })
+    };
+  }
+
+  getTextSummary() {
+    return `STOP - EXPLICIT USER CONFIRMATION REQUIRED !!!
+
+Use ask questions tool to show a Yes/No options asking the user: "Do you accept the MCPBrowser EULA at ${this.eulaUrl}?"
+
+DO NOT call accept_eula until the user explicitly selects "Yes".
+If the user selects "No" or does not respond, DO NOT proceed.
+
+When calling accept_eula, you MUST set userExplicitlyConfirmed=true ONLY if user said Yes.`;
+  }
+}
+
+/**
+ * Response for successful EULA acceptance
+ */
+export class EulaAcceptedResponse extends MCPResponse {
+  /**
+   * @param {string} eulaUrl - URL to the EULA that was accepted
+   * @param {string[]} nextSteps - Suggested next actions
+   */
+  constructor(eulaUrl, nextSteps) {
+    super(nextSteps);
+    
+    if (typeof eulaUrl !== 'string') {
+      throw new TypeError('eulaUrl must be a string');
+    }
+    
+    this.eulaUrl = eulaUrl;
+    this.accepted = true;
+  }
+
+  _getAdditionalFields() {
+    return {
+      accepted: this.accepted,
+      eulaUrl: this.eulaUrl
+    };
+  }
+
+  getTextSummary() {
+    return `EULA accepted (${this.eulaUrl}). You now have full access to MCPBrowser tools.`;
+  }
+}
+
+// ============================================================================
+// TOOL DEFINITION
+// ============================================================================
+
+/**
+ * @type {Tool}
+ */
+export const ACCEPT_EULA_TOOL = {
+  name: "accept_eula",
+  description: "CRITICAL: You MUST ask the user 'Do you accept the MCPBrowser EULA?' and wait for their explicit 'Yes' response BEFORE calling this tool. Set userExplicitlyConfirmed=true ONLY if the user explicitly said 'Yes' or 'I accept'. If the user has not responded or said 'No', DO NOT call this tool. Calling this tool without user consent violates the EULA terms.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      userExplicitlyConfirmed: {
+        type: "boolean",
+        description: "REQUIRED: Must be true. Set to true ONLY if the user explicitly said 'Yes' or 'I accept' to the EULA prompt. Never set to true without explicit user confirmation."
+      }
+    },
+    required: ["userExplicitlyConfirmed"]
+  }
+};
+
+// ============================================================================
+// TOOL IMPLEMENTATION
+// ============================================================================
+
+/**
+ * Handle EULA acceptance
+ * @param {Object} args - Tool arguments
+ * @param {boolean} args.userExplicitlyConfirmed - Whether user explicitly confirmed acceptance
+ * @returns {Promise<MCPResponse>} Response indicating EULA status
+ */
+export async function handleAcceptEula(args) {
+  const { userExplicitlyConfirmed } = args;
+  
+  logger.debug(`accept_eula called with userExplicitlyConfirmed: ${userExplicitlyConfirmed}`);
+  
+  // If already accepted and calling again, just confirm
+  if (isEulaAccepted()) {
+    logger.info('EULA already accepted');
+    return new EulaAcceptedResponse(
+      EULA_URL,
+      [
+        'Use fetch_webpage to navigate to a URL',
+        'Use get_current_html to see the current page content'
+      ]
+    );
+  }
+  
+  // CRITICAL: Validate user explicitly confirmed
+  if (userExplicitlyConfirmed !== true) {
+    logger.warn('accept_eula called without userExplicitlyConfirmed=true - rejecting');
+    return new EulaPendingResponse(
+      EULA_URL,
+      [
+        'Ask the user: "Do you accept the MCPBrowser EULA?"',
+        'Wait for explicit "Yes" response',
+        'Then call accept_eula with userExplicitlyConfirmed=true'
+      ]
+    );
+  }
+  
+  // Accept the EULA
+  acceptEula(EULA_URL);
+  logger.info('EULA accepted with explicit user confirmation');
+  
+  return new EulaAcceptedResponse(
+    EULA_URL,
+    [
+      'Use fetch_webpage to navigate to a URL',
+      'Use click_element to interact with page elements',
+      'Use type_text to enter text into forms'
+    ]
+  );
+}

package/src/actions/click-element.js

@@ -178,9 +178,9 @@ export async function clickElement({ url, selector, text, waitForElementTimeout
     logger.error(`click_element: Failed to connect to browser: ${err.message}`);
     return new InformationalResponse(
       `Browser connection failed: ${err.message}`,
-      'Could not connect to Chrome or Edge browser. The browser must be running with remote debugging enabled.',
+      'The browser must be running with remote debugging enabled.',
       [
-        'Ensure Chrome or Edge browser is installed and running',
+        'Ensure the browser is installed and running',
         'Check that remote debugging is enabled (--remote-debugging-port)',
         'Try restarting the MCP server'
       ]
@@ -192,7 +192,7 @@ export async function clickElement({ url, selector, text, waitForElementTimeout
   
   if (!page) {
     const isConnectionLost = pageError && pageError.includes('connection');
-    logger.info(`click_element: ${pageError || 'No page found for ' + hostname}`);
+    logger.debug(`click_element: ${pageError || 'No page found for ' + hostname}`);
     return new InformationalResponse(
       isConnectionLost ? `Page connection lost for ${hostname}` : `No open page found for ${hostname}`,
       isConnectionLost 
@@ -259,13 +259,13 @@ export async function clickElement({ url, selector, text, waitForElementTimeout
     // await page.evaluate(el => el.scrollIntoView({ behavior: 'smooth', block: 'center' }), elementHandle);
     // await new Promise(r => setTimeout(r, 300)); // Brief delay after scroll
     
-    logger.info(`Clicking: ${selector || `text="${text}"`}`);
+    logger.debug(`Clicking: ${selector || `text="${text}"`}`);
     await elementHandle.click();
     
     if (returnHtml) {
       // Wait for page to stabilize (handles both navigation and SPA content updates)
       // This ensures content is fully loaded before returning, just like fetch_webpage does
-      logger.info('Waiting for page stability...');
+      logger.debug('Waiting for page stability...');
       await waitForPageStability(page);
       
       // Wait for SPAs to render dynamic content after click
@@ -292,7 +292,7 @@ export async function clickElement({ url, selector, text, waitForElementTimeout
       );
     } else {
       // Wait for page to stabilize even for fast clicks (ensures JS has finished)
-      logger.info('Waiting for page stability (fast mode)...');
+      logger.debug('Waiting for page stability (fast mode)...');
       await waitForPageStability(page);
       
       // Wait for SPAs to render dynamic content after click

package/src/actions/fetch-page.js

@@ -6,7 +6,7 @@
 import { getBrowser, domainPages } from '../core/browser.js';
 import { getOrCreatePage, queueRequest, navigateToUrl, waitForPageReady, extractAndProcessHtml, waitForPageStability } from '../core/page.js';
 import { detectRedirectType, waitForAutoAuth, waitForManualAuth } from '../core/auth.js';
-import { MCPResponse, ErrorResponse, HttpStatusResponse } from '../core/responses.js';
+import { MCPResponse, ErrorResponse, HttpStatusResponse, InformationalResponse } from '../core/responses.js';
 import logger from '../core/logger.js';
 
 /**
@@ -156,7 +156,22 @@ async function doFetchPage({ url, hostname, browser, removeUnnecessaryHTML, post
   const authCompletionTimeout = 600000;
   const reuseLastKeptPage = true;
 
-  const browserInstance = await getBrowser(browser);
+  // Ensure browser connection
+  let browserInstance;
+  try {
+    browserInstance = await getBrowser(browser);
+  } catch (err) {
+    logger.error(`fetch_webpage: Failed to connect to browser: ${err.message}`);
+    return new InformationalResponse(
+      `Browser connection failed: ${err.message}`,
+      'The browser must be running with remote debugging enabled.',
+      [
+        'Ensure the browser is installed and running',
+        'Check that remote debugging is enabled (--remote-debugging-port)',
+        'Try restarting the MCP server'
+      ]
+    );
+  }
   
   try {
     // Get or create page for this domain (simple - no locks needed)
@@ -175,7 +190,7 @@ async function doFetchPage({ url, hostname, browser, removeUnnecessaryHTML, post
     const redirectInfo = detectRedirectType(url, hostname, currentUrl, currentHostname);
     
     if (redirectInfo.type === 'requested_auth') {
-      logger.info('User requested auth page directly, returning content');
+      logger.debug('User requested auth page directly, returning content');
       // Update domain mapping if needed
       if (redirectInfo.currentHostname !== hostname) {
         domainPages.delete(hostname);
@@ -183,13 +198,13 @@ async function doFetchPage({ url, hostname, browser, removeUnnecessaryHTML, post
         hostname = redirectInfo.currentHostname;
       }
     } else if (redirectInfo.type === 'permanent') {
-      logger.info(`Redirect: ${hostname} → ${redirectInfo.currentHostname}`);
+      logger.debug(`Redirect: ${hostname} → ${redirectInfo.currentHostname}`);
       
       // Check if we already have a tab for the redirected hostname
       // (can happen after reconnect - we mapped mail.google.com but not gmail.com)
       const existingPage = domainPages.get(redirectInfo.currentHostname);
       if (existingPage && existingPage !== page && !existingPage.isClosed()) {
-        logger.info(`Found existing tab for ${redirectInfo.currentHostname}, reusing it`);
+        logger.debug(`Found existing tab for ${redirectInfo.currentHostname}, reusing it`);
         // Close the new tab we just opened, use the existing one
         await page.close().catch(() => {});
         domainPages.delete(hostname);
@@ -248,7 +263,7 @@ async function doFetchPage({ url, hostname, browser, removeUnnecessaryHTML, post
     
     // Additional wait if requested (for pages that need extra time)
     if (postLoadWait > 0) {
-      logger.info(`Waiting ${postLoadWait}ms (postLoadWait)...`);
+      logger.debug(`Waiting ${postLoadWait}ms (postLoadWait)...`);
       await new Promise(resolve => setTimeout(resolve, postLoadWait));
     }
     
@@ -259,7 +274,7 @@ async function doFetchPage({ url, hostname, browser, removeUnnecessaryHTML, post
     
     // Check for non-2xx HTTP status codes - return informational response (not red error)
     if (statusCode && (statusCode >= 400 && statusCode < 600)) {
-      logger.info(`HTTP ${statusCode} ${statusText} - returning as informational response`);
+      logger.debug(`HTTP ${statusCode} ${statusText} - returning as informational response`);
       return new HttpStatusResponse(
         page.url(),
         statusCode,

package/src/actions/get-current-html.js

@@ -120,9 +120,9 @@ export async function getCurrentHtml({ url, removeUnnecessaryHTML = true }) {
     logger.error(`get_current_html: Failed to connect to browser: ${err.message}`);
     return new InformationalResponse(
       `Browser connection failed: ${err.message}`,
-      'Could not connect to Chrome or Edge browser. The browser must be running with remote debugging enabled.',
+      'The browser must be running with remote debugging enabled.',
       [
-        'Ensure Chrome or Edge browser is installed and running',
+        'Ensure the browser is installed and running',
         'Check that remote debugging is enabled (--remote-debugging-port)',
         'Try restarting the MCP server'
       ]
@@ -134,7 +134,7 @@ export async function getCurrentHtml({ url, removeUnnecessaryHTML = true }) {
   
   if (!page) {
     const isConnectionLost = pageError && pageError.includes('connection');
-    logger.info(`get_current_html: ${pageError || 'No page found for ' + hostname}`);
+    logger.debug(`get_current_html: ${pageError || 'No page found for ' + hostname}`);
     return new InformationalResponse(
       isConnectionLost ? `Page connection lost for ${hostname}` : `No open page found for ${hostname}`,
       isConnectionLost 

package/src/actions/scroll-page.js

@@ -186,9 +186,9 @@ export async function scrollPage({ url, direction, amount = 500, selector, x, y
     logger.error(`scroll_page: Failed to connect to browser: ${err.message}`);
     return new InformationalResponse(
       `Browser connection failed: ${err.message}`,
-      'Could not connect to Chrome or Edge browser. The browser must be running with remote debugging enabled.',
+      'The browser must be running with remote debugging enabled.',
       [
-        'Ensure Chrome or Edge browser is installed and running',
+        'Ensure the browser is installed and running',
         'Check that remote debugging is enabled (--remote-debugging-port)',
         'Try restarting the MCP server'
       ]
@@ -200,7 +200,7 @@ export async function scrollPage({ url, direction, amount = 500, selector, x, y
   
   if (!page) {
     const isConnectionLost = pageError && pageError.includes('connection');
-    logger.info(`scroll_page: ${pageError || 'No page found for ' + hostname}`);
+    logger.debug(`scroll_page: ${pageError || 'No page found for ' + hostname}`);
     return new InformationalResponse(
       isConnectionLost ? `Page connection lost for ${hostname}` : `No open page found for ${hostname}`,
       isConnectionLost 
@@ -219,7 +219,7 @@ export async function scrollPage({ url, direction, amount = 500, selector, x, y
     // Determine scroll mode and execute
     if (selector) {
       // Scroll to element mode
-      logger.info(`scroll_page: Scrolling to element: ${selector}`);
+      logger.debug(`scroll_page: Scrolling to element: ${selector}`);
       
       const elementExists = await page.$(selector);
       if (!elementExists) {
@@ -243,7 +243,7 @@ export async function scrollPage({ url, direction, amount = 500, selector, x, y
       
     } else if (typeof x === 'number' && typeof y === 'number') {
       // Absolute position mode
-      logger.info(`scroll_page: Scrolling to absolute position: (${x}, ${y})`);
+      logger.debug(`scroll_page: Scrolling to absolute position: (${x}, ${y})`);
       
       await page.evaluate(({ scrollX, scrollY }) => {
         window.scrollTo(scrollX, scrollY);
@@ -251,7 +251,7 @@ export async function scrollPage({ url, direction, amount = 500, selector, x, y
       
     } else if (direction) {
       // Directional scroll mode
-      logger.info(`scroll_page: Scrolling ${direction} by ${amount}px`);
+      logger.debug(`scroll_page: Scrolling ${direction} by ${amount}px`);
       
       const scrollDeltas = {
         up: { x: 0, y: -amount },
@@ -271,7 +271,7 @@ export async function scrollPage({ url, direction, amount = 500, selector, x, y
       
     } else {
       // No scroll parameters provided - just return current position
-      logger.info(`scroll_page: No scroll action specified, returning current position`);
+      logger.debug(`scroll_page: No scroll action specified, returning current position`);
     }
     
     // Small delay to let scroll complete

package/src/actions/take-screenshot.js

@@ -149,9 +149,9 @@ export async function takeScreenshot({ url, fullPage = false }) {
     logger.error(`take_screenshot: Failed to connect to browser: ${err.message}`);
     return new InformationalResponse(
       `Browser connection failed: ${err.message}`,
-      'Could not connect to Chrome or Edge browser. The browser must be running with remote debugging enabled.',
+      'The browser must be running with remote debugging enabled.',
       [
-        'Ensure Chrome or Edge browser is installed and running',
+        'Ensure the browser is installed and running',
         'Check that remote debugging is enabled (--remote-debugging-port)',
         'Try restarting the MCP server'
       ]
@@ -163,7 +163,7 @@ export async function takeScreenshot({ url, fullPage = false }) {
   
   if (!page) {
     const isConnectionLost = pageError && pageError.includes('connection');
-    logger.info(`take_screenshot: ${pageError || 'No page found for ' + hostname}`);
+    logger.debug(`take_screenshot: ${pageError || 'No page found for ' + hostname}`);
     return new InformationalResponse(
       isConnectionLost ? `Page connection lost for ${hostname}` : `No open page found for ${hostname}`,
       isConnectionLost 

package/src/actions/type-text.js

@@ -66,21 +66,32 @@ export class TypeTextSuccessResponse extends MCPResponse {
 export const TYPE_TEXT_TOOL = {
   name: "type_text",
   title: "Type Text",
-  description: "**BROWSER INTERACTION** - Types text into input fields on browser-loaded pages. Use this for filling forms, entering search queries, or any text input on the page.\n\nWorks with input fields, textareas, and other editable elements.\n\n**PREREQUISITE**: Page MUST be loaded with fetch_webpage first. This tool operates on an already-loaded page in the browser.",
+  description: "**BROWSER INTERACTION** - Types text into multiple input fields on browser-loaded pages in a single call. Use this for filling forms, entering search queries, or any text input on the page.\n\nWorks with input fields, textareas, and other editable elements. Supports filling multiple fields at once for efficient form filling.\n\n**PREREQUISITE**: Page MUST be loaded with fetch_webpage first. This tool operates on an already-loaded page in the browser.",
   inputSchema: {
     type: "object",
     properties: {
       url: { type: "string", description: "The URL of the page (must match a previously fetched page)" },
-      selector: { type: "string", description: "CSS selector for the input element (e.g., '#username', 'input[name=\"email\"]')" },
-      text: { type: "string", description: "Text to type into the field" },
-      clear: { type: "boolean", description: "Whether to clear existing text first", default: true },
-      typeDelay: { type: "number", description: "Delay between keystrokes in milliseconds (simulates human typing)", default: 50 },
-      waitForElementTimeout: { type: "number", description: "Maximum time to wait for element in milliseconds", default: 5000 },
+      fields: {
+        type: "array",
+        description: "Array of fields to fill. Each field specifies a selector and text to type.",
+        items: {
+          type: "object",
+          properties: {
+            selector: { type: "string", description: "CSS selector for the input element (e.g., '#username', 'input[name=\"email\"]')" },
+            text: { type: "string", description: "Text to type into the field" },
+            clear: { type: "boolean", description: "Whether to clear existing text first", default: true },
+            waitForElementTimeout: { type: "number", description: "Maximum time to wait for element in milliseconds", default: 5000 }
+          },
+          required: ["selector", "text"],
+          additionalProperties: false
+        },
+        minItems: 1
+      },
       returnHtml: { type: "boolean", description: "Whether to wait for stability and return HTML after typing.", default: true },
       removeUnnecessaryHTML: { type: "boolean", description: "Remove Unnecessary HTML for size reduction by 90%. Only used when returnHtml is true.", default: true },
       postTypeWait: { type: "number", description: "Milliseconds to wait after typing for SPAs to render dynamic content.", default: 1000 }
     },
-    required: ["url", "selector", "text"],
+    required: ["url", "fields"],
     additionalProperties: false
   },
   outputSchema: {
@@ -103,38 +114,48 @@ export const TYPE_TEXT_TOOL = {
   }
 };
 
+// ============================================================================
+// CONSTANTS
+// ============================================================================
+
+/** Hardcoded delay between keystrokes in milliseconds */
+const TYPE_DELAY_MS = 10;
+
 // ============================================================================
 // ACTION FUNCTION
 // ============================================================================
 
 /**
- * Type text into an input field
+ * Type text into multiple input fields
  * @param {Object} params - Type parameters
  * @param {string} params.url - The URL of the page to interact with
- * @param {string} params.selector - CSS selector for the input element
- * @param {string} params.text - Text to type
- * @param {boolean} [params.clear=true] - Whether to clear existing text first
- * @param {number} [params.typeDelay=50] - Delay between keystrokes in milliseconds
- * @param {number} [params.waitForElementTimeout=30000] - Maximum time to wait for element
+ * @param {Array<{selector: string, text: string, clear?: boolean, waitForElementTimeout?: number}>} params.fields - Array of fields to fill
  * @param {boolean} [params.returnHtml=true] - Whether to wait for stability and return HTML
  * @param {boolean} [params.removeUnnecessaryHTML=true] - Whether to clean HTML (only if returnHtml is true)
  * @param {number} [params.postTypeWait=1000] - Milliseconds to wait after typing for SPAs to render dynamic content
  * @returns {Promise<Object>} Result object with success status and details
  */
-export async function typeText({ url, selector, text, clear = true, typeDelay = 50, waitForElementTimeout = 30000, returnHtml = true, removeUnnecessaryHTML = true, postTypeWait = 1000 }) {
+export async function typeText({ url, fields, returnHtml = true, removeUnnecessaryHTML = true, postTypeWait = 1000 }) {
   const startTime = Date.now();
-  logger.info(`type_text called: selector=${selector}, url=${url}`);
+  logger.info(`type_text called: ${fields?.length || 0} fields, url=${url}`);
   
   if (!url) {
     throw new Error("url parameter is required");
   }
   
-  if (!selector) {
-    throw new Error("selector parameter is required");
+  if (!fields || !Array.isArray(fields) || fields.length === 0) {
+    throw new Error("fields parameter is required and must be a non-empty array");
   }
   
-  if (text === undefined || text === null) {
-    throw new Error("text parameter is required");
+  // Validate each field
+  for (let i = 0; i < fields.length; i++) {
+    const field = fields[i];
+    if (!field.selector) {
+      throw new Error(`fields[${i}].selector is required`);
+    }
+    if (field.text === undefined || field.text === null) {
+      throw new Error(`fields[${i}].text is required`);
+    }
   }
 
   let hostname;
@@ -151,9 +172,9 @@ export async function typeText({ url, selector, text, clear = true, typeDelay =
     logger.error(`type_text: Failed to connect to browser: ${err.message}`);
     return new InformationalResponse(
       `Browser connection failed: ${err.message}`,
-      'Could not connect to Chrome or Edge browser. The browser must be running with remote debugging enabled.',
+      'The browser must be running with remote debugging enabled.',
       [
-        'Ensure Chrome or Edge browser is installed and running',
+        'Ensure the browser is installed and running',
         'Check that remote debugging is enabled (--remote-debugging-port)',
         'Try restarting the MCP server'
       ]
@@ -165,7 +186,7 @@ export async function typeText({ url, selector, text, clear = true, typeDelay =
   
   if (!page) {
     const isConnectionLost = pageError && pageError.includes('connection');
-    logger.info(`type_text: ${pageError || 'No page found for ' + hostname}`);
+    logger.debug(`type_text: ${pageError || 'No page found for ' + hostname}`);
     return new InformationalResponse(
       isConnectionLost ? `Page connection lost for ${hostname}` : `No open page found for ${hostname}`,
       isConnectionLost 
@@ -178,20 +199,36 @@ export async function typeText({ url, selector, text, clear = true, typeDelay =
     );
   }
 
+  const filledSelectors = [];
+  let currentFieldIndex = 0;
+  let currentSelector = null;
+  
   try {
-    await page.waitForSelector(selector, { timeout: waitForElementTimeout, visible: true });
-    
-    if (clear) {
-      await page.click(selector, { clickCount: 3 }); // Select all text
-      await page.keyboard.press('Backspace');
+    // Type into each field sequentially
+    for (const field of fields) {
+      const { selector, text, clear = true, waitForElementTimeout = 5000 } = field;
+      currentSelector = selector;
+      
+      await page.waitForSelector(selector, { timeout: waitForElementTimeout, visible: true });
+      
+      if (clear) {
+        await page.click(selector, { clickCount: 3 }); // Select all text
+        await page.keyboard.press('Backspace');
+      }
+      
+      logger.debug(`Typing into: ${selector}`);
+      await page.type(selector, String(text), { delay: TYPE_DELAY_MS });
+      filledSelectors.push(selector);
+      currentFieldIndex++;
     }
     
-    logger.info(`Typing into: ${selector}`);
-    await page.type(selector, String(text), { delay: typeDelay });
+    const fieldsSummary = filledSelectors.length === 1 
+      ? filledSelectors[0] 
+      : `${filledSelectors.length} fields (${filledSelectors.join(', ')})`;
     
     if (returnHtml) {
       // Wait for page to stabilize (handles form validation, autocomplete, etc.)
-      logger.info('Waiting for page stability after typing...');
+      logger.debug('Waiting for page stability after typing...');
       await waitForPageStability(page);
       
       // Wait for SPAs to render dynamic content after typing
@@ -202,11 +239,11 @@ export async function typeText({ url, selector, text, clear = true, typeDelay =
       const currentUrl = page.url();
       const html = await extractAndProcessHtml(page, removeUnnecessaryHTML);
       
-      logger.info(`type_text completed: typed into ${selector}`);
+      logger.info(`type_text completed: typed into ${fieldsSummary}`);
       
       return new TypeTextSuccessResponse(
         currentUrl,
-        `Typed text into: ${selector}`,
+        `Typed text into: ${fieldsSummary}`,
         html,
         [
           "Use MCPBrowser's type_text to fill additional fields",
@@ -218,7 +255,7 @@ export async function typeText({ url, selector, text, clear = true, typeDelay =
       );
     } else {
       // Wait for page to stabilize even without returning HTML
-      logger.info('Waiting for page stability after typing (fast mode)...');
+      logger.debug('Waiting for page stability after typing (fast mode)...');
       await waitForPageStability(page);
       
       // Wait for SPAs to render dynamic content after typing
@@ -228,11 +265,11 @@ export async function typeText({ url, selector, text, clear = true, typeDelay =
       
       const currentUrl = page.url();
       
-      logger.info(`type_text completed: typed into ${selector} (no HTML)`);
+      logger.info(`type_text completed: typed into ${fieldsSummary} (no HTML)`);
       
       return new TypeTextSuccessResponse(
         currentUrl,
-        `Typed text into: ${selector}`,
+        `Typed text into: ${fieldsSummary}`,
         null,
         [
           "Use MCPBrowser's get_current_html to see updated page state",
@@ -243,16 +280,63 @@ export async function typeText({ url, selector, text, clear = true, typeDelay =
       );
     }
   } catch (err) {
-    logger.error(`type_text failed: ${err.message}`);
-    return new InformationalResponse(
-      `Failed to type text: ${err.message}`,
-      'The input field was found but text could not be entered. It may be disabled, read-only, or covered by another element.',
-      [
+    // Build informative error message for agent
+    const totalFields = fields.length;
+    const failedFieldNum = currentFieldIndex + 1;
+    const errorMsg = err.message;
+    
+    // Determine error type for better guidance
+    const isNotFound = errorMsg.includes('Waiting for selector') || errorMsg.includes('failed: Waiting failed');
+    const isNotVisible = errorMsg.includes('not visible') || errorMsg.includes('hidden');
+    const isDetached = errorMsg.includes('detached') || errorMsg.includes('Node is detached');
+    
+    let reason;
+    let nextSteps;
+    
+    if (isNotFound) {
+      reason = `Selector not found: "${currentSelector}". The element may not exist on the page or have a different selector.`;
+      nextSteps = [
+        "Use MCPBrowser's get_current_html to find the correct selector",
+        "Use MCPBrowser's take_screenshot to visually inspect the form",
+        "Check for typos in the selector or try a simpler selector (e.g., 'input[type=\"text\"]')",
+        "The element may load dynamically - try increasing waitForElementTimeout"
+      ];
+    } else if (isNotVisible) {
+      reason = `Element "${currentSelector}" exists but is not visible. It may be hidden, collapsed, or off-screen.`;
+      nextSteps = [
+        "Use MCPBrowser's take_screenshot to see the page state",
+        "Use MCPBrowser's click_element to expand/show the form section first",
+        "Use MCPBrowser's scroll_page to bring the element into view"
+      ];
+    } else if (isDetached) {
+      reason = `Element "${currentSelector}" was removed from the page during interaction. The page may have reloaded or updated.`;
+      nextSteps = [
+        "Use MCPBrowser's get_current_html to check current page state",
+        "Retry the type_text call - the page may have stabilized"
+      ];
+    } else {
+      reason = `Failed to interact with "${currentSelector}": ${errorMsg}`;
+      nextSteps = [
         "Use MCPBrowser's get_current_html to verify page state",
         "Use MCPBrowser's take_screenshot to see what's on the page visually",
-        "Check if the selector is correct",
-        "Verify the input field is visible and enabled"
-      ]
+        "The element may be disabled or read-only"
+      ];
+    }
+    
+    // Build progress summary
+    let progressInfo;
+    if (filledSelectors.length === 0) {
+      progressInfo = `Failed on field 1 of ${totalFields}. No fields were filled.`;
+    } else {
+      progressInfo = `Failed on field ${failedFieldNum} of ${totalFields}. Successfully filled ${filledSelectors.length} field(s): ${filledSelectors.join(', ')}. Do NOT re-type these fields.`;
+    }
+    
+    logger.error(`type_text failed on field ${failedFieldNum}/${totalFields} (${currentSelector}): ${errorMsg}`);
+    
+    return new InformationalResponse(
+      `${progressInfo}`,
+      reason,
+      nextSteps
     );
   }
 }

package/src/browsers/brave.js

@@ -0,0 +1,66 @@
+/**
+ * Brave browser implementation for MCPBrowser
+ * Brave is Chromium-based and uses the same CDP protocol as Chrome
+ */
+
+import { ChromiumBrowser } from './ChromiumBrowser.js';
+import os from "os";
+
+/**
+ * Get platform-specific default paths where Brave browser is typically installed.
+ * @returns {string[]} Array of possible Brave executable paths for the current platform
+ */
+function getDefaultBravePaths() {
+  const platform = os.platform();
+  
+  if (platform === "win32") {
+    return [
+      "C:/Program Files/BraveSoftware/Brave-Browser/Application/brave.exe",
+      "C:/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe",
+      `${os.homedir()}/AppData/Local/BraveSoftware/Brave-Browser/Application/brave.exe`,
+    ];
+  } else if (platform === "darwin") {
+    return [
+      "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
+    ];
+  } else {
+    return [
+      "/usr/bin/brave",
+      "/usr/bin/brave-browser",
+      "/usr/bin/brave-browser-stable",
+      "/opt/brave.com/brave/brave-browser",
+      "/snap/bin/brave",
+    ];
+  }
+}
+
+/**
+ * Brave browser class implementation
+ * Extends ChromiumBrowser with Brave-specific configuration
+ */
+export class BraveBrowser extends ChromiumBrowser {
+  constructor() {
+    const config = {
+      name: 'Brave',
+      host: process.env.BRAVE_REMOTE_DEBUG_HOST || "127.0.0.1",
+      port: Number(process.env.BRAVE_REMOTE_DEBUG_PORT || 9224),
+      wsEndpoint: process.env.BRAVE_WS_ENDPOINT,
+      executablePath: process.env.BRAVE_PATH,
+      defaultPaths: getDefaultBravePaths(),
+      userDataDirName: 'BraveDebug'
+    };
+    super(config);
+  }
+}
+
+// Legacy exports for backward compatibility
+export async function connectBrave() {
+  const brave = new BraveBrowser();
+  return await brave.connect();
+}
+
+export async function disconnectBrave(browser) {
+  if (browser && browser.isConnected()) {
+    await browser.disconnect();
+  }
+}

package/src/core/browser.js

@@ -5,6 +5,7 @@
 
 import { ChromeBrowser } from '../browsers/chrome.js';
 import { EdgeBrowser } from '../browsers/edge.js';
+import { BraveBrowser } from '../browsers/brave.js';
 import os from 'os';
 import logger from './logger.js';
 
@@ -17,15 +18,16 @@ const browserInstances = new Map();
 
 /**
  * Detect the default browser on the system
- * @returns {Promise<string>} Browser type (chrome, edge)
+ * @returns {Promise<string>} Browser type (chrome, edge, brave)
  */
 async function detectDefaultBrowser() {
   const platform = os.platform();
   
-  // Priority order: Chrome > Edge
+  // Priority order: Chrome > Edge > Brave
   const browsers = [
     new ChromeBrowser(),
-    new EdgeBrowser()
+    new EdgeBrowser(),
+    new BraveBrowser()
   ];
   
   for (const browser of browsers) {
@@ -67,10 +69,13 @@ export async function GetBrowser(type = '') {
     case 'edge':
       browser = new EdgeBrowser();
       break;
+    case 'brave':
+      browser = new BraveBrowser();
+      break;
     default:
       throw new Error(
         `Unsupported browser type: ${type}. ` +
-        `Supported: chrome, edge. ` +
+        `Supported: chrome, edge, brave. ` +
         `Leave empty for auto-detection.`
       );
   }

package/src/core/eula.js

@@ -0,0 +1,120 @@
+/**
+ * EULA (End User License Agreement) Management
+ * Tracks whether the user has accepted the EULA.
+ * EULA acceptance is persisted to disk and remembered across sessions.
+ */
+
+import logger from './logger.js';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+// EULA URL - where the full license agreement can be found
+export const EULA_URL = 'https://github.com/cherchyk/MCPBrowser/blob/main/EULA.md';
+
+// Config directory and file paths
+const CONFIG_DIR = join(homedir(), '.mcpbrowser');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+
+// In-memory cache of EULA acceptance status
+let eulaAccepted = null;
+
+/**
+ * Load config from disk
+ * @returns {Object} Config object
+ */
+function loadConfig() {
+  try {
+    if (existsSync(CONFIG_FILE)) {
+      const data = readFileSync(CONFIG_FILE, 'utf-8');
+      return JSON.parse(data);
+    }
+  } catch (error) {
+    logger.warn(`Failed to load config: ${error.message}`);
+  }
+  return {};
+}
+
+/**
+ * Save config to disk
+ * @param {Object} config - Config object to save
+ */
+function saveConfig(config) {
+  try {
+    if (!existsSync(CONFIG_DIR)) {
+      mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+    logger.info(`Config saved to ${CONFIG_FILE}`);
+  } catch (error) {
+    logger.error(`Failed to save config: ${error.message}`);
+  }
+}
+
+/**
+ * Initialize EULA status from persisted config
+ */
+function initEulaStatus() {
+  if (eulaAccepted === null) {
+    const config = loadConfig();
+    eulaAccepted = config.eulaAccepted === true;
+    if (eulaAccepted) {
+      logger.info('EULA previously accepted, loaded from config');
+    }
+  }
+}
+
+/**
+ * Check if the EULA has been accepted
+ * @returns {boolean} True if EULA has been accepted
+ */
+export function isEulaAccepted() {
+  initEulaStatus();
+  return eulaAccepted;
+}
+
+/**
+ * Accept the EULA (persisted across sessions)
+ * @param {string} eulaUrl - The EULA URL being accepted
+ */
+export function acceptEula(eulaUrl) {
+  eulaAccepted = true;
+  const config = loadConfig();
+  config.eulaAccepted = true;
+  config.eulaAcceptedAt = new Date().toISOString();
+  config.eulaUrl = eulaUrl;
+  saveConfig(config);
+  logger.info(`EULA accepted and persisted (${eulaUrl})`);
+}
+
+/**
+ * Reset EULA acceptance (clears both memory and persisted state)
+ * @param {boolean} [persistReset=true] - Whether to also clear the persisted config
+ */
+export function resetEula(persistReset = true) {
+  eulaAccepted = false;
+  if (persistReset) {
+    const config = loadConfig();
+    delete config.eulaAccepted;
+    delete config.eulaAcceptedAt;
+    delete config.eulaUrl;
+    saveConfig(config);
+    logger.debug('EULA acceptance reset (memory and disk)');
+  } else {
+    logger.debug('EULA acceptance reset (memory only)');
+  }
+}
+
+/**
+ * Get EULA status summary
+ * @returns {{ accepted: boolean, acceptedAt: string|null, eulaUrl: string }} Current EULA status
+ */
+export function getEulaStatus() {
+  initEulaStatus();
+  const config = loadConfig();
+  return {
+    accepted: eulaAccepted,
+    acceptedAt: config.eulaAcceptedAt || null,
+    eulaUrl: EULA_URL
+  };
+}

package/src/core/logger.js

@@ -14,6 +14,14 @@ function info(message) {
   console.error(`${PREFIX} ${message}`);
 }
 
+/**
+ * Log a warning message
+ * @param {string} message - The message to log
+ */
+function warn(message) {
+  console.error(`${PREFIX} ⚠️ ${message}`);
+}
+
 /**
  * Log an error message
  * @param {string} message - The message to log
@@ -22,5 +30,13 @@ function error(message) {
   console.error(`${PREFIX} ❌ ${message}`);
 }
 
-export const logger = { info, error };
+/**
+ * Log a debug message
+ * @param {string} message - The message to log
+ */
+function debug(message) {
+  console.error(`${PREFIX} 🔍 ${message}`);
+}
+
+export const logger = { info, warn, error, debug };
 export default logger;

package/src/core/page.js

@@ -43,7 +43,7 @@ async function processQueue() {
     const queueLength = requestQueue.length;
     
     if (queueLength > 0) {
-      logger.info(`Queue: ${queueLength} requests waiting`);
+      logger.debug(`Queue: ${queueLength} requests waiting`);
     }
     
     try {
@@ -285,7 +285,7 @@ export async function waitForPageReady(page) {
   const spaCheck = await isItSPA(page);
   
   if (spaCheck.isSPA) {
-    logger.info(`SPA detected: ${spaCheck.indicators.join(', ')}`);
+    logger.debug(`SPA detected: ${spaCheck.indicators.join(', ')}`);
     
     // Wait for SPA to render
     await new Promise(resolve => setTimeout(resolve, 3000));
@@ -296,7 +296,7 @@ export async function waitForPageReady(page) {
     } catch {
       // OK if timeout - SPA might have websockets or long-polling
     }
-    logger.info('SPA content ready');
+    logger.debug('SPA content ready');
   } else {
     // For non-SPAs, just wait briefly for any pending network requests
     try {
@@ -314,17 +314,17 @@ export async function waitForPageReady(page) {
  * @returns {Promise<void>}
  */
 export async function waitForPageStability(page) {
-  logger.info('Waiting for page stability (network idle)...');
+  logger.debug('Waiting for page stability (network idle)...');
   
   // Give time for any triggered actions to complete
   await new Promise(resolve => setTimeout(resolve, 2000));
   
   try {
     await page.waitForNetworkIdle({ timeout: 5000 });
-    logger.info('Page stabilized');
+    logger.debug('Page stabilized');
   } catch {
     // Ignore timeout - page may have long-polling or websockets
-    logger.info('Network still active, continuing anyway');
+    logger.debug('Network still active, continuing anyway');
   }
 }
 

package/src/mcp-browser.js

@@ -16,6 +16,9 @@ import { dirname, join } from 'path';
 import { ErrorResponse } from './core/responses.js';
 import logger from './core/logger.js';
 
+// Import EULA functionality
+import { handleAcceptEula, ACCEPT_EULA_TOOL, requireEulaAcceptance } from './actions/accept-eula.js';
+
 // Import core functionality
 import { fetchPage, FETCH_WEBPAGE_TOOL } from './actions/fetch-page.js';
 import { clickElement, CLICK_ELEMENT_TOOL } from './actions/click-element.js';
@@ -47,7 +50,9 @@ async function main() {
   const server = new Server({ name: "MCP Browser", version: packageJson.version }, { capabilities: { tools: {} } });
 
   // Assemble tools from action imports
+  // ACCEPT_EULA_TOOL must be first - it's required before using other tools
   const tools = [
+    ACCEPT_EULA_TOOL,
     FETCH_WEBPAGE_TOOL,
     CLICK_ELEMENT_TOOL,
     TYPE_TEXT_TOOL,
@@ -66,7 +71,17 @@ async function main() {
     let result;
     
     try {
+      // EULA check - accept_eula is always allowed, other tools require EULA acceptance
+      if (name !== "accept_eula") {
+        const eulaResponse = requireEulaAcceptance(name);
+        if (eulaResponse) return eulaResponse;
+      }
+      
       switch (name) {
+        case "accept_eula":
+          result = await handleAcceptEula(safeArgs);
+          break;
+          
         case "fetch_webpage":
           result = await fetchPage(safeArgs);
           break;
@@ -106,7 +121,7 @@ async function main() {
       // Return a proper error response instead of throwing
       return new ErrorResponse(
         `${name} failed: ${error.message}`,
-        ['Check browser is installed', 'Try specifying browser parameter explicitly (chrome or edge)', 'Check MCP server logs for details']
+        ['Check browser is installed', 'Try specifying browser parameter explicitly (chrome, edge, or brave)', 'Check MCP server logs for details']
       ).toMcpFormat();
     }
     
@@ -144,7 +159,8 @@ export {
   closeTab,
   getCurrentHtml,
   takeScreenshot,
-  scrollPage
+  scrollPage,
+  handleAcceptEula
 };
 
 // Run the MCP server only if this is the main module (not imported for testing)