code-puppy 0.0.171__py3-none-any.whl → 0.0.173__py3-none-any.whl

code_puppy/tools/browser/camoufox_manager.py

@@ -0,0 +1,194 @@
+"""Camoufox browser manager - privacy-focused Firefox automation."""
+
+from typing import Optional
+
+import camoufox
+from playwright.async_api import Browser, BrowserContext, Page, Playwright, async_playwright
+
+from code_puppy.messaging import emit_info
+from camoufox.pkgman import CamoufoxFetcher
+from camoufox.locale import ALLOW_GEOIP, download_mmdb
+from camoufox.addons import maybe_download_addons, DefaultAddons
+
+
+class CamoufoxManager:
+    """Singleton browser manager for Camoufox (privacy-focused Firefox) automation."""
+
+    _instance: Optional["CamoufoxManager"] = None
+    _browser: Optional[Browser] = None
+    _context: Optional[BrowserContext] = None
+    _playwright: Optional[Playwright] = None
+    _initialized: bool = False
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        # Only initialize once
+        if hasattr(self, "_init_done"):
+            return
+        self._init_done = True
+
+        self.headless = False
+        self.homepage = "https://www.google.com"
+        # Camoufox-specific settings
+        self.geoip = True  # Enable GeoIP spoofing
+        self.block_webrtc = True  # Block WebRTC for privacy
+        self.humanize = True  # Add human-like behavior
+
+    @classmethod
+    def get_instance(cls) -> "CamoufoxManager":
+        """Get the singleton instance."""
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance
+
+    async def async_initialize(self) -> None:
+        """Initialize Camoufox browser."""
+        if self._initialized:
+            return
+
+        try:
+            emit_info("[yellow]Initializing Camoufox (privacy Firefox)...[/yellow]")
+            
+            # Ensure Camoufox binary and dependencies are fetched before launching
+            await self._prefetch_camoufox()
+
+            try:
+                await self._initialize_camoufox()
+                emit_info(
+                    "[green]✅ Camoufox initialized successfully (privacy-focused Firefox)[/green]"
+                )
+            except Exception as camoufox_error:
+                error_reason = str(camoufox_error).splitlines()[0]
+                emit_info(
+                    "[yellow]⚠️ Camoufox failed to initialize, falling back to Playwright Firefox[/yellow]"
+                )
+                await self._cleanup()
+                await self._initialize_playwright_firefox(error_reason)
+
+            self._initialized = True
+
+        except Exception as e:
+            emit_info(f"[red]❌ Failed to initialize browser: {e}[/red]")
+            await self._cleanup()
+            raise
+
+    async def _initialize_camoufox(self) -> None:
+        """Try to start Camoufox with the configured privacy settings."""
+        camoufox_instance = camoufox.AsyncCamoufox(
+            headless=self.headless,
+            block_webrtc=self.block_webrtc,
+            humanize=self.humanize,
+        )
+        self._browser = await camoufox_instance.start()
+        self._context = await self._browser.new_context(
+            viewport={"width": 1920, "height": 1080},
+            ignore_https_errors=True,
+        )
+        page = await self._context.new_page()
+        await page.goto(self.homepage)
+
+    async def _initialize_playwright_firefox(self, error_reason: str) -> None:
+        """Fallback to vanilla Playwright Firefox when Camoufox fails."""
+        self._playwright = await async_playwright().start()
+        self._browser = await self._playwright.firefox.launch(headless=self.headless)
+        self._context = await self._browser.new_context(
+            viewport={"width": 1920, "height": 1080},
+            ignore_https_errors=True,
+        )
+        page = await self._context.new_page()
+        await page.goto(self.homepage)
+        emit_info(
+            f"[green]✅ Playwright Firefox fallback ready (Camoufox error: {error_reason})[/green]"
+        )
+
+    async def get_current_page(self) -> Optional[Page]:
+        """Get the currently active page."""
+        if not self._initialized or not self._context:
+            await self.async_initialize()
+
+        if self._context:
+            pages = self._context.pages
+            return pages[0] if pages else None
+        return None
+
+    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 _prefetch_camoufox(self) -> None:
+        """Prefetch Camoufox binary and dependencies."""
+        emit_info("[cyan]🔍 Ensuring Camoufox binary and dependencies are up-to-date...[/cyan]")
+        
+        # Fetch Camoufox binary if needed
+        CamoufoxFetcher().install()
+        
+        # Fetch GeoIP database if enabled
+        if ALLOW_GEOIP:
+            download_mmdb()
+        
+        # Download default addons
+        maybe_download_addons(list(DefaultAddons))
+        
+        emit_info("[cyan]📦 Camoufox dependencies ready[/cyan]")
+
+    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) -> None:
+        """Clean up browser resources."""
+        try:
+            if self._context:
+                await self._context.close()
+                self._context = None
+            if self._browser:
+                await self._browser.close()
+                self._browser = None
+            if self._playwright:
+                await self._playwright.stop()
+                self._playwright = None
+            self._initialized = False
+        except Exception as e:
+            emit_info(f"[yellow]Warning during cleanup: {e}[/yellow]")
+
+    async def close(self) -> None:
+        """Close the browser and clean up resources."""
+        await self._cleanup()
+        emit_info("[yellow]Camoufox browser closed[/yellow]")
+
+    def __del__(self):
+        """Ensure cleanup on object destruction."""
+        # Note: Can't use async in __del__, so this is just a fallback
+        if self._initialized:
+            import asyncio
+
+            try:
+                loop = asyncio.get_event_loop()
+                if loop.is_running():
+                    loop.create_task(self._cleanup())
+                else:
+                    loop.run_until_complete(self._cleanup())
+            except:
+                pass  # Best effort cleanup
+
+
+# Convenience function for getting the singleton instance
+def get_camoufox_manager() -> CamoufoxManager:
+    """Get the singleton CamoufoxManager instance."""
+    return CamoufoxManager.get_instance()

