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

code_puppy/tools/browser/browser_workflows.py

@@ -0,0 +1,221 @@
+"""Browser workflow management tools for saving and reusing automation patterns."""
+
+from pathlib import Path
+from typing import Any, Dict
+
+from pydantic_ai import RunContext
+
+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 (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
+
+
+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"SAVE WORKFLOW 💾 name='{name}'",
+        message_group=group_id,
+    )
+
+    try:
+        workflows_dir = get_workflows_directory()
+
+        # 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"
+
+        # Ensure .md extension
+        if not safe_name.endswith(".md"):
+            safe_name += ".md"
+
+        workflow_path = workflows_dir / safe_name
+
+        # Write the workflow content
+        with open(workflow_path, "w", encoding="utf-8") as f:
+            f.write(content)
+
+        emit_success(
+            f"Workflow saved successfully: {workflow_path}",
+            message_group=group_id,
+        )
+
+        return {
+            "success": True,
+            "path": str(workflow_path),
+            "name": safe_name,
+            "size": len(content),
+        }
+
+    except Exception as e:
+        emit_error(
+            f"Failed to save workflow: {e}",
+            message_group=group_id,
+        )
+        return {"success": False, "error": str(e), "name": name}
+
+
+async def list_workflows() -> Dict[str, Any]:
+    """List all available browser workflows."""
+    group_id = generate_group_id("list_workflows")
+    emit_info(
+        "LIST WORKFLOWS 📋",
+        message_group=group_id,
+    )
+
+    try:
+        workflows_dir = get_workflows_directory()
+
+        # Find all .md files in the workflows directory
+        workflow_files = list(workflows_dir.glob("*.md"))
+
+        workflows = []
+        for workflow_file in workflow_files:
+            try:
+                stat = workflow_file.stat()
+                workflows.append(
+                    {
+                        "name": workflow_file.name,
+                        "path": str(workflow_file),
+                        "size": stat.st_size,
+                        "modified": stat.st_mtime,
+                    }
+                )
+            except Exception as e:
+                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_success(
+            f"Found {len(workflows)} workflow(s)",
+            message_group=group_id,
+        )
+
+        return {
+            "success": True,
+            "workflows": workflows,
+            "count": len(workflows),
+            "directory": str(workflows_dir),
+        }
+
+    except Exception as e:
+        emit_error(
+            f"Failed to list workflows: {e}",
+            message_group=group_id,
+        )
+        return {"success": False, "error": str(e)}
+
+
+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"READ WORKFLOW 📖 name='{name}'",
+        message_group=group_id,
+    )
+
+    try:
+        workflows_dir = get_workflows_directory()
+
+        # Handle both with and without .md extension
+        if not name.endswith(".md"):
+            name += ".md"
+
+        workflow_path = workflows_dir / name
+
+        if not workflow_path.exists():
+            emit_error(
+                f"Workflow not found: {name}",
+                message_group=group_id,
+            )
+            return {
+                "success": False,
+                "error": f"Workflow '{name}' not found",
+                "name": name,
+            }
+
+        # Read the workflow content
+        with open(workflow_path, "r", encoding="utf-8") as f:
+            content = f.read()
+
+        emit_success(
+            f"Workflow read successfully: {len(content)} characters",
+            message_group=group_id,
+        )
+
+        return {
+            "success": True,
+            "name": name,
+            "content": content,
+            "path": str(workflow_path),
+            "size": len(content),
+        }
+
+    except Exception as e:
+        emit_error(
+            f"Failed to read workflow: {e}",
+            message_group=group_id,
+        )
+        return {"success": False, "error": str(e), "name": name}
+
+
+def register_save_workflow(agent):
+    """Register the save workflow tool."""
+
+    @agent.tool
+    async def browser_save_workflow(
+        context: RunContext,
+        name: str,
+        content: str,
+    ) -> Dict[str, Any]:
+        """Save a browser automation workflow to disk for future reuse."""
+        return await save_workflow(name, content)
+
+
+def register_list_workflows(agent):
+    """Register the list workflows tool."""
+
+    @agent.tool
+    async def browser_list_workflows(context: RunContext) -> Dict[str, Any]:
+        """List all saved browser automation workflows."""
+        return await list_workflows()
+
+
+def register_read_workflow(agent):
+    """Register the read workflow tool."""
+
+    @agent.tool
+    async def browser_read_workflow(
+        context: RunContext,
+        name: str,
+    ) -> Dict[str, Any]:
+        """Read the contents of a saved browser automation workflow."""
+        return await read_workflow(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]