connectonion 0.6.1__py3-none-any.whl → 0.6.3__py3-none-any.whl

connectonion/cli/browser_agent/scroll_strategies.py

@@ -1,276 +0,0 @@
-"""
-Purpose: Universal scrolling strategies with AI-powered selection and screenshot-based verification
-LLM-Note:
-  Dependencies: imports from [typing, pydantic, connectonion.llm_do, PIL.Image, os, time] | imported by [web_automation.py] | tested by [tests/test_final_scroll.py]
-  Data flow: receives page: Page, take_screenshot: Callable, times: int, description: str from web_automation.scroll() → scroll_with_verification() orchestrates 3 strategies → ai_scroll_strategy() calls llm_do(HTML+scrollable_elements→ScrollStrategy, gpt-4o) → element_scroll_strategy()/page_scroll_strategy() fallbacks → page.evaluate(javascript) executes scroll → screenshots_are_different() compares PIL Images with 1% pixel threshold → returns success/failure string
-  State/Effects: calls page.evaluate() multiple times (mutates DOM scroll positions) | take_screenshot() writes PNG files to screenshots/*.png | time.sleep(1-1.2) between scroll iterations | AI calls to gpt-4o with temperature=0.1 for strategy generation
-  Integration: exposes scroll_with_verification() as main entry point from WebAutomation.scroll() | exposes scroll_page(), scroll_element() as standalone utilities | ScrollStrategy Pydantic model defines AI output schema (javascript: str, explanation: str) | screenshots_are_different() uses PIL for pixel-level comparison
-  Performance: ai_scroll_strategy() calls llm_do() once per scroll session (100-500ms) | analyzes first 5000 chars of HTML | finds up to 3 scrollable elements | executes JS times iterations with 1.2s delays | element/page strategies are synchronous JS execution (fast) | PIL screenshot comparison ~50-100ms
-  Errors: returns descriptive strings (not exceptions) - "All scroll strategies failed", "Browser not open" | screenshot comparison failure returns True (assumes different) to continue | page.evaluate() exceptions caught and next strategy tried | prints debug output to stdout
-  ⚠️ Strategy order: AI-first may be slower but more accurate for complex sites (Gmail) - reorder if speed critical
-  ⚠️ Screenshot verification: 1% threshold may need tuning for high-resolution displays or subtle animations
-"""
-
-from typing import Callable, List, Tuple
-from pydantic import BaseModel
-from connectonion import llm_do
-
-
-class ScrollStrategy(BaseModel):
-    """AI-generated scroll strategy."""
-    javascript: str
-    explanation: str
-
-
-def scroll_with_verification(
-    page,
-    take_screenshot: Callable,
-    times: int = 5,
-    description: str = "the main content area"
-) -> str:
-    """Universal scroll with automatic strategy selection and fallback.
-
-    Tries multiple strategies in order until one works:
-    1. AI-generated strategy (default)
-    2. Element scrolling
-    3. Page scrolling
-
-    Args:
-        page: Playwright page object
-        take_screenshot: Function to take screenshots
-        times: Number of scroll iterations
-        description: What to scroll (natural language)
-
-    Returns:
-        Status message with successful strategy
-    """
-    if not page:
-        return "Browser not open"
-
-    print(f"\n📜 Starting universal scroll for: '{description}'")
-
-    import time
-    timestamp = int(time.time())
-    before_file = f"scroll_before_{timestamp}.png"
-    after_file = f"scroll_after_{timestamp}.png"
-
-    # Take before screenshot
-    take_screenshot(before_file)
-
-    strategies = [
-        ("AI-generated strategy", lambda: ai_scroll_strategy(page, times, description)),
-        ("Element scrolling", lambda: element_scroll_strategy(page, times)),
-        ("Page scrolling", lambda: page_scroll_strategy(page, times))
-    ]
-
-    for strategy_name, strategy_func in strategies:
-        print(f"\n  Trying: {strategy_name}...")
-
-        try:
-            strategy_func()
-            time.sleep(1)
-
-            # Take after screenshot
-            take_screenshot(after_file)
-
-            # Verify scroll worked
-            if screenshots_are_different(before_file, after_file):
-                print(f"  ✅ {strategy_name} WORKED! Content changed.")
-                return f"Scroll successful using {strategy_name}. Check {before_file} vs {after_file}"
-            else:
-                print(f"  ⚠️  {strategy_name} didn't change content. Trying next...")
-                before_file = after_file
-                after_file = f"scroll_after_{timestamp}_next.png"
-
-        except Exception as e:
-            print(f"  ❌ {strategy_name} failed: {e}")
-            continue
-
-    return "All scroll strategies failed. No visible content change."
-
-
-def screenshots_are_different(file1: str, file2: str) -> bool:
-    """Compare screenshots to verify content changed.
-
-    Args:
-        file1: First screenshot filename
-        file2: Second screenshot filename
-
-    Returns:
-        True if screenshots are different
-    """
-    try:
-        from PIL import Image
-        import os
-
-        path1 = os.path.join("screenshots", file1)
-        path2 = os.path.join("screenshots", file2)
-
-        img1 = Image.open(path1).convert('RGB')
-        img2 = Image.open(path2).convert('RGB')
-
-        # Calculate pixel difference
-        diff = sum(
-            abs(a - b)
-            for pixel1, pixel2 in zip(img1.getdata(), img2.getdata())
-            for a, b in zip(pixel1, pixel2)
-        )
-
-        # 1% threshold
-        threshold = img1.size[0] * img1.size[1] * 3 * 0.01
-
-        is_different = diff > threshold
-        print(f"    Screenshot diff: {diff:.0f} (threshold: {threshold:.0f}) - {'DIFFERENT' if is_different else 'SAME'}")
-
-        return is_different
-
-    except Exception as e:
-        print(f"    Warning: Screenshot comparison failed: {e}")
-        return True  # Assume different if comparison fails
-
-
-def ai_scroll_strategy(page, times: int, description: str):
-    """AI-generated scroll strategy.
-
-    Analyzes page structure and generates custom JavaScript.
-    """
-    # Find scrollable elements
-    scrollable_elements = page.evaluate("""
-        (() => {
-            const scrollable = [];
-            document.querySelectorAll('*').forEach(el => {
-                const style = window.getComputedStyle(el);
-                if ((style.overflow === 'auto' || style.overflowY === 'scroll') &&
-                    el.scrollHeight > el.clientHeight) {
-                    scrollable.push({
-                        tag: el.tagName,
-                        classes: el.className,
-                        id: el.id
-                    });
-                }
-            });
-            return scrollable;
-        })()
-    """)
-
-    # Get simplified HTML
-    simplified_html = page.evaluate("""
-        (() => {
-            const clone = document.body.cloneNode(true);
-            clone.querySelectorAll('script, style, img, svg').forEach(el => el.remove());
-            return clone.innerHTML.substring(0, 5000);
-        })()
-    """)
-
-    # Generate scroll strategy using AI
-    strategy = llm_do(
-        f"""Generate JavaScript to scroll "{description}".
-
-Scrollable elements: {scrollable_elements[:3]}
-HTML structure: {simplified_html}
-
-Return IIFE that scrolls the correct element:
-(() => {{
-  const el = document.querySelector('.selector');
-  if (el) el.scrollTop += 1000;
-  return {{success: true}};
-}})()
-""",
-        output=ScrollStrategy,
-        model="gpt-4o",
-        temperature=0.1
-    )
-
-    print(f"    AI generated: {strategy.explanation}")
-
-    # Execute scroll
-    import time
-    for i in range(times):
-        page.evaluate(strategy.javascript)
-        time.sleep(1.2)
-
-
-def element_scroll_strategy(page, times: int):
-    """Scroll first scrollable element found."""
-    import time
-    for i in range(times):
-        page.evaluate("""
-            (() => {
-                const el = Array.from(document.querySelectorAll('*')).find(e => {
-                    const s = window.getComputedStyle(e);
-                    return (s.overflow === 'auto' || s.overflowY === 'scroll') &&
-                           e.scrollHeight > e.clientHeight;
-                });
-                if (el) el.scrollTop += 1000;
-            })()
-        """)
-        time.sleep(1)
-
-
-def page_scroll_strategy(page, times: int):
-    """Scroll the page window."""
-    import time
-    for i in range(times):
-        page.evaluate("window.scrollBy(0, 1000)")
-        time.sleep(1)
-
-
-# Additional scroll helpers that can be called directly
-def scroll_page(page, direction: str = "down", amount: int = 1000) -> str:
-    """Scroll the page in a specific direction.
-
-    Args:
-        page: Playwright page object
-        direction: "down", "up", "top", or "bottom"
-        amount: Pixels to scroll
-
-    Returns:
-        Status message
-    """
-    if not page:
-        return "Browser not open"
-
-    if direction == "bottom":
-        page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
-        return "Scrolled to bottom of page"
-    elif direction == "top":
-        page.evaluate("window.scrollTo(0, 0)")
-        return "Scrolled to top of page"
-    elif direction == "down":
-        page.evaluate(f"window.scrollBy(0, {amount})")
-        return f"Scrolled down {amount} pixels"
-    elif direction == "up":
-        page.evaluate(f"window.scrollBy(0, -{amount})")
-        return f"Scrolled up {amount} pixels"
-    else:
-        return f"Unknown direction: {direction}"
-
-
-def scroll_element(page, selector: str, amount: int = 1000) -> str:
-    """Scroll a specific element by CSS selector.
-
-    Args:
-        page: Playwright page object
-        selector: CSS selector for the element
-        amount: Pixels to scroll
-
-    Returns:
-        Status message
-    """
-    if not page:
-        return "Browser not open"
-
-    result = page.evaluate(f"""
-        (() => {{
-            const element = document.querySelector('{selector}');
-            if (!element) return 'Element not found: {selector}';
-
-            const beforeScroll = element.scrollTop;
-            element.scrollTop += {amount};
-            const afterScroll = element.scrollTop;
-
-            return `Scrolled from ${{beforeScroll}}px to ${{afterScroll}}px (delta: ${{afterScroll - beforeScroll}}px)`;
-        }})()
-    """)
-
-    return result

