@hybridlabor-api/aos 4.2.0 → 4.4.0

package/mcps/windows-computer-use-mcp/tests/conftest_env.py

@@ -1,116 +0,0 @@
-"""Environment-aware test scaffold (aligned with mcp-central-docs).
-
-**Canonical reference:** ``mcp-central-docs/standards/testing-environment-aware.md``
-
-**windows-computer-use-mcp adaptation:** This server depends on a **local Windows session** and sometimes **OpenCV /
-USB cameras**, not LAN-only IoT. Therefore ``requires_hardware`` means: **skip in CI**, **allow on any
-local developer machine** where ``CI`` is unset — you do **not** need ``local_with_iot`` (router
-probe) to run webcam tests.
-
-Signals:
-  * ``CI=true`` → ``ci`` (GitHub Actions: no real desktop, mock or HTTP-only tests)
-  * Else + LAN probe succeeds → ``local_with_iot`` (optional, for future LAN-dependent tools)
-  * Else → ``local_no_iot`` (local PC, hardware may still be off)
-
-Markers:
-  * ``requires_hardware`` — real OpenCV / camera / host-only paths; **skipped in CI**
-  * ``requires_network`` — skipped in CI
-  * ``ci_only`` — only runs when ``CI=true``
-  * ``destructive`` — mutating real UI; **skipped in CI** (run locally with care)
-  * ``slow`` — opt-in slow tests
-"""
-
-from __future__ import annotations
-
-import os
-import socket
-from typing import Literal
-
-import pytest
-
-EnvType = Literal["ci", "local_no_iot", "local_with_iot"]
-
-
-def _detect_environment() -> EnvType:
-    if os.environ.get("CI", "").lower() in ("true", "1", "yes"):
-        return "ci"
-
-    probe_ip = os.environ.get("IOT_PROBE_IP", "192.168.1.1")
-    probe_port = int(os.environ.get("IOT_PROBE_PORT", "80"))
-    timeout = float(os.environ.get("IOT_PROBE_TIMEOUT", "1.5"))
-
-    try:
-        with socket.create_connection((probe_ip, probe_port), timeout=timeout):
-            return "local_with_iot"
-    except (OSError, TimeoutError):
-        return "local_no_iot"
-
-
-ENV: EnvType = _detect_environment()
-
-
-def _probe_device(ip: str, port: int, timeout: float = 1.0) -> bool:
-    try:
-        with socket.create_connection((ip, port), timeout=timeout):
-            return True
-    except (OSError, TimeoutError):
-        return False
-
-
-def pytest_configure(config: pytest.Config) -> None:
-    config.addinivalue_line(
-        "markers",
-        "requires_hardware: needs local Windows host (OpenCV/camera/desktop) — skipped in CI",
-    )
-    config.addinivalue_line(
-        "markers",
-        "requires_network: needs LAN — skipped in CI",
-    )
-    config.addinivalue_line(
-        "markers",
-        "ci_only: contract tests meant for CI — skipped on local unless CI=true",
-    )
-    config.addinivalue_line(
-        "markers",
-        "slow: opt-in slow tests",
-    )
-    config.addinivalue_line(
-        "markers",
-        "destructive: real UI/input — skipped in CI; run locally with operator awareness",
-    )
-
-
-def pytest_runtest_setup(item: pytest.Item) -> None:
-    env = ENV
-
-    # Fork from generic "IoT only" rule: hardware here = local machine, not LAN probe.
-    if item.get_closest_marker("requires_hardware") and env == "ci":
-        pytest.skip(
-            "requires_hardware: skipped in CI — run on local Windows with OpenCV/devices. "
-            "See mcp-central-docs standards/testing-environment-aware.md"
-        )
-
-    if item.get_closest_marker("requires_network") and env == "ci":
-        pytest.skip("requires_network: no local network in CI")
-
-    if item.get_closest_marker("ci_only") and env != "ci":
-        pytest.skip("ci_only: skipping on local (set CI=true to force)")
-
-    if item.get_closest_marker("destructive") and env == "ci":
-        pytest.skip("destructive: skipped in CI — run locally with PYWINAUTO_TEST_REAL_WINDOWS etc.")
-
-
-@pytest.fixture(scope="session", autouse=True)
-def environment_report() -> None:
-    env_labels = {
-        "ci": "CI — hardware-marked tests skipped; use mocks",
-        "local_no_iot": "Local — LAN probe failed; USB/integrated camera may still work",
-        "local_with_iot": "Local — LAN probe OK; optional IoT + desktop tests",
-    }
-    print(f"\n[pytest env] ENV={ENV} — {env_labels[ENV]}")
-
-
-def skip_if_device_unreachable(ip: str, port: int, label: str) -> None:
-    """Skip if a specific LAN device is not reachable (optional fine-grained skip)."""
-    if not _probe_device(ip, port):
-        pytest.skip(f"Device unreachable: {label} at {ip}:{port}")

