webtap-tool 0.11.0__py3-none-any.whl

webtap/commands/setup.py

@@ -0,0 +1,219 @@
+"""Setup commands for WebTap components."""
+
+from webtap.app import app
+from webtap.services.setup import SetupService
+
+
+@app.command(
+    display="markdown",
+    typer={"name": "setup-extension", "help": "Download Chrome extension from GitHub"},
+    fastmcp={"enabled": False},
+)
+def setup_extension(state, force: bool = False) -> dict:
+    """Download Chrome extension to platform-appropriate location.
+
+    Linux: ~/.local/share/webtap/extension/
+    macOS: ~/Library/Application Support/webtap/extension/
+
+    Args:
+        force: Overwrite existing files (default: False)
+
+    Returns:
+        Markdown-formatted result with success/error messages
+    """
+    service = SetupService()
+    result = service.install_extension(force=force)
+    return _format_setup_result(result, "extension")
+
+
+@app.command(
+    display="markdown",
+    typer={"name": "setup-chrome", "help": "Install Chrome wrapper script for debugging"},
+    fastmcp={"enabled": False},
+)
+def setup_chrome(state, force: bool = False, bindfs: bool = False) -> dict:
+    """Install Chrome wrapper script 'chrome-debug' to ~/.local/bin/.
+
+    The wrapper enables remote debugging on port 9222.
+    Same location on both Linux and macOS: ~/.local/bin/chrome-debug
+
+    Args:
+        force: Overwrite existing script (default: False)
+        bindfs: Use bindfs to mount real Chrome profile for debugging (Linux only, default: False)
+
+    Returns:
+        Markdown-formatted result with success/error messages
+    """
+    service = SetupService()
+    result = service.install_chrome_wrapper(force=force, bindfs=bindfs)
+    return _format_setup_result(result, "chrome")
+
+
+@app.command(
+    display="markdown",
+    typer={"name": "setup-desktop", "help": "Install Chrome Debug GUI launcher"},
+    fastmcp={"enabled": False},
+)
+def setup_desktop(state, force: bool = False) -> dict:
+    """Install Chrome Debug GUI launcher (separate from system Chrome).
+
+    Linux: Creates desktop entry at ~/.local/share/applications/chrome-debug.desktop
+           Shows as "Chrome Debug" in application menu.
+
+    macOS: Creates app bundle at ~/Applications/Chrome Debug.app
+           Shows as "Chrome Debug" in Launchpad and Spotlight.
+
+    Args:
+        force: Overwrite existing launcher (default: False)
+
+    Returns:
+        Markdown-formatted result with success/error messages
+    """
+    service = SetupService()
+    result = service.install_desktop_entry(force=force)
+    return _format_setup_result(result, "desktop")
+
+
+def _format_setup_result(result: dict, component: str) -> dict:
+    """Format setup result as markdown."""
+    elements = []
+
+    # Main message as alert (using "message" key for consistency)
+    level = "success" if result["success"] else "error"
+    elements.append({"type": "alert", "message": result["message"], "level": level})
+
+    # Add details if present
+    if result.get("path"):
+        elements.append({"type": "text", "content": f"**Location:** `{result['path']}`"})
+    if result.get("details"):
+        elements.append({"type": "text", "content": f"**Details:** {result['details']}"})
+
+    # Component-specific next steps
+    if result["success"]:
+        if component == "extension":
+            elements.append({"type": "text", "content": "\n**To install in Chrome:**"})
+            elements.append(
+                {
+                    "type": "list",
+                    "items": [
+                        "Open chrome://extensions/",
+                        "Enable Developer mode",
+                        "Click 'Load unpacked'",
+                        f"Select {result['path']}",
+                    ],
+                }
+            )
+        elif component == "chrome":
+            if "Add to PATH" in result.get("details", ""):
+                elements.append({"type": "text", "content": "\n**Setup PATH:**"})
+                elements.append(
+                    {
+                        "type": "code_block",
+                        "language": "bash",
+                        "content": 'export PATH="$HOME/.local/bin/wrappers:$PATH"',
+                    }
+                )
+                elements.append({"type": "text", "content": "Add to ~/.bashrc to make permanent"})
+            else:
+                elements.append({"type": "text", "content": "\n**Usage:**"})
+                elements.append(
+                    {
+                        "type": "list",
+                        "items": [
+                            "Run `chrome-debug` to start Chrome with debugging",
+                            "Or use `run-chrome` command for direct launch",
+                        ],
+                    }
+                )
+        elif component == "desktop":
+            # Platform-specific instructions are already in the service's details
+            pass
+
+    return {"elements": elements}
+
+
+@app.command(
+    display="markdown",
+    typer={"name": "setup-cleanup", "help": "Clean up old WebTap installations"},
+    fastmcp={"enabled": False},
+)
+def setup_cleanup(state, dry_run: bool = True) -> dict:
+    """Clean up old WebTap installations from previous versions.
+
+    Checks for and removes:
+    - Old extension location (~/.config/webtap/extension/)
+    - Old desktop entries created by webtap
+    - Unmounted bindfs directories
+
+    Args:
+        dry_run: Only show what would be cleaned (default: True)
+
+    Returns:
+        Markdown report of cleanup actions
+    """
+    service = SetupService()
+    result = service.cleanup_old_installations(dry_run=dry_run)
+
+    elements = []
+
+    # Header
+    elements.append({"type": "heading", "level": 2, "content": "WebTap Cleanup Report"})
+
+    # Old installations found
+    if result.get("old_extension"):
+        elements.append({"type": "heading", "level": 3, "content": "Old Extension Location"})
+        elements.append({"type": "text", "content": f"Found: `{result['old_extension']['path']}`"})
+        elements.append({"type": "text", "content": f"Size: {result['old_extension']['size']}"})
+        if not dry_run and result["old_extension"].get("removed"):
+            elements.append({"type": "alert", "message": "✓ Removed old extension", "level": "success"})
+        elif dry_run:
+            elements.append({"type": "alert", "message": "Would remove (dry-run mode)", "level": "info"})
+
+    # Old Chrome wrapper
+    if result.get("old_wrapper"):
+        elements.append({"type": "heading", "level": 3, "content": "Old Chrome Wrapper"})
+        elements.append({"type": "text", "content": f"Found: `{result['old_wrapper']['path']}`"})
+        if not dry_run and result["old_wrapper"].get("removed"):
+            elements.append({"type": "alert", "message": "✓ Removed old wrapper", "level": "success"})
+        elif dry_run:
+            elements.append({"type": "alert", "message": "Would remove (dry-run mode)", "level": "info"})
+
+    # Old desktop entry
+    if result.get("old_desktop"):
+        elements.append({"type": "heading", "level": 3, "content": "Old Desktop Entry"})
+        elements.append({"type": "text", "content": f"Found: `{result['old_desktop']['path']}`"})
+        if not dry_run and result["old_desktop"].get("removed"):
+            elements.append({"type": "alert", "message": "✓ Removed old desktop entry", "level": "success"})
+        elif dry_run:
+            elements.append({"type": "alert", "message": "Would remove (dry-run mode)", "level": "info"})
+
+    # Check for bindfs mounts
+    if result.get("bindfs_mount"):
+        elements.append({"type": "heading", "level": 3, "content": "Bindfs Mount Detected"})
+        elements.append({"type": "text", "content": f"Mount: `{result['bindfs_mount']}`"})
+        elements.append(
+            {"type": "alert", "message": "To unmount: fusermount -u " + result["bindfs_mount"], "level": "warning"}
+        )
+
+    # Summary
+    elements.append({"type": "heading", "level": 3, "content": "Summary"})
+    if dry_run:
+        elements.append({"type": "text", "content": "**Dry-run mode** - no changes made"})
+        elements.append({"type": "text", "content": "To perform cleanup: `setup-cleanup --no-dry-run`"})
+    else:
+        elements.append({"type": "alert", "message": "Cleanup completed", "level": "success"})
+
+    # Next steps
+    elements.append({"type": "heading", "level": 3, "content": "Next Steps"})
+    elements.append(
+        {
+            "type": "list",
+            "items": [
+                "Run `setup-extension` to install extension in new location",
+                "Run `setup-chrome --bindfs` for bindfs mode or `setup-chrome` for standard mode",
+                "Run `setup-desktop` to create Chrome Debug launcher",
+            ],
+        }
+    )
+
+    return {"elements": elements}

