navcli 0.1.0__py3-none-any.whl

navcli/server/routes/explore.py

@@ -0,0 +1,382 @@
+"""Explore routes: find, findall, inspect, wait."""
+
+from typing import Optional
+from fastapi import APIRouter, HTTPException, Query
+from pydantic import BaseModel
+import asyncio
+
+from navcli.core.models import CommandResult, Feedback, Element
+from navcli.server.browser import get_page, get_current_state, start_browser, wait_for_network_idle
+from navcli.utils import wait_for_condition
+
+router = APIRouter()
+
+
+class FindRequest(BaseModel):
+    text: str
+
+
+@router.get("/find")
+async def find(text: str = Query(...)) -> CommandResult:
+    """Find first element containing text."""
+    try:
+        if not text:
+            raise HTTPException(status_code=400, detail="text is required")
+
+        await start_browser()
+        page = get_page()
+
+        # Use page.get_by_text if available
+        try:
+            locator = page.get_by_text(text, exact=False).first
+            count = locator.count()
+            if count > 0:
+                # Get element info
+                tag = await locator.evaluate_handle("el => el.tagName")
+                element_text = await locator.inner_text()
+
+                element = Element(
+                    selector=f"text={text}",
+                    tag=tag.lower(),
+                    text=element_text[:200],
+                    clickable=True,
+                    input=False,
+                )
+
+                state = await get_current_state()
+                state.dom.elements = [element]
+
+                return CommandResult(
+                    success=True,
+                    command="find",
+                    state=state,
+                    feedback=Feedback(
+                        action=f"found element with text: {text}",
+                        result=f"tag: {tag}",
+                    ),
+                )
+            else:
+                return CommandResult(
+                    success=False,
+                    command="find",
+                    error=f"no element found with text: {text}",
+                )
+        except Exception:
+            # Fallback: search all elements
+            state = await get_current_state()
+            for elem in state.dom.elements:
+                if text.lower() in elem.text.lower():
+                    return CommandResult(
+                        success=True,
+                        command="find",
+                        state=state,
+                        feedback=Feedback(
+                            action=f"found element with text: {text}",
+                            result=f"selector: {elem.selector}",
+                        ),
+                    )
+
+            return CommandResult(
+                success=False,
+                command="find",
+                error=f"no element found with text: {text}",
+            )
+    except Exception as e:
+        return CommandResult(
+            success=False,
+            command="find",
+            error=str(e),
+        )
+
+
+class FindAllRequest(BaseModel):
+    text: str
+
+
+@router.get("/findall")
+async def findall(text: str = Query(...)) -> CommandResult:
+    """Find all elements containing text."""
+    try:
+        if not text:
+            raise HTTPException(status_code=400, detail="text is required")
+
+        await start_browser()
+        state = await get_current_state()
+
+        matching = [e for e in state.dom.elements if text.lower() in e.text.lower()]
+
+        if matching:
+            state.dom.elements = matching
+            return CommandResult(
+                success=True,
+                command="findall",
+                state=state,
+                feedback=Feedback(
+                    action=f"found {len(matching)} elements with text: {text}",
+                    result=f"found {len(matching)} elements",
+                ),
+            )
+        else:
+            return CommandResult(
+                success=False,
+                command="findall",
+                error=f"no elements found with text: {text}",
+            )
+    except Exception as e:
+        return CommandResult(
+            success=False,
+            command="findall",
+            error=str(e),
+        )
+
+
+class InspectRequest(BaseModel):
+    selector: str
+
+
+@router.get("/inspect")
+async def inspect(selector: str = Query(...)) -> CommandResult:
+    """Inspect element details."""
+    try:
+        if not selector:
+            raise HTTPException(status_code=400, detail="selector is required")
+
+        await start_browser()
+        page = get_page()
+
+        locator = page.locator(selector)
+        count = locator.count()
+
+        if count == 0:
+            return CommandResult(
+                success=False,
+                command="inspect",
+                error=f"element not found: {selector}",
+            )
+
+        # Get element details
+        first = locator.first
+        tag = await first.evaluate_handle("el => el.tagName")
+        text = await first.inner_text()
+        html = await first.inner_html()
+
+        # Get attributes
+        attributes = {}
+        try:
+            all_attrs = await first.evaluate_handle("""
+                el => {
+                    const attrs = {};
+                    for (const attr of el.attributes) {
+                        attrs[attr.name] = attr.value;
+                    }
+                    return attrs;
+                }
+            """)
+            attributes = dict(all_attrs)
+        except Exception:
+            pass
+
+        element = Element(
+            selector=selector,
+            tag=tag.lower(),
+            text=text[:500],
+            clickable=await first.is_enabled() and await first.is_visible(),
+            input=tag.lower() in ("input", "textarea"),
+            type=attributes.get("type"),
+            href=attributes.get("href"),
+            alt=attributes.get("alt"),
+        )
+
+        state = await get_current_state()
+        state.dom.elements = [element]
+
+        return CommandResult(
+            success=True,
+            command="inspect",
+            state=state,
+            feedback=Feedback(
+                action=f"inspected {selector}",
+                result=f"tag: {tag}, visible: {await first.is_visible()}",
+            ),
+        )
+    except Exception as e:
+        return CommandResult(
+            success=False,
+            command="inspect",
+            error=str(e),
+        )
+
+
+class WaitRequest(BaseModel):
+    selector: Optional[str] = None
+    seconds: Optional[float] = None
+
+
+@router.post("/wait")
+async def wait(req: WaitRequest) -> CommandResult:
+    """Wait for selector or timeout."""
+    try:
+        await start_browser()
+        page = get_page()
+
+        if req.selector:
+            # Wait for selector
+            try:
+                await page.wait_for_selector(req.selector, timeout=10000)
+                state = await get_current_state()
+                return CommandResult(
+                    success=True,
+                    command="wait",
+                    state=state,
+                    feedback=Feedback(
+                        action=f"waited for {req.selector}",
+                        result="element appeared",
+                    ),
+                )
+            except asyncio.TimeoutError:
+                return CommandResult(
+                    success=False,
+                    command="wait",
+                    error=f"timeout waiting for {req.selector}",
+                )
+        elif req.seconds:
+            # Wait for seconds
+            await asyncio.sleep(req.seconds)
+            state = await get_current_state()
+            return CommandResult(
+                success=True,
+                command="wait",
+                state=state,
+                feedback=Feedback(
+                    action=f"waited {req.seconds}s",
+                    result="waited",
+                ),
+            )
+        else:
+            # Default: wait for network idle
+            await wait_for_network_idle(3.0)
+            state = await get_current_state()
+            return CommandResult(
+                success=True,
+                command="wait",
+                state=state,
+                feedback=Feedback(
+                    action="waited for network idle",
+                    result="ready",
+                ),
+            )
+    except Exception as e:
+        return CommandResult(
+            success=False,
+            command="wait",
+            error=str(e),
+        )
+
+
+@router.post("/wait/idle")
+async def wait_idle(timeout: float = 3.0) -> CommandResult:
+    """Wait for network idle."""
+    try:
+        await start_browser()
+        idle = await wait_for_network_idle(timeout)
+
+        state = await get_current_state()
+
+        return CommandResult(
+            success=True,
+            command="wait_idle",
+            state=state,
+            feedback=Feedback(
+                action="waited for network idle",
+                result="idle" if idle else "timeout",
+            ),
+        )
+    except Exception as e:
+        return CommandResult(
+            success=False,
+            command="wait_idle",
+            error=str(e),
+        )
+
+
+class ScrollRequest(BaseModel):
+    direction: Optional[str] = None  # top, bottom, up, down
+    x: Optional[int] = None
+    y: Optional[int] = None
+    selector: Optional[str] = None
+
+
+@router.post("/scroll")
+async def scroll(req: ScrollRequest) -> CommandResult:
+    """Scroll the page or element.
+
+    Usage:
+    - scroll?direction=top|bottom|up|down
+    - scroll?x=<num>&y=<num>
+    - scroll?selector=<sel>&into_view=true
+    """
+    try:
+        await start_browser()
+        page = get_page()
+
+        if req.selector:
+            # Scroll element into view
+            locator = page.locator(req.selector)
+            count = locator.count()
+            if count == 0:
+                return CommandResult(
+                    success=False,
+                    command="scroll",
+                    error=f"element not found: {req.selector}",
+                )
+            await locator.first.scroll_into_view_if_needed()
+            action = f"scrolled to {req.selector}"
+        elif req.direction:
+            # Directional scroll
+            if req.direction == "top":
+                await page.evaluate("window.scrollTo(0, 0)")
+                action = "scrolled to top"
+            elif req.direction == "bottom":
+                await page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
+                action = "scrolled to bottom"
+            elif req.direction == "up":
+                await page.evaluate("window.scrollBy(0, -window.innerHeight)")
+                action = "scrolled up"
+            elif req.direction == "down":
+                await page.evaluate("window.scrollBy(0, window.innerHeight)")
+                action = "scrolled down"
+            else:
+                return CommandResult(
+                    success=False,
+                    command="scroll",
+                    error=f"invalid direction: {req.direction}. Use: top, bottom, up, down",
+                )
+        elif req.x is not None and req.y is not None:
+            # Coordinate scroll
+            await page.evaluate(f"window.scrollTo({req.x}, {req.y})")
+            action = f"scrolled to ({req.x}, {req.y})"
+        else:
+            return CommandResult(
+                success=False,
+                command="scroll",
+                error="provide direction, x/y coordinates, or selector",
+            )
+
+        await asyncio.sleep(0.3)  # Brief wait for scroll to complete
+        state = await get_current_state()
+
+        return CommandResult(
+            success=True,
+            command="scroll",
+            state=state,
+            feedback=Feedback(
+                action=action,
+                result="scrolled",
+            ),
+        )
+    except Exception as e:
+        return CommandResult(
+            success=False,
+            command="scroll",
+            error=str(e),
+        )