package/mcps/windows-computer-use-mcp/tests/e2e/conftest.py

@@ -1,96 +0,0 @@
-"""E2E fixtures — LibreOffice GUI (requires soffice on host)."""
-
-from __future__ import annotations
-
-import os
-import subprocess
-import time
-from pathlib import Path
-
-import pytest
-
-_MARK_E2E = pytest.mark.e2e
-_MARK_LO = pytest.mark.libreoffice
-_MARK_GUI = pytest.mark.requires_gui
-
-
-def _resolve_soffice() -> Path | None:
-    env = os.getenv("PYWINAUTO_E2E_SOFFICE", "").strip()
-    if env:
-        p = Path(env)
-        return p if p.is_file() else None
-    candidates = [
-        Path(r"C:\Program Files\LibreOffice\program\soffice.exe"),
-        Path(r"C:\Program Files (x86)\LibreOffice\program\soffice.exe"),
-    ]
-    for c in candidates:
-        if c.is_file():
-            return c
-    return None
-
-
-SOFFICE_EXE = _resolve_soffice()
-
-
-@pytest.fixture(autouse=True)
-def loose_libreoffice_uia(monkeypatch):
-    """LibreOffice exposes many Custom/Pane nodes — include named visible controls."""
-    monkeypatch.setenv("windows_computer_use_mcp_LOOSE_UIA", "1")
-
-
-SKIP_NO_SOFFICE = pytest.mark.skipif(
-    SOFFICE_EXE is None,
-    reason="LibreOffice soffice not found (set PYWINAUTO_E2E_SOFFICE)",
-)
-
-
-@pytest.fixture
-def soffice_exe():
-    if SOFFICE_EXE is None:
-        pytest.skip("LibreOffice soffice not installed")
-    return SOFFICE_EXE
-
-
-@pytest.fixture
-def libreoffice_calc(soffice_exe: Path):
-    """Launch Calc and yield HWND; kill process on teardown."""
-    proc = subprocess.Popen(
-        [str(soffice_exe), "--calc"],
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL,
-    )
-    handle = _wait_for_window("LibreOffice Calc", timeout=45.0)
-    if handle is None:
-        proc.terminate()
-        pytest.skip("LibreOffice Calc window did not appear")
-    try:
-        yield {"process": proc, "handle": handle, "title_hint": "LibreOffice Calc"}
-    finally:
-        _close_process(proc)
-
-
-def _wait_for_window(title_fragment: str, timeout: float) -> int | None:
-    from pywinauto import Desktop
-
-    deadline = time.time() + timeout
-    while time.time() < deadline:
-        try:
-            for w in Desktop(backend="uia").windows():
-                text = w.window_text() or ""
-                if title_fragment in text:
-                    return int(w.handle)
-        except Exception:
-            pass
-        time.sleep(0.5)
-    return None
-
-
-def _close_process(proc: subprocess.Popen) -> None:
-    try:
-        proc.terminate()
-        proc.wait(timeout=8)
-    except Exception:
-        try:
-            proc.kill()
-        except Exception:
-            pass

package/mcps/windows-computer-use-mcp/tests/e2e/test_libreoffice_cua_loop.py

