webtap-tool 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

webtap/services/dom.py

@@ -0,0 +1,512 @@
+"""DOM inspection service using Chrome DevTools Protocol.
+
+PUBLIC API:
+  - DOMService: Manages element inspection and selection via CDP Overlay domain
+"""
+
+import logging
+import re
+import threading
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from webtap.cdp.session import CDPSession
+    from webtap.app import WebTapState
+
+logger = logging.getLogger(__name__)
+
+
+class DOMService:
+    """Manages element inspection and selection via CDP Overlay domain.
+
+    Uses CDP's native inspect mode (Overlay.setInspectMode) which provides:
+    - Native Chrome highlight on hover (no custom overlay needed)
+    - Click events via Overlay.inspectNodeRequested
+    - Accurate element data via DOM.describeNode, CSS.getComputedStyleForNode
+
+    Selections are stored in state.browser_data (not DuckDB) as they are
+    ephemeral session data cleared after prompt submission.
+
+    Attributes:
+        cdp: CDP session for executing commands
+        state: WebTap state for storing selections
+        _inspection_active: Whether inspect mode is currently active
+        _next_id: Counter for assigning selection IDs
+    """
+
+    def __init__(self, cdp: "CDPSession | None" = None, state: "WebTapState | None" = None):
+        """Initialize DOM service.
+
+        Args:
+            cdp: CDPSession instance. Can be None initially, set via set_cdp().
+            state: WebTapState instance. Can be None initially, set via set_state().
+        """
+        self.cdp = cdp
+        self.state = state
+        self._inspection_active = False
+        self._next_id = 1
+        self._broadcast_queue: "Any | None" = None  # asyncio.Queue for thread-safe broadcasts
+        self._state_lock = threading.Lock()  # Protect state mutations
+        self._pending_selections = 0  # Track in-flight selection processing
+        self._executor = ThreadPoolExecutor(max_workers=2, thread_name_prefix="dom-worker")
+
+    def set_cdp(self, cdp: "CDPSession") -> None:
+        """Set CDP session after initialization."""
+        self.cdp = cdp
+
+    def set_state(self, state: "WebTapState") -> None:
+        """Set state after initialization."""
+        self.state = state
+
+    def set_broadcast_queue(self, queue: "Any") -> None:
+        """Set queue for broadcasting state changes.
+
+        Args:
+            queue: asyncio.Queue for thread-safe signaling
+        """
+        self._broadcast_queue = queue
+
+    def start_inspect(self) -> dict[str, Any]:
+        """Enable CDP element inspection mode.
+
+        Enables Overlay.setInspectMode with searchForNode mode, which:
+        - Shows native Chrome highlight on hover
+        - Fires Overlay.inspectNodeRequested on click
+
+        Returns:
+            Success status dictionary.
+        """
+        if not self.cdp or not self.cdp.ws_app:
+            return {"error": "Not connected to page"}
+
+        if self._inspection_active:
+            return {"error": "Inspection already active"}
+
+        try:
+            # Enable DOM domain first (Overlay depends on it)
+            self.cdp.execute("DOM.enable")
+
+            # Request document to establish DOM tree context
+            # REQUIRED: BackendNodeIds only work after getDocument() is called
+            self.cdp.execute("DOM.getDocument", {"depth": -1})
+
+            # Enable CSS domain (needed for computed styles)
+            self.cdp.execute("CSS.enable")
+
+            # Enable Overlay domain
+            self.cdp.execute("Overlay.enable")
+
+            # Set inspect mode with native Chrome highlighting
+            self.cdp.execute(
+                "Overlay.setInspectMode",
+                {
+                    "mode": "searchForNode",
+                    "highlightConfig": {
+                        "showInfo": True,
+                        "showStyles": True,
+                        "contentColor": {"r": 111, "g": 168, "b": 220, "a": 0.66},
+                        "paddingColor": {"r": 147, "g": 196, "b": 125, "a": 0.55},
+                        "borderColor": {"r": 255, "g": 229, "b": 153, "a": 0.66},
+                        "marginColor": {"r": 246, "g": 178, "b": 107, "a": 0.66},
+                    },
+                },
+            )
+
+            self._inspection_active = True
+            logger.info("Element inspection mode enabled")
+
+            return {"success": True, "inspect_active": True}
+
+        except Exception as e:
+            logger.error(f"Failed to enable inspection mode: {e}")
+            return {"error": str(e)}
+
+    def stop_inspect(self) -> dict[str, Any]:
+        """Disable CDP element inspection mode.
+
+        Returns:
+            Success status dictionary.
+        """
+        if not self.cdp or not self.cdp.ws_app:
+            return {"error": "Not connected to page"}
+
+        if not self._inspection_active:
+            return {"success": True, "inspect_active": False}
+
+        try:
+            # Disable inspect mode
+            # NOTE: highlightConfig required even for mode=none, otherwise CDP throws:
+            # "Internal error: highlight configuration parameter is missing"
+            self.cdp.execute("Overlay.setInspectMode", {"mode": "none", "highlightConfig": {}})
+
+            self._inspection_active = False
+            logger.info("Element inspection mode disabled")
+
+            return {"success": True, "inspect_active": False}
+
+        except Exception as e:
+            logger.error(f"Failed to disable inspection mode: {e}")
+            return {"error": str(e)}
+
+    def handle_inspect_node_requested(self, event: dict) -> None:
+        """Handle Overlay.inspectNodeRequested event (user clicked element).
+
+        CRITICAL: Called from WebSocket thread - MUST NOT make blocking CDP calls!
+        Offload to background thread to avoid deadlock.
+
+        Args:
+            event: CDP event with method and params
+        """
+        if not self.cdp or not self.state:
+            logger.error("DOMService not properly initialized (missing cdp or state)")
+            return
+
+        params = event.get("params", {})
+        backend_node_id = params.get("backendNodeId")
+        if not backend_node_id:
+            logger.warning("inspectNodeRequested event missing backendNodeId")
+            return
+
+        # Increment pending counter (thread-safe)
+        with self._state_lock:
+            self._pending_selections += 1
+        self._trigger_broadcast()
+
+        # Submit to background thread - returns immediately, no blocking
+        self._executor.submit(self._process_node_selection, backend_node_id)
+
+    def handle_frame_navigated(self, event: dict) -> None:
+        """Handle Page.frameNavigated event (page navigation).
+
+        Clears selections when main frame navigates to keep state in sync with page.
+        Called from WebSocket thread - must be non-blocking.
+
+        Args:
+            event: CDP event with method and params
+        """
+        params = event.get("params", {})
+        frame = params.get("frame", {})
+
+        # Only clear on main frame navigation (not iframes)
+        if frame.get("parentId"):
+            return
+
+        logger.info("Main frame navigated - clearing selections")
+        self.clear_selections()
+        self._trigger_broadcast()
+
+    def _process_node_selection(self, backend_node_id: int) -> None:
+        """Process node selection in background thread.
+
+        Safe to make blocking CDP calls here - we're not in WebSocket thread.
+
+        Args:
+            backend_node_id: CDP backend node ID from inspectNodeRequested event
+        """
+        try:
+            # Make blocking CDP calls (OK in background thread)
+            data = self._extract_node_data(backend_node_id)
+
+            # Thread-safe state update
+            with self._state_lock:
+                if not self.state:
+                    logger.error("DOMService state not initialized")
+                    return
+
+                selection_id = str(self._next_id)
+                self._next_id += 1
+
+                if not self.state.browser_data:
+                    self.state.browser_data = {"selections": {}, "prompt": ""}
+                if "selections" not in self.state.browser_data:
+                    self.state.browser_data["selections"] = {}
+
+                self.state.browser_data["selections"][selection_id] = data
+
+            logger.info(f"Element selected: {selection_id} - {data.get('preview', {}).get('tag', 'unknown')}")
+
+        except Exception as e:
+            logger.error(f"Failed to process node selection: {e}")
+            # Set error state for UI display
+            if self.state:
+                import time
+
+                error_msg = str(e)
+                # Provide user-friendly message for common errors
+                if "timed out" in error_msg.lower() or isinstance(e, TimeoutError):
+                    error_msg = "Element selection timed out - page may be unresponsive"
+                self.state.error_state = {"message": error_msg, "timestamp": time.time()}
+        finally:
+            # Decrement pending counter (thread-safe)
+            with self._state_lock:
+                self._pending_selections -= 1
+            self._trigger_broadcast()
+
+    def _trigger_broadcast(self) -> None:
+        """Trigger SSE broadcast via queue (thread-safe helper)."""
+        if self._broadcast_queue:
+            try:
+                self._broadcast_queue.put_nowait({"type": "dom_update"})
+            except Exception as e:
+                logger.debug(f"Failed to queue broadcast: {e}")
+
+    def _extract_node_data(self, backend_node_id: int) -> dict[str, Any]:
+        """Extract complete element data via CDP.
+
+        Args:
+            backend_node_id: CDP backend node ID from inspectNodeRequested event
+
+        Returns:
+            Dictionary with element data compatible with browser_data schema
+
+        Raises:
+            RuntimeError: If CDP is not connected or commands fail
+            TimeoutError: If CDP commands timeout (page busy, heavy load)
+        """
+        if not self.cdp:
+            raise RuntimeError("CDP session not initialized")
+
+        # Use 15s timeout for interactive operations (balanced between responsiveness and heavy pages)
+        # Still shorter than default 30s to provide faster failure feedback
+        timeout = 15.0
+
+        try:
+            # Describe node directly with backendNodeId (no need for resolveNode first!)
+            describe_result = self.cdp.execute("DOM.describeNode", {"backendNodeId": backend_node_id}, timeout=timeout)
+
+            if "node" not in describe_result:
+                raise RuntimeError(f"Failed to describe node {backend_node_id}")
+
+            node = describe_result["node"]
+            node_id = node["nodeId"]
+
+            # Get outer HTML
+            html_result = self.cdp.execute("DOM.getOuterHTML", {"nodeId": node_id}, timeout=timeout)
+            outer_html = html_result.get("outerHTML", "")
+
+            # Get computed styles
+            styles_result = self.cdp.execute("CSS.getComputedStyleForNode", {"nodeId": node_id}, timeout=timeout)
+
+            # Convert styles to dict
+            styles = {}
+            for prop in styles_result.get("computedStyle", []):
+                styles[prop["name"]] = prop["value"]
+
+            # Get box model for badge positioning
+            try:
+                box_result = self.cdp.execute("DOM.getBoxModel", {"nodeId": node_id}, timeout=timeout)
+                # Use top-left corner of content box
+                content_box = box_result["model"]["content"]
+                badge_x = int(content_box[0])  # Top-left x
+                badge_y = int(content_box[1])  # Top-left y
+            except Exception:
+                # Fallback if element has no box model (display: none, etc.)
+                badge_x = 0
+                badge_y = 0
+
+        except TimeoutError as e:
+            logger.warning(f"Timeout extracting node {backend_node_id}: {e}")
+            raise RuntimeError("Element selection timed out - page may be busy or unresponsive") from e
+
+        # Generate CSS selector
+        css_selector = self._generate_css_selector(node)
+
+        # Generate XPath
+        xpath = self._generate_xpath(node)
+
+        # Generate jsPath (for js() command integration)
+        js_path = f"document.querySelector('{css_selector}')"
+
+        # Build preview
+        tag = node.get("nodeName", "").lower()
+        node_attrs = node.get("attributes", [])
+        attrs_dict = {}
+        for i in range(0, len(node_attrs), 2):
+            if i + 1 < len(node_attrs):
+                attrs_dict[node_attrs[i]] = node_attrs[i + 1]
+
+        preview = {
+            "tag": tag,
+            "id": attrs_dict.get("id", ""),
+            "classes": attrs_dict.get("class", "").split() if attrs_dict.get("class") else [],
+            "text": self._get_node_text(outer_html)[:100],  # First 100 chars
+        }
+
+        # Build complete data structure (compatible with existing schema)
+        return {
+            "outerHTML": outer_html,
+            "selector": css_selector,
+            "jsPath": js_path,
+            "styles": styles,
+            "xpath": xpath,
+            "fullXpath": xpath,  # CDP doesn't distinguish, use same
+            "preview": preview,
+            "badge": {"x": badge_x, "y": badge_y},
+            "nodeId": node_id,
+            "backendNodeId": backend_node_id,
+        }
+
+    def _generate_css_selector(self, node: dict) -> str:
+        """Generate unique CSS selector for node.
+
+        Uses a combination of strategies to ensure uniqueness:
+        1. ID if available (most unique)
+        2. Tag + classes + nth-child for specificity
+        3. Falls back to full path if needed
+
+        Args:
+            node: CDP node description
+
+        Returns:
+            CSS selector string
+        """
+        # Parse attributes
+        attrs_dict = self._parse_node_attributes(node)
+
+        # Strategy 1: ID selector (unique by definition)
+        if "id" in attrs_dict and attrs_dict["id"]:
+            return f"#{attrs_dict['id']}"
+
+        # Strategy 2: Build selector with tag + classes + nth-child
+        tag = node.get("nodeName", "").lower()
+        selector = tag
+
+        # Add first 2 classes for specificity without being too brittle
+        if "class" in attrs_dict and attrs_dict["class"]:
+            classes = attrs_dict["class"].split()[:2]
+            if classes:
+                selector += "." + ".".join(classes)
+
+        # Add nth-child for uniqueness within parent
+        # This is key to distinguishing elements with same tag/class
+        parent_id = node.get("parentId")
+        if parent_id and self.cdp:
+            try:
+                # Get parent node to count children
+                parent_result = self.cdp.execute("DOM.describeNode", {"nodeId": parent_id}, timeout=5.0)
+
+                if "node" in parent_result:
+                    parent_node = parent_result["node"]
+                    child_node_ids = parent_node.get("childNodeIds", [])
+
+                    # Find our position among siblings
+                    node_id = node.get("nodeId")
+                    if node_id in child_node_ids:
+                        nth = child_node_ids.index(node_id) + 1
+                        selector += f":nth-child({nth})"
+
+            except Exception as e:
+                logger.debug(f"Could not add nth-child to selector: {e}")
+
+        return selector
+
+    def _parse_node_attributes(self, node: dict) -> dict:
+        """Parse CDP node attributes array into dictionary.
+
+        Args:
+            node: CDP node with attributes array [name1, value1, name2, value2, ...]
+
+        Returns:
+            Dictionary of {name: value}
+        """
+        attrs = node.get("attributes", [])
+        attrs_dict = {}
+        for i in range(0, len(attrs), 2):
+            if i + 1 < len(attrs):
+                attrs_dict[attrs[i]] = attrs[i + 1]
+        return attrs_dict
+
+    def _generate_xpath(self, node: dict) -> str:
+        """Generate XPath for node.
+
+        Args:
+            node: CDP node description
+
+        Returns:
+            XPath string
+        """
+        tag = node.get("nodeName", "").lower()
+        attrs_dict = self._parse_node_attributes(node)
+
+        # Prefer ID (unique)
+        if "id" in attrs_dict and attrs_dict["id"]:
+            return f"//{tag}[@id='{attrs_dict['id']}']"
+
+        # Use class attribute if available
+        if "class" in attrs_dict and attrs_dict["class"]:
+            # XPath class matching (contains all classes)
+            classes = attrs_dict["class"].split()
+            if classes:
+                return f"//{tag}[@class='{attrs_dict['class']}']"
+
+        # Fallback to tag only
+        return f"//{tag}"
+
+    def _get_node_text(self, html: str) -> str:
+        """Extract text content from HTML (simple implementation).
+
+        Args:
+            html: Outer HTML string
+
+        Returns:
+            Extracted text content
+        """
+        # Simple regex to strip tags
+        text = re.sub(r"<[^>]+>", "", html)
+        return text.strip()
+
+    def get_state(self) -> dict[str, Any]:
+        """Get current DOM service state (thread-safe).
+
+        Returns:
+            State dictionary with inspect_active, selections, and pending count
+        """
+        # Thread-safe read: protect against concurrent writes from WebSocket thread
+        with self._state_lock:
+            selections = {}
+            prompt = ""
+
+            if self.state is not None and self.state.browser_data:
+                # Deep copy to prevent mutations during SSE broadcast
+                selections = dict(self.state.browser_data.get("selections", {}))
+                prompt = self.state.browser_data.get("prompt", "")
+
+        return {
+            "inspect_active": self._inspection_active,
+            "selections": selections,
+            "prompt": prompt,
+            "pending_count": self._pending_selections,  # For progress indicator
+        }
+
+    def clear_selections(self) -> None:
+        """Clear all selections (thread-safe)."""
+        with self._state_lock:
+            if self.state is not None and self.state.browser_data:
+                self.state.browser_data["selections"] = {}
+            self._next_id = 1
+        logger.info("Selections cleared")
+
+    def cleanup(self) -> None:
+        """Cleanup resources (executor, callbacks).
+
+        Call this before disconnect or app exit.
+        """
+        # Shutdown executor - wait=False to avoid blocking on stuck tasks
+        # cancel_futures=True prevents hanging on incomplete selections (Python 3.9+)
+        if hasattr(self, "_executor"):
+            try:
+                self._executor.shutdown(wait=False, cancel_futures=True)
+                logger.info("ThreadPoolExecutor shut down")
+            except Exception as e:
+                logger.debug(f"Executor shutdown error (non-fatal): {e}")
+
+        # Clear inspection state
+        if self._inspection_active:
+            try:
+                self.stop_inspect()
+            except Exception as e:
+                logger.debug(f"Failed to stop inspect on cleanup: {e}")
+
+
+__all__ = ["DOMService"]

