wavexis 2.2.1__tar.gz → 2.2.3__tar.gz

{wavexis-2.2.1 → wavexis-2.2.3}/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable changes to wavexis are documented in this file.
 
+## v2.2.3 — 2026-07-07
+
+### Added
+
+- Resource cleanup module (`wavexis.cleanup`) with `atexit` and signal handlers
+- Backends are automatically registered for cleanup on crash or signal (SIGINT, SIGTERM, SIGBREAK)
+- Orphaned browser processes are closed even when the process is killed unexpectedly
+
+## v2.2.2 — 2026-07-07
+
+### Added
+
+- Auto scroll-into-view before `click`, `fill`, and `hover` in both CDP and BiDi backends
+- `_scroll_into_view_if_needed` helper checks if element is in viewport and scrolls if needed
+
 ## v2.2.1 — 2026-07-07
 
 ### Added

{wavexis-2.2.1 → wavexis-2.2.3}/PKG-INFO

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

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

wavexis-2.2.3/tests/unit/test_cleanup.py

@@ -0,0 +1,53 @@
+"""Unit tests for resource cleanup module."""
+
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+import wavexis.cleanup as cleanup_mod
+from wavexis.cleanup import (
+    _cleanup_sync,
+    register_backend,
+    unregister_backend,
+)
+
+
+@pytest.mark.unit
+class TestCleanup:
+    """Tests for browser cleanup on crash."""
+
+    def setup_method(self) -> None:
+        """Reset cleanup state before each test."""
+        cleanup_mod._cleanup_done = False
+        cleanup_mod._registered_backends.clear()
+
+    def test_register_and_unregister(self) -> None:
+        backend = MagicMock()
+        register_backend(backend)
+        unregister_backend(backend)
+
+    def test_cleanup_with_no_backends(self) -> None:
+        _cleanup_sync()
+
+    def test_cleanup_closes_registered_backends(self) -> None:
+        backend = MagicMock()
+        backend.close = AsyncMock()
+        register_backend(backend)
+        _cleanup_sync()
+        backend.close.assert_called_once()
+
+    def test_cleanup_is_idempotent(self) -> None:
+        backend = MagicMock()
+        backend.close = AsyncMock()
+        register_backend(backend)
+        _cleanup_sync()
+        _cleanup_sync()
+        backend.close.assert_called_once()
+
+    def test_cleanup_swallows_errors(self) -> None:
+        backend = MagicMock()
+        backend.close = AsyncMock(side_effect=RuntimeError("boom"))
+        register_backend(backend)
+        _cleanup_sync()

{wavexis-2.2.1 → wavexis-2.2.3}/wavexis/__init__.py

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

{wavexis-2.2.1 → wavexis-2.2.3}/wavexis/backend/bidi.py

@@ -807,19 +807,32 @@ class BiDiBackend(AbstractBackend):
 
     # ── Input ──────────────────────────────────────────────
 
+    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()
+        escaped = selector.replace("'", "\\'")
+        js = (
+            f"(function(){{var el=document.querySelector('{escaped}');"
+            f"if(!el)return;var rect=el.getBoundingClientRect();"
+            f"if(rect.top<0||rect.bottom>window.innerHeight||"
+            f"rect.left<0||rect.right>window.innerWidth)"
+            f"el.scrollIntoView({{block:'center',behavior:'instant'}});}})()"
+        )
+        await client.script.evaluate(self._context, js)
+
     async def click(
         self, selector: str, button: str = "left", click_count: int = 1
     ) -> None:
         """Click an element via BiDi script.evaluate."""
-        if self._client is None or self._context is None:
-            raise RuntimeError("BiDiBackend not launched. Call launch() first.")
+        client = self._require_client()
+        await self._scroll_into_view_if_needed(selector)
         escaped = selector.replace("'", "\\'")
         js = (
             f"document.querySelector('{escaped}')"
             f".dispatchEvent(new MouseEvent('click',{{bubbles:true}}))"
         )
         for _ in range(click_count):