@@ -1,72 +0,0 @@
-"""E2E: Cua-shaped loop against live LibreOffice Calc (pairs with libreoffice-mcp fleet)."""
-
-from __future__ import annotations
-
-import pytest
-
-from windows_computer_use_mcp.desktop_state.capture import DesktopStateCapture, normalize_elements_for_snapshot
-from windows_computer_use_mcp.snapshot_store import SnapshotStore
-from windows_computer_use_mcp.tools.models import ElementOperationRequest, WindowStateRequest
-from windows_computer_use_mcp.tools.portmanteau_elements import automation_elements
-from windows_computer_use_mcp.tools.window_state import get_window_state
-
-pytestmark = [
-    pytest.mark.e2e,
-    pytest.mark.libreoffice,
-    pytest.mark.windows_only,
-    pytest.mark.requires_gui,
-]
-
-
-def test_calc_get_window_state_ax(libreoffice_calc):
-    handle = libreoffice_calc["handle"]
-    req = WindowStateRequest(window_handle=handle, capture_mode="ax", max_depth=6)
-    result = get_window_state(req)
-    assert result.status == "success", result.message
-    assert result.data["element_count"] >= 1, result.data.get("text", result.message)
-    assert result.data["snapshot_id"]
-    assert result.data["elements"][0]["element_index"] == 0
-
-
-def test_calc_capture_modes(libreoffice_calc):
-    handle = libreoffice_calc["handle"]
-    capturer = DesktopStateCapture(max_depth=5, element_timeout=0.3)
-    ax = capturer.capture(capture_mode="ax", window_handle=handle)
-    assert ax["capture_mode"] == "ax"
-    assert ax["element_count"] >= 1
-    vision = capturer.capture(capture_mode="vision", window_handle=handle)
-    assert vision["capture_mode"] == "vision"
-    assert vision.get("screenshot_base64"), "vision mode should return a window screenshot"
-
-
-def test_calc_snapshot_store_roundtrip(libreoffice_calc):
-    handle = libreoffice_calc["handle"]
-    capturer = DesktopStateCapture(max_depth=4, element_timeout=0.3)
-    raw = capturer.capture(capture_mode="ax", window_handle=handle)
-    elements = normalize_elements_for_snapshot(raw.get("interactive_elements") or [])
-    store = SnapshotStore()
-    sid = store.put(window_handle=handle, capture_mode="ax", elements=elements)
-    assert store.resolve_element(sid, 0) is not None
-
-
-@pytest.mark.slow
-def test_calc_background_click_reports_blocked_or_success(libreoffice_calc):
-    """Background click may succeed (invoke) or return background_unavailable — both are valid signals."""
-    handle = libreoffice_calc["handle"]
-    state = get_window_state(WindowStateRequest(window_handle=handle, capture_mode="ax", max_depth=8))
-    assert state.status == "success"
-    if not state.data["elements"]:
-        pytest.skip("No interactive elements in Calc snapshot (UIA tree empty on this host)")
-    sid = state.data["snapshot_id"]
-    idx = state.data["elements"][0]["element_index"]
-    click_req = ElementOperationRequest(
-        window_handle=handle,
-        operation="click",
-        snapshot_id=sid,
-        element_index=idx,
-        dispatch="background",
-    )
-    click_result = automation_elements(click_req)
-    assert click_result.status in ("success", "blocked")
-    if click_result.status == "blocked":
-        assert click_result.data.get("code") == "background_unavailable"

package/mcps/windows-computer-use-mcp/tests/test_app_integration.py

@@ -1,83 +0,0 @@
-import pytest
-
-# Trigger tool registration
-from windows_computer_use_mcp.app import app
-
-
-class TestAppInitialization:
-    """Tests for app initialization."""
-
-    def test_app_instance_exists(self):
-        """Test that app instance is created."""
-        assert app is not None
-        assert hasattr(app, "name")
-        assert app.name == "windows-computer-use-mcp"
-
-    def test_app_version(self):
-        """Test that app has correct version from pyproject.toml."""
-        # Note: In our current industrialized version, app.version is 0.4.2
-        assert app.version == "0.7.0"
-
-    def test_ocr_availability_flag(self):
-        """Test OCR availability flag."""
-        from windows_computer_use_mcp.app import OCR_AVAILABLE
-
-        assert isinstance(OCR_AVAILABLE, bool)
-
-
-class TestToolRegistration:
-    """Tests for tool registration."""
-
-    @pytest.mark.asyncio
-    async def test_tools_are_registered(self, app_instance):
-        """Test that all 9 industrialized portmanteau tools are registered."""
-        # FastMCP 3.2+ list_tools is async
-        tools = await app_instance.list_tools()
-        assert tools is not None
-
-        tool_names = [t.name for t in tools]
-        expected_tools = [
-            "automation_windows",
-            "automation_elements",
-            "automation_mouse",
-            "automation_keyboard",
-            "automation_visual",
-            "automation_system",
-            "automation_mission",
-            "get_desktop_state",
-            # automation_face is optional, so we don't strictly assert it here
-            # without checking the environment first
-        ]
-
-        for name in expected_tools:
-            assert name in tool_names, f"Tool '{name}' not found in registered tools: {tool_names}"
-
-    @pytest.mark.asyncio
-    async def test_automation_system_tool_exists(self, app_instance):
-        """Test that automation_system tool is registered."""
-        tools = await app_instance.list_tools()
-        tool_names = [t.name for t in tools]
-        assert "automation_system" in tool_names
-
-
-class TestModuleImports:
-    """Tests for module imports."""
-
-    def test_all_tool_modules_importable(self):
-        """Test that all tool modules can be imported."""
-        modules = [
-            "windows_computer_use_mcp.tools.portmanteau_windows",
-            "windows_computer_use_mcp.tools.portmanteau_elements",
-            "windows_computer_use_mcp.tools.portmanteau_mouse",
-            "windows_computer_use_mcp.tools.portmanteau_keyboard",
-            "windows_computer_use_mcp.tools.portmanteau_visual",
-            "windows_computer_use_mcp.tools.portmanteau_system",
-            "windows_computer_use_mcp.tools.portmanteau_mission",
-            "windows_computer_use_mcp.tools.desktop_state",
-        ]
-
-        for module_name in modules:
-            try:
-                __import__(module_name)
-            except ImportError as e:
-                pytest.fail(f"Failed to import {module_name}: {e}")