webtap/commands/to_model.py

@@ -0,0 +1,163 @@
+"""Generate Pydantic models from HTTP request/response bodies."""
+
+import json
+from datamodel_code_generator import generate, InputFileType, DataModelType
+from webtap.app import app
+from webtap.commands._builders import success_response, error_response
+from webtap.commands._code_generation import (
+    ensure_output_directory,
+    parse_json,
+    extract_json_path,
+    validate_generation_data,
+)
+from webtap.commands._utils import evaluate_expression, fetch_body_content
+from webtap.commands._tips import get_mcp_description
+
+
+mcp_desc = get_mcp_description("to_model")
+
+
+@app.command(display="markdown", fastmcp={"type": "tool", "mime_type": "text/markdown", "description": mcp_desc or ""})
+def to_model(
+    state,
+    id: int,
+    output: str,
+    model_name: str,
+    field: str = "response.content",
+    json_path: str = None,  # pyright: ignore[reportArgumentType]
+    expr: str = None,  # pyright: ignore[reportArgumentType]
+) -> dict:  # pyright: ignore[reportArgumentType]
+    """Generate Pydantic model from request or response body.
+
+    Args:
+        id: Row ID from network() output
+        output: Output file path for generated model (e.g., "models/user.py")
+        model_name: Class name for generated model (e.g., "User")
+        field: Body to use - "response.content" (default) or "request.postData"
+        json_path: Optional JSON path to extract nested data (e.g., "data[0]")
+        expr: Optional Python expression to transform data (has 'body' variable)
+
+    Examples:
+        to_model(5, "models/user.py", "User")
+        to_model(5, "models/user.py", "User", json_path="data[0]")
+        to_model(5, "models/form.py", "Form", field="request.postData")
+        to_model(5, "models/clean.py", "Clean", expr="{k: v for k, v in json.loads(body).items() if k != 'meta'}")
+
+    Returns:
+        Success message with generation details
+    """
+    # Get HAR entry via RPC - need full entry with request_id for body fetch
+    try:
+        result = state.client.call("request", id=id, fields=["*"])
+        har_entry = result.get("entry")
+    except Exception as e:
+        return error_response(f"Failed to get request: {e}")
+
+    if not har_entry:
+        return error_response(f"Request {id} not found")
+
+    # Fetch body content
+    body_content, err = fetch_body_content(state, har_entry, field)
+    if err or body_content is None:
+        return error_response(
+            err or "Failed to fetch body",
+            suggestions=[
+                f"Field '{field}' could not be fetched",
+                "For response body: field='response.content'",
+                "For POST data: field='request.postData'",
+            ],
+        )
+
+    # Transform via expression or parse as JSON
+    if expr:
+        try:
+            namespace = {"body": body_content}
+            data, _ = evaluate_expression(expr, namespace)
+        except Exception as e:
+            return error_response(
+                f"Expression failed: {e}",
+                suggestions=[
+                    "Variable available: 'body' (str)",
+                    "Example: json.loads(body)['data'][0]",
+                    "Example: dict(urllib.parse.parse_qsl(body))",
+                ],
+            )
+    else:
+        if not body_content.strip():
+            return error_response("Body is empty")
+
+        data, parse_err = parse_json(body_content)
+        if parse_err:
+            return error_response(
+                parse_err,
+                suggestions=[
+                    "Body must be valid JSON, or use expr to transform it",
+                    'For form data: expr="dict(urllib.parse.parse_qsl(body))"',
+                ],
+            )
+
+    # Extract nested path if specified
+    if json_path:
+        data, err = extract_json_path(data, json_path)
+        if err:
+            return error_response(
+                err,
+                suggestions=[
+                    f"Path '{json_path}' not found in body",
+                    'Try a simpler path like "data" or "data[0]"',
+                ],
+            )
+
+    # Validate structure
+    is_valid, validation_err = validate_generation_data(data)
+    if not is_valid:
+        return error_response(
+            validation_err or "Invalid data structure",
+            suggestions=[
+                "Code generation requires dict or list structure",
+                "Use json_path or expr to extract a complex object",
+            ],
+        )
+
+    # Ensure output directory exists
+    output_path = ensure_output_directory(output)
+
+    # Generate model
+    try:
+        generate(
+            json.dumps(data),
+            input_file_type=InputFileType.Json,
+            input_filename="response.json",
+            output=output_path,
+            output_model_type=DataModelType.PydanticV2BaseModel,
+            class_name=model_name,
+            snake_case_field=True,
+            use_standard_collections=True,
+            use_union_operator=True,
+        )
+    except Exception as e:
+        return error_response(
+            f"Model generation failed: {e}",
+            suggestions=[
+                "Check that the JSON structure is valid",
+                "Try simplifying with json_path",
+                "Ensure output directory is writable",
+            ],
+        )
+
+    # Count fields
+    try:
+        model_content = output_path.read_text()
+        field_count = model_content.count(": ")
+    except Exception:
+        field_count = "unknown"
+
+    return success_response(
+        "Model generated successfully",
+        details={
+            "Class": model_name,
+            "Output": str(output_path),
+            "Fields": field_count,
+            "Size": f"{output_path.stat().st_size} bytes",
+        },
+    )

