wavexis 2.2.5__tar.gz → 2.3.0__tar.gz

{wavexis-2.2.5 → wavexis-2.3.0}/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 All notable changes to wavexis are documented in this file.
 
+## v2.3.0 — 2026-07-07
+
+### Added
+
+- Auto-waiting before `click`, `fill`, and `hover` in both CDP and BiDi backends
+- `_wait_for_element` helper polls every 100ms until element exists and is visible (non-zero size)
+- Configurable timeout (default 30s) via `WaitTimeoutError` with actionable hint
+- Prevents `ElementNotFoundError` on dynamically loaded content
+
+## v2.2.6 — 2026-07-07
+
+### Added
+
+- Named sessions: `--name` flag stores sessions in `~/.wavexis/sessions/`
+- `wavexis session list` — list all saved named sessions with size and modification date
+- `wavexis session delete --name <name>` — delete a named session
+- Named sessions persist between runs, enabling stateful workflows
+
 ## v2.2.5 — 2026-07-07
 
 ### Improved

{wavexis-2.2.5 → wavexis-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavexis
-Version: 2.2.5
+Version: 2.3.0
 Summary: Browser automation CLI — wraps cdpwave and bidiwave, no Node.js, no Chromium download
 Project-URL: Homepage, https://github.com/MathiasPaulenko/wavexis
 Project-URL: Repository, https://github.com/MathiasPaulenko/wavexis

{wavexis-2.2.5 → wavexis-2.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "wavexis"
-version = "2.2.5"
+version = "2.3.0"
 description = "Browser automation CLI — wraps cdpwave and bidiwave, no Node.js, no Chromium download"
 readme = "README.md"
 license = { text = "MIT" }

wavexis-2.3.0/tests/unit/test_auto_wait.py

@@ -0,0 +1,97 @@
+"""Unit tests for auto-waiting before click/fill/hover."""
+
+from __future__ import annotations
+
+import asyncio
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from wavexis.exceptions import WaitTimeoutError
+
+
+@pytest.mark.unit
+class TestAutoWait:
+    """Tests for auto-waiting before input actions."""
+
+    def test_cdp_wait_for_element_found(self) -> None:
+        """Test _wait_for_element returns when element is visible."""
+        from wavexis.backend.cdp import CDPBackend
+
+        backend = CDPBackend()
+        backend._session = MagicMock()
+        backend._session.runtime = MagicMock()
+        backend._session.runtime.evaluate = AsyncMock(
+            return_value={"result": {"value": True}}
+        )
+        asyncio.run(backend._wait_for_element("#btn", timeout_ms=100))
+        assert backend._session.runtime.evaluate.call_count >= 1
+
+    def test_cdp_wait_for_element_timeout(self) -> None:
+        """Test _wait_for_element raises WaitTimeoutError on timeout."""
+        from wavexis.backend.cdp import CDPBackend
+
+        backend = CDPBackend()
+        backend._session = MagicMock()
+        backend._session.runtime = MagicMock()
+        backend._session.runtime.evaluate = AsyncMock(
+            return_value={"result": {"value": False}}
+        )
+        with pytest.raises(WaitTimeoutError):
+            asyncio.run(backend._wait_for_element("#missing", timeout_ms=50))
+
+    def test_cdp_click_calls_wait_for_element(self) -> None:
+        """Test that click calls _wait_for_element before acting."""
+        from wavexis.backend.cdp import CDPBackend
+
+        backend = CDPBackend()
+        backend._session = MagicMock()
+        backend._session.input = MagicMock()
+        backend._session.input.dispatch_mouse_event = AsyncMock()
+
+        call_order: list[str] = []
+
+        async def _mock_wait(selector: str, timeout_ms: int = 30000) -> None:
+            call_order.append("wait")
+
+        async def _mock_scroll(selector: str) -> None:
+            call_order.append("scroll")
+
+        async def _mock_box(selector: str) -> tuple[float, float]:
+            call_order.append("box")
+            return 50.0, 25.0
+
+        backend._wait_for_element = _mock_wait  # type: ignore[assignment]
+        backend._scroll_into_view_if_needed = _mock_scroll  # type: ignore[assignment]
+        backend._get_box_center = _mock_box  # type: ignore[assignment]
+
+        asyncio.run(backend.click("#btn"))
+        assert call_order == ["wait", "scroll", "box"]
+
+    def test_bidi_wait_for_element_found(self) -> None:
+        """Test BiDi _wait_for_element returns when element is visible."""
+        from wavexis.backend.bidi import BiDiBackend
+
+        backend = BiDiBackend()
+        backend._client = MagicMock()
+        backend._context = MagicMock()
+        backend._client.script = MagicMock()
+        result = MagicMock()
+        result.value = True
+        backend._client.script.evaluate = AsyncMock(return_value=result)
+        asyncio.run(backend._wait_for_element("#btn", timeout_ms=100))
+        assert backend._client.script.evaluate.call_count >= 1
+
+    def test_bidi_wait_for_element_timeout(self) -> None:
+        """Test BiDi _wait_for_element raises WaitTimeoutError on timeout."""
+        from wavexis.backend.bidi import BiDiBackend
+
+        backend = BiDiBackend()
+        backend._client = MagicMock()
+        backend._context = MagicMock()
+        backend._client.script = MagicMock()
+        result = MagicMock()
+        result.value = False
+        backend._client.script.evaluate = AsyncMock(return_value=result)
+        with pytest.raises(WaitTimeoutError):
+            asyncio.run(backend._wait_for_element("#missing", timeout_ms=50))

{wavexis-2.2.5 → wavexis-2.3.0}/tests/unit/test_bidi_phase5.py

@@ -20,7 +20,9 @@ class TestBiDiBackendPhase5:
         backend._client = MagicMock()
         backend._context = MagicMock()
         backend._client.script = MagicMock()
-        backend._client.script.evaluate = AsyncMock()
+        result = MagicMock()
+        result.value = True
+        backend._client.script.evaluate = AsyncMock(return_value=result)
         backend._client._connection = MagicMock()
         backend._client._connection.send_command = AsyncMock()
         return backend

{wavexis-2.2.5 → wavexis-2.3.0}/wavexis/__init__.py

@@ -1,3 +1,3 @@
 """wavexis — CLI de automatización de navegador."""
 
-__version__ = "2.2.5"
+__version__ = "2.3.0"

{wavexis-2.2.5 → wavexis-2.3.0}/wavexis/backend/bidi.py

@@ -26,7 +26,7 @@ from wavexis.config import (
     ThrottleParams,
     WaitStrategy,
 )
-from wavexis.exceptions import SessionNotInitializedError
+from wavexis.exceptions import SessionNotInitializedError, WaitTimeoutError
 
 try:
     from bidiwave import BiDiClient
@@ -807,6 +807,38 @@ class BiDiBackend(AbstractBackend):
 
     # ── Input ──────────────────────────────────────────────
 
+    async def _wait_for_element(self, selector: str, timeout_ms: int = 30000) -> None:
+        """Wait for an element to exist and be visible in the DOM.
+
+        Polls until the element matches, is attached, and has non-zero size.
+
+        Args:
+            selector: CSS selector for the target element.
+            timeout_ms: Maximum wait time in milliseconds.
+
+        Raises:
+            WaitTimeoutError: If the element is not found within the timeout.
+        """
+        import asyncio as _asyncio
+        import time as _time
+
+        client = self._require_client()
+        escaped = selector.replace("'", "\\'")
+        js = (
+            f"(function(){{var el=document.querySelector('{escaped}');"
+            f"if(!el)return false;"
+            f"var rect=el.getBoundingClientRect();"
+            f"return rect.width>0&&rect.height>0;}})()"
+        )
+        deadline = _time.monotonic() + timeout_ms / 1000
+        while _time.monotonic() < deadline:
+            result = await client.script.evaluate(self._context, js)
+            value = getattr(result, "value", None)
+            if value is True or value == "true":
+                return
+            await _asyncio.sleep(0.1)
+        raise WaitTimeoutError("selector", timeout_ms)
+
     async def _scroll_into_view_if_needed(self, selector: str) -> None:
         """Scroll element into view if it's not visible in the viewport."""
         client = self._require_client()
@@ -825,6 +857,7 @@ class BiDiBackend(AbstractBackend):
     ) -> None:
         """Click an element via BiDi script.evaluate."""
         client = self._require_client()
+        await self._wait_for_element(selector)
         await self._scroll_into_view_if_needed(selector)
         escaped = selector.replace("'", "\\'")
         js = (
@@ -857,6 +890,7 @@ class BiDiBackend(AbstractBackend):
     async def fill(self, selector: str, value: str) -> None:
         """Fill an input element with a value via BiDi."""
         client = self._require_client()
+        await self._wait_for_element(selector)
         await self._scroll_into_view_if_needed(selector)
         escaped = selector.replace("'", "\\'")
         escaped_val = value.replace("\\", "\\\\").replace("'", "\\'")
@@ -875,6 +909,7 @@ class BiDiBackend(AbstractBackend):
     async def hover(self, selector: str) -> None:
         """Hover over an element via BiDi script.evaluate."""
         client = self._require_client()
+        await self._wait_for_element(selector)
         await self._scroll_into_view_if_needed(selector)
         escaped = selector.replace("'", "\\'")
         js = (

{wavexis-2.2.5 → wavexis-2.3.0}/wavexis/backend/cdp.py

@@ -1026,6 +1026,34 @@ class CDPBackend(AbstractBackend):
         cy = (min(ys) + max(ys)) / 2
         return cx, cy
 
+    async def _wait_for_element(self, selector: str, timeout_ms: int = 30000) -> None:
+        """Wait for an element to exist and be visible in the DOM.
+
+        Polls until the element matches, is attached, and has non-zero size.
+
+        Args:
+            selector: CSS selector for the target element.
+            timeout_ms: Maximum wait time in milliseconds.
+
+        Raises:
+            WaitTimeoutError: If the element is not found within the timeout.
+        """
+        session = self._require_session()
+        escaped = selector.replace("'", "\\'")
+        js = (
+            f"(function(){{var el=document.querySelector('{escaped}');"
+            f"if(!el)return false;"
+            f"var rect=el.getBoundingClientRect();"
+            f"return rect.width>0&&rect.height>0;}})()"
+        )
+        deadline = time.monotonic() + timeout_ms / 1000
+        while time.monotonic() < deadline:
+            result = await session.runtime.evaluate(js)
+            if result.get("result", {}).get("value") is True:
+                return
+            await asyncio.sleep(0.1)
+        raise WaitTimeoutError("selector", timeout_ms)
+
     async def _scroll_into_view_if_needed(self, selector: str) -> None:
         """Scroll element into view if it's not visible in the viewport.
 
@@ -1054,6 +1082,7 @@ class CDPBackend(AbstractBackend):
             click_count: Number of clicks to dispatch.
         """
         session = self._require_session()
+        await self._wait_for_element(selector)
         await self._scroll_into_view_if_needed(selector)
         x, y = await self._get_box_center(selector)
         btn_map = {"left": "left", "right": "right", "middle": "middle"}
@@ -1092,6 +1121,7 @@ class CDPBackend(AbstractBackend):
             value: Value to set in the input field.
         """
         session = self._require_session()
+        await self._wait_for_element(selector)
         await self._scroll_into_view_if_needed(selector)
         escaped = selector.replace("'", "\\'")
         js = (
@@ -1132,6 +1162,7 @@ class CDPBackend(AbstractBackend):
             selector: CSS selector for the target element.
         """
         session = self._require_session()
+        await self._wait_for_element(selector)
         await self._scroll_into_view_if_needed(selector)
         x, y = await self._get_box_center(selector)
         await session.input.dispatch_mouse_event(

{wavexis-2.2.5 → wavexis-2.3.0}/wavexis/cleanup.py

@@ -23,8 +23,9 @@ _SIGNAL_NAMES: dict[int, str] = {
     signal.SIGTERM: "SIGTERM",
 }
 
-with contextlib.suppress(AttributeError):
-    _SIGNAL_NAMES[signal.SIGBREAK] = "SIGBREAK"
+_sigbreak = getattr(signal, "SIGBREAK", None)
+if _sigbreak is not None:
+    _SIGNAL_NAMES[_sigbreak] = "SIGBREAK"
 
 
 def register_backend(backend: Any) -> None:

{wavexis-2.2.5 → wavexis-2.3.0}/wavexis/cli/_session.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+import time
 from pathlib import Path
 from typing import Any
 
@@ -21,7 +22,7 @@ from wavexis.config import WaitStrategy
 @app.command()
 def session(
     action: str = typer.Argument(
-        ..., help="Session action: save, load"
+        ..., help="Session action: save, load, list, delete"
     ),
     url: str = typer.Argument(
         "", help="URL to navigate to (for save) or load before navigating (for load)"
@@ -29,18 +30,60 @@ def session(
     output: str = typer.Option(
         "session.json", "--output", "-o", help="Session file path"
     ),
+    name: str = typer.Option(
+        "", "--name", "-n", help="Named session (stored in ~/.wavexis/sessions/)"
+    ),
 ) -> None:
     """Save or load browser session state (cookies + localStorage + sessionStorage).
 
     \b
     Save:  wavexis session save https://app.com -o mysession.json
     Load:  wavexis session load mysession.json https://app.com
+    Named: wavexis session save https://app.com --name mysession
+    List:  wavexis session list
+    Delete: wavexis session delete --name mysession
     """
     from wavexis.actions.session import SessionLoadAction, SessionSaveAction
 
-    session_path = Path(output)
+    sessions_dir = Path.home() / ".wavexis" / "sessions"
+
+    def _session_path() -> Path:
+        if name:
+            return sessions_dir / f"{name}.json"
+        return Path(output)
+
+    if action == "list":
+        if not sessions_dir.exists():
+            typer.echo("No saved sessions found.")
+            return
+        sessions = list(sessions_dir.glob("*.json"))
+        if not sessions:
+            typer.echo("No saved sessions found.")
+            return
+        typer.echo(f"Saved sessions ({len(sessions)}):")
+        for s in sorted(sessions):
+            stat = s.stat()
+            modified = time.strftime("%Y-%m-%d %H:%M", time.localtime(stat.st_mtime))
+            typer.echo(f"  {s.stem}  ({stat.st_size} bytes, {modified})")
+        return
+
+    if action == "delete":
+        if not name:
+            typer.echo("Error: --name required for delete", err=True)
+            raise typer.Exit(1)
+        target = _session_path()
+        if not target.exists():
+            typer.echo(f"Error: session '{name}' not found", err=True)
+            raise typer.Exit(1)
+        target.unlink()
+        typer.echo(f"Deleted session '{name}'")
+        return
+
+    session_path = _session_path()
 
     if action == "save":
+        if name:
+            sessions_dir.mkdir(parents=True, exist_ok=True)
         if not url:
             typer.echo("Error: URL required for session save", err=True)
             raise typer.Exit(1)
@@ -56,11 +99,11 @@ def session(
                 await backend.close()
 
         _run_async(_save_session())
-        typer.echo(f"Session saved to {output}")
+        typer.echo(f"Session saved to {session_path}")
 
     elif action == "load":
         if not session_path.exists():
-            typer.echo(f"Error: session file not found: {output}", err=True)
+            typer.echo(f"Error: session file not found: {session_path}", err=True)
             raise typer.Exit(1)
 
         async def _load_session() -> Any:
@@ -80,10 +123,13 @@ def session(
         result = _run_async(_load_session())
         if result is None:
             return
-        typer.echo(f"Session loaded from {output}: {result}")
+        typer.echo(f"Session loaded from {session_path}: {result}")
 
     else:
-        typer.echo(f"Error: unknown session action '{action}'. Use save or load.", err=True)
+        typer.echo(
+            f"Error: unknown session action '{action}'. Use save, load, list, or delete.",
+            err=True,
+        )
         raise typer.Exit(1)