vibesurf 0.1.9a6__py3-none-any.whl → 0.1.10__py3-none-any.whl

vibe_surf/browser/agent_browser_session.py

@@ -11,6 +11,7 @@ from pydantic import Field
 from browser_use.browser.events import (
     NavigationCompleteEvent,
 )
+from browser_use.utils import _log_pretty_url, is_new_tab_page, time_execution_async
 import time
 from browser_use.browser.profile import BrowserProfile
 from browser_use.browser.views import BrowserStateSummary
@@ -18,71 +19,96 @@ from browser_use.dom.views import TargetInfo
 from vibe_surf.browser.agen_browser_profile import AgentBrowserProfile
 from typing import Self
 from uuid_extensions import uuid7str
+import httpx
+from browser_use.browser.views import BrowserStateSummary, TabInfo
+from browser_use.dom.views import EnhancedDOMTreeNode, TargetInfo
+from browser_use.observability import observe_debug
+from cdp_use import CDPClient
+from browser_use.browser.events import (
+    AgentFocusChangedEvent,
+    BrowserConnectedEvent,
+    BrowserErrorEvent,
+    BrowserLaunchEvent,
+    BrowserLaunchResult,
+    BrowserStartEvent,
+    BrowserStateRequestEvent,
+    BrowserStopEvent,
+    BrowserStoppedEvent,
+    CloseTabEvent,
+    FileDownloadedEvent,
+    NavigateToUrlEvent,
+    NavigationCompleteEvent,
+    NavigationStartedEvent,
+    SwitchTabEvent,
+    TabClosedEvent,
+    TabCreatedEvent,
+)
 
 DEFAULT_BROWSER_PROFILE = AgentBrowserProfile()
 