code_puppy/tools/browser/vqa_agent.py

@@ -0,0 +1,66 @@
+"""Utilities for running visual question-answering via pydantic-ai."""
+
+from __future__ import annotations
+
+from functools import lru_cache
+from typing import Optional
+
+from pydantic import BaseModel, Field
+from pydantic_ai import Agent, BinaryContent, InstrumentationSettings
+
+from code_puppy.config import get_vqa_model_name
+from code_puppy.model_factory import ModelFactory
+
+
+class VisualAnalysisResult(BaseModel):
+    """Structured response from the VQA agent."""
+
+    answer: str
+    confidence: float = Field(ge=0.0, le=1.0)
+    observations: str
+
+
+@lru_cache(maxsize=1)
+def _load_vqa_agent(model_name: str) -> Agent[None, VisualAnalysisResult]:
+    """Create a cached agent instance for visual analysis."""
+    models_config = ModelFactory.load_config()
+    model = ModelFactory.get_model(model_name, models_config)
+
+    instrumentation = InstrumentationSettings(include_binary_content=False)
+
+    instructions = (
+        "You are a visual analysis specialist. Answer the user's question about the provided image. "
+        "Always respond using the structured schema: answer, confidence (0-1 float), observations. "
+        "Confidence reflects how certain you are about the answer. Observations should include useful, concise context."
+    )
+
+    return Agent(
+        model=model,
+        instructions=instructions,
+        output_type=VisualAnalysisResult,
+        retries=2,
+        instrument=instrumentation,
+    )
+
+
+def _get_vqa_agent() -> Agent[None, VisualAnalysisResult]:
+    """Return a cached VQA agent configured with the current model."""
+    model_name = get_vqa_model_name()
+    # lru_cache keyed by model_name ensures refresh when configuration changes
+    return _load_vqa_agent(model_name)
+
+
+def run_vqa_analysis(
+    question: str,
+    image_bytes: bytes,
+    media_type: str = "image/png",
+) -> VisualAnalysisResult:
+    """Execute the VQA agent synchronously against screenshot bytes."""
+    agent = _get_vqa_agent()
+    result = agent.run_sync(
+        [
+            question,
+            BinaryContent(data=image_bytes, media_type=media_type),
+        ]
+    )
+    return result.output

