code-puppy 0.0.214__py3-none-any.whl → 0.0.366__py3-none-any.whl

code_puppy/tools/browser/browser_manager.py

@@ -0,0 +1,316 @@
+"""Playwright browser manager for browser automation.
+
+Supports multiple simultaneous instances with unique profile directories.
+"""
+
+import asyncio
+import atexit
+import contextvars
+import os
+from pathlib import Path
+from typing import Optional
+
+from playwright.async_api import Browser, BrowserContext, Page
+
+from code_puppy import config
+from code_puppy.messaging import emit_info, emit_success, emit_warning
+
+# Store active manager instances by session ID
+_active_managers: dict[str, "BrowserManager"] = {}
+
+# Context variable for browser session - properly inherits through async tasks
+# This allows parallel agent invocations to each have their own browser instance
+_browser_session_var: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar(
+    "browser_session", default=None
+)
+
+
+def set_browser_session(session_id: Optional[str]) -> contextvars.Token:
+    """Set the browser session ID for the current context.
+
+    This must be called BEFORE any tool calls that use the browser.
+    The context will properly propagate to all subsequent async calls.
+
+    Args:
+        session_id: The session ID to use for browser operations.
+
+    Returns:
+        A token that can be used to reset the context.
+    """
+    return _browser_session_var.set(session_id)
+
+
+def get_browser_session() -> Optional[str]:
+    """Get the browser session ID for the current context.
+
+    Returns:
+        The current session ID, or None if not set.
+    """
+    return _browser_session_var.get()
+
+
+def get_session_browser_manager() -> "BrowserManager":
+    """Get the BrowserManager for the current context's session.
+
+    This is the preferred way to get a browser manager in tool functions,
+    as it automatically uses the correct session ID for the current
+    agent context.
+
+    Returns:
+        A BrowserManager instance for the current session.
+    """
+    session_id = get_browser_session()
+    return get_browser_manager(session_id)
+
+
+# Flag to track if cleanup has already run
+_cleanup_done: bool = False
+
+
+class BrowserManager:
+    """Browser manager for Playwright-based browser automation.
+
+    Supports multiple simultaneous instances, each with its own profile directory.
+    Uses Chromium by default for maximum compatibility.
+    """
+
+    _browser: Optional[Browser] = None
+    _context: Optional[BrowserContext] = None
+    _initialized: bool = False
+
+    def __init__(self, session_id: Optional[str] = None):
+        """Initialize manager settings.
+
+        Args:
+            session_id: Optional session ID for this instance.
+                If None, uses 'default' as the session ID.
+        """
+        self.session_id = session_id or "default"
+
+        # Default to headless=True (no browser spam during tests)
+        # Override with BROWSER_HEADLESS=false to see the browser
+        self.headless = os.getenv("BROWSER_HEADLESS", "true").lower() != "false"
+        self.homepage = "https://www.google.com"
+
+        # Unique profile directory per session for browser state
+        self.profile_dir = self._get_profile_directory()
+
+    def _get_profile_directory(self) -> Path:
+        """Get or create the profile directory for this session.
+
+        Each session gets its own profile directory under:
+        XDG_CACHE_HOME/code_puppy/browser_profiles/<session_id>/
+
+        This allows multiple instances to run simultaneously.
+        """
+        cache_dir = Path(config.CACHE_DIR)
+        profiles_base = cache_dir / "browser_profiles"
+        profile_path = profiles_base / self.session_id
+        profile_path.mkdir(parents=True, exist_ok=True, mode=0o700)
+        return profile_path
+
+    async def async_initialize(self) -> None:
+        """Initialize Chromium browser via Playwright."""
+        if self._initialized:
+            return
+
+        try:
+            emit_info(f"Initializing Chromium browser (session: {self.session_id})...")
+            await self._initialize_browser()
+            self._initialized = True
+
+        except Exception:
+            await self._cleanup()
+            raise
+
+    async def _initialize_browser(self) -> None:
+        """Initialize Playwright Chromium browser with persistent context."""
+        from playwright.async_api import async_playwright
+
+        emit_info(f"Using persistent profile: {self.profile_dir}")
+
+        pw = await async_playwright().start()
+        # Use persistent context directory for Chromium to preserve browser state
+        context = await pw.chromium.launch_persistent_context(
+            user_data_dir=str(self.profile_dir), headless=self.headless
+        )
+        self._context = context
+        self._browser = context.browser
+        self._initialized = True
+
+    async def get_current_page(self) -> Optional[Page]:
+        """Get the currently active page. Lazily creates one if none exist."""
+        if not self._initialized or not self._context:
+            await self.async_initialize()
+
+        if not self._context:
+            return None
+
+        pages = self._context.pages
+        if pages:
+            return pages[0]
+
+        # Lazily create a new blank page without navigation
+        return await self._context.new_page()
+
+    async def new_page(self, url: Optional[str] = None) -> Page:
+        """Create a new page and optionally navigate to URL."""
+        if not self._initialized:
+            await self.async_initialize()
+
+        page = await self._context.new_page()
+        if url:
+            await page.goto(url)
+        return page
+
+    async def close_page(self, page: Page) -> None:
+        """Close a specific page."""
+        await page.close()
+
+    async def get_all_pages(self) -> list[Page]:
+        """Get all open pages."""
+        if not self._context:
+            return []
+        return self._context.pages
+
+    async def _cleanup(self, silent: bool = False) -> None:
+        """Clean up browser resources and save persistent state.
+
+        Args:
+            silent: If True, suppress all errors (used during shutdown).
+        """
+        try:
+            # Save browser state before closing (cookies, localStorage, etc.)
+            if self._context:
+                try:
+                    storage_state_path = self.profile_dir / "storage_state.json"
+                    await self._context.storage_state(path=str(storage_state_path))
+                    if not silent:
+                        emit_success(f"Browser state saved to {storage_state_path}")
+                except Exception as e:
+                    if not silent:
+                        emit_warning(f"Could not save storage state: {e}")
+
+                try:
+                    await self._context.close()
+                except Exception:
+                    pass  # Ignore errors during context close
+                self._context = None
+
+            if self._browser:
+                try:
+                    await self._browser.close()
+                except Exception:
+                    pass  # Ignore errors during browser close
+                self._browser = None
+
+            self._initialized = False
+
+            # Remove from active managers
+            if self.session_id in _active_managers:
+                del _active_managers[self.session_id]
+
+        except Exception as e:
+            if not silent:
+                emit_warning(f"Warning during cleanup: {e}")
+
+    async def close(self) -> None:
+        """Close the browser and clean up resources."""
+        await self._cleanup()
+        emit_info(f"Browser closed (session: {self.session_id})")
+
+
+def get_browser_manager(session_id: Optional[str] = None) -> BrowserManager:
+    """Get or create a BrowserManager instance.
+
+    Args:
+        session_id: Optional session ID. If provided and a manager with this
+            session exists, returns that manager. Otherwise creates a new one.
+            If None, uses 'default' as the session ID.
+
+    Returns:
+        A BrowserManager instance.
+
+    Example:
+        # Default session (for single-agent use)
+        manager = get_browser_manager()
+
+        # Named session (for multi-agent use)
+        manager = get_browser_manager("qa-agent-1")
+    """
+    session_id = session_id or "default"
+
+    if session_id not in _active_managers:
+        _active_managers[session_id] = BrowserManager(session_id)
+
+    return _active_managers[session_id]
+
+
+async def cleanup_all_browsers() -> None:
+    """Close all active browser manager instances.
+
+    This should be called before application exit to ensure all browser
+    connections are properly closed and no dangling futures remain.
+    """
+    global _cleanup_done
+
+    if _cleanup_done:
+        return
+
+    _cleanup_done = True
+
+    # Get a copy of the keys since we'll be modifying the dict during cleanup
+    session_ids = list(_active_managers.keys())
+
+    for session_id in session_ids:
+        manager = _active_managers.get(session_id)
+        if manager and manager._initialized:
+            try:
+                await manager._cleanup(silent=True)
+            except Exception:
+                pass  # Silently ignore all errors during exit cleanup
+
+
+def _sync_cleanup_browsers() -> None:
+    """Synchronous cleanup wrapper for use with atexit.
+
+    Creates a new event loop to run the async cleanup since the main
+    event loop may have already been closed when atexit handlers run.
+    """
+    global _cleanup_done
+
+    if _cleanup_done or not _active_managers:
+        return
+
+    try:
+        # Try to get the running loop first
+        try:
+            loop = asyncio.get_running_loop()
+            # If we're in an async context, schedule the cleanup
+            # but this is unlikely in atexit handlers
+            loop.create_task(cleanup_all_browsers())
+            return
+        except RuntimeError:
+            pass  # No running loop, which is expected in atexit
+
+        # Create a new event loop for cleanup
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            loop.run_until_complete(cleanup_all_browsers())
+        finally:
+            loop.close()
+    except Exception:
+        # Silently swallow ALL errors during exit cleanup
+        # We don't want to spam the user with errors on exit
+        pass
+
+
+# Register the cleanup handler with atexit
+# This ensures browsers are closed even if close_browser() isn't explicitly called
+atexit.register(_sync_cleanup_browsers)
+
+
+# Backwards compatibility aliases
+CamoufoxManager = BrowserManager
+get_camoufox_manager = get_browser_manager