navcli/server/routes/interaction.py

@@ -0,0 +1,317 @@
+"""Interaction routes: click, type, clear, upload."""
+
+from typing import Optional
+from fastapi import APIRouter, HTTPException, Query
+
+from navcli.core.models import CommandResult, Feedback
+from navcli.server.browser import get_page, get_current_state, start_browser, wait_for_network_idle
+
+router = APIRouter()
+
+
+@router.post("/click")
+async def click(
+    selector: str = Query(..., description="CSS selector"),
+    force: bool = Query(False, description="Force click without waiting"),
+) -> CommandResult:
+    """Click an element."""
+    try:
+        if not selector:
+            raise HTTPException(status_code=400, detail="selector is required")
+
+        await start_browser()
+        page = get_page()
+
+        locator = page.locator(selector)
+
+        # Check if element exists
+        count = locator.count()
+        if count == 0:
+            return CommandResult(
+                success=False,
+                command="click",
+                error=f"element not found: {selector}",
+            )
+
+        if count > 1:
+            return CommandResult(
+                success=False,
+                command="click",
+                error=f"multiple elements found: {selector}",
+            )
+
+        # Click
+        if force:
+            await locator.click(force=True)
+        else:
+            await locator.click()
+
+        # Wait for network idle
+        await wait_for_network_idle(3.0)
+
+        state = await get_current_state()
+
+        return CommandResult(
+            success=True,
+            command="click",
+            state=state,
+            feedback=Feedback(
+                action=f"clicked {selector}",
+                result="clicked",
+            ),
+        )
+    except Exception as e:
+        return CommandResult(
+            success=False,
+            command="click",
+            error=str(e),
+        )
+
+
+@router.post("/type")
+async def type_text(
+    selector: str = Query(..., description="CSS selector"),
+    text: str = Query(..., description="Text to type"),
+) -> CommandResult:
+    """Type text into an input."""
+    try:
+        if not selector:
+            raise HTTPException(status_code=400, detail="selector is required")
+        if not text:
+            raise HTTPException(status_code=400, detail="text is required")
+
+        await start_browser()
+        page = get_page()
+
+        locator = page.locator(selector)
+
+        # Check if element exists
+        count = locator.count()
+        if count == 0:
+            return CommandResult(
+                success=False,
+                command="type",
+                error=f"element not found: {selector}",
+            )
+
+        # Clear and type
+        await locator.clear()
+        await locator.fill(text)
+
+        state = await get_current_state()
+
+        return CommandResult(
+            success=True,
+            command="type",
+            state=state,
+            feedback=Feedback(
+                action=f"typed into {selector}",
+                result=f"typed: {text[:20]}...",
+            ),
+        )
+    except Exception as e:
+        return CommandResult(
+            success=False,
+            command="type",
+            error=str(e),
+        )
+
+
+@router.post("/clear")
+async def clear_input(
+    selector: str = Query(..., description="CSS selector"),
+) -> CommandResult:
+    """Clear an input field."""
+    try:
+        if not selector:
+            raise HTTPException(status_code=400, detail="selector is required")
+
+        await start_browser()
+        page = get_page()
+
+        locator = page.locator(selector)
+
+        # Check if element exists
+        count = locator.count()
+        if count == 0:
+            return CommandResult(
+                success=False,
+                command="clear",
+                error=f"element not found: {selector}",
+            )
+
+        # Clear
+        await locator.clear()
+
+        state = await get_current_state()
+
+        return CommandResult(
+            success=True,
+            command="clear",
+            state=state,
+            feedback=Feedback(
+                action=f"cleared {selector}",
+                result="cleared",
+            ),
+        )
+    except Exception as e:
+        return CommandResult(
+            success=False,
+            command="clear",
+            error=str(e),
+        )
+
+
+@router.post("/upload")
+async def upload_file(
+    selector: str = Query(..., description="CSS selector"),
+    file_path: str = Query(..., description="Path to file"),
+) -> CommandResult:
+    """Upload a file to an input."""
+    try:
+        if not selector:
+            raise HTTPException(status_code=400, detail="selector is required")
+        if not file_path:
+            raise HTTPException(status_code=400, detail="file_path is required")
+
+        # Check if file exists
+        import os
+        if not os.path.exists(file_path):
+            return CommandResult(
+                success=False,
+                command="upload",
+                error=f"file not found: {file_path}",
+            )
+
+        await start_browser()
+        page = get_page()
+
+        locator = page.locator(selector)
+
+        # Check if element exists
+        count = locator.count()
+        if count == 0:
+            return CommandResult(
+                success=False,
+                command="upload",
+                error=f"element not found: {selector}",
+            )
+
+        # Upload file
+        await locator.set_input_files(file_path)
+
+        state = await get_current_state()
+
+        return CommandResult(
+            success=True,
+            command="upload",
+            state=state,
+            feedback=Feedback(
+                action=f"uploaded {file_path} to {selector}",
+                result="uploaded",
+            ),
+        )
+    except Exception as e:
+        return CommandResult(
+            success=False,
+            command="upload",
+            error=str(e),
+        )
+
+
+@router.post("/dblclick")
+async def dblclick(
+    selector: str = Query(..., description="CSS selector"),
+) -> CommandResult:
+    """Double-click an element."""
+    try:
+        if not selector:
+            raise HTTPException(status_code=400, detail="selector is required")
+
+        await start_browser()
+        page = get_page()
+
+        locator = page.locator(selector)
+        count = locator.count()
+        if count == 0:
+            return CommandResult(
+                success=False,
+                command="dblclick",
+                error=f"element not found: {selector}",
+            )
+        if count > 1:
+            return CommandResult(
+                success=False,
+                command="dblclick",
+                error=f"multiple elements found: {selector}",
+            )
+
+        await locator.dblclick()
+
+        await wait_for_network_idle(3.0)
+        state = await get_current_state()
+
+        return CommandResult(
+            success=True,
+            command="dblclick",
+            state=state,
+            feedback=Feedback(
+                action=f"double-clicked {selector}",
+                result="clicked",
+            ),
+        )
+    except Exception as e:
+        return CommandResult(
+            success=False,
+            command="dblclick",
+            error=str(e),
+        )
+
+
+@router.post("/rightclick")
+async def rightclick(
+    selector: str = Query(..., description="CSS selector"),
+) -> CommandResult:
+    """Right-click an element."""
+    try:
+        if not selector:
+            raise HTTPException(status_code=400, detail="selector is required")
+
+        await start_browser()
+        page = get_page()
+
+        locator = page.locator(selector)
+        count = locator.count()
+        if count == 0:
+            return CommandResult(
+                success=False,
+                command="rightclick",
+                error=f"element not found: {selector}",
+            )
+        if count > 1:
+            return CommandResult(
+                success=False,
+                command="rightclick",
+                error=f"multiple elements found: {selector}",
+            )
+
+        await locator.click(button="right")
+
+        await wait_for_network_idle(3.0)
+        state = await get_current_state()
+
+        return CommandResult(
+            success=True,
+            command="rightclick",
+            state=state,
+            feedback=Feedback(
+                action=f"right-clicked {selector}",
+                result="clicked",
+            ),
+        )
+    except Exception as e:
+        return CommandResult(
+            success=False,
+            command="rightclick",
+            error=str(e),
+        )