wavexis 2.3.4__tar.gz → 2.4.0__tar.gz

{wavexis-2.3.4 → wavexis-2.4.0}/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 All notable changes to wavexis are documented in this file.
 
+## v2.4.0 — 2026-07-07
+
+### Added
+
+- Request/response body inspection: `get_request_body`, `get_response_body` in both CDP and BiDi backends
+- `wavexis inspect <url> -r <request_id> -t request|response` CLI command
+- Request interception and modification: `modify_request` via CDP Fetch domain in both backends
+- `wavexis modify <url> -p <pattern> -h <header> -m <method>` CLI command
+- HAR replay: `replay_har` reads HAR file and replays requests via browser fetch API
+- `wavexis har-replay <har_path> -u <url> -f <filter>` CLI command
+- Combined tracing: `start_combined_trace`/`stop_combined_trace` capturing screenshots, network, console, and trace events
+- `wavexis trace start|stop` CLI command with `--no-screenshots`, `--no-network`, `--no-console` flags
+- axe-core accessibility audit: `axe_audit` injects axe-core JS and returns violations/passes/incomplete/inapplicable
+- `wavexis axe <url> -o <output>` CLI command
+- Event subscription: `subscribe_events`/`unsubscribe_events` for real-time console, network, dialog, and navigation events
+- `wavexis events subscribe <url> -t <types> -d <duration>` CLI command
+- WebSocket event streaming in serve.py for network_request, network_response, and dialog events
+
+## v2.3.5 — 2026-07-07
+
+### Added
+
+- Natural language selector: `find_by_text`, `nl_click`, `nl_fill` in both CDP and BiDi backends
+- `wavexis nl click/fill/find` CLI command with natural language queries
+- Fuzzy text matching scoring: exact match (100), contains query (80), query contains text (60), word overlap (up to 50)
+- Searches textContent, aria-label, placeholder, title, alt, and value attributes
+- Returns best CSS selector for the matched element
+- `--all` flag on `nl find` returns all matches ranked by score
+- `--no-wait` flag to skip auto-waiting
+
 ## v2.3.4 — 2026-07-07
 
 ### Added

{wavexis-2.3.4 → wavexis-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavexis
-Version: 2.3.4
+Version: 2.4.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.3.4 → wavexis-2.4.0}/pyproject.toml

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

{wavexis-2.3.4 → wavexis-2.4.0}/tests/unit/test_backend_manager.py

@@ -138,6 +138,22 @@ class DummyBackend(AbstractBackend):
         """Suggest locator."""
         return selector
 
+    async def find_by_text(
+        self, query: str, all: bool = False
+    ) -> list[str] | str:
+        """Find by text."""
+        return query
+
+    async def nl_click(self, query: str, auto_wait: bool = True) -> None:
+        """NL click."""
+        pass
+
+    async def nl_fill(
+        self, query: str, value: str, auto_wait: bool = True
+    ) -> None:
+        """NL fill."""
+        pass
+
     async def capture_har(self, params: object) -> dict:
         """Capture har."""
         return {}
@@ -588,6 +604,51 @@ class DummyBackend(AbstractBackend):
         """Bluetooth stop."""
         pass
 
+    async def get_request_body(self, request_id: str) -> str | None:
+        """Get request body."""
+        return None
+
+    async def get_response_body(self, request_id: str) -> str | None:
+        """Get response body."""
+        return None
+
+    async def modify_request(
+        self, pattern: dict[str, Any], modifications: dict[str, Any]
+    ) -> None:
+        """Modify request."""
+        pass
+
+    async def replay_har(self, har_path: str, url_filter: str = "") -> None:
+        """Replay har."""
+        pass
+
+    async def start_combined_trace(
+        self,
+        capture_screenshots: bool = True,
+        capture_network: bool = True,
+        capture_console: bool = True,
+    ) -> str:
+        """Start combined trace."""
+        return "trace-dummy"
+
+    async def stop_combined_trace(self, trace_id: str) -> dict[str, Any]:
+        """Stop combined trace."""
+        return {}
+
+    async def axe_audit(self) -> dict[str, Any]:
+        """Axe audit."""
+        return {}
+
+    async def subscribe_events(
+        self, event_types: list[str], callback: Any
+    ) -> str:
+        """Subscribe events."""
+        return "sub-dummy"
+
+    async def unsubscribe_events(self, subscription_id: str) -> None:
+        """Unsubscribe events."""
+        pass
+
 
 @pytest.mark.unit
 class TestBackendManager:

{wavexis-2.3.4 → wavexis-2.4.0}/tests/unit/test_manager.py