connectonion/network/asgi.py

@@ -1,407 +0,0 @@
-"""Raw ASGI utilities for HTTP/WebSocket handling.
-
-This module contains the protocol-level code for handling HTTP and WebSocket
-requests. Separated from host.py for better testing and smaller file size.
-
-Design decision: Raw ASGI instead of Starlette/FastAPI for full protocol control.
-See: docs/design-decisions/022-raw-asgi-implementation.md
-"""
-import asyncio
-import hmac
-import json
-import os
-import queue
-import threading
-from pathlib import Path
-from typing import Any, Dict
-
-from pydantic import BaseModel
-
-from .connection import Connection
-
-
-class AsyncToSyncConnection(Connection):
-    """Bridge async WebSocket to sync Connection interface.
-
-    Uses queues to communicate between async WebSocket handler and sync agent code.
-    The agent runs in a thread, sending/receiving via queues.
-    The async handler pumps messages between WebSocket and queues.
-    """
-
-    def __init__(self):
-        self._outgoing: queue.Queue[Dict[str, Any]] = queue.Queue()
-        self._incoming: queue.Queue[Dict[str, Any]] = queue.Queue()
-        self._closed = False
-
-    def send(self, event: Dict[str, Any]) -> None:
-        """Queue event to be sent to client."""
-        if not self._closed:
-            self._outgoing.put(event)
-
-    def receive(self) -> Dict[str, Any]:
-        """Block until response from client."""
-        return self._incoming.get()
-
-    def close(self):
-        """Mark connection as closed."""
-        self._closed = True
-        # Unblock any waiting receive
-        self._incoming.put({"type": "connection_closed"})
-
-
-def _json_default(obj):
-    """Handle non-serializable objects like Pydantic models.
-
-    This enables native JSON serialization for Pydantic BaseModel instances
-    nested in API response dicts, following FastAPI's pattern.
-    """
-    if isinstance(obj, BaseModel):
-        return obj.model_dump()
-    raise TypeError(f"Object of type {type(obj).__name__} is not JSON serializable")
-
-
-async def read_body(receive) -> bytes:
-    """Read complete request body from ASGI receive."""
-    body = b""
-    while True:
-        m = await receive()
-        body += m.get("body", b"")
-        if not m.get("more_body"):
-            break
-    return body
-
-
-# CORS headers for cross-origin requests (e.g., frontend at o.openonion.ai
-# calling deployed agents at *.agents.openonion.ai)
-CORS_HEADERS = [
-    [b"access-control-allow-origin", b"*"],
-    [b"access-control-allow-methods", b"GET, POST, OPTIONS"],
-    [b"access-control-allow-headers", b"authorization, content-type"],
-]
-
-
-async def send_json(send, data: dict, status: int = 200):
-    """Send JSON response via ASGI send."""
-    body = json.dumps(data, default=_json_default).encode()
-    headers = [[b"content-type", b"application/json"]] + CORS_HEADERS
-    await send({"type": "http.response.start", "status": status, "headers": headers})
-    await send({"type": "http.response.body", "body": body})
-
-
-async def send_html(send, html: bytes, status: int = 200):
-    """Send HTML response via ASGI send."""
-    await send({
-        "type": "http.response.start",
-        "status": status,
-        "headers": [[b"content-type", b"text/html; charset=utf-8"]],
-    })
-    await send({"type": "http.response.body", "body": html})
-
-
-async def send_text(send, text: str, status: int = 200):
-    """Send plain text response via ASGI send."""
-    headers = [[b"content-type", b"text/plain; charset=utf-8"]] + CORS_HEADERS
-    await send({"type": "http.response.start", "status": status, "headers": headers})
-    await send({"type": "http.response.body", "body": text.encode()})
-
-
-async def handle_http(
-    scope,
-    receive,
-    send,
-    *,
-    handlers: dict,
-    storage,
-    trust: str,
-    result_ttl: int,
-    start_time: float,
-    blacklist: list | None = None,
-    whitelist: list | None = None,
-):
-    """Route HTTP requests to handlers.
-
-    Args:
-        scope: ASGI scope dict (method, path, headers, etc.)
-        receive: ASGI receive callable
-        send: ASGI send callable
-        handlers: Dict of handler functions (input, session, sessions, health, info, auth)
-        storage: SessionStorage instance
-        trust: Trust level (open/careful/strict)
-        result_ttl: How long to keep results in seconds
-        start_time: Server start time
-        blacklist: Blocked identities
-        whitelist: Allowed identities
-    """
-    method, path = scope["method"], scope["path"]
-
-    # Handle CORS preflight requests
-    if method == "OPTIONS":
-        headers = CORS_HEADERS + [[b"content-length", b"0"]]
-        await send({"type": "http.response.start", "status": 204, "headers": headers})
-        await send({"type": "http.response.body", "body": b""})
-        return
-
-    # Admin endpoints require API key auth
-    if path.startswith("/admin"):
-        headers = dict(scope.get("headers", []))
-        auth = headers.get(b"authorization", b"").decode()
-        expected = os.environ.get("OPENONION_API_KEY", "")
-        if not expected or not auth.startswith("Bearer ") or not hmac.compare_digest(auth[7:], expected):
-            await send_json(send, {"error": "unauthorized"}, 401)
-            return
-
-        if method == "GET" and path == "/admin/logs":
-            result = handlers["admin_logs"]()
-            if "error" in result:
-                await send_json(send, result, 404)
-            else:
-                await send_text(send, result["content"])
-            return
-
-        if method == "GET" and path == "/admin/sessions":
-            await send_json(send, handlers["admin_sessions"]())
-            return
-
-        await send_json(send, {"error": "not found"}, 404)
-        return
-
-    if method == "POST" and path == "/input":
-        body = await read_body(receive)
-        try:
-            data = json.loads(body) if body else {}
-        except json.JSONDecodeError:
-            await send_json(send, {"error": "Invalid JSON"}, 400)
-            return
-
-        prompt, identity, sig_valid, err = handlers["auth"](
-            data, trust, blacklist=blacklist, whitelist=whitelist
-        )
-        if err:
-            status = 401 if err.startswith("unauthorized") else 403 if err.startswith("forbidden") else 400
-            await send_json(send, {"error": err}, status)
-            return
-
-        # Extract session for conversation continuation
-        session = data.get("session")
-        result = handlers["input"](storage, prompt, result_ttl, session)
-        await send_json(send, result)
-
-    elif method == "GET" and path.startswith("/sessions/"):
-        result = handlers["session"](storage, path[10:])
-        await send_json(send, result or {"error": "not found"}, 404 if not result else 200)
-
-    elif method == "GET" and path == "/sessions":
-        await send_json(send, handlers["sessions"](storage))
-
-    elif method == "GET" and path == "/health":
-        await send_json(send, handlers["health"](start_time))
-
-    elif method == "GET" and path == "/info":
-        await send_json(send, handlers["info"](trust))
-
-    elif method == "GET" and path == "/docs":
-        # Serve static docs page
-        try:
-            base = Path(__file__).resolve().parent
-            html_path = base / "static" / "docs.html"
-            html = html_path.read_bytes()
-        except Exception:
-            html = b"<html><body><h1>ConnectOnion Docs</h1><p>Docs not found.</p></body></html>"
-        await send_html(send, html)
-
-    else:
-        await send_json(send, {"error": "not found"}, 404)
-
-
-async def handle_websocket(
-    scope,
-    receive,
-    send,
-    *,
-    handlers: dict,
-    trust: str,
-    blacklist: list | None = None,
-    whitelist: list | None = None,
-):
-    """Handle WebSocket connections at /ws.
-
-    Supports bidirectional communication via Connection interface:
-    - Agent sends events via connection.log() / connection.send()
-    - Agent requests approval via connection.request_approval()
-    - Client responds to approval requests
-
-    Args:
-        scope: ASGI scope dict
-        receive: ASGI receive callable
-        send: ASGI send callable
-        handlers: Dict with 'ws_input' and 'auth' handlers
-        trust: Trust level
-        blacklist: Blocked identities
-        whitelist: Allowed identities
-    """
-    if scope["path"] != "/ws":
-        await send({"type": "websocket.close", "code": 4004})
-        return
-
-    await send({"type": "websocket.accept"})
-
-    while True:
-        msg = await receive()
-        if msg["type"] == "websocket.disconnect":
-            break
-        if msg["type"] == "websocket.receive":
-            try:
-                data = json.loads(msg.get("text", "{}"))
-            except json.JSONDecodeError:
-                await send({"type": "websocket.send",
-                           "text": json.dumps({"type": "ERROR", "message": "Invalid JSON"})})
-                continue
-
-            if data.get("type") == "INPUT":
-                prompt, identity, sig_valid, err = handlers["auth"](
-                    data, trust, blacklist=blacklist, whitelist=whitelist
-                )
-                if err:
-                    await send({"type": "websocket.send",
-                               "text": json.dumps({"type": "ERROR", "message": err})})
-                    continue
-                if not prompt:
-                    await send({"type": "websocket.send",
-                               "text": json.dumps({"type": "ERROR", "message": "prompt required"})})
-                    continue
-
-                # Create connection for bidirectional communication
-                connection = AsyncToSyncConnection()
-                agent_done = threading.Event()
-                result_holder = [None]
-
-                def run_agent():
-                    result_holder[0] = handlers["ws_input"](prompt, connection)
-                    agent_done.set()
-
-                # Start agent in thread
-                agent_thread = threading.Thread(target=run_agent, daemon=True)
-                agent_thread.start()
-
-                # Pump messages between WebSocket and connection
-                await _pump_messages(receive, send, connection, agent_done)
-
-                # Send final result
-                await send({"type": "websocket.send",
-                           "text": json.dumps({"type": "OUTPUT", "result": result_holder[0]})})
-
-
-async def _pump_messages(ws_receive, ws_send, connection: AsyncToSyncConnection, agent_done: threading.Event):
-    """Pump messages between WebSocket and connection queues.
-
-    Runs until agent completes. Handles:
-    - Outgoing: connection._outgoing queue → WebSocket
-    - Incoming: WebSocket → connection._incoming queue (for approval responses)
-    """
-    loop = asyncio.get_event_loop()
-
-    async def send_outgoing():
-        """Send outgoing messages from connection to WebSocket."""
-        while not agent_done.is_set():
-            # Use run_in_executor for blocking queue.get
-            try:
-                event = await loop.run_in_executor(
-                    None, lambda: connection._outgoing.get(timeout=0.05)
-                )
-                await ws_send({"type": "websocket.send", "text": json.dumps(event)})
-            except queue.Empty:
-                pass
-
-        # Drain remaining
-        while True:
-            try:
-                event = connection._outgoing.get_nowait()
-                await ws_send({"type": "websocket.send", "text": json.dumps(event)})
-            except queue.Empty:
-                break
-
-    async def receive_incoming():
-        """Receive incoming messages from WebSocket to connection."""
-        while not agent_done.is_set():
-            try:
-                msg = await asyncio.wait_for(ws_receive(), timeout=0.1)
-                if msg["type"] == "websocket.receive":
-                    try:
-                        data = json.loads(msg.get("text", "{}"))
-                        connection._incoming.put(data)
-                    except json.JSONDecodeError:
-                        pass
-                elif msg["type"] == "websocket.disconnect":
-                    connection.close()
-                    break
-            except asyncio.TimeoutError:
-                continue
-
-    # Run both tasks concurrently
-    send_task = asyncio.create_task(send_outgoing())
-    recv_task = asyncio.create_task(receive_incoming())
-
-    # Wait for agent to complete
-    while not agent_done.is_set():
-        await asyncio.sleep(0.05)
-
-    # Cancel receive task and wait for send to finish draining
-    recv_task.cancel()
-    try:
-        await recv_task
-    except asyncio.CancelledError:
-        pass
-    await send_task
-
-
-def create_app(
-    *,
-    handlers: dict,
-    storage,
-    trust: str = "careful",
-    result_ttl: int = 86400,
-    blacklist: list | None = None,
-    whitelist: list | None = None,
-):
-    """Create ASGI application.
-
-    Args:
-        handlers: Dict of handler functions
-        storage: SessionStorage instance
-        trust: Trust level (open/careful/strict)
-        result_ttl: How long to keep results in seconds
-        blacklist: Blocked identities
-        whitelist: Allowed identities
-
-    Returns:
-        ASGI application callable
-    """
-    import time
-    start_time = time.time()
-
-    async def app(scope, receive, send):
-        if scope["type"] == "http":
-            await handle_http(
-                scope,
-                receive,
-                send,
-                handlers=handlers,
-                storage=storage,
-                trust=trust,
-                result_ttl=result_ttl,
-                start_time=start_time,
-                blacklist=blacklist,
-                whitelist=whitelist,
-            )
-        elif scope["type"] == "websocket":
-            await handle_websocket(
-                scope,
-                receive,
-                send,
-                handlers=handlers,
-                trust=trust,
-                blacklist=blacklist,
-                whitelist=whitelist,
-            )
-
-    return app