webtap-tool 0.11.0__py3-none-any.whl

webtap/services/network.py

@@ -0,0 +1,401 @@
+"""Network monitoring service using HAR views."""
+
+import json
+import logging
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from webtap.cdp import CDPSession
+    from webtap.filters import FilterManager
+
+logger = logging.getLogger(__name__)
+
+
+class NetworkService:
+    """Network event queries using HAR views."""
+
+    def __init__(self):
+        """Initialize network service."""
+        self.cdp: CDPSession | None = None
+        self.filters: FilterManager | None = None
+
+    @property
+    def request_count(self) -> int:
+        """Count of all network requests."""
+        if not self.cdp:
+            return 0
+        result = self.cdp.query("SELECT COUNT(*) FROM har_summary")
+        return result[0][0] if result else 0
+
+    def get_requests(
+        self,
+        limit: int = 20,
+        status: int | None = None,
+        method: str | None = None,
+        type_filter: str | None = None,
+        url: str | None = None,
+        state: str | None = None,
+        apply_groups: bool = True,
+        order: str = "desc",
+    ) -> list[dict]:
+        """Get network requests from HAR summary view.
+
+        Args:
+            limit: Maximum results.
+            status: Filter by HTTP status code.
+            method: Filter by HTTP method.
+            type_filter: Filter by resource type.
+            url: Filter by URL pattern (supports * wildcard).
+            state: Filter by state (pending, loading, complete, failed, paused).
+            apply_groups: Apply enabled filter groups.
+            order: Sort order - "desc" (newest first) or "asc" (oldest first).
+
+        Returns:
+            List of request summary dicts.
+        """
+        if not self.cdp:
+            return []
+
+        # Build SQL query
+        sql = """
+        SELECT
+            id,
+            request_id,
+            protocol,
+            method,
+            status,
+            url,
+            type,
+            size,
+            time_ms,
+            state,
+            pause_stage,
+            paused_id,
+            frames_sent,
+            frames_received
+        FROM har_summary
+        """
+
+        # Build filter conditions
+        conditions = ""
+        if self.filters:
+            conditions = self.filters.build_filter_sql(
+                status=status,
+                method=method,
+                type_filter=type_filter,
+                url=url,
+                apply_groups=apply_groups,
+            )
+
+        # Add state filter
+        state_conditions = []
+        if state:
+            state_conditions.append(f"state = '{state}'")
+
+        # Combine conditions
+        all_conditions = []
+        if conditions:
+            all_conditions.append(conditions)
+        if state_conditions:
+            all_conditions.append(" AND ".join(state_conditions))
+
+        if all_conditions:
+            sql += f" WHERE {' AND '.join(all_conditions)}"
+
+        sort_dir = "ASC" if order.lower() == "asc" else "DESC"
+        sql += f" ORDER BY id {sort_dir} LIMIT {limit}"
+
+        # Execute query and convert to dicts
+        rows = self.cdp.query(sql)
+        columns = [
+            "id",
+            "request_id",
+            "protocol",
+            "method",
+            "status",
+            "url",
+            "type",
+            "size",
+            "time_ms",
+            "state",
+            "pause_stage",
+            "paused_id",
+            "frames_sent",
+            "frames_received",
+        ]
+
+        return [dict(zip(columns, row)) for row in rows]
+
+    def get_request_details(self, row_id: int) -> dict | None:
+        """Get HAR entry with proper nested structure.
+
+        Args:
+            row_id: Row ID from har_summary.
+
+        Returns:
+            HAR-structured dict or None if not found.
+
+        Structure matches HAR spec:
+            {
+                "id": 123,
+                "request": {"method", "url", "headers", "postData"},
+                "response": {"status", "statusText", "headers", "content"},
+                "time": 150,
+                "state": "complete",
+                "pause_stage": "Response",  # If paused
+                ...
+            }
+        """
+        if not self.cdp:
+            return None
+
+        sql = """
+        SELECT
+            id,
+            request_id,
+            protocol,
+            method,
+            url,
+            status,
+            status_text,
+            type,
+            size,
+            time_ms,
+            state,
+            pause_stage,
+            paused_id,
+            request_headers,
+            post_data,
+            response_headers,
+            mime_type,
+            timing,
+            error_text,
+            frames_sent,
+            frames_received,
+            ws_total_bytes
+        FROM har_entries
+        WHERE id = ?
+        """
+
+        rows = self.cdp.query(sql, [row_id])
+        if not rows:
+            return None
+
+        row = rows[0]
+        columns = [
+            "id",
+            "request_id",
+            "protocol",
+            "method",
+            "url",
+            "status",
+            "status_text",
+            "type",
+            "size",
+            "time_ms",
+            "state",
+            "pause_stage",
+            "paused_id",
+            "request_headers",
+            "post_data",
+            "response_headers",
+            "mime_type",
+            "timing",
+            "error_text",
+            "frames_sent",
+            "frames_received",
+            "ws_total_bytes",
+        ]
+        flat = dict(zip(columns, row))
+
+        # Parse JSON fields
+        def parse_json(val):
+            if val and isinstance(val, str):
+                try:
+                    return json.loads(val)
+                except json.JSONDecodeError:
+                    return val
+            return val
+
+        # Build HAR-nested structure
+        har: dict = {
+            "id": flat["id"],
+            "request_id": flat["request_id"],
+            "protocol": flat["protocol"],
+            "type": flat["type"],
+            "time": flat["time_ms"],
+            "state": flat["state"],
+            "request": {
+                "method": flat["method"],
+                "url": flat["url"],
+                "headers": parse_json(flat["request_headers"]) or {},
+                "postData": flat["post_data"],
+            },
+            "response": {
+                "status": flat["status"],
+                "statusText": flat["status_text"],
+                "headers": parse_json(flat["response_headers"]) or {},
+                "content": {
+                    "size": flat["size"],
+                    "mimeType": flat["mime_type"],
+                },
+            },
+            "timings": parse_json(flat["timing"]),
+        }
+
+        # Add pause info if paused
+        if flat["pause_stage"]:
+            har["pause_stage"] = flat["pause_stage"]
+
+        # Add error if failed
+        if flat["error_text"]:
+            har["error"] = flat["error_text"]
+
+        # Add WebSocket stats if applicable
+        if flat["protocol"] == "websocket":
+            har["websocket"] = {
+                "framesSent": flat["frames_sent"],
+                "framesReceived": flat["frames_received"],
+                "totalBytes": flat["ws_total_bytes"],
+            }
+
+        return har
+
+    def fetch_body(self, request_id: str) -> dict | None:
+        """Fetch response body for a request.
+
+        Args:
+            request_id: CDP request ID.
+
+        Returns:
+            Dict with 'body' and 'base64Encoded' keys, or None.
+        """
+        if not self.cdp:
+            return None
+        return self.cdp.fetch_body(request_id)
+
+    def get_request_by_row_id(self, row_id: int) -> str | None:
+        """Get request_id for a row ID.
+
+        Args:
+            row_id: Row ID from har_summary.
+
+        Returns:
+            CDP request ID or None.
+        """
+        if not self.cdp:
+            return None
+
+        result = self.cdp.query("SELECT request_id FROM har_summary WHERE id = ?", [row_id])
+        return result[0][0] if result else None
+
+    def get_request_id(self, row_id: int) -> str | None:
+        """Get CDP request_id for a row ID.
+
+        Args:
+            row_id: Row ID from network table.
+
+        Returns:
+            CDP request ID or None.
+        """
+        return self.get_request_by_row_id(row_id)
+
+    def select_fields(self, har_entry: dict, patterns: list[str] | None) -> dict:
+        """Apply ES-style field selection to HAR entry.
+
+        Args:
+            har_entry: Full HAR entry with nested structure.
+            patterns: Field patterns or None for minimal.
+
+        Patterns:
+            - None: minimal default fields
+            - ["*"]: all fields
+            - ["request.*"]: all request fields
+            - ["request.headers.*"]: all request headers
+            - ["request.headers.content-type"]: specific header
+            - ["response.content"]: fetch response body on-demand
+
+        Returns:
+            HAR entry with only selected fields.
+        """
+        # Minimal fields for default view
+        minimal_fields = ["request.method", "request.url", "response.status", "time", "state"]
+
+        if patterns is None:
+            # Minimal default - extract specific paths
+            result: dict = {}
+            for pattern in minimal_fields:
+                parts = pattern.split(".")
+                value = _get_nested(har_entry, parts)
+                if value is not None:
+                    _set_nested(result, parts, value)
+            return result
+
+        if patterns == ["*"]:
+            return har_entry
+
+        result = {}
+        for pattern in patterns:
+            if pattern == "*":
+                return har_entry
+
+            parts = pattern.split(".")
+
+            # Special case: response.content triggers body fetch
+            if pattern == "response.content" or pattern.startswith("response.content."):
+                request_id = har_entry.get("request_id")
+                if request_id:
+                    body_result = self.fetch_body(request_id)
+                    if body_result:
+                        content = har_entry.get("response", {}).get("content", {}).copy()
+                        content["text"] = body_result.get("body")
+                        content["encoding"] = "base64" if body_result.get("base64Encoded") else None
+                        _set_nested(result, ["response", "content"], content)
+                    else:
+                        _set_nested(result, ["response", "content"], {"text": None})
+                continue
+
+            # Wildcard: "request.headers.*" -> get all under that path
+            if pattern.endswith(".*"):
+                prefix = pattern[:-2]
+                prefix_parts = prefix.split(".")
+                obj = _get_nested(har_entry, prefix_parts)
+                if obj is not None:
+                    _set_nested(result, prefix_parts, obj)
+            else:
+                # Specific path
+                value = _get_nested(har_entry, parts)
+                if value is not None:
+                    _set_nested(result, parts, value)
+
+        return result
+
+
+def _get_nested(obj: dict | None, path: list[str]):
+    """Get nested value by path, case-insensitive for headers."""
+    for key in path:
+        if obj is None:
+            return None
+        if isinstance(obj, dict):
+            # Case-insensitive lookup
+            matching_key = next((k for k in obj.keys() if k.lower() == key.lower()), None)
+            if matching_key:
+                obj = obj.get(matching_key)
+            else:
+                return None
+        else:
+            return None
+    return obj
+
+
+def _set_nested(result: dict, path: list[str], value) -> None:
+    """Set nested value by path, creating intermediate dicts."""
+    current = result
+    for key in path[:-1]:
+        if key not in current:
+            current[key] = {}
+        current = current[key]
+    current[path[-1]] = value
+
+
+__all__ = ["NetworkService"]