@@ -69,6 +69,13 @@ class FakeBackend(AbstractBackend):
     async def suggest_locator(self, selector, all=False):
         """Suggest locator."""
         return selector
+    async def find_by_text(self, query, all=False):
+        """Find by text."""
+        return query
+    async def nl_click(self, query, auto_wait=True):
+        """NL click."""
+    async def nl_fill(self, query, value, auto_wait=True):
+        """NL fill."""
     async def capture_har(self, params):
         """Capture har."""
     async def get_cookies(self):
@@ -279,6 +286,30 @@ class FakeBackend(AbstractBackend):
         """Shadow click."""
     async def shadow_fill(self, selectors, value, auto_wait=True):
         """Shadow fill."""
+    async def get_request_body(self, request_id):
+        """Get request body."""
+    async def get_response_body(self, request_id):
+        """Get response body."""
+    async def modify_request(self, pattern, modifications):
+        """Modify request."""
+    async def replay_har(self, har_path, url_filter=""):
+        """Replay har."""
+    async def start_combined_trace(
+        self, capture_screenshots=True, capture_network=True, capture_console=True
+    ):
+        """Start combined trace."""
+        return "trace-fake"
+    async def stop_combined_trace(self, trace_id):
+        """Stop combined trace."""
+        return {}
+    async def axe_audit(self):
+        """Axe audit."""
+        return {}
+    async def subscribe_events(self, event_types, callback):
+        """Subscribe events."""
+        return "sub-fake"
+    async def unsubscribe_events(self, subscription_id):
+        """Unsubscribe events."""
 
 
 class TestBackendManager:

wavexis-2.4.0/tests/unit/test_network_inspect.py

