code-puppy 0.0.175__tar.gz → 0.0.176__tar.gz

{code_puppy-0.0.175 → code_puppy-0.0.176}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.175
+Version: 0.0.176
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy

{code_puppy-0.0.175 → code_puppy-0.0.176}/code_puppy/tools/browser/camoufox_manager.py

@@ -3,12 +3,13 @@
 from typing import Optional
 
 import camoufox
-from playwright.async_api import Browser, BrowserContext, Page, Playwright, async_playwright
+from playwright.async_api import Browser, BrowserContext, Page
 
 from code_puppy.messaging import emit_info
-from camoufox.pkgman import CamoufoxFetcher
+from camoufox.pkgman import CamoufoxFetcher, camoufox_path
 from camoufox.locale import ALLOW_GEOIP, download_mmdb
-from camoufox.addons import maybe_download_addons, DefaultAddons
+from camoufox.addons import DefaultAddons
+from camoufox.exceptions import CamoufoxNotInstalled, UnsupportedVersion
 
 
 class CamoufoxManager:
@@ -17,7 +18,6 @@ class CamoufoxManager:
     _instance: Optional["CamoufoxManager"] = None
     _browser: Optional[Browser] = None
     _context: Optional[BrowserContext] = None
-    _playwright: Optional[Playwright] = None
     _initialized: bool = False
 
     def __new__(cls):
@@ -56,23 +56,13 @@ class CamoufoxManager:
             # 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)
-
+            await self._initialize_camoufox()
+            emit_info(
+                "[green]✅ Camoufox initialized successfully (privacy-focused Firefox)[/green]"
+            )
             self._initialized = True
 
         except Exception as e:
-            emit_info(f"[red]❌ Failed to initialize browser: {e}[/red]")
             await self._cleanup()
             raise
 
@@ -82,6 +72,8 @@ class CamoufoxManager:
             headless=self.headless,
             block_webrtc=self.block_webrtc,
             humanize=self.humanize,
+            exclude_addons=list(DefaultAddons),
+            addons=[],
         )
         self._browser = await camoufox_instance.start()
         self._context = await self._browser.new_context(
@@ -91,19 +83,6 @@ class CamoufoxManager:
         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."""
@@ -128,17 +107,25 @@ class CamoufoxManager:
     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()
-        
+
+        needs_install = False
+        try:
+            camoufox_path(download_if_missing=False)
+            emit_info("[cyan]🗃️ Using cached Camoufox installation[/cyan]")
+        except (CamoufoxNotInstalled, FileNotFoundError):
+            emit_info("[cyan]📥 Camoufox not found, installing fresh copy[/cyan]")
+            needs_install = True
+        except UnsupportedVersion:
+            emit_info("[cyan]♻️ Camoufox update required, reinstalling[/cyan]")
+            needs_install = True
+
+        if needs_install:
+            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:
@@ -160,9 +147,6 @@ class CamoufoxManager:
             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]")

{code_puppy-0.0.175 → code_puppy-0.0.176}/code_puppy/tools/browser/vqa_agent.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 from functools import lru_cache
-from typing import Optional
 
 from pydantic import BaseModel, Field
 from pydantic_ai import Agent, BinaryContent
@@ -37,7 +36,6 @@ def _load_vqa_agent(model_name: str) -> Agent[None, VisualAnalysisResult]:
         instructions=instructions,
         output_type=VisualAnalysisResult,
         retries=2,
-        instrument=instrumentation,
     )
 
 

{code_puppy-0.0.175 → code_puppy-0.0.176}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.175"
+version = "0.0.176"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.11"

code_puppy-0.0.175/code_puppy/tools/camoufox_manager.py

@@ -1,150 +0,0 @@
-"""Camoufox browser manager - privacy-focused Firefox automation."""
-
-from typing import Optional
-
-import camoufox
-from playwright.async_api import Browser, BrowserContext, Page
-
-from code_puppy.messaging import emit_info
-
-
-class CamoufoxManager:
-    """Singleton browser manager for Camoufox (privacy-focused Firefox) automation."""
-
-    _instance: Optional["CamoufoxManager"] = None
-    _browser: Optional[Browser] = None
-    _context: Optional[BrowserContext] = 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]")
-
-            # Launch Camoufox with basic privacy settings
-            # Note: Many advanced features require additional packages or are handled internally
-            camoufox_instance = camoufox.AsyncCamoufox(
-                headless=self.headless,
-                # Only using well-supported basic options
-                block_webrtc=self.block_webrtc,
-                humanize=self.humanize,
-                # Let camoufox handle other privacy settings automatically
-            )
-            self._browser = await camoufox_instance.start()
-
-            # Create context (Camoufox handles most privacy settings automatically)
-            self._context = await self._browser.new_context(
-                viewport={"width": 1920, "height": 1080},
-                ignore_https_errors=True,
-            )
-
-            # Create initial page and navigate to homepage
-            page = await self._context.new_page()
-            await page.goto(self.homepage)
-
-            self._initialized = True
-            emit_info(
-                "[green]✅ Camoufox initialized successfully (privacy-focused Firefox)[/green]"
-            )
-
-        except Exception as e:
-            emit_info(f"[red]❌ Failed to initialize Camoufox: {e}[/red]")
-            await self._cleanup()
-            raise
-
-    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 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
-            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()