screenforge 0.4.1__tar.gz → 0.6.0__tar.gz

{screenforge-0.4.1 → screenforge-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: screenforge
-Version: 0.4.1
+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
@@ -113,6 +113,7 @@ Each step: **inspect → decide → act → verify**. The AI decides, ScreenForg
 - **Visual fallback**: When DOM can't locate elements (Canvas, games), VLM parses screenshots
 - **MCP server**: Any MCP-compatible Agent can drive ScreenForge natively
 - **Structured output**: JSON Lines events + `report/runs/<id>/` artifacts for CI integration
+- **Live Mirror playground**: Watch the generated pytest code grow line-by-line beside a live screenshot as the test runs — `screenforge --playground`. See the [Playground Guide](https://github.com/jhinzzz/ScreenForge/blob/main/docs/playground-guide.md)
 
 ## Agent Integration (Claude Code / Cursor / Codex)
 
@@ -205,6 +206,7 @@ If ScreenForge generates tests for your project, add this badge to your README:
 | [MCP Setup (3 min)](https://github.com/jhinzzz/ScreenForge/blob/main/docs/mcp-setup.md) | Connect to Claude Desktop / Cursor / Cline / Claude Code |
 | [Agent Guide](https://github.com/jhinzzz/ScreenForge/blob/main/docs/agent_guide.md) | Integration protocol for AI Agents |
 | [Capability Matrix](https://github.com/jhinzzz/ScreenForge/blob/main/docs/capability-matrix.md) | Supported platforms, actions, and locators |
+| [Playground Guide](https://github.com/jhinzzz/ScreenForge/blob/main/docs/playground-guide.md) | Live Mirror — watch code + screenshots grow as the test runs |
 | [Workflow Examples](https://github.com/jhinzzz/ScreenForge/tree/main/docs/workflows) | YAML workflow templates |
 | [CHANGELOG](https://github.com/jhinzzz/ScreenForge/blob/main/CHANGELOG.md) | Version history |
 

{screenforge-0.4.1 → screenforge-0.6.0}/README.md

@@ -68,6 +68,7 @@ Each step: **inspect → decide → act → verify**. The AI decides, ScreenForg
 - **Visual fallback**: When DOM can't locate elements (Canvas, games), VLM parses screenshots
 - **MCP server**: Any MCP-compatible Agent can drive ScreenForge natively
 - **Structured output**: JSON Lines events + `report/runs/<id>/` artifacts for CI integration
+- **Live Mirror playground**: Watch the generated pytest code grow line-by-line beside a live screenshot as the test runs — `screenforge --playground`. See the [Playground Guide](https://github.com/jhinzzz/ScreenForge/blob/main/docs/playground-guide.md)
 
 ## Agent Integration (Claude Code / Cursor / Codex)
 
@@ -160,6 +161,7 @@ If ScreenForge generates tests for your project, add this badge to your README:
 | [MCP Setup (3 min)](https://github.com/jhinzzz/ScreenForge/blob/main/docs/mcp-setup.md) | Connect to Claude Desktop / Cursor / Cline / Claude Code |
 | [Agent Guide](https://github.com/jhinzzz/ScreenForge/blob/main/docs/agent_guide.md) | Integration protocol for AI Agents |
 | [Capability Matrix](https://github.com/jhinzzz/ScreenForge/blob/main/docs/capability-matrix.md) | Supported platforms, actions, and locators |
+| [Playground Guide](https://github.com/jhinzzz/ScreenForge/blob/main/docs/playground-guide.md) | Live Mirror — watch code + screenshots grow as the test runs |
 | [Workflow Examples](https://github.com/jhinzzz/ScreenForge/tree/main/docs/workflows) | YAML workflow templates |
 | [CHANGELOG](https://github.com/jhinzzz/ScreenForge/blob/main/CHANGELOG.md) | Version history |
 

screenforge-0.6.0/cli/_version.py

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

{screenforge-0.4.1 → screenforge-0.6.0}/cli/modes/action.py

@@ -5,6 +5,7 @@ import os
 import sys
 
 import cli.shared as _shared
+from cli.playground_sink import build_sink_from_args, maybe_push_step
 from cli.reporter import (
     _apply_resume_summary,
     _build_action_summary,
@@ -206,6 +207,18 @@ def run_action_default_mode(
 
         history_manager.add_step(result["code_lines"], result["action_description"])
         save_to_disk(output_script_path, history_manager.get_current_file_content())
+        # ★ Live-mirror bypass (opt-in --playground-sink). join_on_exit=True: a bare
+        # --action exits right after, so wait briefly for the last frame to land.
+        maybe_push_step(
+            build_sink_from_args(args, join_on_exit=True),
+            args=args,
+            reporter=reporter,
+            adapter=adapter,
+            action_data=action_data,
+            result=result,
+            step_index=None,  # resolver picks: session counter, or 1 for a bare action
+            file_path=output_script_path,  # normalized to abs path inside build_step_event
+        )
         reporter.emit_event(
             "action_executed",
             step=1,

{screenforge-0.4.1 → screenforge-0.6.0}/cli/modes/workflow.py

@@ -4,6 +4,7 @@ from pathlib import Path
 
 import cli.shared as _shared
 from cli.modes.dry_run import _build_resolution_hint, _preview_action_resolution
+from cli.playground_sink import build_sink_from_args, maybe_push_step
 from cli.reporter import (
     _apply_resume_summary,
     _build_reporter,
@@ -285,6 +286,9 @@ def run_workflow_default_mode(
         history_manager = _shared.StepHistoryManager(initial_content=header)
         save_to_disk(output_script_path, header)
         executor = _shared.UIExecutor(device, platform=args.platform)
+        # Workflow is one process with many steps (the main use case for live mirror).
+        # Build the sink once; join_on_exit=False — the process lives across all steps.
+        sink = build_sink_from_args(args, join_on_exit=False)
 
         executed_steps = 0
         for index, step in enumerate(workflow.steps, start=1):
@@ -315,6 +319,17 @@ def run_workflow_default_mode(
                 result["code_lines"], result["action_description"]
             )
             save_to_disk(output_script_path, history_manager.get_current_file_content())
+            # ★ Live-mirror bypass: push this step with its loop counter as step_index.
+            maybe_push_step(
+                sink,
+                args=args,
+                reporter=reporter,
+                adapter=adapter,
+                action_data=action_data,
+                result=result,
+                step_index=index,
+                file_path=output_script_path,  # normalized to abs path inside build_step_event
+            )
             reporter.emit_event(
                 "action_executed",
                 step=index,

{screenforge-0.4.1 → screenforge-0.6.0}/cli/parser.py

@@ -151,6 +151,17 @@ def build_parser() -> argparse.ArgumentParser:
         default=7860,
         help="Playground server port (default: 7860)",
     )
+    parser.add_argument(
+        "--playground-sink",
+        action="store_true",
+        help="Push each step's code + screenshot to a running playground (opt-in; off = zero cost)",
+    )
+    parser.add_argument(
+        "--playground-url",
+        type=str,
+        default="http://127.0.0.1:7860",
+        help="Playground base URL for --playground-sink (default: http://127.0.0.1:7860)",
+    )
     parser.add_argument(
         "--device-url",
         type=str,
@@ -270,7 +281,10 @@ def validate_cli_args(args: argparse.Namespace) -> None:
         raise ValueError("--action cannot be combined with --goal or --workflow")
     has_demo = bool(getattr(args, "demo", False))
     has_init = bool(getattr(args, "init", False))
-    if has_demo or has_init:
+    # --playground starts a standalone server (dispatch.py handles it after this
+    # validation, exactly like --init/--demo) — it needs no goal/workflow/action.
+    has_playground = bool(getattr(args, "playground", False))
+    if has_demo or has_init or has_playground:
         return
     has_session_end = bool(str(getattr(args, "session_end", "")).strip())
     if has_session_end:

screenforge-0.6.0/cli/playground_sink.py

@@ -0,0 +1,255 @@
+"""Fire-and-forget visualization sink: short-lived action process → resident playground.
+
+Red line (G5): any network error is swallowed silently. A sink push MUST NEVER
+slow down the action or change its exit code — the 0/1 exit code is a contract to
+the agent (see CLAUDE.md). The sink is a bypass observer hung after save_to_disk;
+it does not touch execute_and_record, codegen, or disk persistence.
+"""
+
+import base64
+import os
+import threading
+
+import requests  # already in requirements.txt (requests==2.32.5) — zero new deps
+from loguru import logger as log
+from pydantic import BaseModel, Field
+
+from cli.session import load_session
+
+DEFAULT_PLAYGROUND_URL = "http://127.0.0.1:7860"
+
+# Latency ceiling on the contract-protected single-step --action path (red line #1:
+# "never slow the action down"). A reachable-but-slow playground must not tax the
+# action beyond this documented budget. (connect, read) is split so a hung peer
+# can't stall on connect; _JOIN_TIMEOUT is the hard cap the single-step process
+# 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
+
+
+class PlaygroundStepEvent(BaseModel):
+    """One step pushed to the playground. Shape == the frontend SSE `step` contract."""
+
+    run_id: str
+    step_index: int  # ⭐ time-travel seed: data accumulates/replays by this index
+    code_lines: list[str] = Field(default_factory=list)
+    action_description: str = ""
+    action: str = ""
+    locator_type: str = ""
+    locator_value: str = ""
+    extra_value: str = ""
+    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:
+    """Pushes each step to a running playground, best-effort.
+
+    Disabled by default: enabled=False means zero cost — no HTTP, no thread, and
+    (at the call sites) take_screenshot is never even invoked.
+    """
+
+    def __init__(
+        self,
+        base_url: str = DEFAULT_PLAYGROUND_URL,
+        enabled: bool = False,
+        join_on_exit: bool = False,
+    ):
+        self.base_url = base_url.rstrip("/")
+        self.enabled = enabled
+        # Single-step --action exits the process right after push_step returns;
+        # join a short window so the daemon thread's last frame can land (§6 单步收尾).
+        self._join_on_exit = join_on_exit
+
+    def push_step(self, event: PlaygroundStepEvent) -> None:
+        """Best-effort push. Hands off to a daemon thread; the caller returns at
+        once (arch#3: never block the action hot path)."""
+        if not self.enabled:
+            return
+        t = threading.Thread(target=self._post, args=(event,), daemon=True)
+        t.start()
+        if self._join_on_exit:
+            # Single-step --action exits right after this returns; wait a bounded
+            # grace (≤ _JOIN_TIMEOUT) for the last frame to land. This is the hard
+            # ceiling on added latency to the contract path — never grow it past a
+            # human-imperceptible budget (HIGH-1 from review: 0.6s was too generous).
+            t.join(timeout=_JOIN_TIMEOUT)
+
+    def _post(self, event: PlaygroundStepEvent) -> None:
+        try:
+            requests.post(
+                f"{self.base_url}/api/step",
+                json=event.model_dump(),
+                timeout=_POST_TIMEOUT,  # (connect, read) split: a hung playground can't stall us
+            )
+        except Exception as e:  # ConnectionError / Timeout / anything — swallow (G5)
+            log.debug(f"[playground-sink] skip (playground unreachable): {e}")
+
+    @staticmethod
+    def encode_screenshot(adapter) -> str:
+        """Cross-platform: take_screenshot() -> bytes → base64. Can't grab → '' (degrade).
+
+        Platform-agnostic on purpose: all three adapters expose take_screenshot()
+        (base_adapter.py:17 abstract), so no per-platform branching is needed here.
+        """
+        try:
+            png = adapter.take_screenshot()
+            return base64.b64encode(png).decode() if png else ""
+        except Exception as e:
+            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(
+    *,
+    run_key: str,
+    step_index: int,
+    action_data: dict,
+    result: dict,
+    screenshot_b64: str,
+    file_path: str = "",
+    has_dom_tree: bool = False,
+) -> PlaygroundStepEvent:
+    """MANDATORY single construction point for every step event (code#4).
+
+    All three entry points (action / workflow / main) build events ONLY through
+    here. Adding a field later (e.g. a seed timestamp) is then one edit, not three
+    — preventing the P9-style schema split where one call site silently drifts.
+
+    file_path is normalized to an absolute path HERE (one idiom, one place) rather
+    than at each call site, so it happens inside maybe_push_step's G5 try/except.
+    Empty stays empty — abspath('') would wrongly yield the cwd, and the frontend
+    treats '' as "no openable file" (disables the IDE button), so guard it.
+    """
+    return PlaygroundStepEvent(
+        run_id=run_key,
+        step_index=step_index,
+        code_lines=result.get("code_lines", []) or [],
+        action_description=result.get("action_description", ""),
+        action=action_data.get("action", ""),
+        locator_type=action_data.get("locator_type", ""),
+        locator_value=action_data.get("locator_value", ""),
+        extra_value=action_data.get("extra_value", ""),
+        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,
+    )
+
+
+def build_sink_from_args(args, *, join_on_exit: bool = False) -> "PlaygroundSink":
+    """Construct a sink from parsed CLI args. Absent flags → disabled (zero cost)."""
+    return PlaygroundSink(
+        base_url=getattr(args, "playground_url", "") or DEFAULT_PLAYGROUND_URL,
+        enabled=bool(getattr(args, "playground_sink", False)),
+        join_on_exit=join_on_exit,
+    )
+
+
+def maybe_push_step(
+    sink: "PlaygroundSink",
+    *,
+    args,
+    reporter,
+    adapter,
+    action_data: dict,
+    result: dict,
+    step_index: int | None = None,
+    file_path: str = "",
+) -> None:
+    """The ONE guarded entry point every call site uses (action / workflow / main).
+
+    Disabled-fast: returns before touching the adapter, so take_screenshot is
+    never called and there is zero device I/O or network on the hot path when the
+    sink is off. Wrapped in a blanket try/except as a belt-and-suspenders G5
+    guard — the bypass observer must never break the action it observes.
+    """
+    if not sink.enabled:
+        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=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}")
+
+
+def resolve_playground_run_key(args, reporter) -> tuple[str, int]:
+    """Return (run_key, step_index) — the cross-process-stable playground timeline key.
+
+    Root cause (arch#1): run_reporter.py mints run_id as `timestamp_uuid`, unique
+    per short-lived process. In agent mode each --action is its own process, so
+    using reporter.run_id directly would shatter a 5-step flow into 5 single-step
+    buckets and the seed's timeline would be born broken.
+
+    --session-id present → use session_id as the key (one session = one timeline);
+      step_index comes from the session's persisted 'steps' counter (cli/session.py),
+      which dispatch.py increments AFTER each successful step, so steps+1 is the
+      1-based index of the step about to be pushed.
+    No session → a bare --action is inherently single-step: reporter.run_id, index 1.
+    """
+    session_id = getattr(args, "session_id", "") or getattr(args, "session_end", "")
+    if session_id:
+        session = load_session(session_id)
+        return session_id, (session.get("steps", 0) + 1 if session else 1)
+    return reporter.run_id, 1

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

@@ -1,6 +1,6 @@
 [project]
 name = "screenforge"
-version = "0.4.1"
+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.4.1 → screenforge-0.6.0}/screenforge.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: screenforge
-Version: 0.4.1
+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
@@ -113,6 +113,7 @@ Each step: **inspect → decide → act → verify**. The AI decides, ScreenForg
 - **Visual fallback**: When DOM can't locate elements (Canvas, games), VLM parses screenshots
 - **MCP server**: Any MCP-compatible Agent can drive ScreenForge natively
 - **Structured output**: JSON Lines events + `report/runs/<id>/` artifacts for CI integration
+- **Live Mirror playground**: Watch the generated pytest code grow line-by-line beside a live screenshot as the test runs — `screenforge --playground`. See the [Playground Guide](https://github.com/jhinzzz/ScreenForge/blob/main/docs/playground-guide.md)
 
 ## Agent Integration (Claude Code / Cursor / Codex)
 
@@ -205,6 +206,7 @@ If ScreenForge generates tests for your project, add this badge to your README:
 | [MCP Setup (3 min)](https://github.com/jhinzzz/ScreenForge/blob/main/docs/mcp-setup.md) | Connect to Claude Desktop / Cursor / Cline / Claude Code |
 | [Agent Guide](https://github.com/jhinzzz/ScreenForge/blob/main/docs/agent_guide.md) | Integration protocol for AI Agents |
 | [Capability Matrix](https://github.com/jhinzzz/ScreenForge/blob/main/docs/capability-matrix.md) | Supported platforms, actions, and locators |
+| [Playground Guide](https://github.com/jhinzzz/ScreenForge/blob/main/docs/playground-guide.md) | Live Mirror — watch code + screenshots grow as the test runs |
 | [Workflow Examples](https://github.com/jhinzzz/ScreenForge/tree/main/docs/workflows) | YAML workflow templates |
 | [CHANGELOG](https://github.com/jhinzzz/ScreenForge/blob/main/CHANGELOG.md) | Version history |
 

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

@@ -6,6 +6,7 @@ cli/_version.py
 cli/dispatch.py
 cli/doctor.py
 cli/parser.py
+cli/playground_sink.py
 cli/reporter.py
 cli/session.py
 cli/shared.py
@@ -70,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
@@ -78,6 +80,9 @@ tests/test_ios_smoke_live.py
 tests/test_mcp_ref_cache.py
 tests/test_ml_optional.py
 tests/test_parser.py
+tests/test_playground_app.py
+tests/test_playground_sink.py
+tests/test_playground_sink_integration.py
 tests/test_run_reporter.py
 tests/test_run_resume.py
 tests/test_runtime_modes.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.4.1 → screenforge-0.6.0}/tests/test_parser.py

@@ -144,3 +144,15 @@ class TestValidateCliArgs:
     def test_demo_valid(self):
         args = self._make_args(goal="", demo=True)
         validate_cli_args(args)
+
+    def test_playground_alone_valid(self):
+        # Regression: --playground starts a standalone server (dispatch handles it
+        # AFTER this validation, like --init/--demo) and needs no goal/action.
+        # Before the fix it raised "Must provide --goal/--workflow/--action",
+        # making the live-mirror entry point impossible to launch from the CLI.
+        args = self._make_args(goal="", playground=True)
+        validate_cli_args(args)
+
+    def test_playground_with_port_valid(self):
+        args = self._make_args(goal="", playground=True, playground_port=8000)
+        validate_cli_args(args)