@@ -0,0 +1,349 @@
+"""Unit tests for v2.4.x network inspection, tracing, axe, and events."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Any
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+
+def _make_cdp_backend() -> Any:
+    """Create a CDPBackend with mocked session."""
+    from wavexis.backend.cdp import CDPBackend
+
+    backend = CDPBackend()
+    backend._session = MagicMock()
+    backend._session.runtime = MagicMock()
+    backend._session.runtime.evaluate = AsyncMock(
+        return_value={"result": {"value": None}}
+    )
+    backend._session.runtime.enable = AsyncMock()
+    backend._session.send = AsyncMock(return_value={})
+    backend._session.network = MagicMock()
+    backend._session.network.enable = AsyncMock()
+    backend._session.page = MagicMock()
+    backend._session.page.capture_screenshot = AsyncMock(return_value="")
+    return backend
+
+
+def _make_bidi_backend() -> Any:
+    """Create a BiDiBackend with mocked client."""
+    from wavexis.backend.bidi import BiDiBackend
+
+    backend = BiDiBackend()
+    backend._client = MagicMock()
+    backend._context = MagicMock()
+    backend._client.script = MagicMock()
+    result = MagicMock()
+    result.value = None
+    backend._client.script.evaluate = AsyncMock(return_value=result)
+    backend._client.cdp = MagicMock()
+    backend._client.cdp.send_command = AsyncMock(return_value={})
+    backend._client.cdp.on = MagicMock()
+    backend._client.cdp.off = MagicMock()
+    return backend
+
+
+@pytest.mark.unit
+class TestGetRequestBodyCDP:
+    """Tests for get_request_body in CDP backend."""
+
+    def test_returns_body(self) -> None:
+        """Test that get_request_body returns the post data."""
+        backend = _make_cdp_backend()
+        backend._session.send = AsyncMock(
+            return_value={"postData": '{"key": "value"}'}
+        )
+        result = asyncio.run(backend.get_request_body("req-123"))
+        assert result == '{"key": "value"}'
+
+    def test_returns_none_on_error(self) -> None:
+        """Test that get_request_body returns None on error."""
+        backend = _make_cdp_backend()
+        backend._session.send = AsyncMock(side_effect=Exception("fail"))
+        result = asyncio.run(backend.get_request_body("req-123"))
+        assert result is None
+
+
+@pytest.mark.unit
+class TestGetResponseBodyCDP:
+    """Tests for get_response_body in CDP backend."""
+
+    def test_returns_body(self) -> None:
+        """Test that get_response_body returns the body."""
+        backend = _make_cdp_backend()
+        backend._session.send = AsyncMock(
+            return_value={"body": "<html>response</html>"}
+        )
+        result = asyncio.run(backend.get_response_body("req-123"))
+        assert result == "<html>response</html>"
+
+    def test_returns_none_on_error(self) -> None:
+        """Test that get_response_body returns None on error."""
+        backend = _make_cdp_backend()
+        backend._session.send = AsyncMock(side_effect=Exception("fail"))
+        result = asyncio.run(backend.get_response_body("req-123"))
+        assert result is None
+
+
+@pytest.mark.unit
+class TestGetRequestBodyBiDi:
+    """Tests for get_request_body in BiDi backend."""
+
+    def test_returns_body(self) -> None:
+        """Test that get_request_body returns the post data."""
+        backend = _make_bidi_backend()
+        backend._client.cdp.send_command = AsyncMock(
+            return_value={"postData": '{"key": "value"}'}
+        )
+        result = asyncio.run(backend.get_request_body("req-123"))
+        assert result == '{"key": "value"}'
+
+    def test_returns_none_on_error(self) -> None:
+        """Test that get_request_body returns None on error."""
+        backend = _make_bidi_backend()
+        backend._client.cdp.send_command = AsyncMock(
+            side_effect=Exception("fail")
+        )
+        result = asyncio.run(backend.get_request_body("req-123"))
+        assert result is None
+
+
+@pytest.mark.unit
+class TestGetResponseBodyBiDi:
+    """Tests for get_response_body in BiDi backend."""
+
+    def test_returns_body(self) -> None:
+        """Test that get_response_body returns the body."""
+        backend = _make_bidi_backend()
+        backend._client.cdp.send_command = AsyncMock(
+            return_value={"body": "<html>response</html>"}
+        )
+        result = asyncio.run(backend.get_response_body("req-123"))
+        assert result == "<html>response</html>"
+
+
+@pytest.mark.unit
+class TestModifyRequestCDP:
+    """Tests for modify_request in CDP backend."""
+
+    def test_calls_fetch_enable(self) -> None:
+        """Test that modify_request enables Fetch domain."""
+        backend = _make_cdp_backend()
+        backend._session.on = MagicMock()
+        asyncio.run(
+            backend.modify_request(
+                {"urlPattern": "*/api/*"},
+                {"method": "POST"},
+            )
+        )
+        backend._session.send.assert_any_call(
+            "Fetch.enable",
+            {"patterns": [{"urlPattern": "*/api/*"}]},
+        )
+
+
+@pytest.mark.unit
+class TestReplayHarCDP:
+    """Tests for replay_har in CDP backend."""
+
+    def test_replays_entries(self, tmp_path: Any) -> None:
+        """Test that replay_har reads and replays HAR entries."""
+        backend = _make_cdp_backend()
+        har_data = {
+            "log": {
+                "entries": [
+                    {
+                        "request": {
+                            "url": "https://api.example.com/data",
+                            "method": "GET",
+                            "headers": [
+                                {"name": "Accept", "value": "application/json"}
+                            ],
+                        }
+                    }
+                ]
+            }
+        }
+        har_path = tmp_path / "test.har"
+        har_path.write_text(json.dumps(har_data))
+
+        asyncio.run(backend.replay_har(str(har_path)))
+        backend._session.runtime.evaluate.assert_called_once()
+
+    def test_filters_by_url(self, tmp_path: Any) -> None:
+        """Test that replay_har filters entries by URL."""
+        backend = _make_cdp_backend()
+        har_data = {
+            "log": {
+                "entries": [
+                    {
+                        "request": {
+                            "url": "https://api.example.com/data",
+                            "method": "GET",
+                            "headers": [],
+                        }
+                    },
+                    {
+                        "request": {
+                            "url": "https://other.example.com/data",
+                            "method": "GET",
+                            "headers": [],
+                        }
+                    },
+                ]
+            }
+        }
+        har_path = tmp_path / "test.har"
+        har_path.write_text(json.dumps(har_data))
+
+        asyncio.run(backend.replay_har(str(har_path), url_filter="api.example"))
+        backend._session.runtime.evaluate.assert_called_once()
+
+
+@pytest.mark.unit
+class TestCombinedTraceCDP:
+    """Tests for start/stop_combined_trace in CDP backend."""
+
+    def test_start_returns_trace_id(self) -> None:
+        """Test that start_combined_trace returns a trace ID."""
+        backend = _make_cdp_backend()
+        backend._session.on = MagicMock()
+        trace_id = asyncio.run(backend.start_combined_trace())
+        assert trace_id.startswith("trace-")
+
+    def test_stop_returns_data(self) -> None:
+        """Test that stop_combined_trace returns collected data."""
+        backend = _make_cdp_backend()
+        backend._session.on = MagicMock()
+        trace_id = asyncio.run(backend.start_combined_trace())
+        result = asyncio.run(backend.stop_combined_trace(trace_id))
+        assert "trace_events" in result
+        assert "screenshots" in result
+        assert "network" in result
+        assert "console" in result
+
+    def test_stop_unknown_trace(self) -> None:
+        """Test that stop_combined_trace returns error for unknown ID."""
+        backend = _make_cdp_backend()
+        result = asyncio.run(backend.stop_combined_trace("unknown"))
+        assert "error" in result
+
+
+@pytest.mark.unit
+class TestAxeAuditCDP:
+    """Tests for axe_audit in CDP backend."""
+
+    def test_returns_violations(self) -> None:
+        """Test that axe_audit returns audit results."""
+        backend = _make_cdp_backend()
+        audit_result = {
+            "violations": [{"id": "color-contrast"}],
+            "passes": [],
+            "incomplete": [],
+            "inapplicable": [],
+        }
+        backend._session.runtime.evaluate = AsyncMock(
+            return_value={"result": {"value": audit_result}}
+        )
+        result = asyncio.run(backend.axe_audit())
+        assert "violations" in result
+        assert len(result["violations"]) == 1
+
+    def test_returns_error_on_failure(self) -> None:
+        """Test that axe_audit returns error dict on failure."""
+        backend = _make_cdp_backend()
+        backend._session.runtime.evaluate = AsyncMock(
+            return_value={"result": {"value": None}}
+        )
+        result = asyncio.run(backend.axe_audit())
+        assert "error" in result
+
+
+@pytest.mark.unit
+class TestSubscribeEventsCDP:
+    """Tests for subscribe/unsubscribe_events in CDP backend."""
+
+    def test_subscribe_returns_id(self) -> None:
+        """Test that subscribe_events returns a subscription ID."""
+        backend = _make_cdp_backend()
+        backend._session.on = MagicMock()
+        sub_id = asyncio.run(
+            backend.subscribe_events(["console"], lambda e: None)
+        )
+        assert sub_id.startswith("sub-")
+
+    def test_unsubscribe_removes_handlers(self) -> None:
+        """Test that unsubscribe_events removes handlers."""
+        backend = _make_cdp_backend()
+        backend._session.on = MagicMock()
+        backend._session.off = MagicMock()
+        sub_id = asyncio.run(
+            backend.subscribe_events(["console"], lambda e: None)
+        )
+        asyncio.run(backend.unsubscribe_events(sub_id))
+        backend._session.off.assert_called()
+
+
+@pytest.mark.unit
+class TestCombinedTraceBiDi:
+    """Tests for combined trace in BiDi backend."""
+
+    def test_start_returns_trace_id(self) -> None:
+        """Test that start_combined_trace returns a trace ID."""
+        backend = _make_bidi_backend()
+        trace_id = asyncio.run(backend.start_combined_trace())
+        assert trace_id.startswith("trace-")
+
+    def test_stop_returns_data(self) -> None:
+        """Test that stop_combined_trace returns collected data."""
+        backend = _make_bidi_backend()
+        trace_id = asyncio.run(backend.start_combined_trace())
+        result = asyncio.run(backend.stop_combined_trace(trace_id))
+        assert "trace_events" in result
+        assert "network" in result
+
+
+@pytest.mark.unit
+class TestAxeAuditBiDi:
+    """Tests for axe_audit in BiDi backend."""
+
+    def test_returns_violations(self) -> None:
+        """Test that axe_audit returns audit results."""
+        backend = _make_bidi_backend()
+        audit_result = {
+            "violations": [{"id": "color-contrast"}],
+            "passes": [],
+            "incomplete": [],
+            "inapplicable": [],
+        }
+        result_mock = MagicMock()
+        result_mock.value = audit_result
+        backend._client.script.evaluate = AsyncMock(return_value=result_mock)
+        result = asyncio.run(backend.axe_audit())
+        assert "violations" in result
+
+
+@pytest.mark.unit
+class TestSubscribeEventsBiDi:
+    """Tests for subscribe_events in BiDi backend."""
+
+    def test_subscribe_returns_id(self) -> None:
+        """Test that subscribe_events returns a subscription ID."""
+        backend = _make_bidi_backend()
+        sub_id = asyncio.run(
+            backend.subscribe_events(["console"], lambda e: None)
+        )
+        assert sub_id.startswith("sub-")
+
+    def test_unsubscribe_removes_handlers(self) -> None:
+        """Test that unsubscribe_events removes handlers."""
+        backend = _make_bidi_backend()
+        sub_id = asyncio.run(
+            backend.subscribe_events(["console"], lambda e: None)
+        )
+        asyncio.run(backend.unsubscribe_events(sub_id))
+        backend._client.cdp.off.assert_called()