code_puppy/tools/browser/browser_navigation.py

@@ -4,21 +4,21 @@ from typing import Any, Dict
 
 from pydantic_ai import RunContext
 
-from code_puppy.messaging import emit_info
+from code_puppy.messaging import emit_error, emit_info, emit_success
 from code_puppy.tools.common import generate_group_id
 
-from .camoufox_manager import get_camoufox_manager
+from .browser_manager import get_session_browser_manager
 
 
 async def navigate_to_url(url: str) -> Dict[str, Any]:
     """Navigate to a specific URL."""
     group_id = generate_group_id("browser_navigate", url)
     emit_info(
-        f"[bold white on blue] BROWSER NAVIGATE [/bold white on blue] 🌐 {url}",
+        f"BROWSER NAVIGATE 🌐 {url}",
         message_group=group_id,
     )
     try:
-        browser_manager = get_camoufox_manager()
+        browser_manager = get_session_browser_manager()
         page = await browser_manager.get_current_page()
 
         if not page:
@@ -31,12 +31,12 @@ async def navigate_to_url(url: str) -> Dict[str, Any]:
         final_url = page.url
         title = await page.title()
 
-        emit_info(f"[green]Navigated to: {final_url}[/green]", message_group=group_id)
+        emit_success(f"Navigated to: {final_url}", message_group=group_id)
 
         return {"success": True, "url": final_url, "title": title, "requested_url": url}
 
     except Exception as e:
-        emit_info(f"[red]Navigation failed: {str(e)}[/red]", message_group=group_id)
+        emit_error(f"Navigation failed: {str(e)}", message_group=group_id)
         return {"success": False, "error": str(e), "url": url}
 
 
@@ -44,11 +44,11 @@ async def get_page_info() -> Dict[str, Any]:
     """Get current page information."""
     group_id = generate_group_id("browser_get_page_info")
     emit_info(
-        "[bold white on blue] BROWSER GET PAGE INFO [/bold white on blue] 📌",
+        "BROWSER GET PAGE INFO 📌",
         message_group=group_id,
     )
     try:
-        browser_manager = get_camoufox_manager()
+        browser_manager = get_session_browser_manager()
         page = await browser_manager.get_current_page()
 
         if not page:
@@ -67,11 +67,11 @@ async def go_back() -> Dict[str, Any]:
     """Navigate back in browser history."""
     group_id = generate_group_id("browser_go_back")
     emit_info(
-        "[bold white on blue] BROWSER GO BACK [/bold white on blue] ⬅️",
+        "BROWSER GO BACK ⬅️",
         message_group=group_id,
     )
     try:
-        browser_manager = get_camoufox_manager()
+        browser_manager = get_session_browser_manager()
         page = await browser_manager.get_current_page()
 
         if not page:
@@ -89,11 +89,11 @@ async def go_forward() -> Dict[str, Any]:
     """Navigate forward in browser history."""
     group_id = generate_group_id("browser_go_forward")
     emit_info(
-        "[bold white on blue] BROWSER GO FORWARD [/bold white on blue] ➡️",
+        "BROWSER GO FORWARD ➡️",
         message_group=group_id,
     )
     try:
-        browser_manager = get_camoufox_manager()
+        browser_manager = get_session_browser_manager()
         page = await browser_manager.get_current_page()
 
         if not page:
@@ -111,11 +111,11 @@ async def reload_page(wait_until: str = "domcontentloaded") -> Dict[str, Any]:
     """Reload the current page."""
     group_id = generate_group_id("browser_reload", wait_until)
     emit_info(
-        f"[bold white on blue] BROWSER RELOAD [/bold white on blue] 🔄 wait_until={wait_until}",
+        f"BROWSER RELOAD 🔄 wait_until={wait_until}",
         message_group=group_id,
     )
     try:
-        browser_manager = get_camoufox_manager()
+        browser_manager = get_session_browser_manager()
         page = await browser_manager.get_current_page()
 
         if not page:
@@ -135,11 +135,11 @@ async def wait_for_load_state(
     """Wait for page to reach a specific load state."""
     group_id = generate_group_id("browser_wait_for_load", f"{state}_{timeout}")
     emit_info(
-        f"[bold white on blue] BROWSER WAIT FOR LOAD [/bold white on blue] ⏱️ state={state} timeout={timeout}ms",
+        f"BROWSER WAIT FOR LOAD ⏱️ state={state} timeout={timeout}ms",
         message_group=group_id,
     )
     try:
-        browser_manager = get_camoufox_manager()
+        browser_manager = get_session_browser_manager()
         page = await browser_manager.get_current_page()
 
         if not page: