Skip to content

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

refactor(cli): move CDP logic into CLI, remove events and watchdogs

ShawnPanaa96102167063
diff --git a/browser_use/browser/events.py b/browser_use/browser/events.py
index b3cd3b909..4c40cb428 100644
--- a/browser_use/browser/events.py
+++ b/browser_use/browser/events.py
@@ -471,146 +471,6 @@ class BrowserErrorEvent(BaseEvent):
event_timeout: float | None = Field(default_factory=lambda: _get_timeout('TIMEOUT_BrowserErrorEvent', 30.0)) # seconds
-# ============================================================================
-# Cookie Events
-# ============================================================================
-
-
-class GetCookiesEvent(BaseEvent[list[dict]]):
- """Get browser cookies."""
-
- url: str | None = None # Optional: filter by URL
-
- event_timeout: float | None = Field(default_factory=lambda: _get_timeout('TIMEOUT_GetCookiesEvent', 15.0))
-
-
-class SetCookieEvent(BaseEvent[bool]):
- """Set a browser cookie."""
-
- name: str
- value: str
- domain: str | None = None
- path: str = '/'
- secure: bool = False
- http_only: bool = False
- same_site: Literal['Strict', 'Lax', 'None'] | None = None
- expires: float | None = None # Unix timestamp
-
- event_timeout: float | None = Field(default_factory=lambda: _get_timeout('TIMEOUT_SetCookieEvent', 15.0))
-
-
-class ClearCookiesEvent(BaseEvent[None]):
- """Clear browser cookies."""
-
- url: str | None = None # Optional: clear only cookies for this URL
-
- event_timeout: float | None = Field(default_factory=lambda: _get_timeout('TIMEOUT_ClearCookiesEvent', 15.0))
-
-
-# ============================================================================
-# Wait Events
-# ============================================================================
-
-
-class WaitForSelectorEvent(BaseEvent[bool]):
- """Wait for a CSS selector to appear on the page."""
-
- selector: str
- timeout_ms: int = 30000
- state: Literal['attached', 'detached', 'visible', 'hidden'] = 'visible'
-
- event_timeout: float | None = Field(default_factory=lambda: _get_timeout('TIMEOUT_WaitForSelectorEvent', 60.0))
-
-
-class WaitForTextEvent(BaseEvent[bool]):
- """Wait for text to appear on the page."""
-
- text: str
- timeout_ms: int = 30000
-
- event_timeout: float | None = Field(default_factory=lambda: _get_timeout('TIMEOUT_WaitForTextEvent', 60.0))
-
-
-# ============================================================================
-# Interaction Events
-# ============================================================================
-
-
-class HoverElementEvent(ElementSelectedEvent[None]):
- """Hover over an element."""
-
- node: 'EnhancedDOMTreeNode'
-
- event_timeout: float | None = Field(default_factory=lambda: _get_timeout('TIMEOUT_HoverElementEvent', 15.0))
-
-
-class ElementDblClickEvent(ElementSelectedEvent[None]):
- """Double-click an element."""
-
- node: 'EnhancedDOMTreeNode'
-
- event_timeout: float | None = Field(default_factory=lambda: _get_timeout('TIMEOUT_ElementDblClickEvent', 15.0))
-
-
-class ElementRightClickEvent(ElementSelectedEvent[None]):
- """Right-click (context menu) an element."""
-
- node: 'EnhancedDOMTreeNode'
-
- event_timeout: float | None = Field(default_factory=lambda: _get_timeout('TIMEOUT_ElementRightClickEvent', 15.0))
-
-
-# ============================================================================
-# Information Retrieval Events
-# ============================================================================
-
-
-class GetPageTitleEvent(BaseEvent[str]):
- """Get the page title."""
-
- event_timeout: float | None = Field(default_factory=lambda: _get_timeout('TIMEOUT_GetPageTitleEvent', 15.0))
-
-
-class GetPageHtmlEvent(BaseEvent[str]):
- """Get page HTML, optionally scoped to a selector."""
-
- selector: str | None = None # None = full document
-
- event_timeout: float | None = Field(default_factory=lambda: _get_timeout('TIMEOUT_GetPageHtmlEvent', 15.0))
-
-
-class GetElementTextEvent(ElementSelectedEvent[str]):
- """Get text content of an element."""
-
- node: 'EnhancedDOMTreeNode'
-
- event_timeout: float | None = Field(default_factory=lambda: _get_timeout('TIMEOUT_GetElementTextEvent', 15.0))
-
-
-class GetElementValueEvent(ElementSelectedEvent[str]):
- """Get value of an input/textarea element. Returns empty string if not found."""
-
- node: 'EnhancedDOMTreeNode'
-
- event_timeout: float | None = Field(default_factory=lambda: _get_timeout('TIMEOUT_GetElementValueEvent', 15.0))
-
-
-class GetElementAttributesEvent(ElementSelectedEvent[dict[str, str]]):
- """Get all attributes of an element."""
-
- node: 'EnhancedDOMTreeNode'
-
- event_timeout: float | None = Field(default_factory=lambda: _get_timeout('TIMEOUT_GetElementAttributesEvent', 15.0))
-
-
-class GetElementBoundingBoxEvent(ElementSelectedEvent[dict]):
- """Get bounding box of an element (x, y, width, height). Returns empty dict if not found."""
-
- node: 'EnhancedDOMTreeNode'
-
- event_timeout: float | None = Field(default_factory=lambda: _get_timeout('TIMEOUT_GetElementBoundingBoxEvent', 15.0))
-
-
# ============================================================================
# Storage State Events
# ============================================================================
diff --git a/browser_use/browser/session.py b/browser_use/browser/session.py
index ee7534ce0..7977cf517 100644
--- a/browser_use/browser/session.py
+++ b/browser_use/browser/session.py
@@ -1480,27 +1480,6 @@ class BrowserSession(BaseModel):
self._recording_watchdog = RecordingWatchdog(event_bus=self.event_bus, browser_session=self)
self._recording_watchdog.attach_to_session()
- # Initialize CookiesWatchdog (handles cookie get/set/clear operations)
- from browser_use.browser.watchdogs.cookies_watchdog import CookiesWatchdog
-
- CookiesWatchdog.model_rebuild()
- self._cookies_watchdog = CookiesWatchdog(event_bus=self.event_bus, browser_session=self)
- self._cookies_watchdog.attach_to_session()
-
- # Initialize WaitWatchdog (handles wait conditions for selectors and text)
- from browser_use.browser.watchdogs.wait_watchdog import WaitWatchdog
-
- WaitWatchdog.model_rebuild()
- self._wait_watchdog = WaitWatchdog(event_bus=self.event_bus, browser_session=self)
- self._wait_watchdog.attach_to_session()
-
- # Initialize InteractionsWatchdog (handles hover, double-click, right-click)
- from browser_use.browser.watchdogs.interactions_watchdog import InteractionsWatchdog
-
- InteractionsWatchdog.model_rebuild()
- self._interactions_watchdog = InteractionsWatchdog(event_bus=self.event_bus, browser_session=self)
- self._interactions_watchdog.attach_to_session()
-
# Mark watchdogs as attached to prevent duplicate attachment
self._watchdogs_attached = True
diff --git a/browser_use/browser/watchdogs/cookies_watchdog.py b/browser_use/browser/watchdogs/cookies_watchdog.py
deleted file mode 100644
index e5139bbbc..000000000
--- a/browser_use/browser/watchdogs/cookies_watchdog.py
+++ /dev/null
@@ -1,136 +0,0 @@
-"""Cookies watchdog for direct cookie manipulation."""
-
-from typing import Any, ClassVar
-
-from bubus import BaseEvent
-from cdp_use.cdp.network import Cookie
-
-from browser_use.browser.events import (
- ClearCookiesEvent,
- GetCookiesEvent,
- SetCookieEvent,
-)
-from browser_use.browser.watchdog_base import BaseWatchdog
-
-
-class CookiesWatchdog(BaseWatchdog):
- """Handles direct cookie get/set/clear operations."""
-
- LISTENS_TO: ClassVar[list[type[BaseEvent]]] = [
- GetCookiesEvent,
- SetCookieEvent,
- ClearCookiesEvent,
- ]
- EMITS: ClassVar[list[type[BaseEvent]]] = []
-
- async def on_GetCookiesEvent(self, event: GetCookiesEvent) -> list[dict[str, Any]]:
- """Get browser cookies, optionally filtered by URL."""
- try:
- cookies = await self.browser_session._cdp_get_cookies()
- # Convert Cookie objects to dicts for the result
- cookie_list: list[dict[str, Any]] = []
- for c in cookies:
- cookie_dict: dict[str, Any] = {
- 'name': c.get('name', ''),
- 'value': c.get('value', ''),
- 'domain': c.get('domain', ''),
- 'path': c.get('path', '/'),
- 'secure': c.get('secure', False),
- 'httpOnly': c.get('httpOnly', False),
- }
- if 'sameSite' in c:
- cookie_dict['sameSite'] = c.get('sameSite')
- if 'expires' in c:
- cookie_dict['expires'] = c.get('expires')
- cookie_list.append(cookie_dict)
-
- # Filter by URL if provided
- if event.url:
- from urllib.parse import urlparse
-
- parsed = urlparse(event.url)
- domain = parsed.netloc
- # Filter cookies that match the domain
- cookie_list = [
- c for c in cookie_list
- if domain.endswith(str(c.get('domain', '')).lstrip('.'))
- or str(c.get('domain', '')).lstrip('.').endswith(domain)
- ]
-
- return cookie_list
- except Exception as e:
- self.logger.error(f'[CookiesWatchdog] Failed to get cookies: {e}')
- return []
-
- async def on_SetCookieEvent(self, event: SetCookieEvent) -> bool:
- """Set a browser cookie."""
- try:
- cookie_dict: dict[str, Any] = {
- 'name': event.name,
- 'value': event.value,
- 'path': event.path,
- 'secure': event.secure,
- 'httpOnly': event.http_only,
- }
-
- if event.domain:
- cookie_dict['domain'] = event.domain
- if event.same_site:
- cookie_dict['sameSite'] = event.same_site
- if event.expires:
- cookie_dict['expires'] = event.expires
-
- # If no domain specified, we need to get current URL's domain
- if not event.domain:
- cdp_session = await self.browser_session.get_or_create_cdp_session(target_id=None)
- if cdp_session:
- # Get current URL to extract domain
- result = await cdp_session.cdp_client.send.Runtime.evaluate(
- params={'expression': 'window.location.hostname', 'returnByValue': True},
- session_id=cdp_session.session_id,
- )
- hostname = result.get('result', {}).get('value', '')
- if hostname:
- cookie_dict['domain'] = hostname
-
- # Convert dict to Cookie object
- cookie_obj = Cookie(**cookie_dict)
- await self.browser_session._cdp_set_cookies([cookie_obj])
- self.logger.debug(f'[CookiesWatchdog] Set cookie: {event.name}')
- return True
- except Exception as e:
- self.logger.error(f'[CookiesWatchdog] Failed to set cookie: {e}')
- return False
-
- async def on_ClearCookiesEvent(self, event: ClearCookiesEvent) -> None:
- """Clear browser cookies."""
- try:
- if event.url:
- # Clear cookies only for specific URL
- # First get all cookies, then delete ones matching the URL
- cookies = await self.browser_session._cdp_get_cookies()
- from urllib.parse import urlparse
-
- parsed = urlparse(event.url)
- domain = parsed.netloc
-
- cdp_session = await self.browser_session.get_or_create_cdp_session(target_id=None)
- if cdp_session:
- for cookie in cookies:
- cookie_domain = str(cookie.get('domain', '')).lstrip('.')
- if domain.endswith(cookie_domain) or cookie_domain.endswith(domain):
- await cdp_session.cdp_client.send.Network.deleteCookies(
- params={
- 'name': cookie.get('name', ''),
- 'domain': cookie.get('domain'),
- 'path': cookie.get('path', '/'),
- },
- session_id=cdp_session.session_id,
- )
- else:
- # Clear all cookies
- await self.browser_session._cdp_clear_cookies()
-
- self.logger.debug(f'[CookiesWatchdog] Cleared cookies' + (f' for {event.url}' if event.url else ''))
- except Exception as e:
- self.logger.error(f'[CookiesWatchdog] Failed to clear cookies: {e}')
diff --git a/browser_use/browser/watchdogs/interactions_watchdog.py b/browser_use/browser/watchdogs/interactions_watchdog.py
deleted file mode 100644
index 6de887b27..000000000
--- a/browser_use/browser/watchdogs/interactions_watchdog.py
+++ /dev/null
@@ -1,311 +0,0 @@
-"""Interactions watchdog for hover, double-click, right-click, and info retrieval."""
-
-import asyncio
-import json
-from typing import Any, ClassVar
-
-from bubus import BaseEvent
-
-from browser_use.browser.events import (
- ElementDblClickEvent,
- GetElementAttributesEvent,
- GetElementBoundingBoxEvent,
- GetElementTextEvent,
- GetElementValueEvent,
- GetPageHtmlEvent,
- GetPageTitleEvent,
- HoverElementEvent,
- ElementRightClickEvent,
-)
-from browser_use.browser.watchdog_base import BaseWatchdog
-from browser_use.dom.service import EnhancedDOMTreeNode
-
-# Rebuild event models that have forward references
-HoverElementEvent.model_rebuild()
-ElementDblClickEvent.model_rebuild()
-ElementRightClickEvent.model_rebuild()
-GetElementTextEvent.model_rebuild()
-GetElementValueEvent.model_rebuild()
-GetElementAttributesEvent.model_rebuild()
-GetElementBoundingBoxEvent.model_rebuild()
-
-
-class InteractionsWatchdog(BaseWatchdog):
- """Handles hover, double-click, right-click, and element info retrieval."""
-
- LISTENS_TO: ClassVar[list[type[BaseEvent]]] = [
- HoverElementEvent,
- ElementDblClickEvent,
- ElementRightClickEvent,
- GetPageTitleEvent,
- GetPageHtmlEvent,
- GetElementTextEvent,
- GetElementValueEvent,
- GetElementAttributesEvent,
- GetElementBoundingBoxEvent,
- ]
- EMITS: ClassVar[list[type[BaseEvent]]] = []
-
- async def _get_element_center(self, element_node: EnhancedDOMTreeNode) -> tuple[float, float] | None:
- """Get the center coordinates of an element."""
- try:
- cdp_session = await self.browser_session.cdp_client_for_node(element_node)
- session_id = cdp_session.session_id
- backend_node_id = element_node.backend_node_id
-
- # Scroll element into view first
- try:
- await cdp_session.cdp_client.send.DOM.scrollIntoViewIfNeeded(
- params={'backendNodeId': backend_node_id}, session_id=session_id
- )
- await asyncio.sleep(0.05)
- except Exception:
- pass
-
- # Get element coordinates
- element_rect = await self.browser_session.get_element_coordinates(backend_node_id, cdp_session)
- if element_rect:
- center_x = element_rect.x + element_rect.width / 2
- center_y = element_rect.y + element_rect.height / 2
- return center_x, center_y
- return None
- except Exception as e:
- self.logger.error(f'[InteractionsWatchdog] Failed to get element center: {e}')
- return None
-
- async def on_HoverElementEvent(self, event: HoverElementEvent) -> None:
- """Hover over an element."""
- try:
- coords = await self._get_element_center(event.node)
- if not coords:
- self.logger.warning('[InteractionsWatchdog] Could not get element coordinates for hover')
- return
-
- center_x, center_y = coords
- cdp_session = await self.browser_session.cdp_client_for_node(event.node)
-
- # Move mouse to element (hover)
- await cdp_session.cdp_client.send.Input.dispatchMouseEvent(
- params={
- 'type': 'mouseMoved',
- 'x': center_x,
- 'y': center_y,
- },
- session_id=cdp_session.session_id,
- )
-
- self.logger.debug(f'[InteractionsWatchdog] Hovered at ({center_x}, {center_y})')
- except Exception as e:
- self.logger.error(f'[InteractionsWatchdog] Failed to hover: {e}')
-
- async def on_ElementDblClickEvent(self, event: ElementDblClickEvent) -> None:
- """Double-click an element."""
- try:
- coords = await self._get_element_center(event.node)
- if not coords:
- self.logger.warning('[InteractionsWatchdog] Could not get element coordinates for double-click')
- return
-
- center_x, center_y = coords
- cdp_session = await self.browser_session.cdp_client_for_node(event.node)
- session_id = cdp_session.session_id
-
- # Move mouse to element
- await cdp_session.cdp_client.send.Input.dispatchMouseEvent(
- params={'type': 'mouseMoved', 'x': center_x, 'y': center_y},
- session_id=session_id,
- )
- await asyncio.sleep(0.05)
-
- # Double click (clickCount: 2)
- await cdp_session.cdp_client.send.Input.dispatchMouseEvent(
- params={
- 'type': 'mousePressed',
- 'x': center_x,
- 'y': center_y,
- 'button': 'left',
- 'clickCount': 2,
- },
- session_id=session_id,
- )
- await asyncio.sleep(0.05)
-
- await cdp_session.cdp_client.send.Input.dispatchMouseEvent(
- params={
- 'type': 'mouseReleased',
- 'x': center_x,
- 'y': center_y,
- 'button': 'left',
- 'clickCount': 2,
- },
- session_id=session_id,
- )
-
- self.logger.debug(f'[InteractionsWatchdog] Double-clicked at ({center_x}, {center_y})')
- except Exception as e:
- self.logger.error(f'[InteractionsWatchdog] Failed to double-click: {e}')
-
- async def on_ElementRightClickEvent(self, event: ElementRightClickEvent) -> None:
- """Right-click (context menu) an element."""
- try:
- coords = await self._get_element_center(event.node)
- if not coords:
- self.logger.warning('[InteractionsWatchdog] Could not get element coordinates for right-click')
- return
-
- center_x, center_y = coords
- cdp_session = await self.browser_session.cdp_client_for_node(event.node)
- session_id = cdp_session.session_id
-
- # Move mouse to element
- await cdp_session.cdp_client.send.Input.dispatchMouseEvent(
- params={'type': 'mouseMoved', 'x': center_x, 'y': center_y},
- session_id=session_id,
- )
- await asyncio.sleep(0.05)
-
- # Right click (button: 'right')
- await cdp_session.cdp_client.send.Input.dispatchMouseEvent(
- params={
- 'type': 'mousePressed',
- 'x': center_x,
- 'y': center_y,
- 'button': 'right',
- 'clickCount': 1,
- },
- session_id=session_id,
- )
- await asyncio.sleep(0.05)
-
- await cdp_session.cdp_client.send.Input.dispatchMouseEvent(
- params={
- 'type': 'mouseReleased',
- 'x': center_x,
- 'y': center_y,
- 'button': 'right',
- 'clickCount': 1,
- },
- session_id=session_id,
- )
-
- self.logger.debug(f'[InteractionsWatchdog] Right-clicked at ({center_x}, {center_y})')
- except Exception as e:
- self.logger.error(f'[InteractionsWatchdog] Failed to right-click: {e}')
-
- async def _execute_js(self, js: str) -> Any:
- """Execute JavaScript in the browser context."""
- cdp_session = await self.browser_session.get_or_create_cdp_session(target_id=None)
- if not cdp_session:
- raise RuntimeError('No active browser session')
-
- result = await cdp_session.cdp_client.send.Runtime.evaluate(
- params={'expression': js, 'returnByValue': True},
- session_id=cdp_session.session_id,
- )
- return result.get('result', {}).get('value')
-
- async def on_GetPageTitleEvent(self, event: GetPageTitleEvent) -> str:
- """Get the page title."""
- try:
- title = await self._execute_js('document.title')
- return title or ''
- except Exception as e:
- self.logger.error(f'[InteractionsWatchdog] Failed to get title: {e}')
- return ''
-
- async def on_GetPageHtmlEvent(self, event: GetPageHtmlEvent) -> str:
- """Get page HTML, optionally scoped to a selector."""
- try:
- if event.selector:
- js = f'''
- (function() {{
- const el = document.querySelector({json.dumps(event.selector)});
- return el ? el.outerHTML : null;
- }})()
- '''
- else:
- js = 'document.documentElement.outerHTML'
-
- html = await self._execute_js(js)
- return html or ''
- except Exception as e:
- self.logger.error(f'[InteractionsWatchdog] Failed to get HTML: {e}')
- return ''
-
- async def on_GetElementTextEvent(self, event: GetElementTextEvent) -> str:
- """Get text content of an element."""
- try:
- # Use the node's text from our model
- text = event.node.get_all_children_text(max_depth=10) if event.node else ''
- return text
- except Exception as e:
- self.logger.error(f'[InteractionsWatchdog] Failed to get element text: {e}')
- return ''
-
- async def on_GetElementValueEvent(self, event: GetElementValueEvent) -> str:
- """Get value of an input/textarea element."""
- try:
- cdp_session = await self.browser_session.cdp_client_for_node(event.node)
- backend_node_id = event.node.backend_node_id
-
- # Use callFunctionOn to get the value
- result = await cdp_session.cdp_client.send.DOM.resolveNode(
- params={'backendNodeId': backend_node_id},
- session_id=cdp_session.session_id,
- )
- object_id = result.get('object', {}).get('objectId')
-
- if object_id:
- value_result = await cdp_session.cdp_client.send.Runtime.callFunctionOn(
- params={
- 'objectId': object_id,
- 'functionDeclaration': 'function() { return this.value; }',
- 'returnByValue': True,
- },
- session_id=cdp_session.session_id,
- )
- value = value_result.get('result', {}).get('value')
- return value or ''
- else:
- return ''
- except Exception as e:
- self.logger.error(f'[InteractionsWatchdog] Failed to get element value: {e}')
- return ''
-
- async def on_GetElementAttributesEvent(self, event: GetElementAttributesEvent) -> dict[str, Any]:
- """Get all attributes of an element."""
- try:
- # Use the attributes from the node model
- attrs = event.node.attributes or {}
- return dict(attrs)
- except Exception as e:
- self.logger.error(f'[InteractionsWatchdog] Failed to get element attributes: {e}')
- return {}
-
- async def on_GetElementBoundingBoxEvent(self, event: GetElementBoundingBoxEvent) -> dict[str, float]:
- """Get bounding box of an element."""
- try:
- cdp_session = await self.browser_session.cdp_client_for_node(event.node)
- backend_node_id = event.node.backend_node_id
-
- # Get box model
- result = await cdp_session.cdp_client.send.DOM.getBoxModel(
- params={'backendNodeId': backend_node_id},
- session_id=cdp_session.session_id,
- )
-
- model = result.get('model', {})
- content = model.get('content', [])
-
- if len(content) >= 8:
- # content is [x1, y1, x2, y2, x3, y3, x4, y4] - corners of the quad
- x = min(content[0], content[2], content[4], content[6])
- y = min(content[1], content[3], content[5], content[7])
- width = max(content[0], content[2], content[4], content[6]) - x
- height = max(content[1], content[3], content[5], content[7]) - y
- return {'x': x, 'y': y, 'width': width, 'height': height}
- else:
- return {}
- except Exception as e:
- self.logger.error(f'[InteractionsWatchdog] Failed to get element bbox: {e}')
- return {}
diff --git a/browser_use/browser/watchdogs/wait_watchdog.py b/browser_use/browser/watchdogs/wait_watchdog.py
deleted file mode 100644
index b90dbef0f..000000000
--- a/browser_use/browser/watchdogs/wait_watchdog.py
+++ /dev/null
@@ -1,121 +0,0 @@
-"""Wait watchdog for wait conditions (selector, text)."""
-
-import asyncio
-import json
-from typing import Any, ClassVar
-
-from bubus import BaseEvent
-
-from browser_use.browser.events import (
- WaitForSelectorEvent,
- WaitForTextEvent,
-)
-from browser_use.browser.watchdog_base import BaseWatchdog
-
-
-class WaitWatchdog(BaseWatchdog):
- """Handles wait conditions for selectors and text."""
-
- LISTENS_TO: ClassVar[list[type[BaseEvent]]] = [
- WaitForSelectorEvent,
- WaitForTextEvent,
- ]
- EMITS: ClassVar[list[type[BaseEvent]]] = []
-
- async def _execute_js(self, js: str) -> Any:
- """Execute JavaScript in the browser context."""
- cdp_session = await self.browser_session.get_or_create_cdp_session(target_id=None)
- if not cdp_session:
- raise RuntimeError('No active browser session')
-
- result = await cdp_session.cdp_client.send.Runtime.evaluate(
- params={'expression': js, 'returnByValue': True},
- session_id=cdp_session.session_id,
- )
- return result.get('result', {}).get('value')
-
- async def on_WaitForSelectorEvent(self, event: WaitForSelectorEvent) -> bool:
- """Wait for a CSS selector to match an element in the specified state."""
- try:
- timeout_seconds = event.timeout_ms / 1000.0
- poll_interval = 0.1 # 100ms polling
- elapsed = 0.0
-
- while elapsed < timeout_seconds:
- # Check based on state
- if event.state == 'attached':
- js = f'document.querySelector({json.dumps(event.selector)}) !== null'
- elif event.state == 'detached':
- js = f'document.querySelector({json.dumps(event.selector)}) === null'
- elif event.state == 'visible':
- js = f'''
- (function() {{
- const el = document.querySelector({json.dumps(event.selector)});
- if (!el) return false;
- const style = window.getComputedStyle(el);
- const rect = el.getBoundingClientRect();
- return style.display !== 'none' &&
- style.visibility !== 'hidden' &&
- style.opacity !== '0' &&
- rect.width > 0 &&
- rect.height > 0;
- }})()
- '''
- elif event.state == 'hidden':
- js = f'''
- (function() {{
- const el = document.querySelector({json.dumps(event.selector)});
- if (!el) return true;
- const style = window.getComputedStyle(el);
- const rect = el.getBoundingClientRect();
- return style.display === 'none' ||
- style.visibility === 'hidden' ||
- style.opacity === '0' ||
- rect.width === 0 ||
- rect.height === 0;
- }})()
- '''
- else:
- js = f'document.querySelector({json.dumps(event.selector)}) !== null'
-
- result = await self._execute_js(js)
- if result:
- self.logger.debug(f'[WaitWatchdog] Selector matched: {event.selector} (state: {event.state})')
- return True
-
- await asyncio.sleep(poll_interval)
- elapsed += poll_interval
-
- self.logger.warning(f'[WaitWatchdog] Timeout waiting for selector: {event.selector}')
- return False
- except Exception as e:
- self.logger.error(f'[WaitWatchdog] Failed to wait for selector: {e}')
- return False
-
- async def on_WaitForTextEvent(self, event: WaitForTextEvent) -> bool:
- """Wait for text to appear on the page."""
- try:
- timeout_seconds = event.timeout_ms / 1000.0
- poll_interval = 0.1 # 100ms polling
- elapsed = 0.0
-
- while elapsed < timeout_seconds:
- js = f'''
- (function() {{
- const text = {json.dumps(event.text)};
- return document.body.innerText.includes(text);
- }})()
- '''
- result = await self._execute_js(js)
- if result:
- self.logger.debug(f'[WaitWatchdog] Text found: {event.text[:50]}...')
- return True
-
- await asyncio.sleep(poll_interval)
- elapsed += poll_interval
-
- self.logger.warning(f'[WaitWatchdog] Timeout waiting for text: {event.text[:50]}...')
- return False
- except Exception as e:
- self.logger.error(f'[WaitWatchdog] Failed to wait for text: {e}')
- return False
diff --git a/browser_use/skill_cli/commands/browser.py b/browser_use/skill_cli/commands/browser.py
index 4dfa4cedf..17005040e 100644
--- a/browser_use/skill_cli/commands/browser.py
+++ b/browser_use/skill_cli/commands/browser.py
@@ -1,5 +1,6 @@
"""Browser control commands."""
+import asyncio
import base64
import logging
from pathlib import Path
@@ -48,6 +49,35 @@ async def _execute_js(session: SessionInfo, js: str) -> Any:
return result.get('result', {}).get('value')
+async def _get_element_center(session: SessionInfo, node: Any) -> tuple[float, float] | None:
+ """Get the center coordinates of an element."""
+ bs = session.browser_session
+ try:
+ cdp_session = await bs.cdp_client_for_node(node)
+ session_id = cdp_session.session_id
+ backend_node_id = node.backend_node_id
+
+ # Scroll element into view first
+ try:
+ await cdp_session.cdp_client.send.DOM.scrollIntoViewIfNeeded(
+ params={'backendNodeId': backend_node_id}, session_id=session_id
+ )
+ await asyncio.sleep(0.05)
+ except Exception:
+ pass
+
+ # Get element coordinates
+ element_rect = await bs.get_element_coordinates(backend_node_id, cdp_session)
+ if element_rect:
+ center_x = element_rect.x + element_rect.width / 2
+ center_y = element_rect.y + element_rect.height / 2
+ return center_x, center_y
+ return None
+ except Exception as e:
+ logger.error(f'Failed to get element center: {e}')
+ return None
+
+
async def handle(action: str, session: SessionInfo, params: dict[str, Any]) -> Any:
"""Handle browser control command."""
bs = session.browser_session
@@ -197,86 +227,252 @@ async def handle(action: str, session: SessionInfo, params: dict[str, Any]) -> A
return {'query': query, 'error': 'extract requires agent mode - use: browser-use run "extract ..."'}
elif action == 'hover':
- from browser_use.browser.events import HoverElementEvent
-
index = params['index']
node = await bs.get_element_by_index(index)
if node is None:
return {'error': f'Element index {index} not found - page may have changed'}
- await bs.event_bus.dispatch(HoverElementEvent(node=node))
+
+ coords = await _get_element_center(session, node)
+ if not coords:
+ return {'error': 'Could not get element coordinates for hover'}
+
+ center_x, center_y = coords
+ cdp_session = await bs.cdp_client_for_node(node)
+ await cdp_session.cdp_client.send.Input.dispatchMouseEvent(
+ params={'type': 'mouseMoved', 'x': center_x, 'y': center_y},
+ session_id=cdp_session.session_id,
+ )
return {'hovered': index}
elif action == 'dblclick':
- from browser_use.browser.events import ElementDblClickEvent
-
index = params['index']
node = await bs.get_element_by_index(index)
if node is None:
return {'error': f'Element index {index} not found - page may have changed'}
- await bs.event_bus.dispatch(ElementDblClickEvent(node=node))
+
+ coords = await _get_element_center(session, node)
+ if not coords:
+ return {'error': 'Could not get element coordinates for double-click'}
+
+ center_x, center_y = coords
+ cdp_session = await bs.cdp_client_for_node(node)
+ session_id = cdp_session.session_id
+
+ # Move mouse to element
+ await cdp_session.cdp_client.send.Input.dispatchMouseEvent(
+ params={'type': 'mouseMoved', 'x': center_x, 'y': center_y},
+ session_id=session_id,
+ )
+ await asyncio.sleep(0.05)
+
+ # Double click (clickCount: 2)
+ await cdp_session.cdp_client.send.Input.dispatchMouseEvent(
+ params={
+ 'type': 'mousePressed',
+ 'x': center_x,
+ 'y': center_y,
+ 'button': 'left',
+ 'clickCount': 2,
+ },
+ session_id=session_id,
+ )
+ await asyncio.sleep(0.05)
+
+ await cdp_session.cdp_client.send.Input.dispatchMouseEvent(
+ params={
+ 'type': 'mouseReleased',
+ 'x': center_x,
+ 'y': center_y,
+ 'button': 'left',
+ 'clickCount': 2,
+ },
+ session_id=session_id,
+ )
return {'double_clicked': index}
elif action == 'rightclick':
- from browser_use.browser.events import ElementRightClickEvent
-
index = params['index']
node = await bs.get_element_by_index(index)
if node is None:
return {'error': f'Element index {index} not found - page may have changed'}
- await bs.event_bus.dispatch(ElementRightClickEvent(node=node))
+
+ coords = await _get_element_center(session, node)
+ if not coords:
+ return {'error': 'Could not get element coordinates for right-click'}
+
+ center_x, center_y = coords
+ cdp_session = await bs.cdp_client_for_node(node)
+ session_id = cdp_session.session_id
+
+ # Move mouse to element
+ await cdp_session.cdp_client.send.Input.dispatchMouseEvent(
+ params={'type': 'mouseMoved', 'x': center_x, 'y': center_y},
+ session_id=session_id,
+ )
+ await asyncio.sleep(0.05)
+
+ # Right click (button: 'right')
+ await cdp_session.cdp_client.send.Input.dispatchMouseEvent(
+ params={
+ 'type': 'mousePressed',
+ 'x': center_x,
+ 'y': center_y,
+ 'button': 'right',
+ 'clickCount': 1,
+ },
+ session_id=session_id,
+ )
+ await asyncio.sleep(0.05)
+
+ await cdp_session.cdp_client.send.Input.dispatchMouseEvent(
+ params={
+ 'type': 'mouseReleased',
+ 'x': center_x,
+ 'y': center_y,
+ 'button': 'right',
+ 'clickCount': 1,
+ },
+ session_id=session_id,
+ )
return {'right_clicked': index}
elif action == 'cookies':
cookies_command = params.get('cookies_command')
if cookies_command == 'get':
- from browser_use.browser.events import GetCookiesEvent
+ # Get cookies via direct CDP
+ cookies = await bs._cdp_get_cookies()
+ # Convert Cookie objects to dicts
+ cookie_list: list[dict[str, Any]] = []
+ for c in cookies:
+ cookie_dict: dict[str, Any] = {
+ 'name': c.get('name', ''),
+ 'value': c.get('value', ''),
+ 'domain': c.get('domain', ''),
+ 'path': c.get('path', '/'),
+ 'secure': c.get('secure', False),
+ 'httpOnly': c.get('httpOnly', False),
+ }
+ if 'sameSite' in c:
+ cookie_dict['sameSite'] = c.get('sameSite')
+ if 'expires' in c:
+ cookie_dict['expires'] = c.get('expires')
+ cookie_list.append(cookie_dict)
+ # Filter by URL if provided
url = params.get('url')
- event = GetCookiesEvent(url=url)
- await bs.event_bus.dispatch(event)
- cookies = await event.event_result()
- return {'cookies': cookies}
+ if url:
+ from urllib.parse import urlparse
+
+ parsed = urlparse(url)
+ domain = parsed.netloc
+ cookie_list = [
+ c for c in cookie_list
+ if domain.endswith(str(c.get('domain', '')).lstrip('.'))
+ or str(c.get('domain', '')).lstrip('.').endswith(domain)
+ ]
+
+ return {'cookies': cookie_list}
elif cookies_command == 'set':
- from browser_use.browser.events import SetCookieEvent
-
- event = SetCookieEvent(
- name=params['name'],
- value=params['value'],
- domain=params.get('domain'),
- path=params.get('path', '/'),
- secure=params.get('secure', False),
- http_only=params.get('http_only', False),
- same_site=params.get('same_site'),
- expires=params.get('expires'),
- )
- await bs.event_bus.dispatch(event)
- success = await event.event_result()
- return {'set': params['name'], 'success': success}
+ from cdp_use.cdp.network import Cookie
+
+ cookie_dict: dict[str, Any] = {
+ 'name': params['name'],
+ 'value': params['value'],
+ 'path': params.get('path', '/'),
+ 'secure': params.get('secure', False),
+ 'httpOnly': params.get('http_only', False),
+ }
+
+ if params.get('domain'):
+ cookie_dict['domain'] = params['domain']
+ if params.get('same_site'):
+ cookie_dict['sameSite'] = params['same_site']
+ if params.get('expires'):
+ cookie_dict['expires'] = params['expires']
+
+ # If no domain specified, get current URL's domain
+ if not params.get('domain'):
+ hostname = await _execute_js(session, 'window.location.hostname')
+ if hostname:
+ cookie_dict['domain'] = hostname
- elif cookies_command == 'clear':
- from browser_use.browser.events import ClearCookiesEvent
+ try:
+ cookie_obj = Cookie(**cookie_dict)
+ await bs._cdp_set_cookies([cookie_obj])
+ return {'set': params['name'], 'success': True}
+ except Exception as e:
+ logger.error(f'Failed to set cookie: {e}')
+ return {'set': params['name'], 'success': False, 'error': str(e)}
+ elif cookies_command == 'clear':
url = params.get('url')
- event = ClearCookiesEvent(url=url)
- await bs.event_bus.dispatch(event)
- # No event_result() call - this is a void operation
+ if url:
+ # Clear cookies only for specific URL domain
+ from urllib.parse import urlparse
+
+ cookies = await bs._cdp_get_cookies()
+ parsed = urlparse(url)
+ domain = parsed.netloc
+
+ cdp_session = await bs.get_or_create_cdp_session(target_id=None, focus=False)
+ if cdp_session:
+ for cookie in cookies:
+ cookie_domain = str(cookie.get('domain', '')).lstrip('.')
+ if domain.endswith(cookie_domain) or cookie_domain.endswith(domain):
+ await cdp_session.cdp_client.send.Network.deleteCookies(
+ params={
+ 'name': cookie.get('name', ''),
+ 'domain': cookie.get('domain'),
+ 'path': cookie.get('path', '/'),
+ },
+ session_id=cdp_session.session_id,
+ )
+ else:
+ # Clear all cookies
+ await bs._cdp_clear_cookies()
+
return {'cleared': True, 'url': url}
elif cookies_command == 'export':
import json
- from browser_use.browser.events import GetCookiesEvent
+ # Get cookies via direct CDP
+ cookies = await bs._cdp_get_cookies()
+ # Convert to list of dicts
+ cookie_list: list[dict[str, Any]] = []
+ for c in cookies:
+ cookie_dict: dict[str, Any] = {
+ 'name': c.get('name', ''),
+ 'value': c.get('value', ''),
+ 'domain': c.get('domain', ''),
+ 'path': c.get('path', '/'),
+ 'secure': c.get('secure', False),
+ 'httpOnly': c.get('httpOnly', False),
+ }
+ if 'sameSite' in c:
+ cookie_dict['sameSite'] = c.get('sameSite')
+ if 'expires' in c:
+ cookie_dict['expires'] = c.get('expires')
+ cookie_list.append(cookie_dict)
+ # Filter by URL if provided
url = params.get('url')
- event = GetCookiesEvent(url=url)
- await bs.event_bus.dispatch(event)
- cookies = await event.event_result()
+ if url:
+ from urllib.parse import urlparse
+
+ parsed = urlparse(url)
+ domain = parsed.netloc
+ cookie_list = [
+ c for c in cookie_list
+ if domain.endswith(str(c.get('domain', '')).lstrip('.'))
+ or str(c.get('domain', '')).lstrip('.').endswith(domain)
+ ]
file_path = Path(params['file'])
- file_path.write_text(json.dumps(cookies, indent=2))
- return {'exported': len(cookies), 'file': str(file_path)}
+ file_path.write_text(json.dumps(cookie_list, indent=2))
+ return {'exported': len(cookie_list), 'file': str(file_path)}
elif cookies_command == 'import':
import json
@@ -322,100 +518,184 @@ async def handle(action: str, session: SessionInfo, params: dict[str, Any]) -> A
return {'error': 'Invalid cookies command. Use: get, set, clear, export, import'}
elif action == 'wait':
+ import json as json_module
+
wait_command = params.get('wait_command')
if wait_command == 'selector':
- from browser_use.browser.events import WaitForSelectorEvent
-
- event = WaitForSelectorEvent(
- selector=params['selector'],
- timeout_ms=params.get('timeout', 30000),
- state=params.get('state', 'visible'),
- )
- await bs.event_bus.dispatch(event)
- success = await event.event_result()
- return {'selector': params['selector'], 'found': success}
+ timeout_seconds = params.get('timeout', 30000) / 1000.0
+ state = params.get('state', 'visible')
+ selector = params['selector']
+ poll_interval = 0.1
+ elapsed = 0.0
+
+ while elapsed < timeout_seconds:
+ # Build JS check based on state
+ if state == 'attached':
+ js = f'document.querySelector({json_module.dumps(selector)}) !== null'
+ elif state == 'detached':
+ js = f'document.querySelector({json_module.dumps(selector)}) === null'
+ elif state == 'visible':
+ js = f'''
+ (function() {{
+ const el = document.querySelector({json_module.dumps(selector)});
+ if (!el) return false;
+ const style = window.getComputedStyle(el);
+ const rect = el.getBoundingClientRect();
+ return style.display !== 'none' &&
+ style.visibility !== 'hidden' &&
+ style.opacity !== '0' &&
+ rect.width > 0 &&
+ rect.height > 0;
+ }})()
+ '''
+ elif state == 'hidden':
+ js = f'''
+ (function() {{
+ const el = document.querySelector({json_module.dumps(selector)});
+ if (!el) return true;
+ const style = window.getComputedStyle(el);
+ const rect = el.getBoundingClientRect();
+ return style.display === 'none' ||
+ style.visibility === 'hidden' ||
+ style.opacity === '0' ||
+ rect.width === 0 ||
+ rect.height === 0;
+ }})()
+ '''
+ else:
+ js = f'document.querySelector({json_module.dumps(selector)}) !== null'
+
+ result = await _execute_js(session, js)
+ if result:
+ return {'selector': selector, 'found': True}
+
+ await asyncio.sleep(poll_interval)
+ elapsed += poll_interval
+
+ return {'selector': selector, 'found': False}
elif wait_command == 'text':
- from browser_use.browser.events import WaitForTextEvent
+ import json as json_module
- event = WaitForTextEvent(
- text=params['text'],
- timeout_ms=params.get('timeout', 30000),
- )
- await bs.event_bus.dispatch(event)
- success = await event.event_result()
- return {'text': params['text'], 'found': success}
+ timeout_seconds = params.get('timeout', 30000) / 1000.0
+ text = params['text']
+ poll_interval = 0.1
+ elapsed = 0.0
+
+ while elapsed < timeout_seconds:
+ js = f'''
+ (function() {{
+ const text = {json_module.dumps(text)};
+ return document.body.innerText.includes(text);
+ }})()
+ '''
+ result = await _execute_js(session, js)
+ if result:
+ return {'text': text, 'found': True}
+
+ await asyncio.sleep(poll_interval)
+ elapsed += poll_interval
+
+ return {'text': text, 'found': False}
return {'error': 'Invalid wait command. Use: selector, text'}
elif action == 'get':
+ import json as json_module
+
get_command = params.get('get_command')
if get_command == 'title':
- from browser_use.browser.events import GetPageTitleEvent
-
- event = GetPageTitleEvent()
- await bs.event_bus.dispatch(event)
- title = await event.event_result()
- return {'title': title}
+ title = await _execute_js(session, 'document.title')
+ return {'title': title or ''}
elif get_command == 'html':
- from browser_use.browser.events import GetPageHtmlEvent
-
selector = params.get('selector')
- event = GetPageHtmlEvent(selector=selector)
- await bs.event_bus.dispatch(event)
- html = await event.event_result()
- return {'html': html}
+ if selector:
+ js = f'(function(){{ const el = document.querySelector({json_module.dumps(selector)}); return el ? el.outerHTML : null; }})()'
+ else:
+ js = 'document.documentElement.outerHTML'
+ html = await _execute_js(session, js)
+ return {'html': html or ''}
elif get_command == 'text':
- from browser_use.browser.events import GetElementTextEvent
-
index = params['index']
node = await bs.get_element_by_index(index)
if node is None:
return {'error': f'Element index {index} not found - page may have changed'}
- event = GetElementTextEvent(node=node)
- await bs.event_bus.dispatch(event)
- text = await event.event_result()
+ # Use the node's text from our model
+ text = node.get_all_children_text(max_depth=10) if node else ''
return {'index': index, 'text': text}
elif get_command == 'value':
- from browser_use.browser.events import GetElementValueEvent
-
index = params['index']
node = await bs.get_element_by_index(index)
if node is None:
return {'error': f'Element index {index} not found - page may have changed'}
- event = GetElementValueEvent(node=node)
- await bs.event_bus.dispatch(event)
- value = await event.event_result()
- return {'index': index, 'value': value}
- elif get_command == 'attributes':
- from browser_use.browser.events import GetElementAttributesEvent
+ try:
+ cdp_session = await bs.cdp_client_for_node(node)
+ result = await cdp_session.cdp_client.send.DOM.resolveNode(
+ params={'backendNodeId': node.backend_node_id},
+ session_id=cdp_session.session_id,
+ )
+ object_id = result.get('object', {}).get('objectId')
+
+ if object_id:
+ value_result = await cdp_session.cdp_client.send.Runtime.callFunctionOn(
+ params={
+ 'objectId': object_id,
+ 'functionDeclaration': 'function() { return this.value; }',
+ 'returnByValue': True,
+ },
+ session_id=cdp_session.session_id,
+ )
+ value = value_result.get('result', {}).get('value')
+ return {'index': index, 'value': value or ''}
+ else:
+ return {'index': index, 'value': ''}
+ except Exception as e:
+ logger.error(f'Failed to get element value: {e}')
+ return {'index': index, 'value': ''}
+ elif get_command == 'attributes':
index = params['index']
node = await bs.get_element_by_index(index)
if node is None:
return {'error': f'Element index {index} not found - page may have changed'}
- event = GetElementAttributesEvent(node=node)
- await bs.event_bus.dispatch(event)
- attrs = await event.event_result()
- return {'index': index, 'attributes': attrs}
+ # Use the attributes from the node model
+ attrs = node.attributes or {}
+ return {'index': index, 'attributes': dict(attrs)}
elif get_command == 'bbox':
- from browser_use.browser.events import GetElementBoundingBoxEvent
-
index = params['index']
node = await bs.get_element_by_index(index)
if node is None:
return {'error': f'Element index {index} not found - page may have changed'}
- event = GetElementBoundingBoxEvent(node=node)
- await bs.event_bus.dispatch(event)
- bbox = await event.event_result()
- return {'index': index, 'bbox': bbox}
+
+ try:
+ cdp_session = await bs.cdp_client_for_node(node)
+ result = await cdp_session.cdp_client.send.DOM.getBoxModel(
+ params={'backendNodeId': node.backend_node_id},
+ session_id=cdp_session.session_id,
+ )
+
+ model = result.get('model', {})
+ content = model.get('content', [])
+
+ if len(content) >= 8:
+ # content is [x1, y1, x2, y2, x3, y3, x4, y4] - corners of the quad
+ x = min(content[0], content[2], content[4], content[6])
+ y = min(content[1], content[3], content[5], content[7])
+ width = max(content[0], content[2], content[4], content[6]) - x
+ height = max(content[1], content[3], content[5], content[7]) - y
+ return {'index': index, 'bbox': {'x': x, 'y': y, 'width': width, 'height': height}}
+ else:
+ return {'index': index, 'bbox': {}}
+ except Exception as e:
+ logger.error(f'Failed to get element bbox: {e}')
+ return {'index': index, 'bbox': {}}
return {'error': 'Invalid get command. Use: title, html, text, value, attributes, bbox'}