+
 class AgentBrowserSession(BrowserSession):
     """Isolated browser session for a specific agent."""
 
     def __init__(
-        self,
-        # Core configuration
-        id: str | None = None,
-        cdp_url: str | None = None,
-        is_local: bool = False,
-        browser_profile: AgentBrowserProfile | None = None,
-        # Custom AgentBrowserSession fields
-        main_browser_session: BrowserSession | None = None,
-        # BrowserProfile fields that can be passed directly
-        # From BrowserConnectArgs
-        headers: dict[str, str] | None = None,
-        # From BrowserLaunchArgs
-        env: dict[str, str | float | bool] | None = None,
-        executable_path: str | Path | None = None,
-        headless: bool | None = None,
-        args: list[str] | None = None,
-        ignore_default_args: list[str] | list[bool] | None = None,
-        channel: str | None = None,
-        chromium_sandbox: bool | None = None,
-        devtools: bool | None = None,
-        downloads_path: str | Path | None = None,
-        traces_dir: str | Path | None = None,
-        # From BrowserContextArgs
-        accept_downloads: bool | None = None,
-        permissions: list[str] | None = None,
-        user_agent: str | None = None,
-        screen: dict | None = None,
-        viewport: dict | None = None,
-        no_viewport: bool | None = None,
-        device_scale_factor: float | None = None,
-        record_har_content: str | None = None,
-        record_har_mode: str | None = None,
-        record_har_path: str | Path | None = None,
-        record_video_dir: str | Path | None = None,
-        # From BrowserLaunchPersistentContextArgs
-        user_data_dir: str | Path | None = None,
-        # From BrowserNewContextArgs
-        storage_state: str | Path | dict[str, Any] | None = None,
-        # BrowserProfile specific fields
-        disable_security: bool | None = None,
-        deterministic_rendering: bool | None = None,
-        allowed_domains: list[str] | None = None,
-        keep_alive: bool | None = None,
-        proxy: any | None = None,
-        enable_default_extensions: bool | None = None,
-        window_size: dict | None = None,
-        window_position: dict | None = None,
-        cross_origin_iframes: bool | None = None,
-        minimum_wait_page_load_time: float | None = None,
-        wait_for_network_idle_page_load_time: float | None = None,
-        wait_between_actions: float | None = None,
-        highlight_elements: bool | None = None,
-        filter_highlight_ids: bool | None = None,
-        auto_download_pdfs: bool | None = None,
-        profile_directory: str | None = None,
-        cookie_whitelist_domains: list[str] | None = None,
-        # AgentBrowserProfile specific fields
-        custom_extensions: list[str] | None = None,
+            self,
+            # Core configuration
+            id: str | None = None,
+            cdp_url: str | None = None,
+            is_local: bool = False,
+            browser_profile: AgentBrowserProfile | None = None,
+            # Custom AgentBrowserSession fields
+            main_browser_session: BrowserSession | None = None,
+            # BrowserProfile fields that can be passed directly
+            # From BrowserConnectArgs
+            headers: dict[str, str] | None = None,
+            # From BrowserLaunchArgs
+            env: dict[str, str | float | bool] | None = None,
+            executable_path: str | Path | None = None,
+            headless: bool | None = None,
+            args: list[str] | None = None,
+            ignore_default_args: list[str] | list[bool] | None = None,
+            channel: str | None = None,
+            chromium_sandbox: bool | None = None,
+            devtools: bool | None = None,
+            downloads_path: str | Path | None = None,
+            traces_dir: str | Path | None = None,
+            # From BrowserContextArgs
+            accept_downloads: bool | None = None,
+            permissions: list[str] | None = None,
+            user_agent: str | None = None,
+            screen: dict | None = None,
+            viewport: dict | None = None,
+            no_viewport: bool | None = None,
+            device_scale_factor: float | None = None,
+            record_har_content: str | None = None,
+            record_har_mode: str | None = None,
+            record_har_path: str | Path | None = None,
+            record_video_dir: str | Path | None = None,
+            # From BrowserLaunchPersistentContextArgs
+            user_data_dir: str | Path | None = None,
+            # From BrowserNewContextArgs
+            storage_state: str | Path | dict[str, Any] | None = None,
+            # BrowserProfile specific fields
+            disable_security: bool | None = None,
+            deterministic_rendering: bool | None = None,
+            allowed_domains: list[str] | None = None,
+            keep_alive: bool | None = None,
+            proxy: any | None = None,
+            enable_default_extensions: bool | None = None,
+            window_size: dict | None = None,
+            window_position: dict | None = None,
+            cross_origin_iframes: bool | None = None,
+            minimum_wait_page_load_time: float | None = None,
+            wait_for_network_idle_page_load_time: float | None = None,
+            wait_between_actions: float | None = None,
+            highlight_elements: bool | None = None,
+            filter_highlight_ids: bool | None = None,
+            auto_download_pdfs: bool | None = None,
+            profile_directory: str | None = None,
+            cookie_whitelist_domains: list[str] | None = None,
+            # AgentBrowserProfile specific fields
+            custom_extensions: list[str] | None = None,
     ):
         # Filter out AgentBrowserSession specific parameters
         agent_session_params = {
@@ -91,8 +117,8 @@ class AgentBrowserSession(BrowserSession):
 
         # Get all browser profile parameters
         profile_kwargs = {k: v for k, v in locals().items()
-                         if k not in ['self', 'browser_profile', 'id', 'main_browser_session']
-                         and v is not None}
+                          if k not in ['self', 'browser_profile', 'id', 'main_browser_session']
+                          and v is not None}
 
         # Apply BrowserSession's is_local logic first
         effective_is_local = is_local
@@ -131,6 +157,155 @@ class AgentBrowserSession(BrowserSession):
     )
     main_browser_session: BrowserSession | None = Field(default=None)
 