package/mcps/windows-computer-use-mcp/tests/test_app_profiles.py

@@ -1,28 +0,0 @@
-"""Tests for app profiles and region masks (T2.4)."""
-
-from windows_computer_use_mcp.app_profiles import get_profile, get_profile_region, list_profiles, region_dict_for_app
-
-
-def test_vroid_profile_has_stable_region():
-    p = get_profile("vroidstudio")
-    assert p is not None
-    assert p.stable_region is not None
-    assert p.stable_region.label == "editor_canvas"
-
-
-def test_get_profile_region_tuple():
-    region = get_profile_region("vroidstudio")
-    assert region == (280, 120, 1640, 980)
-
-
-def test_list_profiles_includes_region():
-    profiles = list_profiles()
-    vroid = next(p for p in profiles if p["app_id"] == "vroidstudio")
-    assert "stable_region" in vroid
-    assert vroid["stable_region"]["region_left"] == 280
-
-
-def test_region_dict_for_app():
-    d = region_dict_for_app("vroidstudio")
-    assert d is not None
-    assert d["region_bottom"] == 980

package/mcps/windows-computer-use-mcp/tests/test_automation_assert.py

@@ -1,185 +0,0 @@
-"""Tests for automation_assert and assert_engine."""
-
-from pathlib import Path
-
-import pytest
-from PIL import Image, ImageDraw
-
-from windows_computer_use_mcp import assert_engine
-from windows_computer_use_mcp.tools.models import AssertOperationRequest, ToolResult
-from windows_computer_use_mcp.tools.portmanteau_assert import automation_assert
-
-
-def _solid(path: Path, color: tuple[int, int, int], size: tuple[int, int] = (100, 100)) -> Path:
-    img = Image.new("RGB", size, color)
-    img.save(path)
-    return path
-
-
-def _with_rect(path: Path, base: tuple[int, int, int], rect_color: tuple[int, int, int]) -> Path:
-    img = Image.new("RGB", (100, 100), base)
-    draw = ImageDraw.Draw(img)
-    draw.rectangle((20, 20, 80, 80), fill=rect_color)
-    img.save(path)
-    return path
-
-
-class TestAssertEngine:
-    def test_sha256_deterministic(self, tmp_path: Path):
-        p = _solid(tmp_path / "a.png", (255, 0, 0))
-        img = assert_engine.capture_image(image_path=str(p))
-        h1 = assert_engine.image_hash(img, "sha256")
-        h2 = assert_engine.image_hash(img, "sha256")
-        assert h1 == h2
-        assert len(h1) == 64
-
-    def test_dhash_similar_images(self, tmp_path: Path):
-        p1 = _solid(tmp_path / "a.png", (100, 100, 100))
-        p2 = _solid(tmp_path / "b.png", (102, 100, 100))
-        h1 = assert_engine.image_hash(assert_engine.capture_image(image_path=str(p1)), "dhash")
-        h2 = assert_engine.image_hash(assert_engine.capture_image(image_path=str(p2)), "dhash")
-        assert assert_engine.hashes_match(h1, h2, algorithm="dhash")
-
-    def test_diff_detects_change(self, tmp_path: Path):
-        before = _solid(tmp_path / "before.png", (0, 0, 0))
-        after = _with_rect(tmp_path / "after.png", (0, 0, 0), (255, 255, 255))
-        b = assert_engine.capture_image(image_path=str(before))
-        a = assert_engine.capture_image(image_path=str(after))
-        diff = assert_engine.image_diff(b, a, output_path=str(tmp_path / "diff.png"))
-        assert diff["changed_pct"] > 10.0
-        assert Path(diff["diff_path"]).is_file()
-
-    def test_diff_identical_zero_change(self, tmp_path: Path):
-        p = _solid(tmp_path / "same.png", (50, 50, 50))
-        img = assert_engine.capture_image(image_path=str(p))
-        diff = assert_engine.image_diff(img, img)
-        assert diff["changed_pct"] == 0.0
-
-    def test_wait_stable_static_file(self, tmp_path: Path):
-        p = _solid(tmp_path / "static.png", (10, 20, 30))
-        result = assert_engine.wait_stable(image_path=str(p), timeout_s=1.0)
-        assert result["stable"] is True
-        assert result["final_hash"]
-
-    def test_crop_region(self):
-        img = Image.new("RGB", (200, 200), (0, 0, 0))
-        cropped = assert_engine.crop_region(img, (10, 10, 50, 50))
-        assert cropped.size == (40, 40)
-
-
-class TestAutomationAssertTool:
-    def test_hash_operation(self, tmp_path: Path):
-        p = _solid(tmp_path / "h.png", (1, 2, 3))
-        req = AssertOperationRequest(operation="hash", image_path=str(p))
-        result = automation_assert(req)
-        assert isinstance(result, ToolResult)
-        assert result.status == "success"
-        assert result.data["hash"]
-        assert result.data["algorithm"] == "dhash"
-
-    def test_hash_region_requires_region(self, tmp_path: Path):
-        p = _solid(tmp_path / "h.png", (1, 2, 3))
-        req = AssertOperationRequest(operation="hash_region", image_path=str(p))
-        result = automation_assert(req)
-        assert result.status == "error"
-
-    def test_diff_operation(self, tmp_path: Path):
-        before = _solid(tmp_path / "b.png", (0, 0, 0))
-        after = _with_rect(tmp_path / "a.png", (0, 0, 0), (200, 200, 200))
-        req = AssertOperationRequest(
-            operation="diff",
-            image_path=str(before),
-            image_path_b=str(after),
-            output_path=str(tmp_path / "out.png"),
-        )
-        result = automation_assert(req)
-        assert result.status == "success"
-        assert result.data["changed_pct"] > 0
-
-    def test_assert_changed_passes(self, tmp_path: Path):
-        before = _solid(tmp_path / "b.png", (0, 0, 0))
-        after = _with_rect(tmp_path / "a.png", (0, 0, 0), (255, 0, 0))
-        req = AssertOperationRequest(
-            operation="assert_changed",
-            image_path=str(before),
-            image_path_b=str(after),
-            change_threshold_pct=1.0,
-        )
-        result = automation_assert(req)
-        assert result.status == "success"
-
-    def test_assert_changed_fails_on_identical(self, tmp_path: Path):
-        p = _solid(tmp_path / "same.png", (42, 42, 42))
-        req = AssertOperationRequest(
-            operation="assert_changed",
-            image_path=str(p),
-            image_path_b=str(p),
-            change_threshold_pct=0.1,
-        )
-        result = automation_assert(req)
-        assert result.status == "error"
-        assert result.recovery_tip
-
-    def test_assert_unchanged_passes(self, tmp_path: Path):
-        p = _solid(tmp_path / "same.png", (42, 42, 42))
-        req = AssertOperationRequest(
-            operation="assert_unchanged",
-            image_path=str(p),
-            image_path_b=str(p),
-        )
-        result = automation_assert(req)
-        assert result.status == "success"
-
-    def test_assert_unchanged_fails_on_change(self, tmp_path: Path):
-        before = _solid(tmp_path / "b.png", (0, 0, 0))
-        after = _with_rect(tmp_path / "a.png", (0, 0, 0), (255, 255, 0))
-        req = AssertOperationRequest(
-            operation="assert_unchanged",
-            image_path=str(before),
-            image_path_b=str(after),
-            unchanged_threshold_pct=0.5,
-        )
-        result = automation_assert(req)
-        assert result.status == "error"
-
-    def test_wait_stable_static(self, tmp_path: Path):
-        p = _solid(tmp_path / "s.png", (5, 5, 5))
-        req = AssertOperationRequest(operation="wait_stable", image_path=str(p), timeout_s=2.0)
-        result = automation_assert(req)
-        assert result.status == "success"
-        assert result.data["stable"] is True
-
-    def test_assert_template_with_synthetic(self, tmp_path: Path):
-        haystack_path = tmp_path / "hay.png"
-        template_path = tmp_path / "tpl.png"
-        _with_rect(haystack_path, (0, 0, 0), (255, 0, 0))
-        tpl = Image.new("RGB", (20, 20), (255, 0, 0))
-        tpl.save(template_path)
-
-        req = AssertOperationRequest(
-            operation="assert_template",
-            image_path=str(haystack_path),
-            template_path=str(template_path),
-            match_threshold=0.7,
-        )
-        result = automation_assert(req)
-        assert result.status == "success"
-        assert result.data["found"] is True
-
-    @pytest.mark.skipif(not assert_engine.OCR_AVAILABLE, reason="pytesseract not installed")
-    def test_assert_text(self, tmp_path: Path):
-        img_path = tmp_path / "text.png"
-        img = Image.new("RGB", (200, 60), (255, 255, 255))
-        draw = ImageDraw.Draw(img)
-        draw.text((10, 10), "Export VRM", fill=(0, 0, 0))
-        img.save(img_path)
-
-        req = AssertOperationRequest(
-            operation="assert_text",
-            image_path=str(img_path),
-            expected_text="Export VRM",
-        )
-        result = automation_assert(req)
-        if result.status == "error" and "tesseract" in (result.message or "").lower():
-            pytest.skip("Tesseract binary not available")
-        assert result.status == "success"

