Open-source Python library for AI browser agents, plus Browser Use Cloud: stealth browsers and a hosted agent API.
Python ai-agentsai-toolsbrowser-agentbrowser-automationbrowser-usecdpcloud-browsercomputer-useheadless-browserllmmcpplaywrightpythonremote-browserstealth-browserweb-automationweb-scraping
feat: CLI is back baby!
Saurav Pandad2092f895ae9
diff --git a/browser_use/cli.py b/browser_use/cli.pynew file mode 100644index 000000000..a1a95d937--- /dev/null+++ b/browser_use/cli.py@@ -0,0 +1,1720 @@+# pyright: reportMissingImports=false+import asyncio+import json+import logging+import os+import sys+import time+from pathlib import Path+from typing import Any++from dotenv import load_dotenv++from browser_use.llm.anthropic.chat import ChatAnthropic+from browser_use.llm.google.chat import ChatGoogle+from browser_use.llm.openai.chat import ChatOpenAI++load_dotenv()++try:+ import click+ from textual import events+ from textual.app import App, ComposeResult+ from textual.binding import Binding+ from textual.containers import Container, HorizontalGroup, VerticalScroll+ from textual.widgets import Footer, Header, Input, Label, Link, RichLog, Static+except ImportError:+ print('⚠️ CLI addon is not installed. Please install it with: `pip install "browser-use[cli]"` and try again.')+ sys.exit(1)+++try:+ import readline++ READLINE_AVAILABLE = True+except ImportError:+ # readline not available on Windows by default+ READLINE_AVAILABLE = False+++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++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)+++# Logo components with styling for rich panels+BROWSER_LOGO = """+ [white] ++++++ +++++++++ [/]+ [white] +++ +++++ +++ [/]+ [white] ++ ++++ ++ ++ [/]+ [white] ++ +++ +++ ++ [/]+ [white] ++++ +++ [/]+ [white] +++ +++ [/]+ [white] +++ +++ [/]+ [white] ++ +++ +++ ++ [/]+ [white] ++ ++++ ++ ++ [/]+ [white] +++ ++++++ +++ [/]+ [white] ++++++ +++++++ [/]++[white]██████╗ ██████╗ ██████╗ ██╗ ██╗███████╗███████╗██████╗[/] [darkorange]██╗ ██╗███████╗███████╗[/]+[white]██╔══██╗██╔══██╗██╔═══██╗██║ ██║██╔════╝██╔════╝██╔══██╗[/] [darkorange]██║ ██║██╔════╝██╔════╝[/]+[white]██████╔╝██████╔╝██║ ██║██║ █╗ ██║███████╗█████╗ ██████╔╝[/] [darkorange]██║ ██║███████╗█████╗[/]+[white]██╔══██╗██╔══██╗██║ ██║██║███╗██║╚════██║██╔══╝ ██╔══██╗[/] [darkorange]██║ ██║╚════██║██╔══╝[/]+[white]██████╔╝██║ ██║╚██████╔╝╚███╔███╔╝███████║███████╗██║ ██║[/] [darkorange]╚██████╔╝███████║███████╗[/]+[white]╚═════╝ ╚═╝ ╚═╝ ╚═════╝ ╚══╝╚══╝ ╚══════╝╚══════╝╚═╝ ╚═╝[/] [darkorange]╚═════╝ ╚══════╝╚══════╝[/]+"""+++# Common UI constants+TEXTUAL_BORDER_STYLES = {'logo': 'blue', 'info': 'blue', 'input': 'orange3', 'working': 'yellow', 'completion': 'green'}+++def get_default_config() -> dict[str, Any]:+ """Return default configuration dictionary using the new config system."""+ # Load config from the new config system+ config_data = CONFIG.load_config()++ # Extract browser profile, llm, and agent configs+ browser_profile = config_data.get('browser_profile', {})+ llm_config = config_data.get('llm', {})+ agent_config = config_data.get('agent', {})++ return {+ 'model': {+ 'name': llm_config.get('model'),+ 'temperature': llm_config.get('temperature', 0.0),+ 'api_keys': {+ 'OPENAI_API_KEY': llm_config.get('api_key', CONFIG.OPENAI_API_KEY),+ 'ANTHROPIC_API_KEY': CONFIG.ANTHROPIC_API_KEY,+ 'GOOGLE_API_KEY': CONFIG.GOOGLE_API_KEY,+ 'DEEPSEEK_API_KEY': CONFIG.DEEPSEEK_API_KEY,+ 'GROK_API_KEY': CONFIG.GROK_API_KEY,+ },+ },+ 'agent': agent_config,+ 'browser': {+ 'headless': browser_profile.get('headless', True),+ 'keep_alive': browser_profile.get('keep_alive', True),+ 'ignore_https_errors': browser_profile.get('ignore_https_errors', False),+ 'user_data_dir': browser_profile.get('user_data_dir'),+ 'allowed_domains': browser_profile.get('allowed_domains'),+ 'wait_between_actions': browser_profile.get('wait_between_actions'),+ 'is_mobile': browser_profile.get('is_mobile'),+ 'device_scale_factor': browser_profile.get('device_scale_factor'),+ 'disable_security': browser_profile.get('disable_security'),+ },+ 'command_history': [],+ }+++def load_user_config() -> dict[str, Any]:+ """Load user configuration using the new config system."""+ # Just get the default config which already loads from the new system+ config = get_default_config()++ # Load command history from a separate file if it exists+ history_file = CONFIG.BROWSER_USE_CONFIG_DIR / 'command_history.json'+ if history_file.exists():+ try:+ with open(history_file) as f:+ config['command_history'] = json.load(f)+ except (FileNotFoundError, json.JSONDecodeError):+ config['command_history'] = []++ return config+++def save_user_config(config: dict[str, Any]) -> None:+ """Save command history only (config is saved via the new system)."""+ # Only save command history to a separate file+ if 'command_history' in config and isinstance(config['command_history'], list):+ # Ensure command history doesn't exceed maximum length+ history = config['command_history']+ if len(history) > MAX_HISTORY_LENGTH:+ history = history[-MAX_HISTORY_LENGTH:]++ # Save to separate history file+ history_file = CONFIG.BROWSER_USE_CONFIG_DIR / 'command_history.json'+ with open(history_file, 'w') as f:+ json.dump(history, f, indent=2)+++def update_config_with_click_args(config: dict[str, Any], ctx: click.Context) -> dict[str, Any]:+ """Update configuration with command-line arguments."""+ # Ensure required sections exist+ if 'model' not in config:+ config['model'] = {}+ if 'browser' not in config:+ config['browser'] = {}++ # Update configuration with command-line args if provided+ if ctx.params.get('model'):+ config['model']['name'] = ctx.params['model']+ if ctx.params.get('headless') is not None:+ config['browser']['headless'] = ctx.params['headless']+ if ctx.params.get('window_width'):+ config['browser']['window_width'] = ctx.params['window_width']+ if ctx.params.get('window_height'):+ config['browser']['window_height'] = ctx.params['window_height']+ if ctx.params.get('user_data_dir'):+ config['browser']['user_data_dir'] = ctx.params['user_data_dir']+ if ctx.params.get('profile_directory'):+ config['browser']['profile_directory'] = ctx.params['profile_directory']+ if ctx.params.get('cdp_url'):+ config['browser']['cdp_url'] = ctx.params['cdp_url']++ # Consolidated proxy dict+ proxy: dict[str, str] = {}+ if ctx.params.get('proxy_url'):+ proxy['server'] = ctx.params['proxy_url']+ if ctx.params.get('no_proxy'):+ # Store as comma-separated list string to match Chrome flag+ proxy['bypass'] = ','.join([p.strip() for p in ctx.params['no_proxy'].split(',') if p.strip()])+ if ctx.params.get('proxy_username'):+ proxy['username'] = ctx.params['proxy_username']+ if ctx.params.get('proxy_password'):+ proxy['password'] = ctx.params['proxy_password']+ if proxy:+ config['browser']['proxy'] = proxy++ return config+++def setup_readline_history(history: list[str]) -> None:+ """Set up readline with command history."""+ if not READLINE_AVAILABLE:+ return++ # Add history items to readline+ for item in history:+ readline.add_history(item)+++def get_llm(config: dict[str, Any]):+ """Get the language model based on config and available API keys."""+ model_config = config.get('model', {})+ model_name = model_config.get('name')+ temperature = model_config.get('temperature', 0.0)++ # Get API key from config or environment+ api_key = model_config.get('api_keys', {}).get('OPENAI_API_KEY') or CONFIG.OPENAI_API_KEY++ if model_name:+ if model_name.startswith('gpt'):+ if not api_key and not CONFIG.OPENAI_API_KEY:+ print('⚠️ OpenAI API key not found. Please update your config or set OPENAI_API_KEY environment variable.')+ sys.exit(1)+ return ChatOpenAI(model=model_name, temperature=temperature, api_key=api_key or CONFIG.OPENAI_API_KEY)+ elif model_name.startswith('claude'):+ if not CONFIG.ANTHROPIC_API_KEY:+ print('⚠️ Anthropic API key not found. Please update your config or set ANTHROPIC_API_KEY environment variable.')+ sys.exit(1)+ return ChatAnthropic(model=model_name, temperature=temperature)+ elif model_name.startswith('gemini'):+ if not CONFIG.GOOGLE_API_KEY:+ print('⚠️ Google API key not found. Please update your config or set GOOGLE_API_KEY environment variable.')+ sys.exit(1)+ return ChatGoogle(model=model_name, temperature=temperature)++ # Auto-detect based on available API keys+ if api_key or CONFIG.OPENAI_API_KEY:+ return ChatOpenAI(model='gpt-5-mini', temperature=temperature, api_key=api_key or CONFIG.OPENAI_API_KEY)+ elif CONFIG.ANTHROPIC_API_KEY:+ return ChatAnthropic(model='claude-4-sonnet', temperature=temperature)+ elif CONFIG.GOOGLE_API_KEY:+ return ChatGoogle(model='gemini-2.5-pro', temperature=temperature)+ else:+ print(+ '⚠️ No API keys found. Please update your config or set one of: OPENAI_API_KEY, ANTHROPIC_API_KEY, or GOOGLE_API_KEY.'+ )+ sys.exit(1)+++class RichLogHandler(logging.Handler):+ """Custom logging handler that redirects logs to a RichLog widget."""++ def __init__(self, rich_log: RichLog):+ super().__init__()+ self.rich_log = rich_log++ def emit(self, record):+ try:+ msg = self.format(record)+ self.rich_log.write(msg)+ except Exception:+ self.handleError(record)+++class BrowserUseApp(App):+ """Browser-use TUI application."""++ # Make it an inline app instead of fullscreen+ # MODES = {"light"} # Ensure app is inline, not fullscreen++ CSS = """+ #main-container {+ height: 100%;+ layout: vertical;+ }++ #logo-panel, #links-panel, #paths-panel, #info-panels {+ border: solid $primary;+ margin: 0 0 0 0;+ padding: 0;+ }++ #info-panels {+ display: none;+ layout: vertical;+ height: auto;+ min-height: 5;+ margin: 0 0 1 0;+ }++ #top-panels {+ layout: horizontal;+ height: auto;+ width: 100%;+ }++ #browser-panel, #model-panel {+ width: 1fr;+ height: 100%;+ padding: 1;+ border-right: solid $primary;+ }++ #model-panel {+ border-right: none;+ }++ #tasks-panel {+ height: auto;+ max-height: 10;+ overflow-y: scroll;+ padding: 1;+ border-top: solid $primary;+ }++ #browser-info, #model-info, #tasks-info {+ height: auto;+ margin: 0;+ padding: 0;+ background: transparent;+ overflow-y: auto;+ min-height: 3;+ }++ #three-column-container {+ height: 1fr;+ layout: horizontal;+ width: 100%;+ display: none;+ }++ #main-output-column {+ width: 1fr;+ height: 100%;+ border: solid $primary;+ padding: 0;+ margin: 0 1 0 0;+ }++ #events-column {+ width: 1fr;+ height: 100%;+ border: solid $warning;+ padding: 0;+ margin: 0 1 0 0;+ }++ #cdp-column {+ width: 1fr;+ height: 100%;+ border: solid $accent;+ padding: 0;+ margin: 0;+ }++ #main-output-log, #events-log, #cdp-log {+ height: 100%;+ overflow-y: scroll;+ background: $surface;+ color: $text;+ width: 100%;+ padding: 1;+ }++ #events-log {+ color: $warning;+ }++ #cdp-log {+ color: $accent-lighten-2;+ }++ #logo-panel {+ width: 100%;+ height: auto;+ content-align: center middle;+ text-align: center;+ }++ #links-panel {+ width: 100%;+ padding: 1;+ border: solid $primary;+ height: auto;+ }++ .link-white {+ color: white;+ }++ .link-purple {+ color: purple;+ }++ .link-magenta {+ color: magenta;+ }++ .link-green {+ color: green;+ }++ HorizontalGroup {+ height: auto;+ }++ .link-label {+ width: auto;+ }++ .link-url {+ width: auto;+ }++ .link-row {+ width: 100%;+ height: auto;+ }++ #paths-panel {+ color: $text-muted;+ }++ #task-input-container {+ border: solid $accent;+ padding: 1;+ margin-bottom: 1;+ height: auto;+ dock: bottom;+ }++ #task-label {+ color: $accent;+ padding-bottom: 1;+ }++ #task-input {+ width: 100%;+ }+ """++ BINDINGS = [+ Binding('ctrl+c', 'quit', 'Quit', priority=True, show=True),+ Binding('ctrl+q', 'quit', 'Quit', priority=True),+ Binding('ctrl+d', 'quit', 'Quit', priority=True),+ Binding('up', 'input_history_prev', 'Previous command', show=False),+ Binding('down', 'input_history_next', 'Next command', show=False),+ ]++ def __init__(self, config: dict[str, Any], *args, **kwargs):+ super().__init__(*args, **kwargs)+ self.config = config+ self.browser_session: BrowserSession | None = None # Will be set before app.run_async()+ self.controller: Controller | None = None # Will be set before app.run_async()+ self.agent: Agent | None = None+ self.llm: Any | None = None # Will be set before app.run_async()+ self.task_history = config.get('command_history', [])+ # Track current position in history for up/down navigation+ self.history_index = len(self.task_history)+ # Initialize telemetry+ self._telemetry = ProductTelemetry()+ # Store for event bus handler+ self._event_bus_handler_id = None+ self._event_bus_handler_func = None+ # Timer for info panel updates+ self._info_panel_timer = None++ def setup_richlog_logging(self) -> None:+ """Set up logging to redirect to RichLog widget instead of stdout."""+ # Try to add RESULT level if it doesn't exist+ try:+ addLoggingLevel('RESULT', 35)+ except AttributeError:+ pass # Level already exists, which is fine++ # Get the main output RichLog widget+ rich_log = self.query_one('#main-output-log', RichLog)++ # Create and set up the custom handler+ log_handler = RichLogHandler(rich_log)+ log_type = os.getenv('BROWSER_USE_LOGGING_LEVEL', 'result').lower()++ class BrowserUseFormatter(logging.Formatter):+ def format(self, record):+ # if isinstance(record.name, str) and record.name.startswith('browser_use.'):+ # record.name = record.name.split('.')[-2]+ return super().format(record)++ # Set up the formatter based on log type+ if log_type == 'result':+ log_handler.setLevel('RESULT')+ log_handler.setFormatter(BrowserUseFormatter('%(message)s'))+ else:+ log_handler.setFormatter(BrowserUseFormatter('%(levelname)-8s [%(name)s] %(message)s'))++ # Configure root logger - Replace ALL handlers, not just stdout handlers+ root = logging.getLogger()++ # Clear all existing handlers to prevent output to stdout/stderr+ root.handlers = []+ root.addHandler(log_handler)++ # Set log level based on environment variable+ if log_type == 'result':+ root.setLevel('RESULT')+ elif log_type == 'debug':+ root.setLevel(logging.DEBUG)+ else:+ root.setLevel(logging.INFO)++ # Configure browser_use logger and all its sub-loggers+ browser_use_logger = logging.getLogger('browser_use')+ browser_use_logger.propagate = False # Don't propagate to root logger+ browser_use_logger.handlers = [log_handler] # Replace any existing handlers+ browser_use_logger.setLevel(root.level)++ # Also ensure agent loggers go to the main output+ # Use a wildcard pattern to catch all agent-related loggers+ for logger_name in ['browser_use.Agent', 'browser_use.controller', 'browser_use.agent', 'browser_use.agent.service']:+ agent_logger = logging.getLogger(logger_name)+ agent_logger.propagate = False+ agent_logger.handlers = [log_handler]+ agent_logger.setLevel(root.level)++ # Also catch any dynamically created agent loggers with task IDs+ for name, logger in logging.Logger.manager.loggerDict.items():+ if isinstance(name, str) and 'browser_use.Agent' in name:+ if isinstance(logger, logging.Logger):+ logger.propagate = False+ logger.handlers = [log_handler]+ logger.setLevel(root.level)++ # Silence third-party loggers but keep them using our handler+ for logger_name in [+ 'WDM',+ 'httpx',+ 'selenium',+ 'playwright',+ 'urllib3',+ 'asyncio',+ 'openai',+ 'httpcore',+ 'charset_normalizer',+ 'anthropic._base_client',+ 'PIL.PngImagePlugin',+ 'trafilatura.htmlprocessing',+ 'trafilatura',+ 'groq',+ 'portalocker',+ 'portalocker.utils',+ ]:+ third_party = logging.getLogger(logger_name)+ third_party.setLevel(logging.ERROR)+ third_party.propagate = False+ third_party.handlers = [log_handler] # Use our handler to prevent stdout/stderr leakage++ def on_mount(self) -> None:+ """Set up components when app is mounted."""+ # We'll use a file logger since stdout is now controlled by Textual+ logger = logging.getLogger('browser_use.on_mount')+ logger.debug('on_mount() method started')++ # Step 1: Set up custom logging to RichLog+ logger.debug('Setting up RichLog logging...')+ try:+ self.setup_richlog_logging()+ logger.debug('RichLog logging set up successfully')+ except Exception as e:+ logger.error(f'Error setting up RichLog logging: {str(e)}', exc_info=True)+ raise RuntimeError(f'Failed to set up RichLog logging: {str(e)}')++ # Step 2: Set up input history+ logger.debug('Setting up readline history...')+ try:+ if READLINE_AVAILABLE and self.task_history:+ for item in self.task_history:+ readline.add_history(item)+ logger.debug(f'Added {len(self.task_history)} items to readline history')+ else:+ logger.debug('No readline history to set up')+ except Exception as e:+ logger.error(f'Error setting up readline history: {str(e)}', exc_info=False)+ # Non-critical, continue++ # Step 3: Focus the input field+ logger.debug('Focusing input field...')+ try:+ input_field = self.query_one('#task-input', Input)+ input_field.focus()+ logger.debug('Input field focused')+ except Exception as e:+ logger.error(f'Error focusing input field: {str(e)}', exc_info=True)+ # Non-critical, continue++ # Step 5: Setup CDP logger and event bus listener if browser session is available+ logger.debug('Setting up CDP logging and event bus listener...')+ try:+ self.setup_cdp_logger()+ if self.browser_session:+ self.setup_event_bus_listener()+ logger.debug('CDP logging and event bus setup complete')+ except Exception as e:+ logger.error(f'Error setting up CDP logging/event bus: {str(e)}', exc_info=True)+ # Non-critical, continue++ # Capture telemetry for CLI start+ self._telemetry.capture(+ CLITelemetryEvent(+ version=get_browser_use_version(),+ action='start',+ mode='interactive',+ model=self.llm.model if self.llm and hasattr(self.llm, 'model') else None,+ model_provider=self.llm.provider if self.llm and hasattr(self.llm, 'provider') else None,+ )+ )++ logger.debug('on_mount() completed successfully')++ def on_input_key_up(self, event: events.Key) -> None:+ """Handle up arrow key in the input field."""+ # For textual key events, we need to check focus manually+ input_field = self.query_one('#task-input', Input)+ if not input_field.has_focus:+ return++ # Only process if we have history+ if not self.task_history:+ return++ # Move back in history if possible+ if self.history_index > 0:+ self.history_index -= 1+ task_input = self.query_one('#task-input', Input)+ task_input.value = self.task_history[self.history_index]+ # Move cursor to end of text+ task_input.cursor_position = len(task_input.value)++ # Prevent default behavior (cursor movement)+ event.prevent_default()+ event.stop()++ def on_input_key_down(self, event: events.Key) -> None:+ """Handle down arrow key in the input field."""+ # For textual key events, we need to check focus manually+ input_field = self.query_one('#task-input', Input)+ if not input_field.has_focus:+ return++ # Only process if we have history+ if not self.task_history:+ return++ # Move forward in history or clear input if at the end+ if self.history_index < len(self.task_history) - 1:+ self.history_index += 1+ task_input = self.query_one('#task-input', Input)+ task_input.value = self.task_history[self.history_index]+ # Move cursor to end of text+ task_input.cursor_position = len(task_input.value)+ elif self.history_index == len(self.task_history) - 1:+ # At the end of history, go to "new line" state+ self.history_index += 1+ self.query_one('#task-input', Input).value = ''++ # Prevent default behavior (cursor movement)+ event.prevent_default()+ event.stop()++ async def on_key(self, event: events.Key) -> None:+ """Handle key events at the app level to ensure graceful exit."""+ # Handle Ctrl+C, Ctrl+D, and Ctrl+Q for app exit+ if event.key == 'ctrl+c' or event.key == 'ctrl+d' or event.key == 'ctrl+q':+ await self.action_quit()+ event.stop()+ event.prevent_default()++ def on_input_submitted(self, event: Input.Submitted) -> None:+ """Handle task input submission."""+ if event.input.id == 'task-input':+ task = event.input.value+ if not task.strip():+ return++ # Add to history if it's new+ if task.strip() and (not self.task_history or task != self.task_history[-1]):+ self.task_history.append(task)+ self.config['command_history'] = self.task_history+ save_user_config(self.config)++ # Reset history index to point past the end of history+ self.history_index = len(self.task_history)++ # Hide logo, links, and paths panels+ self.hide_intro_panels()++ # Process the task+ self.run_task(task)++ # Clear the input+ event.input.value = ''++ def hide_intro_panels(self) -> None:+ """Hide the intro panels, show info panels and the three-column view."""+ try:+ # Get the panels+ logo_panel = self.query_one('#logo-panel')+ links_panel = self.query_one('#links-panel')+ paths_panel = self.query_one('#paths-panel')+ info_panels = self.query_one('#info-panels')+ three_column = self.query_one('#three-column-container')++ # Hide intro panels if they're visible and show info panels + three-column view+ if logo_panel.display:+ logging.debug('Hiding intro panels and showing info panels + three-column view')++ logo_panel.display = False+ links_panel.display = False+ paths_panel.display = False++ # Show info panels and three-column container+ info_panels.display = True+ three_column.display = True++ # Start updating info panels+ self.update_info_panels()++ logging.debug('Info panels and three-column view should now be visible')+ except Exception as e:+ logging.error(f'Error in hide_intro_panels: {str(e)}')++ def setup_event_bus_listener(self) -> None:+ """Setup listener for browser session event bus."""+ if not self.browser_session or not self.browser_session.event_bus:+ return++ # Clean up any existing handler before registering a new one+ if self._event_bus_handler_func is not None:+ try:+ # Remove handler from the event bus's internal handlers dict+ if hasattr(self.browser_session.event_bus, 'handlers'):+ # Find and remove our handler function from all event patterns+ for event_type, handler_list in list(self.browser_session.event_bus.handlers.items()):+ # Remove our specific handler function object+ if self._event_bus_handler_func in handler_list:+ handler_list.remove(self._event_bus_handler_func)+ logging.debug(f'Removed old handler from event type: {event_type}')+ except Exception as e:+ logging.debug(f'Error cleaning up event bus handler: {e}')+ self._event_bus_handler_func = None+ self._event_bus_handler_id = None++ try:+ # Get the events log widget+ events_log = self.query_one('#events-log', RichLog)+ except Exception:+ # Widget not ready yet+ return++ # Create handler to log all events+ def log_event(event):+ event_name = event.__class__.__name__+ # Format event data nicely+ try:+ if hasattr(event, 'model_dump'):+ event_data = event.model_dump(exclude_unset=True)+ # Remove large fields+ if 'screenshot' in event_data:+ event_data['screenshot'] = '<bytes>'+ if 'dom_state' in event_data:+ event_data['dom_state'] = '<truncated>'+ event_str = str(event_data) if event_data else ''+ else:+ event_str = str(event)++ # Truncate long strings+ if len(event_str) > 200:+ event_str = event_str[:200] + '...'++ events_log.write(f'[yellow]→ {event_name}[/] {event_str}')+ except Exception as e:+ events_log.write(f'[red]→ {event_name}[/] (error formatting: {e})')++ # Store the handler function before registering it+ self._event_bus_handler_func = log_event+ self._event_bus_handler_id = id(log_event)++ # Register wildcard handler for all events+ self.browser_session.event_bus.on('*', log_event)+ logging.debug(f'Registered new event bus handler with id: {self._event_bus_handler_id}')++ def setup_cdp_logger(self) -> None:+ """Setup CDP message logger to capture already-transformed CDP logs."""+ # No need to configure levels - setup_logging() already handles that+ # We just need to capture the transformed logs and route them to the CDP pane++ # Get the CDP log widget+ cdp_log = self.query_one('#cdp-log', RichLog)++ # Create custom handler for CDP logging+ class CDPLogHandler(logging.Handler):+ def __init__(self, rich_log: RichLog):+ super().__init__()+ self.rich_log = rich_log++ def emit(self, record):+ try:+ msg = self.format(record)+ # Truncate very long messages+ if len(msg) > 300:+ msg = msg[:300] + '...'+ # Color code by level+ if record.levelno >= logging.ERROR:+ self.rich_log.write(f'[red]{msg}[/]')+ elif record.levelno >= logging.WARNING:+ self.rich_log.write(f'[yellow]{msg}[/]')+ else:+ self.rich_log.write(f'[cyan]{msg}[/]')+ except Exception:+ self.handleError(record)++ # Setup handler for cdp_use loggers+ cdp_handler = CDPLogHandler(cdp_log)+ cdp_handler.setFormatter(logging.Formatter('%(message)s'))+ cdp_handler.setLevel(logging.DEBUG)++ # Route CDP logs to the CDP pane+ # These are already transformed by cdp_use and at the right level from setup_logging+ for logger_name in ['websockets.client', 'cdp_use', 'cdp_use.client', 'cdp_use.cdp', 'cdp_use.cdp.registry']:+ logger = logging.getLogger(logger_name)+ # Add our handler (don't replace - keep existing console handler too)+ if cdp_handler not in logger.handlers:+ logger.addHandler(cdp_handler)++ def scroll_to_input(self) -> None:+ """Scroll to the input field to ensure it's visible."""+ input_container = self.query_one('#task-input-container')+ input_container.scroll_visible()++ def run_task(self, task: str) -> None:+ """Launch the task in a background worker."""+ # Create or update the agent+ agent_settings = AgentSettings.model_validate(self.config.get('agent', {}))++ # Get the logger+ logger = logging.getLogger('browser_use.app')++ # Make sure intro is hidden and log is ready+ self.hide_intro_panels()++ # Clear the main output log to start fresh+ rich_log = self.query_one('#main-output-log', RichLog)+ rich_log.clear()++ if self.agent is None:+ if not self.llm:+ raise RuntimeError('LLM not initialized')+ self.agent = Agent(+ task=task,+ llm=self.llm,+ controller=self.controller if self.controller else Controller(),+ browser_session=self.browser_session,+ source='cli',+ **agent_settings.model_dump(),+ )+ # Update our browser_session reference to point to the agent's+ if hasattr(self.agent, 'browser_session'):+ self.browser_session = self.agent.browser_session+ # Set up event bus listener (will clean up any old handler first)+ self.setup_event_bus_listener()+ else:+ self.agent.add_new_task(task)++ # Let the agent run in the background+ async def agent_task_worker() -> None:+ logger.debug('\n🚀 Working on task: %s', task)++ # Set flags to indicate the agent is running+ if self.agent:+ self.agent.running = True # type: ignore+ self.agent.last_response_time = 0 # type: ignore++ # Panel updates are already happening via the timer in update_info_panels++ task_start_time = time.time()+ error_msg = None++ try:+ # Capture telemetry for message sent+ self._telemetry.capture(+ CLITelemetryEvent(+ version=get_browser_use_version(),+ action='message_sent',+ mode='interactive',+ model=self.llm.model if self.llm and hasattr(self.llm, 'model') else None,+ model_provider=self.llm.provider if self.llm and hasattr(self.llm, 'provider') else None,+ )+ )++ # Run the agent task, redirecting output to RichLog through our handler+ if self.agent:+ await self.agent.run()+ except Exception as e:+ error_msg = str(e)+ logger.error('\nError running agent: %s', str(e))+ finally:+ # Clear the running flag+ if self.agent:+ self.agent.running = False # type: ignore++ # Capture telemetry for task completion+ duration = time.time() - task_start_time+ self._telemetry.capture(+ CLITelemetryEvent(+ version=get_browser_use_version(),+ action='task_completed' if error_msg is None else 'error',+ mode='interactive',+ model=self.llm.model if self.llm and hasattr(self.llm, 'model') else None,+ model_provider=self.llm.provider if self.llm and hasattr(self.llm, 'provider') else None,+ duration_seconds=duration,+ error_message=error_msg,+ )+ )++ logger.debug('\n✅ Task completed!')++ # Make sure the task input container is visible+ task_input_container = self.query_one('#task-input-container')+ task_input_container.display = True++ # Refocus the input field+ input_field = self.query_one('#task-input', Input)+ input_field.focus()++ # Ensure the input is visible by scrolling to it+ self.call_after_refresh(self.scroll_to_input)++ # Run the worker+ self.run_worker(agent_task_worker, name='agent_task')++ def action_input_history_prev(self) -> None:+ """Navigate to the previous item in command history."""+ # Only process if we have history and input is focused+ input_field = self.query_one('#task-input', Input)+ if not input_field.has_focus or not self.task_history:+ return++ # Move back in history if possible+ if self.history_index > 0:+ self.history_index -= 1+ input_field.value = self.task_history[self.history_index]+ # Move cursor to end of text+ input_field.cursor_position = len(input_field.value)++ def action_input_history_next(self) -> None:+ """Navigate to the next item in command history or clear input."""+ # Only process if we have history and input is focused+ input_field = self.query_one('#task-input', Input)+ if not input_field.has_focus or not self.task_history:+ return++ # Move forward in history or clear input if at the end+ if self.history_index < len(self.task_history) - 1:+ self.history_index += 1+ input_field.value = self.task_history[self.history_index]+ # Move cursor to end of text+ input_field.cursor_position = len(input_field.value)+ elif self.history_index == len(self.task_history) - 1:+ # At the end of history, go to "new line" state+ self.history_index += 1+ input_field.value = ''++ async def action_quit(self) -> None:+ """Quit the application and clean up resources."""+ # Note: We don't need to close the browser session here because:+ # 1. If an agent exists, it already called browser_session.stop() in its run() method+ # 2. If keep_alive=True (default), we want to leave the browser running anyway+ # This prevents the duplicate "stop() called" messages in the logs++ # Flush telemetry before exiting+ self._telemetry.flush()++ # Exit the application+ self.exit()+ print('\nTry running tasks on our cloud: https://browser-use.com')++ def compose(self) -> ComposeResult:+ """Create the UI layout."""+ yield Header()++ # Main container for app content+ with Container(id='main-container'):+ # Logo panel+ yield Static(BROWSER_LOGO, id='logo-panel', markup=True)++ # Links panel with URLs+ with Container(id='links-panel'):+ with HorizontalGroup(classes='link-row'):+ yield Static('Run at scale on cloud: [blink]☁️[/] ', markup=True, classes='link-label')+ yield Link('https://browser-use.com', url='https://browser-use.com', classes='link-white link-url')++ yield Static('') # Empty line++ with HorizontalGroup(classes='link-row'):+ yield Static('Chat & share on Discord: 🚀 ', markup=True, classes='link-label')+ yield Link(+ 'https://discord.gg/ESAUZAdxXY', url='https://discord.gg/ESAUZAdxXY', classes='link-purple link-url'+ )++ with HorizontalGroup(classes='link-row'):+ yield Static('Get prompt inspiration: 🦸 ', markup=True, classes='link-label')+ yield Link(+ 'https://github.com/browser-use/awesome-prompts',+ url='https://github.com/browser-use/awesome-prompts',+ classes='link-magenta link-url',+ )++ with HorizontalGroup(classes='link-row'):+ yield Static('[dim]Report any issues:[/] 🐛 ', markup=True, classes='link-label')+ yield Link(+ 'https://github.com/browser-use/browser-use/issues',+ url='https://github.com/browser-use/browser-use/issues',+ classes='link-green link-url',+ )++ # Paths panel+ yield Static(+ f' ⚙️ Settings saved to: {str(CONFIG.BROWSER_USE_CONFIG_FILE.resolve()).replace(str(Path.home()), "~")}\n'+ f' 📁 Outputs & recordings saved to: {str(Path(".").resolve()).replace(str(Path.home()), "~")}',+ id='paths-panel',+ markup=True,+ )++ # Info panels (hidden by default, shown when task starts)+ with Container(id='info-panels'):+ # Top row with browser and model panels side by side+ with Container(id='top-panels'):+ # Browser panel+ with Container(id='browser-panel'):+ yield RichLog(id='browser-info', markup=True, highlight=True, wrap=True)++ # Model panel+ with Container(id='model-panel'):+ yield RichLog(id='model-info', markup=True, highlight=True, wrap=True)++ # Tasks panel (full width, below browser and model)+ with VerticalScroll(id='tasks-panel'):+ yield RichLog(id='tasks-info', markup=True, highlight=True, wrap=True, auto_scroll=True)++ # Three-column container (hidden by default)+ with Container(id='three-column-container'):+ # Column 1: Main output+ with VerticalScroll(id='main-output-column'):+ yield RichLog(highlight=True, markup=True, id='main-output-log', wrap=True, auto_scroll=True)++ # Column 2: Event bus events+ with VerticalScroll(id='events-column'):+ yield RichLog(highlight=True, markup=True, id='events-log', wrap=True, auto_scroll=True)++ # Column 3: CDP messages+ with VerticalScroll(id='cdp-column'):+ yield RichLog(highlight=True, markup=True, id='cdp-log', wrap=True, auto_scroll=True)++ # Task input container (now at the bottom)+ with Container(id='task-input-container'):+ yield Label('🔍 What would you like me to do on the web?', id='task-label')+ yield Input(placeholder='Enter your task...', id='task-input')++ yield Footer()++ def update_info_panels(self) -> None:+ """Update all information panels with current state."""+ try:+ # Update actual content+ self.update_browser_panel()+ self.update_model_panel()+ self.update_tasks_panel()+ except Exception as e:+ logging.error(f'Error in update_info_panels: {str(e)}')+ finally:+ # Always schedule the next update - will update at 1-second intervals+ # This ensures continuous updates even if agent state changes+ self.set_timer(1.0, self.update_info_panels)++ def update_browser_panel(self) -> None:+ """Update browser information panel with details about the browser."""+ browser_info = self.query_one('#browser-info', RichLog)+ browser_info.clear()++ # Try to use the agent's browser session if available+ browser_session = self.browser_session+ if hasattr(self, 'agent') and self.agent and hasattr(self.agent, 'browser_session'):+ browser_session = self.agent.browser_session++ if browser_session:+ try:+ # Check if browser session has a CDP client+ if not hasattr(browser_session, 'cdp_client') or browser_session.cdp_client is None:+ browser_info.write('[yellow]Browser session created, waiting for browser to launch...[/]')+ return++ # Update our reference if we're using the agent's session+ if browser_session != self.browser_session:+ self.browser_session = browser_session++ # Get basic browser info from browser_profile+ browser_type = 'Chromium'+ headless = browser_session.browser_profile.headless++ # Determine connection type based on config+ connection_type = 'playwright' # Default+ if browser_session.cdp_url:+ connection_type = 'CDP'+ elif browser_session.browser_profile.executable_path:+ connection_type = 'user-provided'++ # Get window size details from browser_profile+ window_width = None+ window_height = None+ if browser_session.browser_profile.viewport:+ window_width = browser_session.browser_profile.viewport.width+ window_height = browser_session.browser_profile.viewport.height++ # Try to get browser PID+ browser_pid = 'Unknown'+ connected = False+ browser_status = '[red]Disconnected[/]'++ try:+ # Check if browser PID is available+ # Check if we have a CDP client+ if browser_session.cdp_client is not None:+ connected = True+ browser_status = '[green]Connected[/]'+ browser_pid = 'N/A'+ except Exception as e:+ browser_pid = f'Error: {str(e)}'++ # Display browser information+ browser_info.write(f'[bold cyan]Chromium[/] Browser ({browser_status})')+ browser_info.write(+ f'Type: [yellow]{connection_type}[/] [{"green" if not headless else "red"}]{" (headless)" if headless else ""}[/]'+ )+ browser_info.write(f'PID: [dim]{browser_pid}[/]')+ browser_info.write(f'CDP Port: {browser_session.cdp_url}')++ if window_width and window_height:+ browser_info.write(f'Window: [blue]{window_width}[/] × [blue]{window_height}[/]')++ # Include additional information about the browser if needed+ if connected and hasattr(self, 'agent') and self.agent:+ try:+ # Show when the browser was connected+ timestamp = int(time.time())+ current_time = time.strftime('%H:%M:%S', time.localtime(timestamp))+ browser_info.write(f'Last updated: [dim]{current_time}[/]')+ except Exception:+ pass++ # Show the agent's current page URL if available+ if browser_session.agent_focus:+ current_url = (+ browser_session.agent_focus.url.replace('https://', '')+ .replace('http://', '')+ .replace('www.', '')[:36]+ + '…'+ )+ browser_info.write(f'👁️ [green]{current_url}[/]')+ except Exception as e:+ browser_info.write(f'[red]Error updating browser info: {str(e)}[/]')+ else:+ browser_info.write('[red]Browser not initialized[/]')++ def update_model_panel(self) -> None:+ """Update model information panel with details about the LLM."""+ model_info = self.query_one('#model-info', RichLog)+ model_info.clear()++ if self.llm:+ # Get model details+ model_name = 'Unknown'+ if hasattr(self.llm, 'model_name'):+ model_name = self.llm.model_name+ elif hasattr(self.llm, 'model'):+ model_name = self.llm.model++ # Show model name+ if self.agent:+ temp_str = f'{self.llm.temperature}ºC ' if self.llm.temperature else ''+ vision_str = '+ vision ' if self.agent.settings.use_vision else ''+ model_info.write(+ f'[white]LLM:[/] [blue]{self.llm.__class__.__name__} [yellow]{model_name}[/] {temp_str}{vision_str}'+ )+ else:+ model_info.write(f'[white]LLM:[/] [blue]{self.llm.__class__.__name__} [yellow]{model_name}[/]')++ # Show token usage statistics if agent exists and has history+ if self.agent and hasattr(self.agent, 'state') and hasattr(self.agent.state, 'history'):+ # Calculate tokens per step+ num_steps = len(self.agent.history.history)++ # Get the last step metadata to show the most recent LLM response time+ if num_steps > 0 and self.agent.history.history[-1].metadata:+ last_step = self.agent.history.history[-1]+ if last_step.metadata:+ step_duration = last_step.metadata.duration_seconds+ else:+ step_duration = 0++ # Show total duration+ total_duration = self.agent.history.total_duration_seconds()+ if total_duration > 0:+ model_info.write(f'[white]Total Duration:[/] [magenta]{total_duration:.2f}s[/]')++ # Calculate response time metrics+ model_info.write(f'[white]Last Step Duration:[/] [magenta]{step_duration:.2f}s[/]')++ # Add current state information+ if hasattr(self.agent, 'running'):+ if getattr(self.agent, 'running', False):+ model_info.write('[yellow]LLM is thinking[blink]...[/][/]')+ elif hasattr(self.agent, 'state') and hasattr(self.agent.state, 'paused') and self.agent.state.paused:+ model_info.write('[orange]LLM paused[/]')+ else:+ model_info.write('[red]Model not initialized[/]')++ def update_tasks_panel(self) -> None:+ """Update tasks information panel with details about the tasks and steps hierarchy."""+ tasks_info = self.query_one('#tasks-info', RichLog)+ tasks_info.clear()++ if self.agent:+ # Check if agent has tasks+ task_history = []+ message_history = []++ # Try to extract tasks by looking at message history+ if hasattr(self.agent, '_message_manager') and self.agent._message_manager:+ message_history = self.agent._message_manager.state.history.get_messages()++ # Extract original task(s)+ original_tasks = []+ for msg in message_history:+ if hasattr(msg, 'content'):+ content = msg.content+ if isinstance(content, str) and 'Your ultimate task is:' in content:+ task_text = content.split('"""')[1].strip()+ original_tasks.append(task_text)++ if original_tasks:+ tasks_info.write('[bold green]TASK:[/]')+ for i, task in enumerate(original_tasks, 1):+ # Only show latest task if multiple task changes occurred+ if i == len(original_tasks):+ tasks_info.write(f'[white]{task}[/]')+ tasks_info.write('')++ # Get current state information+ current_step = self.agent.state.n_steps if hasattr(self.agent, 'state') else 0++ # Get all agent history items+ history_items = []+ if hasattr(self.agent, 'state') and hasattr(self.agent.state, 'history'):+ history_items = self.agent.history.history++ if history_items:+ tasks_info.write('[bold yellow]STEPS:[/]')++ for idx, item in enumerate(history_items, 1):+ # Determine step status+ step_style = '[green]✓[/]'++ # For the current step, show it as in progress+ if idx == current_step:+ step_style = '[yellow]⟳[/]'++ # Check if this step had an error+ if item.result and any(result.error for result in item.result):+ step_style = '[red]✗[/]'++ # Show step number+ tasks_info.write(f'{step_style} Step {idx}/{current_step}')++ # Show goal if available+ if item.model_output and hasattr(item.model_output, 'current_state'):+ # Show goal for this step+ goal = item.model_output.current_state.next_goal+ if goal:+ # Take just the first line for display+ goal_lines = goal.strip().split('\n')+ goal_summary = goal_lines[0]+ tasks_info.write(f' [cyan]Goal:[/] {goal_summary}')++ # Show evaluation of previous goal (feedback)+ eval_prev = item.model_output.current_state.evaluation_previous_goal+ if eval_prev and idx > 1: # Only show for steps after the first+ eval_lines = eval_prev.strip().split('\n')+ eval_summary = eval_lines[0]+ eval_summary = eval_summary.replace('Success', '✅ ').replace('Failed', '❌ ').strip()+ tasks_info.write(f' [tan]Evaluation:[/] {eval_summary}')++ # Show actions taken in this step+ if item.model_output and item.model_output.action:+ tasks_info.write(' [purple]Actions:[/]')+ for action_idx, action in enumerate(item.model_output.action, 1):+ action_type = action.__class__.__name__+ if hasattr(action, 'model_dump'):+ # For proper actions, show the action type+ action_dict = action.model_dump(exclude_unset=True)+ if action_dict:+ action_name = list(action_dict.keys())[0]+ tasks_info.write(f' {action_idx}. [blue]{action_name}[/]')++ # Show results or errors from this step+ if item.result:+ for result in item.result:+ if result.error:+ error_text = result.error+ tasks_info.write(f' [red]Error:[/] {error_text}')+ elif result.extracted_content:+ content = result.extracted_content+ tasks_info.write(f' [green]Result:[/] {content}')++ # Add a space between steps for readability+ tasks_info.write('')++ # If agent is actively running, show a status indicator+ if hasattr(self.agent, 'running') and getattr(self.agent, 'running', False):+ tasks_info.write('[yellow]Agent is actively working[blink]...[/][/]')+ elif hasattr(self.agent, 'state') and hasattr(self.agent.state, 'paused') and self.agent.state.paused:+ tasks_info.write('[orange]Agent is paused (press Enter to resume)[/]')+ else:+ tasks_info.write('[dim]Agent not initialized[/]')++ # Force scroll to bottom+ tasks_panel = self.query_one('#tasks-panel')+ tasks_panel.scroll_end(animate=False)+++async def run_prompt_mode(prompt: str, ctx: click.Context, debug: bool = False):+ """Run browser-use in non-interactive mode with a single prompt."""+ # Import and call setup_logging to ensure proper initialization+ from browser_use.logging_config import setup_logging++ # Set up logging to only show results by default+ os.environ['BROWSER_USE_LOGGING_LEVEL'] = 'result'++ # Re-run setup_logging to apply the new log level+ setup_logging()++ # The logging is now properly configured by setup_logging()+ # No need to manually configure handlers since setup_logging() handles it++ # Initialize telemetry+ telemetry = ProductTelemetry()+ start_time = time.time()+ error_msg = None++ try:+ # Load config+ config = load_user_config()+ config = update_config_with_click_args(config, ctx)++ # Get LLM+ llm = get_llm(config)++ # Capture telemetry for CLI start in oneshot mode+ telemetry.capture(+ CLITelemetryEvent(+ version=get_browser_use_version(),+ action='start',+ mode='oneshot',+ model=llm.model if hasattr(llm, 'model') else None,+ model_provider=llm.__class__.__name__ if llm else None,+ )+ )++ # Get agent settings from config+ agent_settings = AgentSettings.model_validate(config.get('agent', {}))++ # Create browser session with config parameters+ browser_config = config.get('browser', {})+ # Remove None values from browser_config+ browser_config = {k: v for k, v in browser_config.items() if v is not None}+ # Create BrowserProfile with user_data_dir+ profile = BrowserProfile(user_data_dir=str(USER_DATA_DIR), **browser_config)+ browser_session = BrowserSession(+ browser_profile=profile,+ )++ # Create and run agent+ agent = Agent(+ task=prompt,+ llm=llm,+ browser_session=browser_session,+ source='cli',+ **agent_settings.model_dump(),+ )++ await agent.run()++ # Ensure the browser session is fully stopped+ # The agent's close() method only kills the browser if keep_alive=False,+ # but we need to ensure all background tasks are stopped regardless+ if browser_session:+ try:+ # Kill the browser session to stop all background tasks+ await browser_session.kill()+ except Exception:+ # Ignore errors during cleanup+ pass++ # Capture telemetry for successful completion+ telemetry.capture(+ CLITelemetryEvent(+ version=get_browser_use_version(),+ action='task_completed',+ mode='oneshot',+ model=llm.model if hasattr(llm, 'model') else None,+ model_provider=llm.__class__.__name__ if llm else None,+ duration_seconds=time.time() - start_time,+ )+ )++ except Exception as e:+ error_msg = str(e)+ # Capture telemetry for error+ telemetry.capture(+ CLITelemetryEvent(+ version=get_browser_use_version(),+ action='error',+ mode='oneshot',+ model=llm.model if hasattr(llm, 'model') else None,+ model_provider=llm.__class__.__name__ if llm and 'llm' in locals() else None,+ duration_seconds=time.time() - start_time,+ error_message=error_msg,+ )+ )+ if debug:+ import traceback++ traceback.print_exc()+ else:+ print(f'Error: {str(e)}', file=sys.stderr)+ sys.exit(1)+ finally:+ # Ensure telemetry is flushed+ telemetry.flush()++ # Give a brief moment for cleanup to complete+ await asyncio.sleep(0.1)++ # Cancel any remaining tasks to ensure clean exit+ tasks = [t for t in asyncio.all_tasks() if t != asyncio.current_task()]+ for task in tasks:+ task.cancel()++ # Wait for all tasks to be cancelled+ if tasks:+ await asyncio.gather(*tasks, return_exceptions=True)+++async def textual_interface(config: dict[str, Any]):+ """Run the Textual interface."""+ # Prevent browser_use from setting up logging at import time+ os.environ['BROWSER_USE_SETUP_LOGGING'] = 'false'++ logger = logging.getLogger('browser_use.startup')++ # Set up logging for Textual UI - prevent any logging to stdout+ def setup_textual_logging():+ # Replace all handlers with null handler+ root_logger = logging.getLogger()+ for handler in root_logger.handlers:+ root_logger.removeHandler(handler)++ # Add null handler to ensure no output to stdout/stderr+ null_handler = logging.NullHandler()+ root_logger.addHandler(null_handler)+ logger.debug('Logging configured for Textual UI')++ logger.debug('Setting up Browser, Controller, and LLM...')++ # Step 1: Initialize BrowserSession with config+ logger.debug('Initializing BrowserSession...')+ try:+ # Get browser config from the config dict+ browser_config = config.get('browser', {})++ logger.info('Browser type: chromium') # BrowserSession only supports chromium+ if browser_config.get('executable_path'):+ logger.info(f'Browser binary: {browser_config["executable_path"]}')+ if browser_config.get('headless'):+ logger.info('Browser mode: headless')+ else:+ logger.info('Browser mode: visible')++ # Create BrowserSession directly with config parameters+ # Remove None values from browser_config+ browser_config = {k: v for k, v in browser_config.items() if v is not None}+ # Create BrowserProfile with user_data_dir+ profile = BrowserProfile(user_data_dir=str(USER_DATA_DIR), **browser_config)+ browser_session = BrowserSession(+ browser_profile=profile,+ )+ logger.debug('BrowserSession initialized successfully')++ # Set up FIFO logging pipes for streaming logs to UI+ try:+ from browser_use.logging_config import setup_log_pipes++ setup_log_pipes(session_id=browser_session.id)+ logger.debug(f'FIFO logging pipes set up for session {browser_session.id[-4:]}')+ except Exception as e:+ logger.debug(f'Could not set up FIFO logging pipes: {e}')++ # Browser version logging not available with CDP implementation+ except Exception as e:+ logger.error(f'Error initializing BrowserSession: {str(e)}', exc_info=True)+ raise RuntimeError(f'Failed to initialize BrowserSession: {str(e)}')++ # Step 3: Initialize Controller+ logger.debug('Initializing Controller...')+ try:+ controller = Controller()+ logger.debug('Controller initialized successfully')+ except Exception as e:+ logger.error(f'Error initializing Controller: {str(e)}', exc_info=True)+ raise RuntimeError(f'Failed to initialize Controller: {str(e)}')++ # Step 4: Get LLM+ logger.debug('Getting LLM...')+ try:+ # Ensure setup_logging is not called when importing modules+ os.environ['BROWSER_USE_SETUP_LOGGING'] = 'false'+ llm = get_llm(config)+ # Log LLM details+ model_name = getattr(llm, 'model_name', None) or getattr(llm, 'model', 'Unknown model')+ provider = llm.__class__.__name__+ temperature = getattr(llm, 'temperature', 0.0)+ logger.info(f'LLM: {provider} ({model_name}), temperature: {temperature}')+ logger.debug(f'LLM initialized successfully: {provider}')+ except Exception as e:+ logger.error(f'Error getting LLM: {str(e)}', exc_info=True)+ raise RuntimeError(f'Failed to initialize LLM: {str(e)}')++ logger.debug('Initializing BrowserUseApp instance...')+ try:+ app = BrowserUseApp(config)+ # Pass the initialized components to the app+ app.browser_session = browser_session+ app.controller = controller+ app.llm = llm++ # Set up event bus listener now that browser session is available+ # Note: This needs to be called before run_async() but after browser_session is set+ # We'll defer this to on_mount() since it needs the widgets to be available++ # Configure logging for Textual UI before going fullscreen+ setup_textual_logging()++ # Log browser and model configuration that will be used+ browser_type = 'Chromium' # BrowserSession only supports Chromium+ model_name = config.get('model', {}).get('name', 'auto-detected')+ headless = config.get('browser', {}).get('headless', False)+ headless_str = 'headless' if headless else 'visible'++ logger.info(f'Preparing {browser_type} browser ({headless_str}) with {model_name} LLM')++ logger.debug('Starting Textual app with run_async()...')+ # No more logging after this point as we're in fullscreen mode+ await app.run_async()+ except Exception as e:+ logger.error(f'Error in textual_interface: {str(e)}', exc_info=True)+ # Note: We don't close the browser session here to avoid duplicate stop() calls+ # The browser session will be cleaned up by its __del__ method if needed+ raise++[email protected]('--version', is_flag=True, help='Print version and exit')[email protected]('--model', type=str, help='Model to use (e.g., gpt-5-mini, claude-4-sonnet, gemini-2.5-flash)')[email protected]('--debug', is_flag=True, help='Enable verbose startup logging')[email protected]('--headless', is_flag=True, help='Run browser in headless mode', default=None)[email protected]('--window-width', type=int, help='Browser window width')[email protected]('--window-height', type=int, help='Browser window height')+ '--user-data-dir', type=str, help='Path to Chrome user data directory (e.g. ~/Library/Application Support/Google/Chrome)'+)[email protected]('--profile-directory', type=str, help='Chrome profile directory name (e.g. "Default", "Profile 1")')[email protected]('--cdp-url', type=str, help='Connect to existing Chrome via CDP URL (e.g. http://localhost:9222)')[email protected]('--proxy-url', type=str, help='Proxy server for Chromium traffic (e.g. http://host:8080 or socks5://host:1080)')[email protected]('--no-proxy', type=str, help='Comma-separated hosts to bypass proxy (e.g. localhost,127.0.0.1,*.internal)')[email protected]('--proxy-username', type=str, help='Proxy auth username')[email protected]('--proxy-password', type=str, help='Proxy auth password')[email protected]('-p', '--prompt', type=str, help='Run a single task without the TUI (headless mode)')[email protected]('--mcp', is_flag=True, help='Run as MCP server (exposes JSON RPC via stdin/stdout)')[email protected]_context+def main(ctx: click.Context, debug: bool = False, **kwargs):+ """Browser-Use Interactive TUI or Command Line Executor++ Use --user-data-dir to specify a local Chrome profile directory.+ Common Chrome profile locations:+ macOS: ~/Library/Application Support/Google/Chrome+ Linux: ~/.config/google-chrome+ Windows: %LOCALAPPDATA%\\Google\\Chrome\\User Data++ Use --profile-directory to specify which profile within the user data directory.+ Examples: "Default", "Profile 1", "Profile 2", etc.+ """++ if kwargs['version']:+ from importlib.metadata import version++ print(version('browser-use'))+ sys.exit(0)++ # 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',+ )+ )+ # Run as MCP server+ from browser_use.mcp.server import main as mcp_main++ asyncio.run(mcp_main())+ return++ # Check if prompt mode is activated+ if kwargs.get('prompt'):+ # Set environment variable for prompt mode before running+ os.environ['BROWSER_USE_LOGGING_LEVEL'] = 'result'+ # Run in non-interactive mode+ asyncio.run(run_prompt_mode(kwargs['prompt'], ctx, debug))+ return++ # Configure console logging+ console_handler = logging.StreamHandler(sys.stdout)+ console_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s', '%H:%M:%S'))++ # Configure root logger+ root_logger = logging.getLogger()+ root_logger.setLevel(logging.INFO if not debug else logging.DEBUG)+ root_logger.addHandler(console_handler)++ logger = logging.getLogger('browser_use.startup')+ logger.info('Starting Browser-Use initialization')+ if debug:+ logger.debug(f'System info: Python {sys.version.split()[0]}, Platform: {sys.platform}')++ logger.debug('Loading environment variables from .env file...')+ load_dotenv()+ logger.debug('Environment variables loaded')++ # Load user configuration+ logger.debug('Loading user configuration...')+ try:+ config = load_user_config()+ logger.debug(f'User configuration loaded from {CONFIG.BROWSER_USE_CONFIG_FILE}')+ except Exception as e:+ logger.error(f'Error loading user configuration: {str(e)}', exc_info=True)+ print(f'Error loading configuration: {str(e)}')+ sys.exit(1)++ # Update config with command-line arguments+ logger.debug('Updating configuration with command line arguments...')+ try:+ config = update_config_with_click_args(config, ctx)+ logger.debug('Configuration updated')+ except Exception as e:+ logger.error(f'Error updating config with command line args: {str(e)}', exc_info=True)+ print(f'Error updating configuration: {str(e)}')+ sys.exit(1)++ # Save updated config+ logger.debug('Saving user configuration...')+ try:+ save_user_config(config)+ logger.debug('Configuration saved')+ except Exception as e:+ logger.error(f'Error saving user configuration: {str(e)}', exc_info=True)+ print(f'Error saving configuration: {str(e)}')+ sys.exit(1)++ # Setup handlers for console output before entering Textual UI+ logger.debug('Setting up handlers for Textual UI...')++ # Log browser and model configuration that will be used+ browser_type = 'Chromium' # BrowserSession only supports Chromium+ model_name = config.get('model', {}).get('name', 'auto-detected')+ headless = config.get('browser', {}).get('headless', False)+ headless_str = 'headless' if headless else 'visible'++ logger.info(f'Preparing {browser_type} browser ({headless_str}) with {model_name} LLM')++ try:+ # Run the Textual UI interface - now all the initialization happens before we go fullscreen+ logger.debug('Starting Textual UI interface...')+ asyncio.run(textual_interface(config))+ except Exception as e:+ # Restore console logging for error reporting+ root_logger.setLevel(logging.INFO)+ for handler in root_logger.handlers:+ root_logger.removeHandler(handler)+ root_logger.addHandler(console_handler)++ logger.error(f'Error initializing Browser-Use: {str(e)}', exc_info=debug)+ print(f'\nError launching Browser-Use: {str(e)}')+ if debug:+ import traceback++ traceback.print_exc()+ sys.exit(1)+++if __name__ == '__main__':+ main()