-            await self._client.script.evaluate(self._context, js)
+            await client.script.evaluate(self._context, js)
 
     async def type_text(self, selector: str, text: str, delay: int = 0) -> None:
         """Type text into an element via BiDi."""
@@ -843,12 +856,12 @@ class BiDiBackend(AbstractBackend):
 
     async def fill(self, selector: str, value: str) -> None:
         """Fill an input element with a value via BiDi."""
-        if self._client is None or self._context is None:
-            raise RuntimeError("BiDiBackend not launched. Call launch() first.")
+        client = self._require_client()
+        await self._scroll_into_view_if_needed(selector)
         escaped = selector.replace("'", "\\'")
         escaped_val = value.replace("\\", "\\\\").replace("'", "\\'")
         js = f"document.querySelector('{escaped}').value = '{escaped_val}'"
-        await self._client.script.evaluate(self._context, js)
+        await client.script.evaluate(self._context, js)
 
     async def select_option(self, selector: str, value: str) -> None:
         """Select an option in a <select> element by value via BiDi."""
@@ -861,15 +874,15 @@ class BiDiBackend(AbstractBackend):
 
     async def hover(self, selector: str) -> None:
         """Hover over an element via BiDi script.evaluate."""
-        if self._client is None or self._context is None:
-            raise RuntimeError("BiDiBackend not launched. Call launch() first.")
+        client = self._require_client()
+        await self._scroll_into_view_if_needed(selector)
         escaped = selector.replace("'", "\\'")
         js = (
             f"var el=document.querySelector('{escaped}');"
             f"el.dispatchEvent(new MouseEvent('mouseover',{{bubbles:true}}));"
             f"el.dispatchEvent(new MouseEvent('mousemove',{{bubbles:true}}))"
         )
-        await self._client.script.evaluate(self._context, js)
+        await client.script.evaluate(self._context, js)
 
     async def key_press(self, key: str) -> None:
         """Press a keyboard key via BiDi script.evaluate."""

{wavexis-2.2.1 → wavexis-2.2.3}/wavexis/backend/cdp.py

@@ -1026,6 +1026,23 @@ class CDPBackend(AbstractBackend):
         cy = (min(ys) + max(ys)) / 2
         return cx, cy
 
+    async def _scroll_into_view_if_needed(self, selector: str) -> None:
+        """Scroll element into view if it's not visible in the viewport.
+
+        Args:
+            selector: CSS selector for the target element.
+        """
+        session = self._require_session()
+        escaped = selector.replace("'", "\\'")
+        js = (
+            f"(function(){{var el=document.querySelector('{escaped}');"
+            f"if(!el)return;var rect=el.getBoundingClientRect();"
+            f"if(rect.top<0||rect.bottom>window.innerHeight||"
+            f"rect.left<0||rect.right>window.innerWidth)"
+            f"el.scrollIntoView({{block:'center',behavior:'instant'}});}})()"
+        )
+        await session.runtime.evaluate(js)
+
     async def click(
         self, selector: str, button: str = "left", click_count: int = 1
     ) -> None:
@@ -1037,6 +1054,7 @@ class CDPBackend(AbstractBackend):
             click_count: Number of clicks to dispatch.
         """
         session = self._require_session()
+        await self._scroll_into_view_if_needed(selector)
         x, y = await self._get_box_center(selector)
         btn_map = {"left": "left", "right": "right", "middle": "middle"}
         btn = btn_map.get(button, "left")
@@ -1074,6 +1092,7 @@ class CDPBackend(AbstractBackend):
             value: Value to set in the input field.
         """
         session = self._require_session()
