cmdop 0.1.17__py3-none-any.whl → 0.1.18__py3-none-any.whl

cmdop/__init__.py

@@ -124,7 +124,7 @@ from cmdop.logging import (
     get_log_dir,
 )
 
-__version__ = "0.1.17"
+__version__ = "0.1.18"
 
 __all__ = [
     # Version

cmdop/services/browser/aio/session.py

@@ -4,9 +4,17 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
+import asyncio
+
 from cmdop.services.browser.base.session import BaseSession
-from cmdop.services.browser.models import BrowserCookie, BrowserState
+from cmdop.services.browser.models import (
+    BrowserCookie,
+    BrowserState,
+    ScrollInfo,
+    ScrollResult,
+)
 from cmdop.services.browser.js import parse_json_result
+from cmdop.services.browser.parsing import parse_html as _parse_html, SoupWrapper
 
 if TYPE_CHECKING:
     from cmdop.services.browser.aio.service import AsyncBrowserService
@@ -158,6 +166,112 @@ class AsyncBrowserSession(BaseSession):
             self._session_id, item, fields_json, limit
         )
 
+    # === HTML Parsing ===
+
+    async def parse_html(self, html: str | None = None, selector: str | None = None) -> "BeautifulSoup":
+        """Parse HTML with BeautifulSoup."""
+        if html is None:
+            html = await self.get_html(selector)
+        return _parse_html(html)
+
+    async def soup(self, selector: str | None = None) -> SoupWrapper:
+        """Get page HTML as SoupWrapper."""
+        html = await self.get_html(selector)
+        return SoupWrapper(html=html)
+
+    # === Scroll & Navigation ===
+
+    async def scroll(
+        self,
+        direction: str = "down",
+        amount: int = 500,
+        selector: str | None = None,
+        smooth: bool = True,
+        human_like: bool = False,
+        container: str | None = None,
+    ) -> ScrollResult:
+        """Scroll the page or container."""
+        js = self._build_scroll(direction, amount, selector, smooth, human_like, container)
+        result = await self.execute_script(js)
+        data = parse_json_result(result) or {}
+        return ScrollResult(
+            success=data.get("success", False),
+            scroll_y=int(data.get("scrollY", 0)),
+            scrolled_by=int(data.get("scrolledBy", 0)),
+            at_bottom=data.get("atBottom", False),
+            error=data.get("error"),
+        )
+
+    async def scroll_to(self, selector: str) -> ScrollResult:
+        """Scroll element into view."""
+        return await self.scroll(selector=selector)
+
+    async def scroll_to_bottom(self) -> ScrollResult:
+        """Scroll to page bottom."""
+        js = self._build_scroll_to_bottom()
+        result = await self.execute_script(js)
+        data = parse_json_result(result) or {}
+        return ScrollResult(
+            success=data.get("success", False),
+            scroll_y=int(data.get("scrollY", 0)),
+            scrolled_by=int(data.get("scrolledBy", 0)),
+            at_bottom=True,
+        )
+
+    async def get_scroll_info(self) -> ScrollInfo:
+        """Get current scroll position and page dimensions."""
+        js = self._build_get_scroll_info()
+        result = await self.execute_script(js)
+        data = parse_json_result(result) or {}
+        return ScrollInfo(
+            scroll_x=int(data.get("scrollX", 0)),
+            scroll_y=int(data.get("scrollY", 0)),
+            page_height=int(data.get("pageHeight", 0)),
+            page_width=int(data.get("pageWidth", 0)),
+            viewport_height=int(data.get("viewportHeight", 0)),
+            viewport_width=int(data.get("viewportWidth", 0)),
+            at_bottom=data.get("atBottom", False),
+            at_top=data.get("atTop", True),
+        )
+
+    # === UI Interaction Helpers ===
+
+    async def hover(self, selector: str) -> bool:
+        """Hover over element."""
+        js = self._build_hover(selector)
+        result = await self.execute_script(js)
+        data = parse_json_result(result) or {}
+        return data.get("success", False)
+
+    async def select(self, selector: str, value: str | None = None, text: str | None = None) -> dict:
+        """Select option from dropdown."""
+        js = self._build_select(selector, value, text)
+        result = await self.execute_script(js)
+        return parse_json_result(result) or {}
+
+    async def close_modal(self, selectors: list[str] | None = None) -> bool:
+        """Try to close modal/dialog."""
+        js = self._build_close_modal(selectors)
+        result = await self.execute_script(js)
+        data = parse_json_result(result) or {}
+        return data.get("success", False)
+
+    async def wait_seconds(self, seconds: float) -> None:
+        """Wait for specified seconds."""
+        await asyncio.sleep(seconds)
+
+    async def wait_random(self, min_sec: float = 0.5, max_sec: float = 1.5) -> None:
+        """Wait for random time between min and max seconds."""
+        import random
+        await asyncio.sleep(min_sec + random.random() * (max_sec - min_sec))
+
+    async def click_all_by_text(self, text: str, role: str = "button") -> int:
+        """Click all elements containing specific text."""
+        js = self._build_click_all_by_text(text, role)
+        result = await self.execute_script(js)
+        data = parse_json_result(result) or {}
+        return data.get("clicked", 0)
+
     # === Context Manager ===
 
     async def close(self) -> None:

cmdop/services/browser/base/session.py

@@ -10,6 +10,13 @@ from cmdop.services.browser.js import (
     build_async_js,
     build_fetch_js,
     build_fetch_all_js,
+    build_scroll_js,
+    build_scroll_to_bottom_js,
+    build_get_scroll_info_js,
+    build_hover_js,
+    build_select_js,
+    build_close_modal_js,
+    build_click_all_by_text_js,
     parse_json_result,
 )
 
@@ -70,3 +77,43 @@ class BaseSession(ABC):
     def _parse_fetch_all(self, result: Any) -> dict[str, Any]:
         """Ensure fetch_all returns dict."""
         return result if isinstance(result, dict) else {}
+
+    # === Scroll helpers ===
+
+    def _build_scroll(
+        self,
+        direction: str,
+        amount: int,
+        selector: str | None,
+        smooth: bool,
+        human_like: bool,
+        container: str | None = None,
+    ) -> str:
+        """Build scroll JS."""
+        return build_scroll_js(direction, amount, selector, smooth, human_like, container)
+
+    def _build_scroll_to_bottom(self) -> str:
+        """Build scroll to bottom JS."""
+        return build_scroll_to_bottom_js()
+
+    def _build_get_scroll_info(self) -> str:
+        """Build get scroll info JS."""
+        return build_get_scroll_info_js()
+
+    # === Interaction helpers ===
+
+    def _build_hover(self, selector: str) -> str:
+        """Build hover JS."""
+        return build_hover_js(selector)
+
+    def _build_select(self, selector: str, value: str | None, text: str | None) -> str:
+        """Build select JS."""
+        return build_select_js(selector, value, text)
+
+    def _build_close_modal(self, selectors: list[str] | None) -> str:
+        """Build close modal JS."""
+        return build_close_modal_js(selectors)
+
+    def _build_click_all_by_text(self, text: str, role: str) -> str:
+        """Build click all by text JS."""
+        return build_click_all_by_text_js(text, role)

cmdop/services/browser/js/__init__.py

@@ -28,6 +28,7 @@ from cmdop.services.browser.js.interaction import (
     build_hover_js,
     build_select_js,
     build_close_modal_js,
+    build_click_all_by_text_js,
 )
 
 __all__ = [
@@ -46,4 +47,5 @@ __all__ = [
     "build_hover_js",
     "build_select_js",
     "build_close_modal_js",
+    "build_click_all_by_text_js",
 ]

cmdop/services/browser/js/interaction.py

@@ -107,3 +107,31 @@ def build_close_modal_js(
         return JSON.stringify({{ success: false, error: 'No modal close button found' }});
     }})()
     """
+
+
+def build_click_all_by_text_js(text: str, role: str = "button") -> str:
+    """
+    Build JS to click all elements containing specific text.
+
+    Args:
+        text: Text to match (case-insensitive)
+        role: Element role to filter (default: "button")
+
+    Returns:
+        JS code that returns { clicked: number }
+    """
+    return f"""
+    (function() {{
+        const elements = document.querySelectorAll('[role="{role}"]');
+        let clicked = 0;
+        const targetText = "{text}".toLowerCase();
+        elements.forEach(el => {{
+            const elText = el.textContent.trim().toLowerCase();
+            if (elText === targetText || elText.includes(targetText)) {{
+                el.click();
+                clicked++;
+            }}
+        }});
+        return JSON.stringify({{ clicked: clicked }});
+    }})()
+    """

cmdop/services/browser/js/scroll.py

@@ -9,6 +9,9 @@ def build_scroll_js(
     direction: str = "down",
     amount: int = 500,
     selector: str | None = None,
+    smooth: bool = True,
+    human_like: bool = False,
+    container: str | None = None,
 ) -> str:
     """
     Build JS for scrolling.
