screenforge 0.5.0__tar.gz → 0.6.0__tar.gz

{screenforge-0.5.0/screenforge.egg-info → screenforge-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: screenforge
-Version: 0.5.0
+Version: 0.6.0
 Summary: AI-driven cross-platform UI automation engine with test script generation
 License: MIT
 Project-URL: Homepage, https://github.com/jhinzzz/ScreenForge

screenforge-0.6.0/cli/_version.py

@@ -0,0 +1 @@
+__version__ = "0.6.0"

{screenforge-0.5.0 → screenforge-0.6.0}/cli/playground_sink.py

@@ -25,6 +25,7 @@ DEFAULT_PLAYGROUND_URL = "http://127.0.0.1:7860"
 # waits for the last frame to land before sys.exit — kept ≤ read+ε and well under
 # human-perceptible. Worst added latency on --action ≈ _JOIN_TIMEOUT.
 _POST_TIMEOUT = (0.2, 0.25)  # (connect, read) seconds
+_DOM_POST_TIMEOUT = (0.2, 0.4)  # tree body is larger; read budget a touch higher
 _JOIN_TIMEOUT = 0.3  # seconds; single-step last-frame grace
 
 
@@ -42,6 +43,7 @@ class PlaygroundStepEvent(BaseModel):
     success: bool = True
     screenshot_b64: str = ""  # empty = no screenshot this step (degrade, never crash)
     file_path: str = ""  # abs path of the generated test file (for "open in IDE")
+    has_dom_tree: bool = False  # a sidecar DOM tree was captured for this step
 
 
 class PlaygroundSink:
@@ -101,6 +103,50 @@ class PlaygroundSink:
             log.debug(f"[playground-sink] screenshot skip: {e}")
             return ""
 
+    @staticmethod
+    def capture_dom_tree(adapter, platform: str) -> dict | None:
+        """Sidecar hierarchical tree from the SAME raw source the compressors use,
+        without touching them. Any failure → None (degrade, never crash the action).
+
+        web:  build_web_tree(adapter.driver)            (Playwright page.evaluate)
+        android: build_mobile_tree(driver.dump_hierarchy(), 'android')
+        ios:  build_mobile_tree(driver.source(), 'ios')
+        """
+        try:
+            from playground.dom_capture import build_mobile_tree, build_web_tree
+
+            driver = adapter.driver
+            if platform == "web":
+                return build_web_tree(driver)
+            if platform == "android":
+                return build_mobile_tree(driver.dump_hierarchy(), "android")
+            if platform == "ios":
+                return build_mobile_tree(driver.source(), "ios")
+            return None
+        except Exception as e:
+            log.debug(f"[playground-sink] dom capture skip: {e}")
+            return None
+
+    def push_dom_tree(self, run_id: str, step_index: int, tree: dict) -> None:
+        """Fire-and-forget POST of the captured tree, DECOUPLED from push_step and
+        NEVER join-waited — a big tree body must never delay the lean step push or
+        the action's exit. Disabled sink → no-op."""
+        if not self.enabled:
+            return
+        threading.Thread(
+            target=self._post_dom, args=(run_id, step_index, tree), daemon=True
+        ).start()
+
+    def _post_dom(self, run_id: str, step_index: int, tree: dict) -> None:
+        try:
+            requests.post(
+                f"{self.base_url}/api/dom",
+                json={"run_id": run_id, "step_index": step_index, "tree": tree},
+                timeout=_DOM_POST_TIMEOUT,
+            )
+        except Exception as e:  # swallow (G5)
+            log.debug(f"[playground-sink] dom skip (unreachable): {e}")
+
 
 def build_step_event(
     *,
@@ -110,6 +156,7 @@ def build_step_event(
     result: dict,
     screenshot_b64: str,
     file_path: str = "",
+    has_dom_tree: bool = False,
 ) -> PlaygroundStepEvent:
     """MANDATORY single construction point for every step event (code#4).
 
@@ -134,6 +181,7 @@ def build_step_event(
         success=bool(result.get("success", True)),
         screenshot_b64=screenshot_b64,
         file_path=os.path.abspath(file_path) if file_path else "",
+        has_dom_tree=has_dom_tree,
     )
 
 
@@ -168,15 +216,20 @@ def maybe_push_step(
         return
     try:
         run_key, resolved_index = resolve_playground_run_key(args, reporter)
+        idx = step_index if step_index is not None else resolved_index
+        tree = sink.capture_dom_tree(adapter, getattr(args, "platform", ""))
         event = build_step_event(
             run_key=run_key,
-            step_index=step_index if step_index is not None else resolved_index,
+            step_index=idx,
             action_data=action_data,
             result=result,
             screenshot_b64=PlaygroundSink.encode_screenshot(adapter),
             file_path=file_path,
+            has_dom_tree=tree is not None,
         )
         sink.push_step(event)
+        if tree is not None:
+            sink.push_dom_tree(run_key, idx, tree)  # decoupled, never joined
     except Exception as e:  # never let visualization break the observed action
         log.debug(f"[playground-sink] push skipped: {e}")
 

{screenforge-0.5.0 → screenforge-0.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "screenforge"
-version = "0.5.0"
+version = "0.6.0"
 description = "AI-driven cross-platform UI automation engine with test script generation"
 readme = "README.md"
 requires-python = ">=3.11"

{screenforge-0.5.0 → screenforge-0.6.0/screenforge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: screenforge
-Version: 0.5.0
+Version: 0.6.0
 Summary: AI-driven cross-platform UI automation engine with test script generation
 License: MIT
 Project-URL: Homepage, https://github.com/jhinzzz/ScreenForge

{screenforge-0.5.0 → screenforge-0.6.0}/screenforge.egg-info/SOURCES.txt

@@ -71,6 +71,7 @@ tests/test_cli_action_json.py
 tests/test_codegen_quality.py
 tests/test_dispatch.py
 tests/test_doctor_orphan_browser.py
+tests/test_dom_capture.py
 tests/test_error_codes.py
 tests/test_executor.py
 tests/test_failure_diagnosis.py

screenforge-0.6.0/tests/test_dom_capture.py

@@ -0,0 +1,136 @@
+"""Tests for playground/dom_capture.py — the sidecar HIERARCHICAL tree builders.
+
+Unlike utils/utils_xml.py (which flattens for the LLM), these preserve parent/
+child so the playground can render a real tree. They REUSE utils_xml predicates
+(never modify them) and degrade to None on any failure (never crash the sink).
+"""
+
+from playground.dom_capture import build_mobile_tree, build_web_tree  # noqa: F401
+
+
+class TestBuildMobileTree:
+    def test_returns_none_on_parse_error(self):
+        assert build_mobile_tree("<<not xml", "android") is None
+
+    def test_empty_hierarchy_yields_none(self):
+        # An empty hierarchy has no surviving elements ⇒ no tree (keeps has_dom_tree
+        # truthful: the pip must not light when there is nothing to show).
+        xml = '<hierarchy rotation="0"></hierarchy>'
+        assert build_mobile_tree(xml, "android") is None
+
+    def test_ios_xcuitest_xml_yields_none_today(self):
+        # iOS WDA returns XCUITest XML (XCUIElementType* tags + name/label/value/type),
+        # which the Android predicates don't recognize → every node filtered → None.
+        # This pins the HONEST v1 boundary: iOS DOM-tree capture is not yet supported.
+        ios_xml = (
+            '<XCUIElementTypeApplication name="MyApp" label="MyApp">'
+            '<XCUIElementTypeButton name="login" label="登录" value="" type="XCUIElementTypeButton"/>'
+            '</XCUIElementTypeApplication>'
+        )
+        assert build_mobile_tree(ios_xml, "ios") is None
+
+    def test_single_clickable_node_emitted(self):
+        xml = (
+            '<hierarchy rotation="0">'
+            '<node class="android.widget.Button" text="Login" clickable="true"/>'
+            '</hierarchy>'
+        )
+        tree = build_mobile_tree(xml, "android")
+        assert tree["platform"] == "android"
+        assert len(tree["nodes"]) == 1
+        n = tree["nodes"][0]
+        assert n["class"] == "Button"
+        assert n["text"] == "Login"
+        assert n["clickable"] is True
+        assert n["children"] == []
+
+    def test_hierarchy_is_preserved_not_flattened(self):
+        # A clickable container with a labeled child: the tree keeps the nesting
+        # (the FLAT compressor would emit them as siblings; we must not).
+        xml = (
+            '<hierarchy rotation="0">'
+            '<node class="android.widget.LinearLayout" text="Settings" clickable="true">'
+            '  <node class="android.widget.TextView" text="Wi-Fi"/>'
+            '</node>'
+            '</hierarchy>'
+        )
+        tree = build_mobile_tree(xml, "android")
+        assert len(tree["nodes"]) == 1
+        parent = tree["nodes"][0]
+        assert parent["text"] == "Settings"
+        assert len(parent["children"]) == 1
+        assert parent["children"][0]["text"] == "Wi-Fi"
+
+    def test_dead_wrapper_collapses_lifting_children(self):
+        # A non-surviving wrapper (no text/desc/clickable/disabled) must NOT appear;
+        # its surviving child lifts to the wrapper's parent level.
+        xml = (
+            '<hierarchy rotation="0">'
+            '<node class="android.widget.FrameLayout">'
+            '  <node class="android.widget.Button" text="OK" clickable="true"/>'
+            '</node>'
+            '</hierarchy>'
+        )
+        tree = build_mobile_tree(xml, "android")
+        assert len(tree["nodes"]) == 1
+        assert tree["nodes"][0]["text"] == "OK"   # lifted, wrapper gone
+
+    def test_disabled_emitted_without_clickable(self):
+        xml = (
+            '<hierarchy rotation="0">'
+            '<node class="android.widget.Button" text="Send" enabled="false"/>'
+            '</hierarchy>'
+        )
+        tree = build_mobile_tree(xml, "android")
+        n = tree["nodes"][0]
+        assert n["disabled"] is True
+        assert "clickable" not in n
+
+    def test_full_resource_id_emitted(self):
+        xml = (
+            '<hierarchy rotation="0">'
+            '<node class="android.widget.Button" text="Go" clickable="true" '
+            'resource-id="com.app:id/go_btn"/>'
+            '</hierarchy>'
+        )
+        tree = build_mobile_tree(xml, "android")
+        assert tree["nodes"][0]["id"] == "com.app:id/go_btn"
+
+    def test_no_ref_and_no_bbox_on_mobile(self):
+        xml = (
+            '<hierarchy rotation="0">'
+            '<node class="android.widget.Button" text="X" clickable="true" '
+            'bounds="[0,0][100,50]"/>'
+            '</hierarchy>'
+        )
+        n = build_mobile_tree(xml, "android")["nodes"][0]
+        assert "ref" not in n
+        assert "x" not in n and "w" not in n   # honest: mobile has no bbox in this shape
+
+
+class _FakePage:
+    def __init__(self, result=None, raises=None):
+        self._result = result
+        self._raises = raises
+
+    def evaluate(self, _js):
+        if self._raises:
+            raise self._raises
+        return self._result
+
+
+class TestBuildWebTree:
+    def test_passthrough_wellformed_result(self):
+        page = _FakePage(result={"nodes": [{"ref": "@1", "class": "button", "children": []}]})
+        tree = build_web_tree(page)
+        assert tree["platform"] == "web"
+        assert tree["nodes"][0]["ref"] == "@1"
+
+    def test_none_when_result_missing_nodes(self):
+        assert build_web_tree(_FakePage(result={"oops": 1})) is None
+
+    def test_none_when_result_not_a_dict(self):
+        assert build_web_tree(_FakePage(result="not a dict")) is None
+
+    def test_none_when_evaluate_raises(self):
+        assert build_web_tree(_FakePage(raises=RuntimeError("page closed"))) is None

{screenforge-0.5.0 → screenforge-0.6.0}/tests/test_playground_app.py

@@ -311,3 +311,75 @@ class TestOpenInEditor:
             "file_path": str(f), "line": "not-a-number", "editor": "trae"})
         assert resp.json()["ok"] is True
         assert captured["cmd"] == ["/usr/local/bin/trae", "-g", f"{f}:1"]
+
+
+class TestDomStore:
+    def test_post_dom_persists_and_get_returns_it(self, client, tmp_path):
+        app_module._DOM_DIR = tmp_path  # redirect store to a temp dir
+        app_module._dom_index.clear()
+        tree = {"platform": "web", "nodes": [{"ref": "@1", "class": "button", "children": []}]}
+        r = client.post("/api/dom", json={"run_id": "s1", "step_index": 2, "tree": tree})
+        assert r.status_code == 200 and r.json()["ok"] is True
+        got = client.get("/api/run/s1/step/2/dom")
+        assert got.status_code == 200
+        assert got.json()["nodes"][0]["ref"] == "@1"
+
+    def test_get_absent_returns_404(self, client, tmp_path):
+        app_module._DOM_DIR = tmp_path
+        app_module._dom_index.clear()
+        assert client.get("/api/run/nope/step/9/dom").status_code == 404
+
+    def test_lru_evicts_oldest_run_dir(self, client, tmp_path):
+        app_module._DOM_DIR = tmp_path
+        app_module._dom_index.clear()
+        app_module._MAX_DOM_RUNS = 2
+        for rid in ("a", "b", "c"):  # 3 runs, cap 2 → 'a' evicted
+            client.post("/api/dom", json={"run_id": rid, "step_index": 1,
+                                          "tree": {"platform": "web", "nodes": []}})
+        assert client.get("/api/run/a/step/1/dom").status_code == 404
+        assert client.get("/api/run/c/step/1/dom").status_code == 200
+
+    def test_dotdot_run_id_cannot_escape_dom_dir(self, client, tmp_path):
+        app_module._DOM_DIR = tmp_path
+        app_module._dom_index.clear()
+        # '..'/'.' run_ids must collapse to the 'run' fallback — a single
+        # component INSIDE _DOM_DIR — not resolve to the store's parent.
+        for evil in ("..", "."):
+            resolved = app_module._dom_run_dir(evil)
+            assert resolved.parent.resolve() == tmp_path.resolve()
+            assert resolved.resolve() == (tmp_path / "run").resolve()
+        # a POST with run_id='..' writes inside tmp_path, never tmp_path.parent
+        r = client.post("/api/dom", json={"run_id": "..", "step_index": 1,
+                                          "tree": {"platform": "web", "nodes": []}})
+        assert r.json()["ok"] is True
+        # the file landed under tmp_path (the 'run' fallback), not tmp_path.parent
+        assert not (tmp_path.parent / "step_001.json").exists()
+        assert (tmp_path / "run" / "step_001.json").exists()
+
+    def test_cjk_text_round_trips_through_dom_store(self, client, tmp_path):
+        app_module._DOM_DIR = tmp_path
+        app_module._dom_index.clear()
+        tree = {"platform": "web", "nodes": [{"ref": "@1", "class": "button", "text": "登录", "children": []}]}
+        client.post("/api/dom", json={"run_id": "cjk", "step_index": 1, "tree": tree})
+        got = client.get("/api/run/cjk/step/1/dom")
+        assert got.status_code == 200
+        assert got.json()["nodes"][0]["text"] == "登录"
+
+
+class TestHasDomTreePassthrough:
+    def test_step_event_carries_has_dom_tree_to_sse(self, client):
+        import asyncio
+
+        q: asyncio.Queue = asyncio.Queue()
+        app_module._subscribers.append(q)
+        try:
+            body = _step_body(run_id="r1", step_index=1)
+            body["has_dom_tree"] = True
+            resp = client.post("/api/step", json=body)
+            assert resp.status_code == 200
+            evt = q.get_nowait()
+        finally:
+            app_module._subscribers.remove(q)
+
+        assert evt["type"] == "step"
+        assert evt.get("has_dom_tree") is True

{screenforge-0.5.0 → screenforge-0.6.0}/tests/test_playground_sink.py

@@ -6,6 +6,7 @@ cross-process run-key resolution (arch#1) and daemon non-blocking (arch#3).
 """
 
 import argparse
+import threading
 import time
 from unittest.mock import MagicMock, patch
 
@@ -421,3 +422,165 @@ class TestMaybePushStep:
                 result=_result(),
                 step_index=1,
             )
+
+    def test_enabled_pushes_dom_tree_when_capture_succeeds(self):
+        """End-to-end wiring: a captured tree flows to push_dom_tree with the
+        resolved (run_key, idx, tree), and the step event advertises has_dom_tree."""
+        sink = PlaygroundSink(enabled=True)
+        adapter = MagicMock()
+        args = argparse.Namespace(session_id="", session_end="", platform="web")
+        reporter = MagicMock(run_id="r1")
+        fake_tree = {
+            "platform": "web",
+            "nodes": [{"ref": "@1", "class": "button", "children": []}],
+        }
+        with patch.object(
+            PlaygroundSink, "capture_dom_tree", return_value=fake_tree
+        ), patch.object(
+            PlaygroundSink, "encode_screenshot", return_value=""
+        ), patch.object(sink, "push_step") as mock_push_step, patch.object(
+            sink, "push_dom_tree"
+        ) as mock_push_dom:
+            maybe_push_step(
+                sink,
+                args=args,
+                reporter=reporter,
+                adapter=adapter,
+                action_data=_action_data(),
+                result=_result(),
+                step_index=3,
+            )
+        mock_push_step.assert_called_once()
+        mock_push_dom.assert_called_once()
+        # the step event must advertise the tree
+        assert mock_push_step.call_args[0][0].has_dom_tree is True
+        # push_dom_tree gets (run_key, idx, tree)
+        called = mock_push_dom.call_args[0]
+        assert called[0] == "r1"
+        assert called[1] == 3
+        assert called[2] == fake_tree
+
+    def test_enabled_skips_dom_tree_when_capture_returns_none(self):
+        """Mirror: capture degraded to None → no tree POST, flag stays False, but
+        the lean step push still fires (the sink keeps observing without a tree)."""
+        sink = PlaygroundSink(enabled=True)
+        adapter = MagicMock()
+        args = argparse.Namespace(session_id="", session_end="", platform="web")
+        reporter = MagicMock(run_id="r1")
+        with patch.object(
+            PlaygroundSink, "capture_dom_tree", return_value=None
+        ), patch.object(
+            PlaygroundSink, "encode_screenshot", return_value=""
+        ), patch.object(sink, "push_step") as mock_push_step, patch.object(
+            sink, "push_dom_tree"
+        ) as mock_push_dom:
+            maybe_push_step(
+                sink,
+                args=args,
+                reporter=reporter,
+                adapter=adapter,
+                action_data=_action_data(),
+                result=_result(),
+                step_index=3,
+            )
+        mock_push_step.assert_called_once()
+        mock_push_dom.assert_not_called()
+        assert mock_push_step.call_args[0][0].has_dom_tree is False
+
+    def test_step_and_dom_tree_share_run_key_and_index(self):
+        # seam#2 regression: the SSE step event and the /api/dom push MUST use the
+        # SAME key + index from one maybe_push_step. With a --session-id the key is
+        # the session_id (NOT reporter.run_id) and the index is session steps()+1.
+        import argparse
+        sink = PlaygroundSink(enabled=True)
+        reporter = MagicMock()
+        reporter.run_id = "RID"
+        args = argparse.Namespace(platform="web", session_id="SESS", session_end="", playground_url="")
+        fake_tree = {"platform": "web", "nodes": [{"ref": "@1", "class": "button", "children": []}]}
+        captured = {}
+
+        def _grab_step(ev):
+            captured["step_run_id"] = ev.run_id
+            captured["step_idx"] = ev.step_index
+        with patch.object(PlaygroundSink, "capture_dom_tree", return_value=fake_tree), \
+             patch.object(PlaygroundSink, "encode_screenshot", return_value=""), \
+             patch("cli.playground_sink.load_session", return_value={"steps": 4}), \
+             patch.object(sink, "push_step", side_effect=_grab_step), \
+             patch.object(sink, "push_dom_tree") as mock_dom:
+            maybe_push_step(sink, args=args, reporter=reporter, adapter=MagicMock(),
+                            action_data=_action_data(), result=_result())
+        dom_run_id, dom_idx, _tree = mock_dom.call_args[0]
+        # the SSE step event and the /api/dom push MUST use the same key + index
+        assert dom_run_id == captured["step_run_id"] == "SESS"   # session_id is the run_key, not reporter.run_id
+        assert dom_idx == captured["step_idx"] == 5              # session steps(4)+1
+
+
+class TestCaptureDomTree:
+    def test_capture_returns_none_when_capture_raises(self):
+        from cli.playground_sink import PlaygroundSink
+
+        class _Adapter:
+            driver = object()
+
+        # platform 'web' path lazy-imports build_web_tree; force a failure by
+        # passing an adapter whose driver.evaluate doesn't exist → swallowed → None.
+        assert PlaygroundSink.capture_dom_tree(_Adapter(), "web") is None
+
+    def test_has_dom_tree_flag_defaults_false(self):
+        from cli.playground_sink import PlaygroundStepEvent
+
+        ev = PlaygroundStepEvent(run_id="r1", step_index=1)
+        assert ev.has_dom_tree is False
+
+    def test_disabled_sink_never_posts_tree(self):
+        import cli.playground_sink as mod
+        from cli.playground_sink import PlaygroundSink
+
+        sink = PlaygroundSink(enabled=False)
+        with patch.object(mod.requests, "post") as mock_post:
+            sink.push_dom_tree("r1", 1, {"platform": "web", "nodes": []})
+            mock_post.assert_not_called()
+
+    def test_push_dom_tree_returns_immediately_under_slow_post(self):
+        """Red line: the tree POST is fire-and-forget with NO join, so even a very
+        slow playground cannot delay the action's exit. Mirrors the timing pattern
+        of TestDaemonNonBlocking — the 2s sleep rides the daemon thread, the caller
+        returns near-instantly. (push_dom_tree, unlike push_step, never join-waits.)"""
+        import cli.playground_sink as mod
+        from cli.playground_sink import PlaygroundSink
+
+        sink = PlaygroundSink(enabled=True)
+
+        def _slow_post(*a, **k):
+            time.sleep(2.0)
+            return MagicMock()
+
+        with patch.object(mod.requests, "post", side_effect=_slow_post):
+            start = time.perf_counter()
+            sink.push_dom_tree("r1", 1, {"platform": "web", "nodes": []})
+            elapsed = time.perf_counter() - start
+        # Daemon thread carries the 2s sleep; the caller returns at once.
+        assert elapsed < 0.3, f"push_dom_tree blocked for {elapsed:.2f}s"
+
+    def test_push_dom_tree_swallows_post_errors_in_thread(self):
+        """G5: a ConnectionError inside the daemon thread must be swallowed, never
+        propagate. We join the spawned thread (no .join() exists in production —
+        the test does it itself) so the error has actually fired before asserting."""
+        import cli.playground_sink as mod
+        from cli.playground_sink import PlaygroundSink
+
+        sink = PlaygroundSink(enabled=True)
+        before = threading.active_count()
+        with patch.object(
+            mod.requests,
+            "post",
+            side_effect=mod.requests.exceptions.ConnectionError("refused"),
+        ):
+            # Must not raise on the caller's thread.
+            sink.push_dom_tree("r1", 1, {"platform": "web", "nodes": []})
+            # Drain the daemon thread(s) push_dom_tree spawned so the swallow runs.
+            for t in threading.enumerate():
+                if t is not threading.current_thread() and t.daemon:
+                    t.join(timeout=2.0)
+        # No thread leaked and, crucially, no exception surfaced.
+        assert threading.active_count() <= before

{screenforge-0.5.0 → screenforge-0.6.0}/tests/test_web_dom_complex_live.py

@@ -735,3 +735,87 @@ def test_did_you_mean_offers_close_match_on_typo(page):
     )
     # The suggested locator should be a web ref the agent can retry with.
     assert diag.candidates[0].locator["type"] == "ref"