+        await self._scroll_into_view_if_needed(selector)
         escaped = selector.replace("'", "\\'")
         js = (
             f"(function(){{var el=document.querySelector('{escaped}');"
@@ -1113,6 +1132,7 @@ class CDPBackend(AbstractBackend):
             selector: CSS selector for the target element.
         """
         session = self._require_session()
+        await self._scroll_into_view_if_needed(selector)
         x, y = await self._get_box_center(selector)
         await session.input.dispatch_mouse_event(
             type_="mouseMoved", x=x, y=y

wavexis-2.2.3/wavexis/cleanup.py

@@ -0,0 +1,96 @@
+"""Resource cleanup for orphaned browser processes.
+
+Registers atexit and signal handlers to ensure browser backends are closed
+even when the process crashes or is interrupted.
+"""
+
+from __future__ import annotations
+
+import atexit
+import contextlib
+import logging
+import signal
+import sys
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+_registered_backends: list[Any] = []
+_cleanup_done = False
+
+_SIGNAL_NAMES: dict[int, str] = {
+    signal.SIGINT: "SIGINT",
+    signal.SIGTERM: "SIGTERM",
+}
+
+with contextlib.suppress(AttributeError):
+    _SIGNAL_NAMES[signal.SIGBREAK] = "SIGBREAK"
+
+
+def register_backend(backend: Any) -> None:
+    """Register a backend for cleanup on exit.
+
+    Args:
+        backend: A backend instance with an async ``close()`` method.
+    """
+    _registered_backends.append(backend)
+
+
+def unregister_backend(backend: Any) -> None:
+    """Unregister a backend after it has been closed normally.
+
+    Args:
+        backend: The backend instance to remove from cleanup tracking.
+    """
+    if backend in _registered_backends:
+        _registered_backends.remove(backend)
+
+
+def _cleanup_sync() -> None:
+    """Synchronously attempt to close all registered backends.
+
+    Uses ``asyncio.run`` if there are backends to close.
+    """
+    global _cleanup_done
+    if _cleanup_done:
+        return
+    _cleanup_done = True
+
+    if not _registered_backends:
+        return
+
+    import asyncio
+
+    async def _close_all() -> None:
+        for backend in _registered_backends:
+            with contextlib.suppress(Exception):
+                await backend.close()
+
+    with contextlib.suppress(Exception):
+        asyncio.run(_close_all())
+
+    _registered_backends.clear()
+
+
+def _signal_handler(signum: int, frame: Any) -> None:
+    """Handle signals by cleaning up and re-raising.
+
+    Args:
+        signum: Signal number received.
+        frame: Current stack frame.
+    """
+    _cleanup_sync()
+    name = _SIGNAL_NAMES.get(signum, str(signum))
+    sys.stderr.write(f"\nwavexis: received {name}, cleaning up…\n")
+    sys.exit(128 + signum)
+
+
+def _setup_signal_handlers() -> None:
+    """Register signal handlers for cleanup."""
+    for sig in _SIGNAL_NAMES:
+        with contextlib.suppress(OSError, ValueError):
+            signal.signal(sig, _signal_handler)
+
+
+atexit.register(_cleanup_sync)
+_setup_signal_handlers()

{wavexis-2.2.1 → wavexis-2.2.3}/wavexis/cli/_shared.py

@@ -11,6 +11,7 @@ from typing import Any
 import typer
 
 from wavexis.backend.manager import get_manager
+from wavexis.cleanup import register_backend, unregister_backend
 from wavexis.config import (
     DEVICE_PRESETS,
     BrowserOptions,
@@ -51,6 +52,7 @@ __all__ = [
     "_write_json_output",
     "app",
     "get_manager",
+    "unregister_backend",
 ]
 
 EXIT_SUCCESS = 0
@@ -229,8 +231,13 @@ def _run_async(coro: Any) -> Any:
 
 
 def _get_backend() -> Any:
-    """Select a backend using the preferred backend if set."""
-    return get_manager().select(_get_ctx().preferred_backend)
+    """Select a backend using the preferred backend if set.
+
+    Registers the backend for automatic cleanup on crash or signal.
+    """
+    backend = get_manager().select(_get_ctx().preferred_backend)
+    register_backend(backend)
+    return backend
 
 
 def _browser_options() -> BrowserOptions: