code-puppy 0.0.170__py3-none-any.whl → 0.0.172__py3-none-any.whl

code_puppy/tools/browser_scripts.py

@@ -0,0 +1,478 @@
+"""JavaScript execution and advanced page manipulation 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 execute_javascript(
+    script: str,
+    timeout: int = 30000,
+) -> Dict[str, Any]:
+    """Execute JavaScript code in the browser context."""
+    group_id = generate_group_id("browser_execute_js", script[:100])
+    emit_info(
+        f"[bold white on blue] BROWSER EXECUTE JS [/bold white on blue] 📜 script='{script[:100]}{'...' if len(script) > 100 else ''}'",
+        message_group=group_id,
+    )
+    try:
+        browser_manager = get_camoufox_manager()
+        page = await browser_manager.get_current_page()
+
+        if not page:
+            return {"success": False, "error": "No active browser page available"}
+
+        # Execute JavaScript
+        result = await page.evaluate(script, timeout=timeout)
+
+        emit_info(
+            "[green]JavaScript executed successfully[/green]", message_group=group_id
+        )
+
+        return {"success": True, "script": script, "result": result}
+
+    except Exception as e:
+        emit_info(
+            f"[red]JavaScript execution failed: {str(e)}[/red]", message_group=group_id
+        )
+        return {"success": False, "error": str(e), "script": script}
+
+
+async def scroll_page(
+    direction: str = "down",
+    amount: int = 3,
+    element_selector: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Scroll the page or a specific element."""
+    target = element_selector or "page"
+    group_id = generate_group_id("browser_scroll", f"{direction}_{amount}_{target}")
+    emit_info(
+        f"[bold white on blue] BROWSER SCROLL [/bold white on blue] 📋 direction={direction} amount={amount} target='{target}'",
+        message_group=group_id,
+    )
+    try:
+        browser_manager = get_camoufox_manager()
+        page = await browser_manager.get_current_page()
+
+        if not page:
+            return {"success": False, "error": "No active browser page available"}
+
+        if element_selector:
+            # Scroll specific element
+            element = page.locator(element_selector)
+            await element.scroll_into_view_if_needed()
+
+            # Get element's current scroll position and dimensions
+            scroll_info = await element.evaluate("""
+                el => {
+                    const rect = el.getBoundingClientRect();
+                    return {
+                        scrollTop: el.scrollTop,
+                        scrollLeft: el.scrollLeft,
+                        scrollHeight: el.scrollHeight,
+                        scrollWidth: el.scrollWidth,
+                        clientHeight: el.clientHeight,
+                        clientWidth: el.clientWidth
+                    };
+                }
+            """)
+
+            # Calculate scroll amount based on element size
+            scroll_amount = scroll_info["clientHeight"] * amount / 3
+
+            if direction.lower() == "down":
+                await element.evaluate(f"el => el.scrollTop += {scroll_amount}")
+            elif direction.lower() == "up":
+                await element.evaluate(f"el => el.scrollTop -= {scroll_amount}")
+            elif direction.lower() == "left":
+                await element.evaluate(f"el => el.scrollLeft -= {scroll_amount}")
+            elif direction.lower() == "right":
+                await element.evaluate(f"el => el.scrollLeft += {scroll_amount}")
+
+            target = f"element '{element_selector}'"
+
+        else:
+            # Scroll page
+            viewport_height = await page.evaluate("() => window.innerHeight")
+            scroll_amount = viewport_height * amount / 3
+
+            if direction.lower() == "down":
+                await page.evaluate(f"window.scrollBy(0, {scroll_amount})")
+            elif direction.lower() == "up":
+                await page.evaluate(f"window.scrollBy(0, -{scroll_amount})")
+            elif direction.lower() == "left":
+                await page.evaluate(f"window.scrollBy(-{scroll_amount}, 0)")
+            elif direction.lower() == "right":
+                await page.evaluate(f"window.scrollBy({scroll_amount}, 0)")
+
+            target = "page"
+
+        # Get current scroll position
+        scroll_pos = await page.evaluate("""
+            () => ({
+                x: window.pageXOffset,
+                y: window.pageYOffset
+            })
+        """)
+
+        emit_info(
+            f"[green]Scrolled {target} {direction}[/green]", message_group=group_id
+        )
+
+        return {
+            "success": True,
+            "direction": direction,
+            "amount": amount,
+            "target": target,
+            "scroll_position": scroll_pos,
+        }
+
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e),
+            "direction": direction,
+            "element_selector": element_selector,
+        }
+
+
+async def scroll_to_element(
+    selector: str,
+    timeout: int = 10000,
+) -> Dict[str, Any]:
+    """Scroll to bring an element into view."""
+    group_id = generate_group_id("browser_scroll_to_element", selector[:100])
+    emit_info(
+        f"[bold white on blue] BROWSER SCROLL TO ELEMENT [/bold white on blue] 🎯 selector='{selector}'",
+        message_group=group_id,
+    )
+    try:
+        browser_manager = get_camoufox_manager()
+        page = await browser_manager.get_current_page()
+
+        if not page:
+            return {"success": False, "error": "No active browser page available"}
+
+        element = page.locator(selector)
+        await element.wait_for(state="attached", timeout=timeout)
+        await element.scroll_into_view_if_needed()
+
+        # Check if element is now visible
+        is_visible = await element.is_visible()
+
+        emit_info(
+            f"[green]Scrolled to element: {selector}[/green]", message_group=group_id
+        )
+
+        return {"success": True, "selector": selector, "visible": is_visible}
+
+    except Exception as e:
+        return {"success": False, "error": str(e), "selector": selector}
+
+
+async def set_viewport_size(
+    width: int,
+    height: int,
+) -> Dict[str, Any]:
+    """Set the viewport size."""
+    group_id = generate_group_id("browser_set_viewport", f"{width}x{height}")
+    emit_info(
+        f"[bold white on blue] BROWSER SET VIEWPORT [/bold white on blue] 🖥️ size={width}x{height}",
+        message_group=group_id,
+    )
+    try:
+        browser_manager = get_camoufox_manager()
+        page = await browser_manager.get_current_page()
+
+        if not page:
+            return {"success": False, "error": "No active browser page available"}
+
+        await page.set_viewport_size({"width": width, "height": height})
+
+        emit_info(
+            f"[green]Set viewport size to {width}x{height}[/green]",
+            message_group=group_id,
+        )
+
+        return {"success": True, "width": width, "height": height}
+
+    except Exception as e:
+        return {"success": False, "error": str(e), "width": width, "height": height}
+
+
+async def wait_for_element(
+    selector: str,
+    state: str = "visible",
+    timeout: int = 30000,
+) -> Dict[str, Any]:
+    """Wait for an element to reach a specific state."""
+    group_id = generate_group_id("browser_wait_for_element", f"{selector[:50]}_{state}")
+    emit_info(
+        f"[bold white on blue] BROWSER WAIT FOR ELEMENT [/bold white on blue] ⏱️ selector='{selector}' state={state} timeout={timeout}ms",
+        message_group=group_id,
+    )
+    try:
+        browser_manager = get_camoufox_manager()
+        page = await browser_manager.get_current_page()
+
+        if not page:
+            return {"success": False, "error": "No active browser page available"}
+
+        element = page.locator(selector)
+        await element.wait_for(state=state, timeout=timeout)
+
+        emit_info(
+            f"[green]Element {selector} is now {state}[/green]", message_group=group_id
+        )
+
+        return {"success": True, "selector": selector, "state": state}
+
+    except Exception as e:
+        return {"success": False, "error": str(e), "selector": selector, "state": state}
+
+
+
+
+
+async def highlight_element(
+    selector: str,
+    color: str = "red",
+    timeout: int = 10000,
+) -> Dict[str, Any]:
+    """Highlight an element with a colored border."""
+    group_id = generate_group_id(
+        "browser_highlight_element", f"{selector[:50]}_{color}"
+    )
+    emit_info(
+        f"[bold white on blue] BROWSER HIGHLIGHT ELEMENT [/bold white on blue] 🔦 selector='{selector}' color={color}",
+        message_group=group_id,
+    )
+    try:
+        browser_manager = get_camoufox_manager()
+        page = await browser_manager.get_current_page()
+
+        if not page:
+            return {"success": False, "error": "No active browser page available"}
+
+        element = page.locator(selector)
+        await element.wait_for(state="visible", timeout=timeout)
+
+        # Add highlight style
+        highlight_script = f"""
+            el => {{
+                el.style.outline = '3px solid {color}';
+                el.style.outlineOffset = '2px';
+                el.style.backgroundColor = '{color}20';  // 20% opacity
+                el.setAttribute('data-highlighted', 'true');
+            }}
+        """
+
+        await element.evaluate(highlight_script)
+
+        emit_info(
+            f"[green]Highlighted element: {selector}[/green]", message_group=group_id
+        )
+
+        return {"success": True, "selector": selector, "color": color}
+
+    except Exception as e:
+        return {"success": False, "error": str(e), "selector": selector}
+
+
+async def clear_highlights() -> Dict[str, Any]:
+    """Clear all element highlights."""
+    group_id = generate_group_id("browser_clear_highlights")
+    emit_info(
+        "[bold white on blue] BROWSER CLEAR HIGHLIGHTS [/bold white on blue] 🧹",
+        message_group=group_id,
+    )
+    try:
+        browser_manager = get_camoufox_manager()
+        page = await browser_manager.get_current_page()
+
+        if not page:
+            return {"success": False, "error": "No active browser page available"}
+
+        # Remove all highlights
+        clear_script = """
+            () => {
+                const highlighted = document.querySelectorAll('[data-highlighted="true"]');
+                highlighted.forEach(el => {
+                    el.style.outline = '';
+                    el.style.outlineOffset = '';
+                    el.style.backgroundColor = '';
+                    el.removeAttribute('data-highlighted');
+                });
+                return highlighted.length;
+            }
+        """
+
+        count = await page.evaluate(clear_script)
+
+        emit_info(f"[green]Cleared {count} highlights[/green]", message_group=group_id)
+
+        return {"success": True, "cleared_count": count}
+
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+# Tool registration functions
+def register_execute_javascript(agent):
+    """Register the JavaScript execution tool."""
+
+    @agent.tool
+    async def browser_execute_js(
+        context: RunContext,
+        script: str,
+        timeout: int = 30000,
+    ) -> Dict[str, Any]:
+        """
+        Execute JavaScript code in the browser context.
+
+        Args:
+            script: JavaScript code to execute
+            timeout: Timeout in milliseconds
+
+        Returns:
+            Dict with execution results
+        """
+        return await execute_javascript(script, timeout)
+
+
+def register_scroll_page(agent):
+    """Register the scroll page tool."""
+
+    @agent.tool
+    async def browser_scroll(
+        context: RunContext,
+        direction: str = "down",
+        amount: int = 3,
+        element_selector: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Scroll the page or a specific element.
+
+        Args:
+            direction: Scroll direction (up, down, left, right)
+            amount: Scroll amount multiplier (1-10)
+            element_selector: Optional selector to scroll specific element
+
+        Returns:
+            Dict with scroll results
+        """
+        return await scroll_page(direction, amount, element_selector)
+
+
+def register_scroll_to_element(agent):
+    """Register the scroll to element tool."""
+
+    @agent.tool
+    async def browser_scroll_to_element(
+        context: RunContext,
+        selector: str,
+        timeout: int = 10000,
+    ) -> Dict[str, Any]:
+        """
+        Scroll to bring an element into view.
+
+        Args:
+            selector: CSS or XPath selector for the element
+            timeout: Timeout in milliseconds
+
+        Returns:
+            Dict with scroll results
+        """
+        return await scroll_to_element(selector, timeout)
+
+
+def register_set_viewport_size(agent):
+    """Register the viewport size tool."""
+
+    @agent.tool
+    async def browser_set_viewport(
+        context: RunContext,
+        width: int,
+        height: int,
+    ) -> Dict[str, Any]:
+        """
+        Set the browser viewport size.
+
+        Args:
+            width: Viewport width in pixels
+            height: Viewport height in pixels
+
+        Returns:
+            Dict with viewport size results
+        """
+        return await set_viewport_size(width, height)
+
+
+def register_wait_for_element(agent):
+    """Register the wait for element tool."""
+
+    @agent.tool
+    async def browser_wait_for_element(
+        context: RunContext,
+        selector: str,
+        state: str = "visible",
+        timeout: int = 30000,
+    ) -> Dict[str, Any]:
+        """
+        Wait for an element to reach a specific state.
+
+        Args:
+            selector: CSS or XPath selector for the element
+            state: State to wait for (visible, hidden, attached, detached)
+            timeout: Timeout in milliseconds
+
+        Returns:
+            Dict with wait results
+        """
+        return await wait_for_element(selector, state, timeout)
+
+
+
+
+
+def register_browser_highlight_element(agent):
+    """Register the element highlighting tool."""
+
+    @agent.tool
+    async def browser_highlight_element(
+        context: RunContext,
+        selector: str,
+        color: str = "red",
+        timeout: int = 10000,
+    ) -> Dict[str, Any]:
+        """
+        Highlight an element with a colored border for visual identification.
+
+        Args:
+            selector: CSS or XPath selector for the element
+            color: Highlight color (red, blue, green, yellow, etc.)
+            timeout: Timeout in milliseconds
+
+        Returns:
+            Dict with highlight results
+        """
+        return await highlight_element(selector, color, timeout)
+
+
+def register_browser_clear_highlights(agent):
+    """Register the clear highlights tool."""
+
+    @agent.tool
+    async def browser_clear_highlights(context: RunContext) -> Dict[str, Any]:
+        """
+        Clear all element highlights from the page.
+
+        Returns:
+            Dict with clear results
+        """
+        return await clear_highlights()

code_puppy/tools/browser_workflows.py

@@ -0,0 +1,215 @@
+"""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.messaging import emit_info
+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)
+    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"[bold white on blue] SAVE WORKFLOW [/bold white on blue] 💾 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()
+        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_info(
+            f"[green]✅ Workflow saved successfully: {workflow_path}[/green]",
+            message_group=group_id,
+        )
+
+        return {
+            "success": True,
+            "path": str(workflow_path),
+            "name": safe_name,
+            "size": len(content)
+        }
+
+    except Exception as e:
+        emit_info(
+            f"[red]❌ Failed to save workflow: {e}[/red]",
+            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(
+        "[bold white on blue] LIST WORKFLOWS [/bold white on blue] 📋",
+        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_info(f"[yellow]Warning: Could not read {workflow_file}: {e}[/yellow]")
+
+        # 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]",
+            message_group=group_id,
+        )
+
+        return {
+            "success": True,
+            "workflows": workflows,
+            "count": len(workflows),
+            "directory": str(workflows_dir)
+        }
+
+    except Exception as e:
+        emit_info(
+            f"[red]❌ Failed to list workflows: {e}[/red]",
+            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"[bold white on blue] READ WORKFLOW [/bold white on blue] 📖 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_info(
+                f"[red]❌ Workflow not found: {name}[/red]",
+                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_info(
+            f"[green]✅ Workflow read successfully: {len(content)} characters[/green]",
+            message_group=group_id,
+        )
+
+        return {
+            "success": True,
+            "name": name,
+            "content": content,
+            "path": str(workflow_path),
+            "size": len(content)
+        }
+
+    except Exception as e:
+        emit_info(
+            f"[red]❌ Failed to read workflow: {e}[/red]",
+            message_group=group_id,
+        )
+        return {"success": False, "error": str(e), "name": name}
+
+
+def register_save_workflow(agent):
+    """Register the save workflow tool."""
+
+    async def save_workflow_tool(
+        context: RunContext,
+        name: str,
+        content: str,
+    ) -> Dict[str, Any]:
+        """
+        Save a browser automation workflow as a markdown file.
+
+        Args:
+            name: Name for the workflow (will be sanitized for filename)
+            content: Markdown content describing the workflow steps
+
+        Returns:
+            Dict with success status and file path
+        """
+        return await save_workflow(name, content)
+
+
+def register_list_workflows(agent):
+    """Register the list workflows tool."""
+
+    async def list_workflows_tool(context: RunContext) -> Dict[str, Any]:
+        """
+        List all saved browser automation workflows.
+
+        Returns:
+            Dict with list of available workflows and their metadata
+        """
+        return await list_workflows()
+
+
+def register_read_workflow(agent):
+    """Register the read workflow tool."""
+
+    async def read_workflow_tool(
+        context: RunContext,
+        name: str,
+    ) -> Dict[str, Any]:
+        """
+        Read a saved browser automation workflow.
+
+        Args:
+            name: Name of the workflow to read (with or without .md extension)
+
+        Returns:
+            Dict with workflow content and metadata
+        """
+        return await read_workflow(name)