+    async def connect(self, cdp_url: str | None = None) -> Self:
+        """Connect to a remote chromium-based browser via CDP using cdp-use.
+
+        This MUST succeed or the browser is unusable. Fails hard on any error.
+        """
+
+        self.browser_profile.cdp_url = cdp_url or self.cdp_url
+        if not self.cdp_url:
+            raise RuntimeError('Cannot setup CDP connection without CDP URL')
+
+        if not self.cdp_url.startswith('ws'):
+            # If it's an HTTP URL, fetch the WebSocket URL from /json/version endpoint
+            url = self.cdp_url.rstrip('/')
+            if not url.endswith('/json/version'):
+                url = url + '/json/version'
+
+            # Run a tiny HTTP client to query for the WebSocket URL from the /json/version endpoint
+            async with httpx.AsyncClient() as client:
+                headers = self.browser_profile.headers or {}
+                version_info = await client.get(url, headers=headers)
+                self.browser_profile.cdp_url = version_info.json()['webSocketDebuggerUrl']
+
+        assert self.cdp_url is not None
+
+        browser_location = 'local browser' if self.is_local else 'remote browser'
+        self.logger.debug(
+            f'🌎 Connecting to existing chromium-based browser via CDP: {self.cdp_url} -> ({browser_location})')
+
+        try:
+            # Import cdp-use client
+
+            # Convert HTTP URL to WebSocket URL if needed
+
+            # Create and store the CDP client for direct CDP communication
+            self._cdp_client_root = CDPClient(self.cdp_url)
+            assert self._cdp_client_root is not None
+            await self._cdp_client_root.start()
+            await self._cdp_client_root.send.Target.setAutoAttach(
+                params={'autoAttach': True, 'waitForDebuggerOnStart': False, 'flatten': True}
+            )
+            self.logger.debug('CDP client connected successfully')
+
+            # Get browser targets to find available contexts/pages
+            targets = await self._cdp_client_root.send.Target.getTargets()
+
+            # Find main browser pages (avoiding iframes, workers, extensions, etc.)
+            page_targets: list[TargetInfo] = [
+                t
+                for t in targets['targetInfos']
+                if self._is_valid_target(
+                    t, include_http=True, include_about=True, include_pages=True, include_iframes=False,
+                    include_workers=False
+                )
+            ]
+
+            # Check for chrome://newtab pages and immediately redirect them
+            # to about:blank to avoid JS issues from CDP on chrome://* urls
+            from browser_use.utils import is_new_tab_page
+
+            # Collect all targets that need redirection
+            redirected_targets = []
+            redirect_sessions = {}  # Store sessions created for redirection to potentially reuse
+            for target in page_targets:
+                target_url = target.get('url', '')
+                if is_new_tab_page(target_url) and target_url != '':
+                    # Redirect chrome://newtab to about:blank to avoid JS issues preventing driving chrome://newtab
+                    target_id = target['targetId']
+                    self.logger.debug(f'🔄 Redirecting {target_url} to about:blank for target {target_id}')
+                    try:
+                        # Create a CDP session for redirection (minimal domains to avoid duplicate event handlers)
+                        # Only enable Page domain for navigation, avoid duplicate event handlers
+                        redirect_session = await CDPSession.for_target(self._cdp_client_root, target_id,
+                                                                       domains=['Page'])
+                        # Navigate to about:blank
+                        await redirect_session.cdp_client.send.Page.navigate(
+                            params={'url': ''}, session_id=redirect_session.session_id
+                        )
+                        redirected_targets.append(target_id)
+                        redirect_sessions[target_id] = redirect_session  # Store for potential reuse
+                        # Update the target's URL in our list for later use
+                        target['url'] = ''
+                        # Small delay to ensure navigation completes
+                        await asyncio.sleep(0.1)
+                    except Exception as e:
+                        self.logger.warning(f'Failed to redirect {target_url} to about:blank: {e}')
+
+            # Log summary of redirections
+            if redirected_targets:
+                self.logger.debug(f'Redirected {len(redirected_targets)} chrome://newtab pages to about:blank')
+
+            if not page_targets:
+                # No pages found, create a new one
+                new_target = await self._cdp_client_root.send.Target.createTarget(params={'url': ''})
+                target_id = new_target['targetId']
+                self.logger.debug(f'📄 Created new blank page with target ID: {target_id}')
+            else:
+                # Use the first available page
+                target_id = [page for page in page_targets if page.get('type') == 'page'][0]['targetId']
+                self.logger.debug(f'📄 Using existing page with target ID: {target_id}')
+
+            # Store the current page target ID and add to pool
+            # Reuse redirect session if available, otherwise create new one
+            if target_id in redirect_sessions:
+                self.logger.debug(f'Reusing redirect session for target {target_id}')
+                self.agent_focus = redirect_sessions[target_id]
+            else:
+                # For the initial connection, we'll use the shared root WebSocket
+                self.agent_focus = await CDPSession.for_target(self._cdp_client_root, target_id, new_socket=False)
+            if self.agent_focus:
+                self._cdp_session_pool[target_id] = self.agent_focus
+
+            # Enable proxy authentication handling if configured
+            await self._setup_proxy_auth()
+
+            # Verify the session is working
+            try:
+                if self.agent_focus:
+                    assert self.agent_focus.title != 'Unknown title'
+                else:
+                    raise RuntimeError('Failed to create CDP session')
+            except Exception as e:
+                self.logger.warning(f'Failed to create CDP session: {e}')
+                raise
+
+            # Dispatch TabCreatedEvent for all initial tabs (so watchdogs can initialize)
+            # This replaces the duplicated logic from navigation_watchdog's _initialize_agent_focus
+            for idx, target in enumerate(page_targets):
+                target_url = target.get('url', '')
+                self.logger.debug(f'Dispatching TabCreatedEvent for initial tab {idx}: {target_url}')
+                await self.event_bus.dispatch(TabCreatedEvent(url=target_url, target_id=target['targetId']))
+
+            # Dispatch initial focus event
+            if page_targets:
+                initial_url = page_targets[0].get('url', '')
+                await self.event_bus.dispatch(
+                    AgentFocusChangedEvent(target_id=page_targets[0]['targetId'], url=initial_url))
+                self.logger.debug(f'Initial agent focus set to tab 0: {initial_url}')
+
+        except Exception as e:
+            # Fatal error - browser is not usable without CDP connection
+            self.logger.error(f'❌ FATAL: Failed to setup CDP connection: {e}')
+            self.logger.error('❌ Browser cannot continue without CDP connection')
+            # Clean up any partial state
+            self._cdp_client_root = None
+            self.agent_focus = None
+            # Re-raise as a fatal error
+            raise RuntimeError(f'Failed to establish CDP connection to browser: {e}') from e
+
+        return self
 
     async def connect_agent(self, target_id: str) -> Self:
         """Register agent to browser with optional target assignment."""
@@ -286,7 +461,7 @@ class AgentBrowserSession(BrowserSession):
             return
         await self.get_or_create_cdp_session(self.agent_focus.target_id, focus=True)
 
-    async def navigate_to_url(self, url: str, new_tab: bool = False) -> None:
+    async def navigate_to_url(self, url: str, new_tab: bool = False) -> Optional[str]:
         """
         Concurrent navigation method that bypasses serial bottlenecks in on_NavigateToUrlEvent.
         
@@ -294,7 +469,7 @@ class AgentBrowserSession(BrowserSession):
         """
         if not self.agent_focus:
             self.logger.warning('Cannot navigate - browser not connected')
-            return
+            return None
 
         target_id = None
 
@@ -351,6 +526,8 @@ class AgentBrowserSession(BrowserSession):
                     )
                 )
             raise
+        finally:
+            return target_id
 
     async def _wait_for_stable_network(self):
         """Wait for page stability - simplified for CDP-only branch."""
@@ -477,3 +654,76 @@ class AgentBrowserSession(BrowserSession):
             include_recent_events=include_recent_events
         )
         return browser_state
+
+    @observe_debug(ignore_input=True, ignore_output=True, name='get_tabs')
+    async def get_tabs(self) -> list[TabInfo]:
+        """Get information about all open tabs using CDP Target.getTargetInfo for speed."""
+        tabs = []
+
+        # Safety check - return empty list if browser not connected yet
+        if not self._cdp_client_root:
+            return tabs
+
+        # Get all page targets using CDP
+        pages = await self._cdp_get_all_pages()
+
+        for i, page_target in enumerate(pages):
+            target_id = page_target['targetId']
+            url = page_target['url']
+
+            # Try to get the title directly from Target.getTargetInfo - much faster!
+            # The initial getTargets() doesn't include title, but getTargetInfo does
+            try:
+                target_info = await self.cdp_client.send.Target.getTargetInfo(params={'targetId': target_id})
+                # The title is directly available in targetInfo
+                title = target_info.get('targetInfo', {}).get('title', '')
+
+                # Skip JS execution for chrome:// pages and new tab pages
+                if not title:
+                    # For chrome:// pages without a title, use the URL itself
+                    title = url
+
+                # Special handling for PDF pages without titles
+                if (not title or title == '') and (url.endswith('.pdf') or 'pdf' in url):
+                    # PDF pages might not have a title, use URL filename
+                    try:
+                        from urllib.parse import urlparse
+
+                        filename = urlparse(url).path.split('/')[-1]
+                        if filename:
+                            title = filename
+                    except Exception:
+                        pass
+
+            except Exception as e:
+                # Fallback to basic title handling
+                self.logger.debug(
+                    f'⚠️ Failed to get target info for tab #{i}: {_log_pretty_url(url)} - {type(e).__name__}')
+                title = ''
+
+            tab_info = TabInfo(
+                target_id=target_id,
+                url=url,
+                title=title,
+                parent_target_id=None,
+            )
+            tabs.append(tab_info)
+
+        return tabs
+
+    async def refresh_page(self):
+        cdp_session = await self.browser_session.get_or_create_cdp_session()
+        try:
+            # Reload the target
+            await cdp_session.cdp_client.send.Page.reload(session_id=cdp_session.session_id)
+
+            # Wait for reload
+            await asyncio.sleep(1.0)
+
+            # Note: We don't clear cached state here - let the next state fetch rebuild as needed
+
+            # Navigation is handled by BrowserSession via events
+
+            self.logger.info('🔄 Target refreshed')
+        except Exception as e:
+            raise

vibe_surf/browser/browser_manager.py

@@ -62,7 +62,7 @@ class BrowserManager:
             agent_session._cdp_client_root = await self._get_root_cdp_client()
             logger.info(f"🚀 Starting agent session for {agent_id} to initialize watchdogs...")
             await agent_session.start()
-            
+
             self._agent_sessions[agent_id] = agent_session
         await self.assign_target_to_agent(agent_id, target_id)
         return agent_session
@@ -89,7 +89,7 @@ class BrowserManager:
         # Get or create available target
         if target_id is None:
             new_target = await self.main_browser_session.cdp_client.send.Target.createTarget(
-                params={'url': ''})
+                params={'url': 'about:blank'})
             target_id = new_target["targetId"]
 
         await agent_session.connect_agent(target_id=target_id)
@@ -176,121 +176,86 @@ class BrowserManager:
         """Async context manager exit."""
         await self.close()
 
-    async def _is_target_focused(self, target_id: str) -> bool:
-        """Check if a given target has focus using multiple detection methods."""
-        client = self.main_browser_session.cdp_client
-        session_id = None
-
-        try:
-            # Use document.visibilityState and document.hasFocus()
-            attach_result = await client.send.Target.attachToTarget(
-                params={"targetId": target_id, "flatten": True}
-            )
-            session_id = attach_result["sessionId"]
-
-            # Check both visibility and focus
-            combined_script = """
-            ({
-                hasFocus: document.hasFocus(),
-                visibilityState: document.visibilityState,
-                hidden: document.hidden,
-                activeElement: document.activeElement ? document.activeElement.tagName : null,
-                timestamp: Date.now()
-            })
-            """
-
-            eval_result = await client.send.Runtime.evaluate(
-                params={
-                    "expression": combined_script,
-                    "returnByValue": True
-                },
-                session_id=session_id
-            )
+    async def check_browser_connected(self):
+        import aiohttp
 
-            # Detach immediately after checking
-            await client.send.Target.detachFromTarget(
-                params={"sessionId": session_id}
-            )
-            session_id = None
-
-            if "result" in eval_result and "value" in eval_result["result"]:
-                focus_data = eval_result["result"]["value"]
-                has_focus = focus_data.get("hasFocus", False)
-                visibility_state = focus_data.get("visibilityState", "")
-                is_hidden = focus_data.get("hidden", True)
-
-                # A target is considered focused if:
-                # 1. Document has focus OR
-                # 2. Document is visible (not hidden)
-                is_focused = has_focus or (visibility_state == "visible" and not is_hidden)
-                return is_focused
-            else:
-                return False
-
-        except Exception:
-            if session_id:
-                try:
-                    await client.send.Target.detachFromTarget(
-                        params={"sessionId": session_id}
-                    )
-                except Exception:
-                    pass  # Ignore cleanup errors
+        if not self.main_browser_session:
+            logger.info("No Main browser session available.")
             return False
 
+        for _ in range(5):
+            try:
+                targets = await self.main_browser_session.cdp_client.send.Target.getTargets()
+                await asyncio.sleep(1)
+                return len(targets) > 0
+            except Exception as e:
+                logger.error(f"Connect failed: {e}")
+        return False
+
     async def _get_active_target(self) -> str:
         """Get current focused target, or an available target, or create a new one."""
-        client = self.main_browser_session.cdp_client
-        targets_info = await client.send.Target.getTargets()
-        page_targets = [t for t in targets_info["targetInfos"] if t["type"] == "page"]
-
+        tab_infos = await self.get_all_tabs()
         # 1. Check for a focused page among ALL pages (not just unassigned)
-        for target in page_targets:
-            target_id = target["targetId"]
+        for tab_info in tab_infos:
+            target_id = tab_info.target_id
             try:
-                is_focused = await self._is_target_focused(target_id)
-                if is_focused:
-                    return target_id
+                simple_check = """
+                            ({
+                                hasFocus: document.hasFocus(),
+                                isVisible: document.visibilityState === 'visible',
+                                notHidden: !document.hidden
+                            })
+                            """
+                cdb_session = await self.main_browser_session.get_or_create_cdp_session(target_id, focus=False,
+                                                                                        new_socket=None)
+                eval_result = await cdb_session.cdp_client.send.Runtime.evaluate(
+                    params={
+                        "expression": simple_check,
+                        "returnByValue": True
+                    },
+                    session_id=cdb_session.session_id
+                )
+                if "result" in eval_result and "value" in eval_result["result"]:
+                    data = eval_result["result"]["value"]
+                    is_visible = data.get("isVisible", False)
+                    not_hidden = data.get("notHidden", False)
+                    if is_visible and not_hidden:
+                        return target_id
             except Exception as e:
+                logger.warning(f"Get active target {e}")
                 continue  # Skip invalid targets
 
         # 2. If no pages are available, create a new one
-        if page_targets:
-            target_id = page_targets[-1]["targetId"]
+        if tab_infos:
+            target_id = tab_infos[0].target_id
         else:
-            new_target = await client.send.Target.createTarget(params={'url': ''})
-            target_id = new_target["targetId"]
-        await self.main_browser_session.get_or_create_cdp_session(target_id, focus=False)
+            target_id = await self.main_browser_session.navigate_to_url(url="about:blank", new_tab=True)
         return target_id
 
-    async def _get_activate_tab_info(self) -> Optional[TabInfo]:
+    async def get_activate_tab(self) -> Optional[TabInfo]:
         """Get tab information for the currently active target."""
         try:
             # Get the active target ID
             active_target_id = await self._get_active_target()
-
+            if active_target_id is None:
+                return None
             # Get target information from CDP
-            client = self.main_browser_session.cdp_client
-            targets_info = await client.send.Target.getTargets()
+            tab_infos = await self.get_all_tabs()
 
             # Find the active target in the targets list
-            for target in targets_info["targetInfos"]:
-                if target["targetId"] == active_target_id and target["type"] == "page":
-                    # Get additional target info for title if needed
-                    try:
-                        target_info = await client.send.Target.getTargetInfo(
-                            params={'targetId': active_target_id}
-                        )
-                        target_details = target_info.get('targetInfo', target)
-                    except Exception:
-                        target_details = target
-
+            for tab_info in tab_infos:
+                if tab_info.target_id == active_target_id:
+                    await self.main_browser_session.get_or_create_cdp_session(active_target_id, focus=True)
                     # Create TabInfo object
                     return TabInfo(
-                        url=target_details.get('url', ''),
-                        title=target_details.get('title', ''),
+                        url=tab_info.url,
+                        title=tab_info.title,
                         target_id=active_target_id
                     )
-
             return None
         except Exception:
             return None
+
+    async def get_all_tabs(self) -> list[TabInfo]:
+        tabs = await self.main_browser_session.get_tabs()
+        return tabs