code_puppy/tools/browser_control.py

@@ -0,0 +1,293 @@
+"""Browser initialization and control tools."""
+
+from typing import Any, Dict, Optional
+
+from pydantic_ai import RunContext
+
+from code_puppy.messaging import emit_info
+from code_puppy.tools.common import generate_group_id
+
+from .camoufox_manager import get_camoufox_manager
+
+
+async def initialize_browser(
+    headless: bool = False,
+    browser_type: str = "chromium",
+    homepage: str = "https://www.google.com",
+) -> Dict[str, Any]:
+    """Initialize the browser with specified settings."""
+    group_id = generate_group_id("browser_initialize", f"{browser_type}_{homepage}")
+    emit_info(
+        f"[bold white on blue] BROWSER INITIALIZE [/bold white on blue] 🌐 {browser_type} → {homepage}",
+        message_group=group_id,
+    )
+    try:
+        browser_manager = get_camoufox_manager()
+
+        # Configure browser settings
+        browser_manager.headless = headless
+        browser_manager.browser_type = browser_type
+        browser_manager.homepage = homepage
+
+        # Initialize browser
+        await browser_manager.async_initialize()
+
+        # Get page info
+        page = await browser_manager.get_current_page()
+        if page:
+            url = page.url
+            title = await page.title()
+        else:
+            url = "Unknown"
+            title = "Unknown"
+
+        emit_info(
+            "[green]Browser initialized successfully[/green]", message_group=group_id
+        )
+
+        return {
+            "success": True,
+            "browser_type": browser_type,
+            "headless": headless,
+            "homepage": homepage,
+            "current_url": url,
+            "current_title": title,
+        }
+
+    except Exception as e:
+        emit_info(
+            f"[red]Browser initialization failed: {str(e)}[/red]",
+            message_group=group_id,
+        )
+        return {
+            "success": False,
+            "error": str(e),
+            "browser_type": browser_type,
+            "headless": headless,
+        }
+
+
+async def close_browser() -> Dict[str, Any]:
+    """Close the browser and clean up resources."""
+    group_id = generate_group_id("browser_close")
+    emit_info(
+        "[bold white on blue] BROWSER CLOSE [/bold white on blue] 🔒",
+        message_group=group_id,
+    )
+    try:
+        browser_manager = get_camoufox_manager()
+        await browser_manager.close()
+
+        emit_info(
+            "[yellow]Browser closed successfully[/yellow]", message_group=group_id
+        )
+
+        return {"success": True, "message": "Browser closed"}
+
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+async def get_browser_status() -> Dict[str, Any]:
+    """Get current browser status and information."""
+    group_id = generate_group_id("browser_status")
+    emit_info(
+        "[bold white on blue] BROWSER STATUS [/bold white on blue] 📊",
+        message_group=group_id,
+    )
+    try:
+        browser_manager = get_camoufox_manager()
+
+        if not browser_manager._initialized:
+            return {
+                "success": True,
+                "status": "not_initialized",
+                "browser_type": browser_manager.browser_type,
+                "headless": browser_manager.headless,
+            }
+
+        page = await browser_manager.get_current_page()
+        if page:
+            url = page.url
+            title = await page.title()
+
+            # Get all pages
+            all_pages = await browser_manager.get_all_pages()
+            page_count = len(all_pages)
+        else:
+            url = None
+            title = None
+            page_count = 0
+
+        return {
+            "success": True,
+            "status": "initialized",
+            "browser_type": browser_manager.browser_type,
+            "headless": browser_manager.headless,
+            "current_url": url,
+            "current_title": title,
+            "page_count": page_count,
+        }
+
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+async def create_new_page(url: Optional[str] = None) -> Dict[str, Any]:
+    """Create a new browser page/tab."""
+    group_id = generate_group_id("browser_new_page", url or "blank")
+    emit_info(
+        f"[bold white on blue] BROWSER NEW PAGE [/bold white on blue] 📄 {url or 'blank page'}",
+        message_group=group_id,
+    )
+    try:
+        browser_manager = get_camoufox_manager()
+
+        if not browser_manager._initialized:
+            return {
+                "success": False,
+                "error": "Browser not initialized. Use browser_initialize first.",
+            }
+
+        page = await browser_manager.new_page(url)
+
+        final_url = page.url
+        title = await page.title()
+
+        emit_info(
+            f"[green]Created new page: {final_url}[/green]", message_group=group_id
+        )
+
+        return {"success": True, "url": final_url, "title": title, "requested_url": url}
+
+    except Exception as e:
+        return {"success": False, "error": str(e), "url": url}
+
+
+async def list_pages() -> Dict[str, Any]:
+    """List all open browser pages/tabs."""
+    group_id = generate_group_id("browser_list_pages")
+    emit_info(
+        "[bold white on blue] BROWSER LIST PAGES [/bold white on blue] 📋",
+        message_group=group_id,
+    )
+    try:
+        browser_manager = get_camoufox_manager()
+
+        if not browser_manager._initialized:
+            return {"success": False, "error": "Browser not initialized"}
+
+        all_pages = await browser_manager.get_all_pages()
+
+        pages_info = []
+        for i, page in enumerate(all_pages):
+            try:
+                url = page.url
+                title = await page.title()
+                is_closed = page.is_closed()
+
+                pages_info.append(
+                    {"index": i, "url": url, "title": title, "closed": is_closed}
+                )
+            except Exception as e:
+                pages_info.append(
+                    {
+                        "index": i,
+                        "url": "Error",
+                        "title": "Error",
+                        "error": str(e),
+                        "closed": True,
+                    }
+                )
+
+        return {"success": True, "page_count": len(all_pages), "pages": pages_info}
+
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# Tool registration functions
+def register_initialize_browser(agent):
+    """Register the browser initialization tool."""
+
+    @agent.tool
+    async def browser_initialize(
+        context: RunContext,
+        headless: bool = False,
+        browser_type: str = "chromium",
+        homepage: str = "https://www.google.com",
+    ) -> Dict[str, Any]:
+        """
+        Initialize the browser with specified settings. Must be called before using other browser tools.
+
+        Args:
+            headless: Run browser in headless mode (no GUI)
+            browser_type: Browser engine (chromium, firefox, webkit)
+            homepage: Initial page to load
+
+        Returns:
+            Dict with initialization results
+        """
+        return await initialize_browser(headless, browser_type, homepage)
+
+
+def register_close_browser(agent):
+    """Register the browser close tool."""
+
+    @agent.tool
+    async def browser_close(context: RunContext) -> Dict[str, Any]:
+        """
+        Close the browser and clean up all resources.
+
+        Returns:
+            Dict with close results
+        """
+        return await close_browser()
+
+
+def register_get_browser_status(agent):
+    """Register the browser status tool."""
+
+    @agent.tool
+    async def browser_status(context: RunContext) -> Dict[str, Any]:
+        """
+        Get current browser status and information.
+
+        Returns:
+            Dict with browser status and metadata
+        """
+        return await get_browser_status()
+
+
+def register_create_new_page(agent):
+    """Register the new page creation tool."""
+
+    @agent.tool
+    async def browser_new_page(
+        context: RunContext,
+        url: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Create a new browser page/tab.
+
+        Args:
+            url: Optional URL to navigate to in the new page
+
+        Returns:
+            Dict with new page results
+        """
+        return await create_new_page(url)
+
+
+def register_list_pages(agent):
+    """Register the list pages tool."""
+
+    @agent.tool
+    async def browser_list_pages(context: RunContext) -> Dict[str, Any]:
+        """
+        List all open browser pages/tabs.
+
+        Returns:
+            Dict with information about all open pages
+        """
+        return await list_pages()