Skip to content

Open-source Python library for AI browser agents, plus Browser Use Cloud: stealth browsers and a hosted agent API.

feat: fix MCP server JSON-RPC corruption and removed http mode

Saurav Panda12a0c76a328a
diff --git a/browser_use/cli.py b/browser_use/cli.py
index c69014de8..54ffe2922 100644
--- a/browser_use/cli.py
+++ b/browser_use/cli.py
@@ -1,9 +1,20 @@
# pyright: reportMissingImports=false
+
+# Check for MCP mode early to prevent logging initialization
+import sys
+
+if '--mcp' in sys.argv:
+ import logging
+ import os
+
+ os.environ['BROWSER_USE_LOGGING_LEVEL'] = 'critical'
+ os.environ['BROWSER_USE_SETUP_LOGGING'] = 'false'
+ logging.disable(logging.CRITICAL)
+
import asyncio
import json
import logging
import os
-import sys
import time
from pathlib import Path
from typing import Any
@@ -16,6 +27,13 @@ from browser_use.llm.openai.chat import ChatOpenAI
load_dotenv()
+from browser_use import Agent, Controller
+from browser_use.agent.views import AgentSettings
+from browser_use.browser import BrowserProfile, BrowserSession
+from browser_use.logging_config import addLoggingLevel
+from browser_use.telemetry import CLITelemetryEvent, ProductTelemetry
+from browser_use.utils import get_browser_use_version
+
try:
import click
from textual import events
@@ -39,23 +57,20 @@ except ImportError:
os.environ['BROWSER_USE_LOGGING_LEVEL'] = 'result'
-from browser_use import Agent, Controller
-from browser_use.agent.views import AgentSettings
-from browser_use.browser import BrowserProfile, BrowserSession
from browser_use.config import CONFIG
-from browser_use.logging_config import addLoggingLevel
-from browser_use.telemetry import CLITelemetryEvent, ProductTelemetry
-from browser_use.utils import get_browser_use_version
+# Set USER_DATA_DIR now that CONFIG is imported
USER_DATA_DIR = CONFIG.BROWSER_USE_PROFILES_DIR / 'cli'
-# Default User settings
-MAX_HISTORY_LENGTH = 100
-
# Ensure directories exist
CONFIG.BROWSER_USE_CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
USER_DATA_DIR.mkdir(parents=True, exist_ok=True)
+# Default User settings
+MAX_HISTORY_LENGTH = 100
+
+# Directory setup will happen in functions that need CONFIG
+
# Logo components with styling for rich panels
BROWSER_LOGO = """
@@ -1871,15 +1886,19 @@ def run_main_interface(ctx: click.Context, debug: bool = False, **kwargs):
# Check if MCP server mode is activated
if kwargs.get('mcp'):
- # Capture telemetry for MCP server mode via CLI
- telemetry = ProductTelemetry()
- telemetry.capture(
- CLITelemetryEvent(
- version=get_browser_use_version(),
- action='start',
- mode='mcp_server',
+ # Capture telemetry for MCP server mode via CLI (suppress any logging from this)
+ try:
+ telemetry = ProductTelemetry()
+ telemetry.capture(
+ CLITelemetryEvent(
+ version=get_browser_use_version(),
+ action='start',
+ mode='mcp_server',
+ )
)
- )
+ except Exception:
+ # Ignore telemetry errors in MCP mode to prevent any stdout contamination
+ pass
# Run as MCP server
from browser_use.mcp.server import main as mcp_main
diff --git a/browser_use/mcp/__main__.py b/browser_use/mcp/__main__.py
index c3e8dfc17..e26f758fe 100644
--- a/browser_use/mcp/__main__.py
+++ b/browser_use/mcp/__main__.py
@@ -1,7 +1,7 @@
"""Entry point for running MCP server as a module.
Usage:
- python -m browser_use.mcp.server
+ python -m browser_use.mcp
"""
import asyncio
diff --git a/browser_use/mcp/server.py b/browser_use/mcp/server.py
index 89c9f1f4f..8633b178f 100644
--- a/browser_use/mcp/server.py
+++ b/browser_use/mcp/server.py
@@ -23,15 +23,23 @@ Or as an MCP server in Claude Desktop or other MCP clients:
}
"""
+import os
+import sys
+
+# Set environment variables BEFORE any browser_use imports to prevent early logging
+os.environ['BROWSER_USE_LOGGING_LEVEL'] = 'critical'
+os.environ['BROWSER_USE_SETUP_LOGGING'] = 'false'
+
import asyncio
import json
import logging
-import os
-import sys
import time
from pathlib import Path
from typing import Any
+# Disable all logging immediately for MCP mode
+logging.disable(logging.CRITICAL)
+
try:
import psutil
@@ -48,32 +56,38 @@ from browser_use.logging_config import setup_logging
def _configure_mcp_server_logging():
"""Configure logging for MCP server mode - redirect all logs to stderr to prevent JSON RPC interference."""
+ # Completely disable all logging for MCP mode
+ logging.disable(logging.CRITICAL)
+
# Set environment to suppress browser-use logging during server mode
- os.environ['BROWSER_USE_LOGGING_LEVEL'] = 'error'
+ os.environ['BROWSER_USE_LOGGING_LEVEL'] = 'critical'
os.environ['BROWSER_USE_SETUP_LOGGING'] = 'false' # Prevent automatic logging setup
- # Configure logging to stderr for MCP mode
- setup_logging(stream=sys.stderr, log_level='error', force_setup=True)
+ # Configure logging to stderr for MCP mode - use CRITICAL to suppress almost everything
+ setup_logging(stream=sys.stderr, log_level='critical', force_setup=True)
# Also configure the root logger and all existing loggers to use stderr
logging.root.handlers = []
stderr_handler = logging.StreamHandler(sys.stderr)
stderr_handler.setFormatter(logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
logging.root.addHandler(stderr_handler)
- logging.root.setLevel(logging.ERROR)
+ logging.root.setLevel(logging.CRITICAL)
- # Configure all existing loggers to use stderr
+ # Configure all existing loggers to use stderr and CRITICAL level
for name in list(logging.root.manager.loggerDict.keys()):
logger_obj = logging.getLogger(name)
logger_obj.handlers = []
+ logger_obj.setLevel(logging.CRITICAL)
logger_obj.addHandler(stderr_handler)
- logger_obj.setLevel(logging.ERROR)
logger_obj.propagate = False
# Configure MCP server logging before any browser_use imports to capture early log lines
_configure_mcp_server_logging()
+# Additional suppression - disable all logging completely for MCP mode
+logging.disable(logging.CRITICAL)
+
# Import browser_use modules
from browser_use import ActionModel, Agent
from browser_use.browser import BrowserProfile, BrowserSession
@@ -100,13 +114,13 @@ def _ensure_all_loggers_use_stderr():
# Configure root logger
logging.root.handlers = [stderr_handler]
- logging.root.setLevel(logging.ERROR)
+ logging.root.setLevel(logging.CRITICAL)
# Configure all existing loggers
for name in list(logging.root.manager.loggerDict.keys()):
logger_obj = logging.getLogger(name)
logger_obj.handlers = [stderr_handler]
- logger_obj.setLevel(logging.ERROR)
+ logger_obj.setLevel(logging.CRITICAL)
logger_obj.propagate = False
@@ -116,16 +130,10 @@ _ensure_all_loggers_use_stderr()
# Try to import MCP SDK
try:
- import contextlib
-
import mcp.server.stdio
import mcp.types as types
from mcp.server import NotificationOptions, Server
from mcp.server.models import InitializationOptions
- from mcp.server.streamable_http_manager import StreamableHTTPSessionManager
- from starlette.applications import Starlette
- from starlette.routing import Mount
- from starlette.types import Receive, Scope, Send
MCP_AVAILABLE = True
@@ -178,7 +186,7 @@ def get_parent_process_cmdline() -> str | None:
class BrowserUseServer:
"""MCP Server for browser-use capabilities."""
- def __init__(self):
+ def __init__(self, session_timeout_minutes: int = 10):
# Ensure all logging goes to stderr (in case new loggers were created)
_ensure_all_loggers_use_stderr()
@@ -192,6 +200,11 @@ class BrowserUseServer:
self._telemetry = ProductTelemetry()
self._start_time = time.time()
+ # Session management
+ self.active_sessions: dict[str, dict[str, Any]] = {} # session_id -> session info
+ self.session_timeout_minutes = session_timeout_minutes
+ self._cleanup_task: Any = None
+
# Setup handlers
self._setup_handlers()
@@ -365,8 +378,43 @@ class BrowserUseServer:
'required': ['task'],
},
),
+ # Browser session management tools
+ types.Tool(
+ name='browser_list_sessions',
+ description='List all active browser sessions with their details and last activity time',
+ inputSchema={'type': 'object', 'properties': {}},
+ ),
+ types.Tool(
+ name='browser_close_session',
+ description='Close a specific browser session by its ID',
+ inputSchema={
+ 'type': 'object',
+ 'properties': {
+ 'session_id': {
+ 'type': 'string',
+ 'description': 'The browser session ID to close (get from browser_list_sessions)',
+ }
+ },
+ 'required': ['session_id'],
+ },
+ ),
+ types.Tool(
+ name='browser_close_all',
+ description='Close all active browser sessions and clean up resources',
+ inputSchema={'type': 'object', 'properties': {}},
+ ),
]
+ @self.server.list_resources()
+ async def handle_list_resources() -> list[types.Resource]:
+ """List available resources (none for browser-use)."""
+ return []
+
+ @self.server.list_prompts()
+ async def handle_list_prompts() -> list[types.Prompt]:
+ """List available prompts (none for browser-use)."""
+ return []
+
@self.server.call_tool()
async def handle_call_tool(name: str, arguments: dict[str, Any] | None) -> list[types.TextContent]:
"""Handle tool execution."""
@@ -444,6 +492,16 @@ class BrowserUseServer:
elif tool_name == 'browser_close_tab':
return await self._close_tab(arguments['tab_id'])
+ # Browser session management tools (don't require active session)
+ elif tool_name == 'browser_list_sessions':
+ return await self._list_sessions()
+
+ elif tool_name == 'browser_close_session':
+ return await self._close_session(arguments['session_id'])
+
+ elif tool_name == 'browser_close_all':
+ return await self._close_all_sessions()
+
return f'Unknown tool: {tool_name}'
async def _init_browser_session(self, allowed_domains: list[str] | None = None, **kwargs):
@@ -486,6 +544,9 @@ class BrowserUseServer:
self.browser_session = BrowserSession(browser_profile=profile)
await self.browser_session.start()
+ # Track the session for management
+ self._track_session(self.browser_session)
+
# Create tools for direct actions
self.tools = Tools()
@@ -592,6 +653,9 @@ class BrowserUseServer:
if not self.browser_session:
return 'Error: No browser session active'
+ # Update session activity
+ self._update_session_activity(self.browser_session.id)
+
from browser_use.browser.events import NavigateToUrlEvent
if new_tab:
@@ -608,6 +672,9 @@ class BrowserUseServer:
if not self.browser_session:
return 'Error: No browser session active'
+ # Update session activity
+ self._update_session_activity(self.browser_session.id)
+
# Get the element
element = await self.browser_session.get_dom_element_by_index(index)
if not element:
@@ -812,8 +879,140 @@ class BrowserUseServer:
current_url = await self.browser_session.get_current_page_url()
return f'Closed tab # {tab_id}, now on {current_url}'
+ def _track_session(self, session: BrowserSession) -> None:
+ """Track a browser session for management."""
+ self.active_sessions[session.id] = {
+ 'session': session,
+ 'created_at': time.time(),
+ 'last_activity': time.time(),
+ 'url': getattr(session, 'current_url', None),
+ }
+
+ def _update_session_activity(self, session_id: str) -> None:
+ """Update the last activity time for a session."""
+ if session_id in self.active_sessions:
+ self.active_sessions[session_id]['last_activity'] = time.time()
+
+ async def _list_sessions(self) -> str:
+ """List all active browser sessions."""
+ if not self.active_sessions:
+ return 'No active browser sessions'
+
+ sessions_info = []
+ for session_id, session_data in self.active_sessions.items():
+ session = session_data['session']
+ created_at = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(session_data['created_at']))
+ last_activity = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(session_data['last_activity']))
+
+ # Check if session is still active
+ is_active = hasattr(session, 'cdp_client') and session.cdp_client is not None
+
+ sessions_info.append(
+ {
+ 'session_id': session_id,
+ 'created_at': created_at,
+ 'last_activity': last_activity,
+ 'active': is_active,
+ 'current_url': session_data.get('url', 'Unknown'),
+ 'age_minutes': (time.time() - session_data['created_at']) / 60,
+ }
+ )
+
+ return json.dumps(sessions_info, indent=2)
+
+ async def _close_session(self, session_id: str) -> str:
+ """Close a specific browser session."""
+ if session_id not in self.active_sessions:
+ return f'Session {session_id} not found'
+
+ session_data = self.active_sessions[session_id]
+ session = session_data['session']
+
+ try:
+ # Close the session
+ if hasattr(session, 'kill'):
+ await session.kill()
+ elif hasattr(session, 'close'):
+ await session.close()
+
+ # Remove from tracking
+ del self.active_sessions[session_id]
+
+ # If this was the current session, clear it
+ if self.browser_session and self.browser_session.id == session_id:
+ self.browser_session = None
+ self.tools = None
+
+ return f'Successfully closed session {session_id}'
+ except Exception as e:
+ return f'Error closing session {session_id}: {str(e)}'
+
+ async def _close_all_sessions(self) -> str:
+ """Close all active browser sessions."""
+ if not self.active_sessions:
+ return 'No active sessions to close'
+
+ closed_count = 0
+ errors = []
+
+ for session_id in list(self.active_sessions.keys()):
+ try:
+ result = await self._close_session(session_id)
+ if 'Successfully closed' in result:
+ closed_count += 1
+ else:
+ errors.append(f'{session_id}: {result}')
+ except Exception as e:
+ errors.append(f'{session_id}: {str(e)}')
+
+ # Clear current session references
+ self.browser_session = None
+ self.tools = None
+
+ result = f'Closed {closed_count} sessions'
+ if errors:
+ result += f'. Errors: {"; ".join(errors)}'
+
+ return result
+
+ async def _cleanup_expired_sessions(self) -> None:
+ """Background task to clean up expired sessions."""
+ current_time = time.time()
+ timeout_seconds = self.session_timeout_minutes * 60
+
+ expired_sessions = []
+ for session_id, session_data in self.active_sessions.items():
+ last_activity = session_data['last_activity']
+ if current_time - last_activity > timeout_seconds:
+ expired_sessions.append(session_id)
+
+ for session_id in expired_sessions:
+ try:
+ await self._close_session(session_id)
+ logger.info(f'Auto-closed expired session {session_id}')
+ except Exception as e:
+ logger.error(f'Error auto-closing session {session_id}: {e}')
+
+ async def _start_cleanup_task(self) -> None:
+ """Start the background cleanup task."""
+
+ async def cleanup_loop():
+ while True:
+ try:
+ await self._cleanup_expired_sessions()
+ # Check every 2 minutes
+ await asyncio.sleep(120)
+ except Exception as e:
+ logger.error(f'Error in cleanup task: {e}')
+ await asyncio.sleep(120)
+
+ self._cleanup_task = asyncio.create_task(cleanup_loop())
+
async def run(self):
"""Run the MCP server."""
+ # Start the cleanup task
+ await self._start_cleanup_task()
+
async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
await self.server.run(
read_stream,
@@ -828,45 +1027,13 @@ class BrowserUseServer:
),
)
- async def run_http(self, port: int = 3000, json_response: bool = False):
- """Run the MCP server over Streamable HTTP."""
- session_manager = StreamableHTTPSessionManager(
- app=self.server,
- event_store=None,
- json_response=json_response,
- stateless=True,
- )
-
- async def handle_streamable_http(scope: Scope, receive: Receive, send: Send) -> None:
- await session_manager.handle_request(scope, receive, send)
-
- @contextlib.asynccontextmanager
- async def lifespan(app: Starlette):
- async with session_manager.run():
- logger.info('BrowserUseServer started in Streamable HTTP mode')
- yield
-
- starlette_app = Starlette(
- debug=False,
- routes=[
- Mount('/mcp', app=handle_streamable_http),
- ],
- lifespan=lifespan,
- )
-
- import uvicorn
-
- config = uvicorn.Config(starlette_app, host='127.0.0.1', port=port, loop='asyncio')
- server = uvicorn.Server(config)
- await server.serve()
-
-async def main(http: bool = False, port: int = 3000, json_response: bool = False):
+async def main(session_timeout_minutes: int = 10):
if not MCP_AVAILABLE:
print('MCP SDK is required. Install with: pip install mcp', file=sys.stderr)
sys.exit(1)
- server = BrowserUseServer()
+ server = BrowserUseServer(session_timeout_minutes=session_timeout_minutes)
server._telemetry.capture(
MCPServerTelemetryEvent(
version=get_browser_use_version(),
@@ -876,10 +1043,7 @@ async def main(http: bool = False, port: int = 3000, json_response: bool = False
)
try:
- if http:
- await server.run_http(port=port, json_response=json_response)
- else:
- await server.run()
+ await server.run()
finally:
duration = time.time() - server._start_time
server._telemetry.capture(
@@ -894,12 +1058,4 @@ async def main(http: bool = False, port: int = 3000, json_response: bool = False
if __name__ == '__main__':
- import argparse
-
- parser = argparse.ArgumentParser()
- parser.add_argument('--http', action='store_true', help='Run in Streamable HTTP mode instead of stdio')
- parser.add_argument('--port', type=int, default=3000, help='HTTP port (only in HTTP mode)')
- parser.add_argument('--json-response', action='store_true', help='Use JSON responses instead of SSE')
- args = parser.parse_args()
-
- asyncio.run(main(http=args.http, port=args.port, json_response=args.json_response))
+ asyncio.run(main())