webtap/daemon.py

@@ -0,0 +1,185 @@
+"""Daemon lifecycle management for WebTap.
+
+PUBLIC API:
+  - daemon_running: Check if daemon is running
+  - ensure_daemon: Spawn daemon if not running
+  - start_daemon: Run daemon in foreground (--daemon flag)
+  - stop_daemon: Gracefully shut down daemon
+  - daemon_status: Get daemon status information
+"""
+
+import logging
+import os
+import signal
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+import httpx
+
+
+logger = logging.getLogger(__name__)
+
+PIDFILE = Path("~/.local/state/webtap/daemon.pid").expanduser()
+DAEMON_URL = "http://localhost:8765"
+LOG_FILE = Path("~/.local/state/webtap/daemon.log").expanduser()
+
+
+def daemon_running() -> bool:
+    """Check if daemon is running.
+
+    Verifies both pidfile existence and health endpoint response.
+
+    Returns:
+        True if daemon is running and responsive, False otherwise.
+    """
+    if not PIDFILE.exists():
+        return False
+
+    # Check if process exists
+    try:
+        pid = int(PIDFILE.read_text().strip())
+        os.kill(pid, 0)  # Signal 0 just checks if process exists
+    except (ValueError, ProcessLookupError, OSError):
+        # Stale pidfile
+        PIDFILE.unlink(missing_ok=True)
+        return False
+
+    # Check if health endpoint responds
+    try:
+        response = httpx.get(f"{DAEMON_URL}/health", timeout=1.0)
+        return response.status_code == 200
+    except Exception:
+        return False
+
+
+def ensure_daemon() -> None:
+    """Spawn daemon if not running.
+
+    Raises:
+        RuntimeError: If daemon fails to start within 5 seconds.
+    """
+    if daemon_running():
+        logger.debug("Daemon already running")
+        return
+
+    logger.info("Starting daemon...")
+
+    # Ensure directories exist
+    PIDFILE.parent.mkdir(parents=True, exist_ok=True)
+    LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
+
+    # Spawn daemon process
+    with open(LOG_FILE, "a") as log:
+        subprocess.Popen(
+            [sys.executable, "-m", "webtap", "--daemon"],
+            start_new_session=True,
+            stdout=log,
+            stderr=subprocess.STDOUT,
+            close_fds=True,
+        )
+
+    # Wait for daemon to be ready
+    for i in range(50):  # 5 seconds total
+        time.sleep(0.1)
+        if daemon_running():
+            logger.info("Daemon started successfully")
+            return
+
+    raise RuntimeError(f"Daemon failed to start. Check log: {LOG_FILE}")
+
+
+def start_daemon() -> None:
+    """Run daemon in foreground (--daemon flag).
+
+    This function blocks until the daemon is shut down. It:
+    1. Creates pidfile
+    2. Starts API server
+    3. Cleans up on exit
+
+    The API server initialization is handled in api.py.
+    Uvicorn handles SIGINT/SIGTERM signals for graceful shutdown.
+    """
+    # Ensure directories exist
+    PIDFILE.parent.mkdir(parents=True, exist_ok=True)
+
+    # Check if already running
+    if daemon_running():
+        print(f"Daemon already running (pid: {PIDFILE.read_text().strip()})")
+        sys.exit(1)
+
+    # Write pidfile
+    PIDFILE.write_text(str(os.getpid()))
+    logger.info(f"Daemon started (pid: {os.getpid()})")
+
+    # Note: Don't register signal handlers here - uvicorn handles SIGINT/SIGTERM
+    # and calling sys.exit() in a signal handler conflicts with uvicorn's shutdown
+
+    try:
+        # Initialize and run daemon server (blocks)
+        from webtap.api import run_daemon_server
+
+        run_daemon_server()
+    finally:
+        PIDFILE.unlink(missing_ok=True)
+        logger.info("Daemon stopped")
+
+
+def stop_daemon() -> None:
+    """Send SIGTERM to daemon.
+
+    Raises:
+        RuntimeError: If daemon is not running.
+    """
+    if not PIDFILE.exists():
+        raise RuntimeError("Daemon is not running (no pidfile)")
+
+    try:
+        pid = int(PIDFILE.read_text().strip())
+        os.kill(pid, signal.SIGTERM)
+        logger.info(f"Sent SIGTERM to daemon (pid: {pid})")
+
+        # Wait for daemon to stop
+        for _ in range(30):  # 3 seconds
+            time.sleep(0.1)
+            if not daemon_running():
+                logger.info("Daemon stopped")
+                return
+
+        logger.warning("Daemon did not stop gracefully, may need manual intervention")
+    except (ValueError, ProcessLookupError, OSError) as e:
+        PIDFILE.unlink(missing_ok=True)
+        raise RuntimeError(f"Failed to stop daemon: {e}")
+
+
+def daemon_status() -> dict:
+    """Get daemon status information.
+
+    Returns:
+        Dictionary with status information:
+        - running: bool
+        - pid: int or None
+        - connected: bool
+        - event_count: int
+        - Other status fields from /status endpoint
+    """
+    if not daemon_running():
+        return {"running": False, "pid": None}
+
+    try:
+        pid = int(PIDFILE.read_text().strip())
+    except Exception:
+        pid = None
+
+    try:
+        response = httpx.get(f"{DAEMON_URL}/status", timeout=2.0)
+        status = response.json()
+        status["running"] = True
+        status["pid"] = pid
+        return status
+    except Exception as e:
+        return {"running": False, "pid": pid, "error": str(e)}
+
+
+__all__ = ["daemon_running", "ensure_daemon", "start_daemon", "stop_daemon", "daemon_status"]