webtap/services/setup/__init__.py

@@ -0,0 +1,185 @@
+"""Setup service for installing WebTap components (cross-platform).
+
+PUBLIC API:
+  - SetupService: Main service class for all setup operations
+"""
+
+from typing import Dict, Any
+
+from .extension import ExtensionSetupService
+from .chrome import ChromeSetupService
+from .desktop import DesktopSetupService
+from .platform import get_platform_info, ensure_directories, APP_NAME
+
+# Old installation paths to clean up
+OLD_EXTENSION_PATH = ".config/webtap/extension"
+OLD_WRAPPER_PATH = ".local/bin/wrappers/google-chrome-stable"
+OLD_DESKTOP_PATH = ".local/share/applications/google-chrome.desktop"
+OLD_DEBUG_DIR = ".config/google-chrome-debug"
+
+# Path components
+WRAPPERS_DIR = "wrappers"
+GOOGLE_CHROME_STABLE = "google-chrome-stable"
+
+# Size formatting constants
+KB_SIZE = 1024
+SIZE_FORMAT_KB = "{:.1f} KB"
+SIZE_FORMAT_EMPTY = "empty"
+
+# Mount point command
+MOUNTPOINT_CMD = "mountpoint"
+MOUNTPOINT_CHECK_FLAG = "-q"
+
+
+class SetupService:
+    """Orchestrator service for installing WebTap components.
+
+    Delegates to specialized service classes for each component type.
+    """
+
+    def __init__(self):
+        """Initialize setup service with platform information."""
+        self.info = get_platform_info()
+        ensure_directories()
+
+        # Initialize component services
+        self.extension_service = ExtensionSetupService()
+        self.chrome_service = ChromeSetupService()
+        self.desktop_service = DesktopSetupService()
+
+    def install_extension(self, force: bool = False) -> Dict[str, Any]:
+        """Install Chrome extension files.
+
+        Args:
+            force: Overwrite existing files
+
+        Returns:
+            Dict with success, message, path, details
+        """
+        return self.extension_service.install_extension(force=force)
+
+    def install_chrome_wrapper(self, force: bool = False, bindfs: bool = False) -> Dict[str, Any]:
+        """Install Chrome wrapper script.
+
+        Args:
+            force: Overwrite existing script
+            bindfs: Use bindfs to mount real Chrome profile (Linux only)
+
+        Returns:
+            Dict with success, message, path, details
+        """
+        return self.chrome_service.install_wrapper(force=force, bindfs=bindfs)
+
+    def install_desktop_entry(self, force: bool = False) -> Dict[str, Any]:
+        """Install desktop entry or app bundle for GUI integration.
+
+        On Linux: Creates .desktop file
+        On macOS: Creates .app bundle
+
+        Args:
+            force: Overwrite existing entry
+
+        Returns:
+            Dict with success, message, path, details
+        """
+        return self.desktop_service.install_launcher(force=force)
+
+    def get_platform_info(self) -> Dict[str, Any]:
+        """Get platform information for debugging.
+
+        Returns:
+            Platform information including paths and capabilities
+        """
+        return self.info
+
+    def cleanup_old_installations(self, dry_run: bool = True) -> Dict[str, Any]:
+        """Clean up old WebTap installations.
+
+        Checks locations that webtap previously wrote to:
+        - ~/.config/webtap/extension/ (old extension location)
+        - ~/.local/bin/wrappers/google-chrome-stable (old wrapper location)
+        - ~/.local/share/applications/google-chrome.desktop (old desktop entry)
+        - ~/.config/google-chrome-debug (bindfs mount)
+
+        Args:
+            dry_run: If True, only report what would be done
+
+        Returns:
+            Dict with cleanup results
+        """
+        import shutil
+        import subprocess
+        from pathlib import Path
+
+        result = {}
+
+        # Check old extension location
+        old_extension_path = Path.home() / OLD_EXTENSION_PATH
+        if old_extension_path.exists():
+            # Calculate size
+            size = sum(f.stat().st_size for f in old_extension_path.rglob("*") if f.is_file())
+            size_str = SIZE_FORMAT_KB.format(size / KB_SIZE) if size > 0 else SIZE_FORMAT_EMPTY
+
+            result["old_extension"] = {"path": str(old_extension_path), "size": size_str, "removed": False}
+
+            if not dry_run:
+                try:
+                    shutil.rmtree(old_extension_path)
+                    result["old_extension"]["removed"] = True
+                    # Also try to remove parent if empty
+                    parent = old_extension_path.parent
+                    if parent.exists() and not any(parent.iterdir()):
+                        parent.rmdir()
+                except Exception as e:
+                    result["old_extension"]["error"] = str(e)
+
+        # Check old Chrome wrapper location
+        old_wrapper_path = Path.home() / OLD_WRAPPER_PATH
+        if old_wrapper_path.exists():
+            result["old_wrapper"] = {"path": str(old_wrapper_path), "removed": False}
+
+            if not dry_run:
+                try:
+                    old_wrapper_path.unlink()
+                    result["old_wrapper"]["removed"] = True
+                    # Try to remove wrappers dir if empty (but keep it if other wrappers exist)
+                    wrappers_dir = old_wrapper_path.parent
+                    if wrappers_dir.exists() and not any(wrappers_dir.iterdir()):
+                        wrappers_dir.rmdir()
+                except Exception as e:
+                    result["old_wrapper"]["error"] = str(e)
+
+        # Check old desktop entry
+        old_desktop_path = Path.home() / OLD_DESKTOP_PATH
+        if old_desktop_path.exists():
+            # Check if it's our override (contains reference to wrapper)
+            try:
+                content = old_desktop_path.read_text()
+                wrapper_ref = f"{WRAPPERS_DIR}/{GOOGLE_CHROME_STABLE}"
+                if wrapper_ref in content or APP_NAME in content.lower():
+                    result["old_desktop"] = {"path": str(old_desktop_path), "removed": False}
+
+                    if not dry_run:
+                        try:
+                            old_desktop_path.unlink()
+                            result["old_desktop"]["removed"] = True
+                        except Exception as e:
+                            result["old_desktop"]["error"] = str(e)
+            except Exception:
+                pass  # If we can't read it, skip it
+
+        # Check for bindfs mount
+        debug_dir = Path.home() / OLD_DEBUG_DIR
+        if debug_dir.exists():
+            try:
+                # Check if it's a mount point
+                output = subprocess.run([MOUNTPOINT_CMD, MOUNTPOINT_CHECK_FLAG, str(debug_dir)], capture_output=True)
+                if output.returncode == 0:
+                    result["bindfs_mount"] = str(debug_dir)
+            except (FileNotFoundError, OSError):
+                pass  # mountpoint command might not exist
+
+        return result
+
+
+__all__ = ["SetupService"]