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

connectonion/cli/browser_agent/scroll_strategies.py

@@ -0,0 +1,276 @@
+"""
+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/cli/commands/copy_commands.py

@@ -39,6 +39,18 @@ PLUGINS = {
     "calendar_plugin": "calendar_plugin.py",
 }
 
+# Registry of copyable TUI components
+TUI = {
+    "chat": "chat.py",
+    "fuzzy": "fuzzy.py",
+    "divider": "divider.py",
+    "footer": "footer.py",
+    "status_bar": "status_bar.py",
+    "dropdown": "dropdown.py",
+    "pick": "pick.py",
+    "keys": "keys.py",
+}
+
 
 def handle_copy(
     names: List[str],
@@ -56,9 +68,11 @@ def handle_copy(
     # Get source directories using import system (works for installed packages)
     import connectonion.useful_tools as tools_module
     import connectonion.useful_plugins as plugins_module
+    import connectonion.tui as tui_module
 
     useful_tools_dir = Path(tools_module.__file__).parent
     useful_plugins_dir = Path(plugins_module.__file__).parent
+    tui_dir = Path(tui_module.__file__).parent
 
     current_dir = Path.cwd()
 
@@ -77,6 +91,12 @@ def handle_copy(
             dest_dir = Path(path) if path else current_dir / "plugins"
             copy_file(source, dest_dir, force)
 
+        # Check if it's a TUI component
+        elif name_lower in TUI:
+            source = tui_dir / TUI[name_lower]
+            dest_dir = Path(path) if path else current_dir / "tui"
+            copy_file(source, dest_dir, force)
+
         else:
             console.print(f"[red]Unknown: {name}[/red]")
             console.print("Use [cyan]co copy --list[/cyan] to see available items")
@@ -100,7 +120,7 @@ def copy_file(source: Path, dest_dir: Path, force: bool):
 
 
 def show_available_items():
-    """Display available tools and plugins."""
+    """Display available tools, plugins, and TUI components."""
     table = Table(title="Available Items to Copy")
     table.add_column("Name", style="cyan")
     table.add_column("Type", style="green")
@@ -112,5 +132,8 @@ def show_available_items():
     for name, file in sorted(PLUGINS.items()):
         table.add_row(name, "plugin", file)
 
+    for name, file in sorted(TUI.items()):
+        table.add_row(name, "tui", file)
+
     console.print(table)
     console.print("\n[dim]Usage: co copy <name> [--path ./custom/][/dim]")

connectonion/cli/commands/deploy_commands.py

@@ -217,4 +217,19 @@ def handle_deploy():
     # Always show URL if we have one
     if url:
         console.print(f"Agent URL: {url}")
+
+    # Always fetch and display container logs
+    if deployment_id:
+        logs_resp = requests.get(
+            f"{API_BASE}/api/v1/deploy/{deployment_id}/logs?tail=20",
+            headers={"Authorization": f"Bearer {api_key}"},
+            timeout=10,
+        )
+        if logs_resp.status_code == 200:
+            logs = logs_resp.json().get("logs", "")
+            if logs:
+                console.print()
+                console.print("[dim]Container logs:[/dim]")
+                console.print(f"[dim]{logs}[/dim]")
+
     console.print()

connectonion/cli/commands/eval_commands.py

@@ -0,0 +1,286 @@
+"""
+Purpose: CLI command for running and managing evals
+LLM-Note:
+  Dependencies: imports from [pathlib, yaml, json, rich, importlib] | imported by [cli/main.py]
+  Data flow: handle_eval() → reads .co/evals/*.yaml → imports agent → runs with stored input → compares expected vs output
+  Integration: exposes handle_eval(name, run) for CLI
+
+Eval YAML format:
+  - `turns`: List of inputs to send to agent sequentially (like a conversation).
+    Each turn can have one input. Turns run in order within same agent session,
+    simulating multi-round conversations. Use single turn for simple evals,
+    or multiple turns to test conversation flow.
+"""
+
+import importlib.util
+import json
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+import yaml
+from pydantic import BaseModel
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+
+class JudgeResult(BaseModel):
+    """Result from LLM judge evaluation."""
+    passed: bool
+    analysis: str
+
+
+def get_agent_from_file(file_path: str, cwd: str):
+    """Import agent instance from file."""
+    from connectonion import Agent
+
+    if not os.path.isabs(file_path):
+        file_path = os.path.join(cwd, file_path)
+
+    if cwd not in sys.path:
+        sys.path.insert(0, cwd)
+
+    spec = importlib.util.spec_from_file_location("agent_module", file_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+    if hasattr(module, 'agent') and isinstance(module.agent, Agent):
+        agent = module.agent
+        agent.logger.enable_sessions = False  # Prevent duplicate eval files
+        return agent
+
+    raise ValueError(
+        f"No 'agent' instance found in {file_path}.\n\n"
+        f"Structure your file like this:\n\n"
+        f"    agent = Agent(...)\n\n"
+        f"    if __name__ == '__main__':\n"
+        f"        agent.input('...')\n"
+    )
+
+
+def handle_eval(name: Optional[str] = None, agent_file: Optional[str] = None):
+    """Run evals and show results.
+
+    Args:
+        name: Optional specific eval name to run
+        agent_file: Optional agent file path (overrides YAML setting)
+    """
+    evals_dir = Path(".co/evals")
+
+    if not evals_dir.exists():
+        console.print("[yellow]No evals found.[/yellow]")
+        console.print("[dim]Create eval files in .co/evals/*.yaml[/dim]")
+        return
+
+    if name:
+        eval_files = list(evals_dir.glob(f"{name}.yaml"))
+        if not eval_files:
+            console.print(f"[red]Eval not found: {name}[/red]")
+            return
+    else:
+        eval_files = list(evals_dir.glob("*.yaml"))
+
+    if not eval_files:
+        console.print("[yellow]No eval files found in .co/evals/[/yellow]")
+        return
+
+    _run_evals(eval_files, agent_file)
+
+    # Reload and show status
+    if name:
+        eval_files = list(evals_dir.glob(f"{name}.yaml"))
+    else:
+        eval_files = list(evals_dir.glob("*.yaml"))
+
+    _show_eval_status(eval_files)
+
+
+def _run_evals(eval_files: list, agent_override: Optional[str] = None):
+    """Run agents for each eval and capture output."""
+    cwd = os.getcwd()
+    agents_cache = {}  # Cache agents by file path
+
+    for eval_file in eval_files:
+        with open(eval_file) as f:
+            data = yaml.safe_load(f)
+
+        # Get agent file: CLI override > YAML > error
+        agent_file = agent_override or data.get('agent')
+        if not agent_file:
+            console.print(f"[red]No agent specified for {eval_file.stem}[/red]")
+            console.print(f"[dim]Add 'agent: agent.py' to the YAML or use --agent flag[/dim]")
+            continue
+
+        # Load agent (cached)
+        if agent_file not in agents_cache:
+            console.print(f"[cyan]Loading:[/cyan] {agent_file}")
+            agents_cache[agent_file] = get_agent_from_file(agent_file, cwd)
+        agent = agents_cache[agent_file]
+
+        turns = data.get('turns', [])
+        if not turns:
+            console.print(f"[yellow]No turns found in {eval_file.stem}[/yellow]")
+            continue
+
+        console.print(f"[cyan]Running:[/cyan] {eval_file.stem}")
+
+        # Reset agent session for fresh state each eval
+        agent.reset_conversation()
+
+        file_modified = False
+        for turn in turns:
+            input_text = turn.get('input', '')
+            if not input_text:
+                continue
+
+            # Show input (truncated)
+            display_input = input_text[:60] + "..." if len(input_text) > 60 else input_text
+            console.print(f"  [dim]input:[/dim] {display_input}")
+
+            # Run agent and capture result
+            result = agent.input(input_text)
+
+            # Extract tools_called and metrics from agent session
+            trace = agent.current_session.get('trace', [])
+            tool_calls = [t for t in trace if t.get('type') == 'tool_execution']
+            llm_calls = [t for t in trace if t.get('type') == 'llm_call']
+            tools_called = [agent.logger._format_tool_call(t) for t in tool_calls]
+
+            total_tokens = sum(
+                (t.get('usage').input_tokens + t.get('usage').output_tokens)
+                for t in llm_calls if t.get('usage')
+            )
+            total_cost = sum(
+                t.get('usage').cost for t in llm_calls if t.get('usage')
+            )
+
+            # Build history as JSON array string (compact, easy to scan)
+            history_str = turn.get('history', '[]')
+            history = json.loads(history_str) if isinstance(history_str, str) else []
+            if turn.get('output'):
+                history.insert(0, {
+                    "ts": turn.get('ts', ''),
+                    "pass": turn.get('pass'),
+                    "tokens": turn.get('tokens', 0),
+                    "cost": turn.get('cost', 0)
+                })
+
+            # Store result in turn
+            turn['output'] = result
+            turn['tools_called'] = tools_called
+            turn['tokens'] = total_tokens
+            turn['cost'] = round(total_cost, 4)
+            turn['ts'] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            turn['run'] = data.get('runs', 0) + 1
+            # Format history as multi-line JSON for readability
+            if history:
+                lines = [json.dumps(h) for h in history]
+                turn['history'] = "[\n" + ",\n".join(lines) + "]"
+            else:
+                turn['history'] = "[]"
+            file_modified = True
+
+            # Judge immediately if expected exists
+            expected = turn.get('expected', '')
+            if expected:
+                judge = _judge_with_llm(expected, result, input_text)
+                turn['pass'] = judge.passed
+                turn['analysis'] = judge.analysis
+                status = "[green]✓[/green]" if judge.passed else "[red]✗[/red]"
+                console.print(f"  {status} {judge.analysis[:60]}...")
+            else:
+                # Show output (truncated)
+                display_output = result[:60] + "..." if len(result) > 60 else result
+                console.print(f"  [green]output:[/green] {display_output}")
+
+        if file_modified:
+            # Update runs count and save
+            data['runs'] = data.get('runs', 0) + 1
+            data['updated'] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            with open(eval_file, 'w') as f:
+                yaml.dump(data, f, default_flow_style=False, allow_unicode=True, sort_keys=False)
+
+        console.print(f"[green]✓[/green] {eval_file.stem} completed")
+        console.print()
+
+    console.print()
+
+
+def _judge_with_llm(expected: str, output: str, input_text: str) -> JudgeResult:
+    """Use LLM to judge if output matches expected."""
+    from connectonion import llm_do
+
+    prompt = f"""You are an eval judge. Determine if the agent's output satisfies the expected criteria.
+
+Input: {input_text}
+Expected: {expected}
+Output: {output}
+
+Does the output satisfy the expected criteria? Consider:
+- Semantic similarity (not exact match)
+- Key information presence
+- Intent fulfillment
+"""
+    return llm_do(prompt, output=JudgeResult)
+
+
+def _show_eval_status(eval_files: list):
+    """Show pass/fail status for all evals (uses stored results, no re-judging)."""
+    table = Table(title="Eval Results", show_header=True)
+    table.add_column("Eval", style="cyan")
+    table.add_column("Status", justify="center")
+    table.add_column("Expected", max_width=30)
+    table.add_column("Output", max_width=30)
+
+    passed = 0
+    failed = 0
+    no_expected = 0
+
+    for eval_file in sorted(eval_files):
+        with open(eval_file) as f:
+            data = yaml.safe_load(f)
+
+        for turn in data.get('turns', []):
+            expected = turn.get('expected', '')
+            output = turn.get('output', '')
+            pass_result = turn.get('pass')
+
+            if not expected:
+                status = "[dim]—[/dim]"
+                no_expected += 1
+            elif pass_result is True:
+                status = "[green]✓ pass[/green]"
+                passed += 1
+            elif pass_result is False:
+                status = "[red]✗ fail[/red]"
+                failed += 1
+            else:
+                status = "[dim]pending[/dim]"
+                no_expected += 1
+
+            # Truncate for display
+            expected_display = (expected[:27] + "...") if len(expected) > 30 else expected
+            output_display = (output[:27] + "...") if len(output) > 30 else output
+
+            table.add_row(
+                eval_file.stem,
+                status,
+                expected_display or "[dim]not set[/dim]",
+                output_display
+            )
+
+    console.print(table)
+    console.print()
+
+    # Summary
+    if failed > 0:
+        console.print(f"[bold red]✗ {failed} failed[/bold red], ", end="")
+    if passed > 0:
+        console.print(f"[bold green]✓ {passed} passed[/bold green], ", end="")
+    if no_expected > 0:
+        console.print(f"[dim]{no_expected} no expected[/dim]", end="")
+    console.print()

connectonion/cli/commands/project_cmd_lib.py

@@ -622,7 +622,7 @@ def generate_custom_template_with_name(description: str, api_key: str, model: st
     # Try to use AI to generate name and code
     if model or api_key:
         try:
-            from ...llm import create_llm
+            from ...core.llm import create_llm
 
             # Use the model specified or default to co/gemini-2.5-pro
             llm_model = model if model else "co/gemini-2.5-pro"

connectonion/cli/main.py

@@ -55,6 +55,7 @@ def _show_help():
     console.print("  [green]create[/green]  <name>     Create new project")
     console.print("  [green]init[/green]              Initialize in current directory")
     console.print("  [green]copy[/green]   <name>     Copy tool/plugin source to project")
+    console.print("  [green]eval[/green]              Run evals and show status")
     console.print("  [green]deploy[/green]            Deploy to ConnectOnion Cloud")
     console.print("  [green]auth[/green]              Authenticate for managed keys")
     console.print("  [green]status[/green]            Check account balance")
@@ -152,6 +153,16 @@ def copy(
     handle_copy(names=names or [], list_all=list_all, path=path, force=force)
 
 
+@app.command()
+def eval(
+    name: Optional[str] = typer.Argument(None, help="Specific eval name"),
+    agent: Optional[str] = typer.Option(None, "--agent", "-a", help="Agent file (overrides YAML)"),
+):
+    """Run evals and show results."""
+    from .commands.eval_commands import handle_eval
+    handle_eval(name=name, agent_file=agent)
+
+
 def cli():
     """Entry point."""
     app()