webtap/services/main.py

@@ -11,6 +11,7 @@ from webtap.services.fetch import FetchService
 from webtap.services.network import NetworkService
 from webtap.services.console import ConsoleService
 from webtap.services.body import BodyService
+from webtap.services.dom import DOMService
 
 
 REQUIRED_DOMAINS = [
@@ -37,6 +38,7 @@ class WebTapService:
         network: Network monitoring service.
         console: Console message service.
         body: Response body fetching service.
+        dom: DOM inspection and element selection service.
     """
 
     def __init__(self, state):
@@ -55,17 +57,24 @@ class WebTapService:
         self.network = NetworkService()
         self.console = ConsoleService()
         self.body = BodyService()
+        self.dom = DOMService()
 
         self.fetch.cdp = self.cdp
         self.network.cdp = self.cdp
         self.console.cdp = self.cdp
         self.body.cdp = self.cdp
+        self.dom.set_cdp(self.cdp)
+        self.dom.set_state(self.state)
 
         self.fetch.body_service = self.body
 
         # Legacy wiring for CDP event handler
         self.cdp.fetch_service = self.fetch
 
+        # Register DOM event callbacks
+        self.cdp.register_event_callback("Overlay.inspectNodeRequested", self.dom.handle_inspect_node_requested)
+        self.cdp.register_event_callback("Page.frameNavigated", self.dom.handle_frame_navigated)
+
     @property
     def event_count(self) -> int:
         """Total count of all CDP events stored."""
@@ -108,6 +117,11 @@ class WebTapService:
             self.fetch.disable()
 
         self.body.clear_cache()
+        self.dom.clear_selections()
+
+        # Clear error state on disconnect
+        if self.state.error_state:
+            self.state.error_state = None
 
         self.cdp.disconnect()
         self.enabled_domains.clear()

{webtap_tool-0.3.0.dist-info → webtap_tool-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webtap-tool
-Version: 0.3.0
+Version: 0.5.0
 Summary: Terminal-based web page inspector for AI debugging sessions
 Author-email: Fredrik Angelsen <fredrikangelsen@gmail.com>
 Classifier: Development Status :: 3 - Alpha
@@ -21,7 +21,7 @@ Requires-Dist: platformdirs>=4.4.0
 Requires-Dist: protobuf>=6.32.0
 Requires-Dist: pyjwt>=2.10.1
 Requires-Dist: pyyaml>=6.0.2
-Requires-Dist: replkit2[all]>=0.11.0
+Requires-Dist: replkit2[all]>=0.12.0
 Requires-Dist: requests>=2.32.4
 Requires-Dist: uvicorn>=0.35.0
 Requires-Dist: websocket-client>=1.8.0

{webtap_tool-0.3.0.dist-info → webtap_tool-0.5.0.dist-info}/RECORD

@@ -1,41 +1,42 @@
 webtap/VISION.md,sha256=kfoJfEPVc4chOrD9tNMDmYBY9rX9KB-286oZj70ALCE,7681
 webtap/__init__.py,sha256=DFWJGmqZfX8_h4csLA5pKPR4SkaHBMlUgU-WQIE96Gw,1092
-webtap/api.py,sha256=QLfwO_21uSyxBCsqei45c5Uyg7OVfaVopmBncx9ZRfw,8018
-webtap/app.py,sha256=OC8-767GtQ_hAOxUNqD6Yu3JYLNB3ZXdzKn-A1S_RJI,3305
-webtap/filters.py,sha256=nphF2bFRbFtS2ue-CbV1uzKpuK3IYBbwjLeLhMDdLEk,11034
+webtap/api.py,sha256=twDO_aA861yjjvrKquZ0phm2SIL07Wq37DmFjtVbTw4,17990
+webtap/app.py,sha256=UipzpRGS6riZxU7CgyW_eeWcB-6817P3egEO0pIdcp4,3790
+webtap/filters.py,sha256=kRCicGMSV3R_zSvwzqZqksnry6jxJNdXRcgWvpoBLfc,13323
 webtap/cdp/README.md,sha256=0TS0V_dRgRAzBqhddpXWD4S0YVi5wI4JgFJSll_KUBE,5660
 webtap/cdp/__init__.py,sha256=c6NFG0XJnAa5GTe9MLr9mDZcLZqoTQN7A1cvvOfLcgY,453
 webtap/cdp/query.py,sha256=x2Cy7KMolYkTelpROGezOfMFgYnbSlCvHkvvW1v_gLI,4229
-webtap/cdp/session.py,sha256=BTajmDH6nel2dvia7IX9k6C-RinkN2NxY4rxtUJAJE0,12362
+webtap/cdp/session.py,sha256=LkN676_gig06w9kcXhJXZQF0z0kDZG1TTvispiYw8fQ,16212
 webtap/cdp/schema/README.md,sha256=hnWCzbXYcYtWaZb_SgjVaFBiG81S9b9Y3x-euQFwQDo,1222
 webtap/cdp/schema/cdp_protocol.json,sha256=dp9_OLYLuVsQb1oV5r6MZfMzURscBLyAXUckdaPWyv4,1488452
 webtap/cdp/schema/cdp_version.json,sha256=OhGy1qpfQjSe3Z7OqL6KynBFlDFBXxKGPZCY-ZN_lVU,399
-webtap/commands/DEVELOPER_GUIDE.md,sha256=lii-bOUVNBiFjpZlYIipnFNNfUI9vI5VwAhGi2jvQAU,9870
-webtap/commands/TIPS.md,sha256=gE75m66QxU-7RG8NS9z5EchMoEN2OrQ0ZzHMETsAd_w,6854
+webtap/commands/DEVELOPER_GUIDE.md,sha256=LYOhycZ3k5EHx5nREfkjvLz7vOs8pXCRLlcDm-keWao,11973
+webtap/commands/TIPS.md,sha256=LnzNHb6fhoeqEyNIhx5IOKd05nY-xCiDLCrJ5zBOmNY,8131
 webtap/commands/__init__.py,sha256=rr3xM_bY0BgxkDOjsnsI8UBhjlz7nqiYlgJ8fjiJ1jQ,270
-webtap/commands/_builders.py,sha256=nUZLcMWXVWx6KmEV9KLajV-Gbxv2m2NB5lNZgR5Be1c,3842
-webtap/commands/_errors.py,sha256=W64bGcUDsvdncD3WiL4H7hVTVE58OiwWYC391SAk43s,3400
+webtap/commands/_builders.py,sha256=SYacZmZTdkolQ7OOf3rFtFPCjkukY8z020WFA-i_O_A,7902
 webtap/commands/_tips.py,sha256=SleMpwdghrHNqdzR60Cu8T0NZqJfWfcfrgIcyWI6GIQ,4793
 webtap/commands/_utils.py,sha256=VLXDhhhJITrQjwEyeLRTU2ey0QcLzY-_OxTjtPJlhYM,6816
-webtap/commands/body.py,sha256=e67q_rT8vtRz5_ViQjl5a6BAolW4uwedRZkVp8TJ5Vo,7111
-webtap/commands/connection.py,sha256=ZYV2TmK1LRVFyMneNYswJmnaoi45rFTApQew5Gm-CC0,5465
-webtap/commands/console.py,sha256=moGLsZ-k5wtukjrPFkEXjBl-Jj_yj4bHEArPXVmZLUc,2180
-webtap/commands/events.py,sha256=yx3iJgTANKsoGXBMu1WfBOjEW_thmNKMmUTXtamqRtQ,4093
-webtap/commands/fetch.py,sha256=_TzOvJfVzPaw4ZmyI95Qb7rS3iKx2nmp_IL3jaQO_6g,7772
-webtap/commands/filters.py,sha256=trZvcbHTaF0FZC8dyMAmhmS2dlBoA82VXe5_DDS3eU8,8986
-webtap/commands/inspect.py,sha256=6PGN7iDT1oLzQJboNeYozLILrW2VsAzmtMpF3_XhD30,5746
-webtap/commands/javascript.py,sha256=QpQdqqoQwwTyz1lpibZ92XKOL89scu_ndgSjkhaYuDk,3195
+webtap/commands/body.py,sha256=hJAoVU3iWBYCctPwBxVJM_xVe02TQnePB_OMTpsh1q4,7076
+webtap/commands/connection.py,sha256=nvJ5k1KlyphTeVW9yJaATHo4N-hX7w62pf1-fAypSRk,5430
+webtap/commands/console.py,sha256=BBaxSiLsVBChBY3Xi_nXwWjFlfc5KW9FQTPp5PzMUoE,2145
+webtap/commands/events.py,sha256=dsS6xd8GfkZ4VOnAQSCMxyEvwdha9J0Kh9oeK0CaU5Y,4058
+webtap/commands/fetch.py,sha256=8J6TPBWhStbkN5c5Q4KmK6nB5WiIgnAk0BkPFbh9ggg,7737
+webtap/commands/filters.py,sha256=jDZ8JcYIZv_K6aupwuAo9uqAi85e3EIKbf38BXz5nnI,10316
+webtap/commands/inspect.py,sha256=QonZigFYnfEVWYQY__r0n1aVvTqFBukFV-AWzc5KmfA,5711
+webtap/commands/javascript.py,sha256=9n4gOA7cjFjCL_p1cePRS1j7WZRV771MwADZeC5g66s,4098
 webtap/commands/launch.py,sha256=iZDLundKlxKRLKf3Vz5at42-tp2f-Uj5wZf7fbhBfA0,2202
-webtap/commands/navigation.py,sha256=Mapawp2AZTJQaws2uwlTgMUhqz7HlVTLxiZ06n_MQc0,6071
-webtap/commands/network.py,sha256=hwZshGGdVsJ_9MFjOKJXT07I990JjZInw2LLnKXLQ5Y,2910
-webtap/commands/server.py,sha256=LSs3l3Pb_vwmWRnYH-sA9JUPxBTQtRedjFQ4KvDaZK0,6032
+webtap/commands/navigation.py,sha256=aRVW-t2YJ0Haf6Wkg7uq8GstiRftklop9W1TicUk3oo,6036
+webtap/commands/network.py,sha256=gEOg_u7VF9A5aKv5myzLCuvfAUkF1OPxsuj4UAgbS44,3111
+webtap/commands/selections.py,sha256=uyEET9eaKcLWjBz0QUdMRuRU-HIBXGtARxK6k71zOMY,4910
+webtap/commands/server.py,sha256=DOcIgYuKp0ydwrK9EA3hGwqOwfwM9DABhdPu3hk_jjo,6948
 webtap/commands/setup.py,sha256=dov1LaN50nAEMNIuBLSK7mcnwhfn9rtqdTopBm1-PhA,9648
 webtap/services/README.md,sha256=rala_jtnNgSiQ1lFLM7x_UQ4SJZDceAm7dpkQMRTYaI,2346
 webtap/services/__init__.py,sha256=IjFqu0Ak6D-r18aokcQMtenDV3fbelvfjTCejGv6CZ0,570
 webtap/services/body.py,sha256=XQPa19y5eUc3XJ2TuwVK6kffO1VQoKqNs33MBBz7hzU,3913
 webtap/services/console.py,sha256=XVfSKTvEHyyOdujsg85S3wtj1CdZhzKtWwlx25MvSv8,3768
+webtap/services/dom.py,sha256=PC-mV56NMLvw37JNzI_jOnZrM7BiDPPn3kOQI9U81vI,19067
 webtap/services/fetch.py,sha256=nl6bpU2Vnf40kau4-mqAnIkhC-7Lx2vbTJKUglz9KnE,13602
-webtap/services/main.py,sha256=HcXdPuI7hzsxsNvfN0npGhj_M7HObc83Lr3fuy7BMeE,5673
+webtap/services/main.py,sha256=KUJFXzXL0ORlYfDV6DNULv_nzNfmlBFz_mfOvscp2wY,6287
 webtap/services/network.py,sha256=0o_--F6YvmXqqFqrcjL1gc6Vr9V1Ytb_U7r_DSUWupA,3444
 webtap/services/setup/__init__.py,sha256=lfoKCAroc-JoE_r7L-KZkF85ZWiB41MBIgrR7ZISSoE,7157
 webtap/services/setup/chrome.py,sha256=zfPWeb6zm_xjIfiS2S_O9lR2BjGKaPXXo06pN_B9lAU,7187
@@ -43,7 +44,7 @@ webtap/services/setup/desktop.py,sha256=fXwQa201W-s2mengm_dJZ9BigJopVrO9YFUQcW_T
 webtap/services/setup/extension.py,sha256=OvTLuSi5u-kBAkqWAzfYt5lTNZrduXoCMZhFCuMisew,3318
 webtap/services/setup/filters.py,sha256=lAPSLMH_KZQO-7bRkmURwzforx7C3SDrKEw2ZogN-Lo,3220
 webtap/services/setup/platform.py,sha256=7yn-7LQFffgerWzWRtOG-yNEsR36ICThYUAu_N2FAso,4532
-webtap_tool-0.3.0.dist-info/METADATA,sha256=jm3l2rpT1TBdGU8AU7NJYV7RgwpfzITuPyjh4Zb1_pk,17588
-webtap_tool-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-webtap_tool-0.3.0.dist-info/entry_points.txt,sha256=iFe575I0CIb1MbfPt0oX2VYyY5gSU_dA551PKVR83TU,39
-webtap_tool-0.3.0.dist-info/RECORD,,
+webtap_tool-0.5.0.dist-info/METADATA,sha256=qRqF6_yp9fLVO_c57vgBkKpvC-wLGhVrpWaMMMWwJXU,17588
+webtap_tool-0.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+webtap_tool-0.5.0.dist-info/entry_points.txt,sha256=iFe575I0CIb1MbfPt0oX2VYyY5gSU_dA551PKVR83TU,39
+webtap_tool-0.5.0.dist-info/RECORD,,