package/mcps/windows-computer-use-mcp/tests/test_automation_dialog.py

@@ -1,43 +0,0 @@
-"""Tests for automation_dialog and dialog_engine."""
-
-from unittest.mock import patch
-
-from windows_computer_use_mcp import dialog_engine
-from windows_computer_use_mcp.tools.models import DialogOperationRequest, ToolResult
-from windows_computer_use_mcp.tools.portmanteau_dialog import automation_dialog
-
-
-class TestDialogEngine:
-    @patch("windows_computer_use_mcp.dialog_engine.pyautogui")
-    @patch("windows_computer_use_mcp.dialog_engine.pyperclip")
-    def test_submit_path_clipboard(self, mock_clip, mock_gui):
-        dialog_engine.CLIPBOARD_AVAILABLE = True
-        result = dialog_engine.submit_path(r"D:\exports\model.vrm", use_clipboard=True)
-        mock_clip.copy.assert_called_once_with(r"D:\exports\model.vrm")
-        mock_gui.hotkey.assert_any_call("ctrl", "v")
-        mock_gui.press.assert_called_with("enter")
-        assert result["submitted"] is True
-        assert result["method"] == "clipboard"
-
-    @patch("windows_computer_use_mcp.dialog_engine.pyautogui")
-    def test_set_path_type_fallback(self, mock_gui):
-        dialog_engine.CLIPBOARD_AVAILABLE = False
-        result = dialog_engine.set_path_field("short.vrm", use_clipboard=True)
-        mock_gui.write.assert_called_once()
-        assert result["method"] == "type"
-
-
-class TestAutomationDialogTool:
-    @patch("windows_computer_use_mcp.tools.portmanteau_dialog.dialog_engine.submit_path")
-    def test_submit_path_operation(self, mock_submit):
-        mock_submit.return_value = {"method": "clipboard", "submitted": True, "confirm_key": "enter", "pause_s": 0.3}
-        req = DialogOperationRequest(operation="submit_path", path=r"C:\out\a.vrm")
-        result = automation_dialog(req)
-        assert isinstance(result, ToolResult)
-        assert result.status == "success"
-        mock_submit.assert_called_once()
-
-    def test_submit_path_requires_path(self):
-        req = DialogOperationRequest(operation="submit_path")
-        result = automation_dialog(req)
-        assert result.status == "error"