+
+
+# --- sidecar/compressor parity: cursor:pointer clickability ----------------
+#
+# These exercise playground/dom_capture.build_web_tree (the "Brain's Eye View"
+# sidecar), NOT compress_web_dom. The sidecar's whole job is to show the panel
+# what the brain PERCEIVED — so its interactivity predicate must match the
+# compressor's. utils_web.py treats style.cursor==='pointer' as a clickability
+# signal; the sidecar originally did not, so cursor:pointer "fake buttons" (the
+# div/span-as-button pattern) showed up in the panel mislabeled clickable=false
+# — the panel lying about what the brain saw. That's the bug these pin.
+
+
+def _web_tree_flat(page, html: str) -> list:
+    """Render HTML, build the sidecar hierarchical tree, and flatten it to a list
+    so a test can find a node regardless of nesting depth (the sidecar emits a
+    parent/child forest, unlike compress_web_dom's flat ui_elements)."""
+    from playground.dom_capture import build_web_tree
+
+    page.goto("data:text/html," + _quote(html))
+    page.wait_for_timeout(200)
+    tree = build_web_tree(page)
+    flat: list = []
+
+    def _walk(nodes):
+        for n in nodes:
+            flat.append(n)
+            _walk(n.get("children") or [])
+
+    _walk((tree or {}).get("nodes") or [])
+    return flat
+
+
+def test_cursor_pointer_div_is_clickable_in_sidecar(page):
+    """A div-as-button (no native tag / role / onclick, only style:cursor:pointer)
+    is what the brain SEES as clickable — compress_web_dom marks it clickable via
+    style.cursor==='pointer' (utils_web.py). The sidecar tree must agree, or the
+    Brain's Eye panel under-reports the brain's clickable set (the pionex finding:
+    panel showed fewer clickables than the brain perceived). Pins parity."""
+    nodes = _web_tree_flat(page, "<div style='cursor:pointer'>FakeButton</div>")
+    fake = next((n for n in nodes if (n.get("text") or "") == "FakeButton"), None)
+    assert fake is not None, (
+        "cursor:pointer div not captured at all — sidecar blind to a div-as-button"
+    )
+    assert fake.get("clickable") is True, (
+        "cursor:pointer div reported clickable=false in the sidecar — the Brain's Eye "
+        "panel under-counts what the brain actually perceived as clickable "
+        "(compress_web_dom counts it via style.cursor==='pointer'); parity broken"
+    )
+
+
+def test_plain_text_div_not_clickable_in_sidecar(page):
+    """Over-correction guard: a plain text div (default cursor, no interactivity
+    signal) is still captured for its text, but must stay clickable=false. Pins
+    that the cursor:pointer fix keys on 'pointer' specifically, not 'has any text'."""
+    nodes = _web_tree_flat(page, "<div>JustText</div>")
+    plain = next((n for n in nodes if (n.get("text") or "") == "JustText"), None)
+    assert plain is not None, "plain text div should still be captured (for its label)"
+    assert plain.get("clickable") is not True, (
+        "plain text div (cursor:auto) wrongly marked clickable — the cursor:pointer "
+        "fix over-reached and now flags any text node as clickable"
+    )
+
+
+def test_inert_cursor_pointer_div_not_clickable_in_sidecar(page):
+    """Parity at the inert∩cursor:pointer intersection. The compressor gates
+    interactivity on `!isInert` (utils_web.py: `isInteractive = !isDisabled &&
+    !isInert && (… || cursor==='pointer')`), so a cursor:pointer div inside an
+    inert subtree (the open-<dialog> backdrop pattern) is clickable=false to the
+    brain. The sidecar must agree — otherwise the cursor:pointer fix REINTRODUCES
+    the 'panel lies about what the brain saw' bug in the opposite direction
+    (over-reporting a dead control behind a modal as clickable). The node is still
+    captured and carries the inert flag; only `clickable` must be false."""
+    nodes = _web_tree_flat(
+        page, "<div inert><div style='cursor:pointer'>BehindModal</div></div>"
+    )
+    behind = next((n for n in nodes if (n.get("text") or "") == "BehindModal"), None)
+    assert behind is not None, "inert cursor:pointer div should still be captured"
+    assert behind.get("inert") is True, "node inside an inert subtree must carry the inert flag"
+    assert behind.get("clickable") is not True, (
+        "inert cursor:pointer div reported clickable=true in the sidecar — diverges "
+        "from the compressor (which gates isInteractive on !isInert); the panel would "
+        "show a dead control behind a modal as clickable"
+    )

screenforge-0.5.0/cli/_version.py

@@ -1 +0,0 @@
-__version__ = "0.5.0"