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

code_puppy/tools/browser/browser_workflows.py

@@ -5,15 +5,16 @@ from typing import Any, Dict
 
 from pydantic_ai import RunContext
 
-from code_puppy.messaging import emit_info
+from code_puppy import config
+from code_puppy.messaging import emit_error, emit_info, emit_success, emit_warning
 from code_puppy.tools.common import generate_group_id
 
 
 def get_workflows_directory() -> Path:
-    """Get the browser workflows directory, creating it if it doesn't exist."""
-    home_dir = Path.home()
-    workflows_dir = home_dir / ".code_puppy" / "browser_workflows"
-    workflows_dir.mkdir(parents=True, exist_ok=True)
+    """Get the browser workflows directory, creating it if it doesn't exist (uses XDG_DATA_HOME)."""
+    data_dir = Path(config.DATA_DIR)
+    workflows_dir = data_dir / "browser_workflows"
+    workflows_dir.mkdir(parents=True, exist_ok=True, mode=0o700)
     return workflows_dir
 
 
@@ -21,15 +22,33 @@ async def save_workflow(name: str, content: str) -> Dict[str, Any]:
     """Save a browser workflow as a markdown file."""
     group_id = generate_group_id("save_workflow", name)
     emit_info(
-        f"[bold white on blue] SAVE WORKFLOW [/bold white on blue] 💾 name='{name}'",
+        f"SAVE WORKFLOW 💾 name='{name}'",
         message_group=group_id,
     )
 
     try:
         workflows_dir = get_workflows_directory()
 
-        # Clean up the filename - remove spaces, special chars, etc.
-        safe_name = "".join(c for c in name if c.isalnum() or c in ("-", "_")).lower()
+        # Clean up the filename - convert spaces to hyphens, handle special chars
+        import re
+
+        # Remove .md extension if present (we'll add it back at the end)
+        if name.lower().endswith(".md"):
+            name = name[:-3]
+
+        # Convert spaces to hyphens
+        safe_name = name.replace(" ", "-")
+
+        # Replace special characters with double hyphens
+        safe_name = re.sub(r"[^a-zA-Z0-9\-_]", "--", safe_name)
+
+        # Convert to lowercase
+        safe_name = safe_name.lower()
+
+        # Remove any leading/trailing hyphens and collapse multiple hyphens
+        safe_name = re.sub(r"^-+|-+$", "", safe_name)
+        safe_name = re.sub(r"-{3,}", "--", safe_name)
+
         if not safe_name:
             safe_name = "workflow"
 
@@ -43,8 +62,8 @@ async def save_workflow(name: str, content: str) -> Dict[str, Any]:
         with open(workflow_path, "w", encoding="utf-8") as f:
             f.write(content)
 
-        emit_info(
-            f"[green]✅ Workflow saved successfully: {workflow_path}[/green]",
+        emit_success(
+            f"Workflow saved successfully: {workflow_path}",
             message_group=group_id,
         )
 
@@ -56,8 +75,8 @@ async def save_workflow(name: str, content: str) -> Dict[str, Any]:
         }
 
     except Exception as e:
-        emit_info(
-            f"[red]❌ Failed to save workflow: {e}[/red]",
+        emit_error(
+            f"Failed to save workflow: {e}",
             message_group=group_id,
         )
         return {"success": False, "error": str(e), "name": name}
@@ -67,7 +86,7 @@ async def list_workflows() -> Dict[str, Any]:
     """List all available browser workflows."""
     group_id = generate_group_id("list_workflows")
     emit_info(
-        "[bold white on blue] LIST WORKFLOWS [/bold white on blue] 📋",
+        "LIST WORKFLOWS 📋",
         message_group=group_id,
     )
 
@@ -90,15 +109,13 @@ async def list_workflows() -> Dict[str, Any]:
                     }
                 )
             except Exception as e:
-                emit_info(
-                    f"[yellow]Warning: Could not read {workflow_file}: {e}[/yellow]"
-                )
+                emit_warning(f"Could not read {workflow_file}: {e}")
 
         # Sort by modification time (newest first)
         workflows.sort(key=lambda x: x["modified"], reverse=True)
 
-        emit_info(
-            f"[green]✅ Found {len(workflows)} workflow(s)[/green]",
+        emit_success(
+            f"Found {len(workflows)} workflow(s)",
             message_group=group_id,
         )
 
@@ -110,8 +127,8 @@ async def list_workflows() -> Dict[str, Any]:
         }
 
     except Exception as e:
-        emit_info(
-            f"[red]❌ Failed to list workflows: {e}[/red]",
+        emit_error(
+            f"Failed to list workflows: {e}",
             message_group=group_id,
         )
         return {"success": False, "error": str(e)}
@@ -121,7 +138,7 @@ async def read_workflow(name: str) -> Dict[str, Any]:
     """Read a saved browser workflow."""
     group_id = generate_group_id("read_workflow", name)
     emit_info(
-        f"[bold white on blue] READ WORKFLOW [/bold white on blue] 📖 name='{name}'",
+        f"READ WORKFLOW 📖 name='{name}'",
         message_group=group_id,
     )
 
@@ -135,8 +152,8 @@ async def read_workflow(name: str) -> Dict[str, Any]:
         workflow_path = workflows_dir / name
 
         if not workflow_path.exists():
-            emit_info(
-                f"[red]❌ Workflow not found: {name}[/red]",
+            emit_error(
+                f"Workflow not found: {name}",
                 message_group=group_id,
             )
             return {
@@ -149,8 +166,8 @@ async def read_workflow(name: str) -> Dict[str, Any]:
         with open(workflow_path, "r", encoding="utf-8") as f:
             content = f.read()
 
-        emit_info(
-            f"[green]✅ Workflow read successfully: {len(content)} characters[/green]",
+        emit_success(
+            f"Workflow read successfully: {len(content)} characters",
             message_group=group_id,
         )
 
@@ -163,8 +180,8 @@ async def read_workflow(name: str) -> Dict[str, Any]:
         }
 
     except Exception as e:
-        emit_info(
-            f"[red]❌ Failed to read workflow: {e}[/red]",
+        emit_error(
+            f"Failed to read workflow: {e}",
             message_group=group_id,
         )
         return {"success": False, "error": str(e), "name": name}

code_puppy/tools/browser/chromium_terminal_manager.py

@@ -0,0 +1,259 @@
+"""Chromium Terminal Manager - Simple Chromium browser for terminal use.
+
+This module provides a browser manager for Chromium terminal automation.
+Each instance gets its own ephemeral browser context, allowing multiple
+terminal QA agents to run simultaneously without profile conflicts.
+"""
+
+import logging
+import uuid
+from typing import Optional
+
+from playwright.async_api import Browser, BrowserContext, Page, async_playwright
+
+from code_puppy.messaging import emit_info, emit_success
+
+logger = logging.getLogger(__name__)
+
+# Store active manager instances by session ID
+_active_managers: dict[str, "ChromiumTerminalManager"] = {}
+
+
+class ChromiumTerminalManager:
+    """Browser manager for Chromium terminal automation.
+
+    Each instance gets its own ephemeral browser context, allowing multiple
+    terminal QA agents to run simultaneously without profile conflicts.
+
+    Key features:
+    - Ephemeral contexts (no profile locking issues)
+    - Multiple instances can run simultaneously
+    - Visible (headless=False) by default for terminal use
+    - Simple API: initialize, get_current_page, new_page, close
+
+    Usage:
+        manager = get_chromium_terminal_manager()  # or with session_id
+        await manager.async_initialize()
+        page = await manager.get_current_page()
+        await page.goto("https://example.com")
+        await manager.close()
+    """
+
+    _browser: Optional[Browser] = None
+    _context: Optional[BrowserContext] = None
+    _playwright: Optional[object] = None
+    _initialized: bool = False
+
+    def __init__(self, session_id: Optional[str] = None) -> None:
+        """Initialize manager settings.
+
+        Args:
+            session_id: Optional session ID for tracking this instance.
+                If None, a UUID will be generated.
+        """
+        import os
+
+        self.session_id = session_id or str(uuid.uuid4())[:8]
+
+        # Default to headless=False - we want to see the terminal browser!
+        # Can override with CHROMIUM_HEADLESS=true if needed
+        self.headless = os.getenv("CHROMIUM_HEADLESS", "false").lower() == "true"
+
+        logger.debug(
+            f"ChromiumTerminalManager created: session={self.session_id}, "
+            f"headless={self.headless}"
+        )
+
+    async def async_initialize(self) -> None:
+        """Initialize the Chromium browser.
+
+        Launches a Chromium browser with an ephemeral context. The browser
+        runs in visible mode by default (headless=False) for terminal use.
+
+        Raises:
+            Exception: If browser initialization fails.
+        """
+        if self._initialized:
+            logger.debug(
+                f"ChromiumTerminalManager {self.session_id} already initialized"
+            )
+            return
+
+        try:
+            emit_info(
+                f"Initializing Chromium terminal browser (session: {self.session_id})..."
+            )
+
+            # Start Playwright
+            self._playwright = await async_playwright().start()
+
+            # Launch browser (not persistent - allows multiple instances)
+            self._browser = await self._playwright.chromium.launch(
+                headless=self.headless,
+            )
+
+            # Create ephemeral context
+            self._context = await self._browser.new_context()
+            self._initialized = True
+
+            emit_success(
+                f"Chromium terminal browser initialized (session: {self.session_id})"
+            )
+            logger.info(
+                f"Chromium initialized: session={self.session_id}, headless={self.headless}"
+            )
+
+        except Exception as e:
+            logger.error(f"Failed to initialize Chromium: {e}")
+            await self._cleanup()
+            raise
+
+    async def get_current_page(self) -> Optional[Page]:
+        """Get the currently active page, creating one if none exist.
+
+        Lazily initializes the browser if not already initialized.
+
+        Returns:
+            The current page, or None if context is unavailable.
+        """
+        if not self._initialized or not self._context:
+            await self.async_initialize()
+
+        if not self._context:
+            logger.warning("No browser context available")
+            return None
+
+        pages = self._context.pages
+        if pages:
+            return pages[0]
+
+        # Create a new blank page if none exist
+        logger.debug("No existing pages, creating new blank page")
+        return await self._context.new_page()
+
+    async def new_page(self, url: Optional[str] = None) -> Page:
+        """Create a new page, optionally navigating to a URL.
+
+        Lazily initializes the browser if not already initialized.
+
+        Args:
+            url: Optional URL to navigate to after creating the page.
+
+        Returns:
+            The newly created page.
+
+        Raises:
+            RuntimeError: If browser context is not available.
+        """
+        if not self._initialized:
+            await self.async_initialize()
+
+        if not self._context:
+            raise RuntimeError("Browser context not available")
+
+        page = await self._context.new_page()
+        logger.debug(f"Created new page{f' navigating to {url}' if url else ''}")
+
+        if url:
+            await page.goto(url)
+
+        return page
+
+    async def close_page(self, page: Page) -> None:
+        """Close a specific page.
+
+        Args:
+            page: The page to close.
+        """
+        await page.close()
+        logger.debug("Page closed")
+
+    async def get_all_pages(self) -> list[Page]:
+        """Get all open pages.
+
+        Returns:
+            List of all open pages, or empty list if no context.
+        """
+        if not self._context:
+            return []
+        return self._context.pages
+
+    async def _cleanup(self, silent: bool = False) -> None:
+        """Clean up browser resources.
+
+        Args:
+            silent: If True, suppress all errors (used during shutdown).
+        """
+        try:
+            if self._context:
+                try:
+                    await self._context.close()
+                except Exception:
+                    pass
+                self._context = None
+
+            if self._browser:
+                try:
+                    await self._browser.close()
+                except Exception:
+                    pass
+                self._browser = None
+
+            if self._playwright:
+                try:
+                    await self._playwright.stop()
+                except Exception:
+                    pass
+                self._playwright = None
+
+            self._initialized = False
+
+            # Remove from active managers
+            if self.session_id in _active_managers:
+                del _active_managers[self.session_id]
+
+            if not silent:
+                logger.debug(
+                    f"Browser resources cleaned up (session: {self.session_id})"
+                )
+
+        except Exception as e:
+            if not silent:
+                logger.warning(f"Warning during cleanup: {e}")
+
+    async def close(self) -> None:
+        """Close the browser and clean up all resources.
+
+        This properly shuts down the browser and releases all resources.
+        Should be called when done with the browser.
+        """
+        await self._cleanup()
+        emit_info(f"Chromium terminal browser closed (session: {self.session_id})")
+
+
+def get_chromium_terminal_manager(
+    session_id: Optional[str] = None,
+) -> ChromiumTerminalManager:
+    """Get or create a ChromiumTerminalManager 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 ChromiumTerminalManager instance.
+
+    Example:
+        # Default session (for single-agent use)
+        manager = get_chromium_terminal_manager()
+
+        # Named session (for multi-agent use)
+        manager = get_chromium_terminal_manager("agent-1")
+    """
+    session_id = session_id or "default"
+
+    if session_id not in _active_managers:
+        _active_managers[session_id] = ChromiumTerminalManager(session_id)
+
+    return _active_managers[session_id]