webtap/daemon_state.py

@@ -0,0 +1,53 @@
+"""Daemon-side state with CDP session and services.
+
+PUBLIC API:
+  - DaemonState: State container for daemon process
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from webtap.cdp import CDPSession
+    from webtap.services import WebTapService
+
+
+class DaemonState:
+    """Daemon-side state with CDP session and services.
+
+    This class is only used in daemon mode (--daemon flag).
+    It holds the CDP session and service layer that manage
+    browser connections and state.
+
+    Attributes:
+        cdp: CDP session for Chrome DevTools Protocol communication
+        browser_data: DOM selections and inspection state
+        service: WebTapService orchestrator for all operations
+        error_state: Current error state dict or None
+    """
+
+    cdp: "CDPSession"
+    browser_data: Any
+    service: "WebTapService"
+    error_state: dict[str, Any] | None
+
+    def __init__(self):
+        """Initialize daemon state with CDP session and services."""
+        from webtap.cdp import CDPSession
+        from webtap.services import WebTapService
+
+        self.cdp = CDPSession()
+        self.browser_data = None
+        self.service = WebTapService(self)
+        self.error_state = None
+
+    def cleanup(self):
+        """Clean up resources on shutdown."""
+        if self.service:
+            self.service.disconnect()  # Cleans up DOM, fetch, body services
+        if self.cdp:
+            self.cdp.cleanup()
+
+
+__all__ = ["DaemonState"]