@@ -16,40 +19,128 @@ def build_scroll_js(
     Args:
         direction: "up", "down", "left", "right"
         amount: Pixels to scroll (ignored if selector provided)
-        selector: CSS selector to scroll into view
+        selector: CSS selector to scroll element into view
+        smooth: Use smooth scroll animation (default True)
+        human_like: Add random variations for natural scrolling
+        container: CSS selector for scroll container (default: window)
     """
     if selector:
+        behavior = "smooth" if smooth else "instant"
         return f"""
-        (function() {{
+        (async function() {{
             const el = document.querySelector("{selector}");
             if (el) {{
-                el.scrollIntoView({{ behavior: 'smooth', block: 'center' }});
-                return JSON.stringify({{ success: true }});
+                el.scrollIntoView({{ behavior: '{behavior}', block: 'center' }});
+                await new Promise(r => setTimeout(r, {300 if smooth else 50}));
+                return JSON.stringify({{ success: true, scrollY: window.scrollY }});
             }}
             return JSON.stringify({{ success: false, error: 'Element not found' }});
         }})()
         """
 
-    scroll_map = {
-        "down": f"window.scrollBy(0, {amount})",
-        "up": f"window.scrollBy(0, -{amount})",
-        "right": f"window.scrollBy({amount}, 0)",
-        "left": f"window.scrollBy(-{amount}, 0)",
-    }
-    scroll_code = scroll_map.get(direction, scroll_map["down"])
+    behavior = "smooth" if smooth else "instant"
 
-    return f"""
-    (function() {{
-        const before = window.scrollY;
-        {scroll_code};
-        return JSON.stringify({{
-            success: true,
-            scrollY: window.scrollY,
-            scrolledBy: window.scrollY - before,
-            atBottom: (window.innerHeight + window.scrollY) >= document.body.scrollHeight
-        }});
-    }})()
-    """
+    # Container scroll target
+    container_js = f'document.querySelector("{container}")' if container else "null"
+
+    if human_like:
+        # Human-like scroll with random variation and micro-scrolls
+        return f"""
+        (async function() {{
+            const container = {container_js};
+            const scrollTarget = container || window;
+            const getScrollY = () => container ? container.scrollTop : window.scrollY;
+            const getMaxScroll = () => container
+                ? container.scrollHeight - container.clientHeight
+                : document.body.scrollHeight - window.innerHeight;
+
+            const before = getScrollY();
+            const baseAmount = {amount};
+            const direction = "{direction}";
+
+            // Random variation ±15%
+            const variation = 0.85 + Math.random() * 0.3;
+            const actualAmount = Math.round(baseAmount * variation);
+
+            // Split into 2-4 micro-scrolls
+            const steps = 2 + Math.floor(Math.random() * 3);
+            const stepAmount = actualAmount / steps;
+
+            for (let i = 0; i < steps; i++) {{
+                const stepVariation = 0.8 + Math.random() * 0.4;
+                const thisStep = Math.round(stepAmount * stepVariation);
+
+                let x = 0, y = 0;
+                if (direction === "down") y = thisStep;
+                else if (direction === "up") y = -thisStep;
+                else if (direction === "right") x = thisStep;
+                else if (direction === "left") x = -thisStep;
+
+                if (container) {{
+                    container.scrollBy({{ left: x, top: y, behavior: '{behavior}' }});
+                }} else {{
+                    window.scrollBy({{ left: x, top: y, behavior: '{behavior}' }});
+                }}
+
+                // Random micro-pause 50-150ms between steps
+                if (i < steps - 1) {{
+                    await new Promise(r => setTimeout(r, 50 + Math.random() * 100));
+                }}
+            }}
+
+            // Wait for smooth scroll to finish
+            await new Promise(r => setTimeout(r, {250 if smooth else 50}));
+
+            const after = getScrollY();
+            return JSON.stringify({{
+                success: true,
+                scrollY: after,
+                scrolledBy: after - before,
+                atBottom: after >= getMaxScroll() - 50
+            }});
+        }})()
+        """
+    else:
+        # Standard scroll
+        scroll_x = 0
+        scroll_y = 0
+        if direction == "down":
+            scroll_y = amount
+        elif direction == "up":
+            scroll_y = -amount
+        elif direction == "right":
+            scroll_x = amount
+        elif direction == "left":
+            scroll_x = -amount
+
+        return f"""
+        (async function() {{
+            const container = {container_js};
+            const getScrollY = () => container ? container.scrollTop : window.scrollY;
+            const getMaxScroll = () => container
+                ? container.scrollHeight - container.clientHeight
+                : document.body.scrollHeight - window.innerHeight;
+
+            const before = getScrollY();
+
+            if (container) {{
+                container.scrollBy({{ left: {scroll_x}, top: {scroll_y}, behavior: '{behavior}' }});
+            }} else {{
+                window.scrollBy({{ left: {scroll_x}, top: {scroll_y}, behavior: '{behavior}' }});
+            }}
+
+            // Wait for scroll to complete
+            await new Promise(r => setTimeout(r, {200 if smooth else 30}));
+
+            const after = getScrollY();
+            return JSON.stringify({{
+                success: true,
+                scrollY: after,
+                scrolledBy: after - before,
+                atBottom: after >= getMaxScroll() - 50
+            }});
+        }})()
+        """
 
 
 def build_scroll_to_bottom_js() -> str:

cmdop/services/browser/sync/session.py

@@ -15,13 +15,7 @@ from cmdop.services.browser.models import (
 )
 from cmdop.services.browser.js import (
     parse_json_result,
-    build_scroll_js,
-    build_scroll_to_bottom_js,
     build_infinite_scroll_js,
-    build_hover_js,
-    build_select_js,
-    build_close_modal_js,
-    build_get_scroll_info_js,
 )
 from cmdop.services.browser.parsing import (
     parse_html as _parse_html,
@@ -236,25 +230,41 @@ class BrowserSession(BaseSession):
         direction: str = "down",
         amount: int = 500,
         selector: str | None = None,
+        smooth: bool = True,
+        human_like: bool = False,
+        container: str | None = None,
     ) -> ScrollResult:
         """
-        Scroll the page.
+        Scroll the page or container.
 
         Args:
             direction: "up", "down", "left", "right"
             amount: Pixels to scroll
             selector: If provided, scroll element into view instead
+            smooth: Use smooth scroll animation (default True)
+            human_like: Add random variations for natural scrolling
+            container: CSS selector for scroll container (default: window)
 
         Returns:
             ScrollResult with position info
+
+        Example:
+            # Fast scroll
+            browser.scroll("down", 800)
+
+            # Natural human-like scroll
+            browser.scroll("down", 600, human_like=True)
+
+            # Scroll inside a container (e.g., Facebook feed)
+            browser.scroll("down", 800, container="[role='feed']")
         """
-        js = build_scroll_js(direction, amount, selector)
+        js = self._build_scroll(direction, amount, selector, smooth, human_like, container)
         result = self.execute_script(js)
         data = parse_json_result(result) or {}
         return ScrollResult(
             success=data.get("success", False),
-            scroll_y=data.get("scrollY", 0),
-            scrolled_by=data.get("scrolledBy", 0),
+            scroll_y=int(data.get("scrollY", 0)),
+            scrolled_by=int(data.get("scrolledBy", 0)),
             at_bottom=data.get("atBottom", False),
             error=data.get("error"),
         )
@@ -265,28 +275,28 @@ class BrowserSession(BaseSession):
 
     def scroll_to_bottom(self) -> ScrollResult:
         """Scroll to page bottom."""
-        js = build_scroll_to_bottom_js()
+        js = self._build_scroll_to_bottom()
         result = self.execute_script(js)
         data = parse_json_result(result) or {}
         return ScrollResult(
             success=data.get("success", False),
-            scroll_y=data.get("scrollY", 0),
-            scrolled_by=data.get("scrolledBy", 0),
+            scroll_y=int(data.get("scrollY", 0)),
+            scrolled_by=int(data.get("scrolledBy", 0)),
             at_bottom=True,
         )
 
     def get_scroll_info(self) -> ScrollInfo:
         """Get current scroll position and page dimensions."""
-        js = build_get_scroll_info_js()
+        js = self._build_get_scroll_info()
         result = self.execute_script(js)
         data = parse_json_result(result) or {}
         return ScrollInfo(
-            scroll_x=data.get("scrollX", 0),
-            scroll_y=data.get("scrollY", 0),
-            page_height=data.get("pageHeight", 0),
-            page_width=data.get("pageWidth", 0),
-            viewport_height=data.get("viewportHeight", 0),
-            viewport_width=data.get("viewportWidth", 0),
+            scroll_x=int(data.get("scrollX", 0)),
+            scroll_y=int(data.get("scrollY", 0)),
+            page_height=int(data.get("pageHeight", 0)),
+            page_width=int(data.get("pageWidth", 0)),
+            viewport_height=int(data.get("viewportHeight", 0)),
+            viewport_width=int(data.get("viewportWidth", 0)),
             at_bottom=data.get("atBottom", False),
             at_top=data.get("atTop", True),
         )
@@ -374,7 +384,7 @@ class BrowserSession(BaseSession):
 
     def hover(self, selector: str) -> bool:
         """Hover over element."""
-        js = build_hover_js(selector)
+        js = self._build_hover(selector)
         result = self.execute_script(js)
         data = parse_json_result(result) or {}
         return data.get("success", False)
@@ -396,7 +406,7 @@ class BrowserSession(BaseSession):
         Returns:
             Dict with selected_value and selected_text
         """
-        js = build_select_js(selector, value, text)
+        js = self._build_select(selector, value, text)
         result = self.execute_script(js)
         return parse_json_result(result) or {}
 
@@ -410,7 +420,7 @@ class BrowserSession(BaseSession):
         Returns:
             True if modal was closed
         """
-        js = build_close_modal_js(selectors)
+        js = self._build_close_modal(selectors)
         result = self.execute_script(js)
         data = parse_json_result(result) or {}
         return data.get("success", False)
@@ -419,6 +429,31 @@ class BrowserSession(BaseSession):
         """Wait for specified seconds."""
         time.sleep(seconds)
 
+    def wait_random(self, min_sec: float = 0.5, max_sec: float = 1.5) -> None:
+        """Wait for random time between min and max seconds."""
+        import random
+        time.sleep(min_sec + random.random() * (max_sec - min_sec))
+
+    def click_all_by_text(self, text: str, role: str = "button") -> int:
+        """
+        Click all elements containing specific text.
+
+        Args:
+            text: Text to match (case-insensitive)
+            role: Element role to filter (default: "button")
+
+        Returns:
+            Number of elements clicked
+
+        Example:
+            browser.click_all_by_text("See more")  # Expand all posts
+            browser.click_all_by_text("Load more", role="link")
+        """
+        js = self._build_click_all_by_text(text, role)
+        result = self.execute_script(js)
+        data = parse_json_result(result) or {}
+        return data.get("clicked", 0)
+
     # === Context Manager ===
 
     def close(self) -> None:

{cmdop-0.1.17.dist-info → cmdop-0.1.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmdop
-Version: 0.1.17
+Version: 0.1.18
 Summary: Python SDK for CMDOP agent interaction
 Project-URL: Homepage, https://cmdop.com
 Project-URL: Documentation, https://cmdop.com
@@ -148,56 +148,63 @@ health: Health = result.output  # Typed!
 ```python
 with client.browser.create_session() as b:
     b.navigate("https://shop.com/products")
+    b.close_modal()  # Close popups
 
-    # DOM extraction
-    products = b.extract_data(".product-card", '{"name": "h2", "price": ".price"}', limit=100)
+    # BeautifulSoup parsing
+    soup = b.soup()  # SoupWrapper with chainable API
+    for item in soup.select(".product"):
+        title = item.select_one("h2").text()
+        price = item.attr("data-price")
 
-    # Get HTML for BeautifulSoup parsing
-    html = b.get_html("[role='feed']")
-    soup = b.parse_html(html)  # Returns BeautifulSoup object
-
-    # Scroll & extract pattern
+    # Human-like scrolling with random delays
     for _ in range(10):
-        html = b.get_html(".listings")
-        # ... parse with soup ...
-        b.scroll("down", 800)
-        b.wait_seconds(1.0)
+        soup = b.soup(".listings")
+        # ... parse ...
+        b.scroll("down", 700, human_like=True)  # Natural micro-scrolls
+        b.wait_random(0.8, 1.5)  # Random delay
+
+    # Scroll inside container (Facebook, Twitter feeds)
+    b.scroll("down", 800, container="[role='feed']")
+
+    # Click all "See more" buttons
+    b.click_all_by_text("See more")
 
     # JS fetch (bypass CORS, inherit cookies)
     data = b.fetch_json("https://api.site.com/v1/items")
-
-    # Parallel fetch
-    results = b.fetch_all({
-        "users": "https://api.site.com/v1/users",
-        "orders": "https://api.site.com/v1/orders",
-    }, credentials=True)
 ```
 
 | Method | Description |
 |--------|-------------|
 | `navigate(url)` | Go to URL |
 | `click(selector)` | Click element |
+| `click_all_by_text(text, role)` | Click all matching elements |
 | `type(selector, text)` | Type text |
 | `wait_for(selector, ms)` | Wait for element |
 | `wait_seconds(n)` | Sleep |
+| `wait_random(min, max)` | Random sleep |
 | `extract(selector, attr)` | Get text/attr |
 | `get_html(selector)` | Get HTML |
-| `get_text(selector)` | Get text |
+| `soup(selector)` | → SoupWrapper |
 | `parse_html(html)` | → BeautifulSoup |
-| `extract_data(item, fields, limit)` | Bulk extract |
 | `fetch_json(url)` | JS fetch → dict |
-| `fetch_all(urls, credentials)` | Parallel fetch |
+| `fetch_all(urls)` | Parallel fetch |
 | `execute_js(code)` | Run async JS |
 | `screenshot()` | PNG bytes |
-| `scroll(dir, amount)` | Scroll page |
+| `scroll(dir, amount, ...)` | Scroll page/container |
 | `scroll_to(selector)` | Scroll to element |
 | `get_scroll_info()` | Position + page size |
-| `infinite_scroll(fn, limit)` | Smart scroll loop |
 | `hover(selector)` | Hover |
 | `select(selector, value)` | Dropdown select |
 | `close_modal()` | Close dialogs |
 | `get/set_cookies()` | Cookie management |
 
+**scroll() parameters:**
+- `direction`: "up", "down", "left", "right"
+- `amount`: pixels to scroll
+- `smooth`: animate scroll (default True)
+- `human_like`: random micro-scrolls + variation
+- `container`: CSS selector for scroll container
+
 ## SDKBaseModel
 
 Auto-cleaning Pydantic model for scraped data:

{cmdop-0.1.17.dist-info → cmdop-0.1.18.dist-info}/RECORD

@@ -1,4 +1,4 @@
-cmdop/__init__.py,sha256=sbn29kS94dhezvrLsrn2r_O-T8kpbHFIPAgqcp_8hsM,5200
+cmdop/__init__.py,sha256=tqdxrpPGr61930IR-Igh10FiIwvyNHquP6Vt7ujlv88,5200
 cmdop/client.py,sha256=NzCBMIAj2vnVzwU1OUttW_kpgJh5aRtmixOwa9HUUUg,14924
 cmdop/config.py,sha256=vpw1aGCyS4NKlZyzVur81Lt06QmN3FnscZji0bypUi0,4398
 cmdop/discovery.py,sha256=HNxSOa5tSuG7ppfFs21XdviW5ucjpRswVPguhX5j8Dg,7479
@@ -171,18 +171,18 @@ cmdop/services/browser/models.py,sha256=2xvbydS2SHLb0BtATBktaZxAn5pRMYVoqTn91eZI
 cmdop/services/browser/parsing.py,sha256=0hQAy-0ZwJqtmhEqHO3EEdVB3iYmyhXRdouN_dCbig8,3820
 cmdop/services/browser/aio/__init__.py,sha256=7DI4Q0LZaAdu3fl8D1SaZ8E3LCGpTw97lqca1pOi5Kk,241
 cmdop/services/browser/aio/service.py,sha256=dSiT6hS1wKRinoon1zfO34xR_irGrNYIDU1gt_6OD54,11494
-cmdop/services/browser/aio/session.py,sha256=CcDsAuAvE1Gtxxkffei0A8eH4knzTgOLNGELyMdQAkc,6148
+cmdop/services/browser/aio/session.py,sha256=It9XjLxe73Kqm0vYbLv3rYXyZG0QaH1tfDsXNJHtzCU,10518
 cmdop/services/browser/base/__init__.py,sha256=mgG4y324zSDy-13uQiTg6rlFpaQFLc67ynbykRZuMms,227
 cmdop/services/browser/base/service.py,sha256=w8foDUGZcD4HyF5eyLZUFxbx_fctAFsYRovvsksi3l4,1584
-cmdop/services/browser/base/session.py,sha256=PMTZ5ol1Wl9nRDvRYeLuau3Z50N2gOlbh_zP7L9A3Ac,2139
-cmdop/services/browser/js/__init__.py,sha256=_wxU2cqrmeHxZPhSMPwfK_24EZz4iqFYA4hf6jfWqcE,1119
+cmdop/services/browser/base/session.py,sha256=YymfV_G-b9HGae26hMoCNAlNzwb_pGEWgE4i6dgH4_s,3594
+cmdop/services/browser/js/__init__.py,sha256=u4mkKwUeCZSe8EshwRIdcfqbnGqkUcuF8h2qUkXY_xs,1185
 cmdop/services/browser/js/core.py,sha256=QXCCX_al5tMgz7aCwMqhIs1aRe_IdG8teOJniaumA5Q,995
 cmdop/services/browser/js/fetch.py,sha256=WPy_H4LLkneSx06wpfnx4Sx_0Okf2ENXi6bveCd9ZCg,2188
-cmdop/services/browser/js/interaction.py,sha256=LjneAMc0ZFZspNaaRUKHCG2NwmqRkH_dU3b69TFnCf8,3211
-cmdop/services/browser/js/scroll.py,sha256=BPu1jJh_on0cKep8zQC9SWKs1TgghKT9EuyuvwFEE4I,3998
+cmdop/services/browser/js/interaction.py,sha256=CkuUjTtwgBWWtO48L1-YGh6NkKZbplp8-GUtlA2ODPE,4049
+cmdop/services/browser/js/scroll.py,sha256=2nGH-zqbxJkmC5uuAJxv4MY43y0vJJoGzGja3gX0DNQ,7681
 cmdop/services/browser/sync/__init__.py,sha256=sFePvIsWqhaeCU9fw_ZyOITeeEHvZx4Gtcp8W3KBKG0,222
 cmdop/services/browser/sync/service.py,sha256=TVw8yMuGWXc0NetUnxTGU39uv4UH_nPBBk27nPWs7eI,11136
-cmdop/services/browser/sync/session.py,sha256=Z1gAFxTQCFeiWgF8UUDixQWeE5-_0EWlCp2VtbFTt6U,13994
+cmdop/services/browser/sync/session.py,sha256=rj8xIoocpuIMGn_xMwBbcwWGmd-QtFklo8TDoUoAbFc,15478
 cmdop/streaming/__init__.py,sha256=kG9UlJRqv8ndcwKMzWUddPlZT61pFO_Uf_c08A_8TxA,877
 cmdop/streaming/base.py,sha256=r7Q2QlRxgULzs9vlSGcOC_fwAQ_cF3Z3M7WsPQtxG5I,2990
 cmdop/streaming/handlers.py,sha256=FDEhADmCEFRbifvr9dU1X3C-K_96noz89Bl3tuDa_rQ,2616
@@ -193,7 +193,7 @@ cmdop/transport/base.py,sha256=2pkV8i9epgp_21dyReCfX47abRUrnALm0W5BXb-Fuz0,5571
 cmdop/transport/discovery.py,sha256=rcGAuVrR1l6jwcP0dqZxVhX1NsFK7sRHygFMCLmmUbA,10673
 cmdop/transport/local.py,sha256=ob6tWVxSdKwblHSMK8CkgjyuSdQoAeWgy5OAUd5ZNuE,7411
 cmdop/transport/remote.py,sha256=FNVqus9wOv7LlxKarXjLmSyvJiHwhvPbNDOPv1IQkmE,4329
-cmdop-0.1.17.dist-info/METADATA,sha256=ks-gUDJ-TclfSqXt8mspBu65PbsqKGSSnHIbh0-tBMs,6422
-cmdop-0.1.17.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-cmdop-0.1.17.dist-info/licenses/LICENSE,sha256=6hyzbI1QVXW6B-XT7PaQ6UG9lns11Y_nnap8uUKGUqo,1062
-cmdop-0.1.17.dist-info/RECORD,,
+cmdop-0.1.18.dist-info/METADATA,sha256=hyz91IkVkE_zZy1RfQpn7TCSXj30jjQgetxXpUU5DhI,6721
+cmdop-0.1.18.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+cmdop-0.1.18.dist-info/licenses/LICENSE,sha256=6hyzbI1QVXW6B-XT7PaQ6UG9lns11Y_nnap8uUKGUqo,1062
+cmdop-0.1.18.dist-info/RECORD,,