Skip to content

The agent that grows with you

11.1 KB
Raw Blame
"""CUA runtime validation, explicit PM setup, and native host integration."""

import json
from types import SimpleNamespace
from unittest.mock import patch
from xml.sax.saxutils import escape

import pytest


def _runtime_manifest(version="0.20.0", *, omit=()):
    required = {
        "mcp": {"--socket", "--grant"},
        "serve": {"--socket", "--permission-mode", "--capability-manifest",
                  "--approve-capability-manifest", "--embedded"},
        "stop": {"--socket"},
    }
    return {
        "binary_version": version,
        "mcp_invocation": {"command": "cua-driver", "args": ["mcp"]},
        "subcommands": [
            {"name": command, "args": [{"name": arg} for arg in sorted(args - set(omit))]}
            for command, args in required.items()
        ],
    }


@pytest.mark.parametrize("version,omit,ready", [
    ("0.20.0", (), True),
    ("0.19.4", (), False),
    ("bad-version", (), False),
    ("0.20.0", ("--approve-capability-manifest",), False),
])
def test_runtime_contract(version, omit, ready, tmp_path):
    from hermes_cli import tools_config_cua as cua

    result = SimpleNamespace(returncode=0, stderr="",
                             stdout=json.dumps(_runtime_manifest(version, omit=omit)))
    binary = str(tmp_path / "cua-driver")
    with patch("subprocess.run", return_value=result):
        state = cua._cua_driver_contract_status(binary)
    assert state["ready"] is ready
    assert state["binary"] == binary
    assert bool(state["reason"]) is not ready
    if omit:
        assert "serve --approve-capability-manifest" in state["reason"]


@pytest.mark.parametrize("upgrade", [False, True])
def test_pm_failure_is_reported_without_vendor_fallback(monkeypatch, capsys, upgrade):
    import pm
    from hermes_cli import tools_config_cua as cua

    monkeypatch.delenv("HERMES_CUA_DRIVER_CMD", raising=False)
    monkeypatch.setattr(cua, "_resolved_cua_driver_cmd", lambda: None)
    with patch.object(pm, "ensure", side_effect=pm.InstallError("cua-driver", "offline")) as ensure, \
         patch.object(cua.subprocess, "Popen", side_effect=AssertionError("vendor installer")):
        assert not cua.install_cua_driver(upgrade=upgrade)
    ensure.assert_called_once_with("cua-driver", explicit=True)
    assert "offline" in capsys.readouterr().out


@pytest.mark.parametrize("upgrade", [False, True])
def test_broken_override_never_acquires_standard_driver(tmp_path, monkeypatch, upgrade):
    import pm
    from hermes_cli import tools_config_cua as cua

    monkeypatch.setenv("HERMES_CUA_DRIVER_CMD", str(tmp_path / "missing-driver"))
    with patch.object(pm, "ensure", side_effect=AssertionError("override was replaced")):
        assert not cua.install_cua_driver(upgrade=upgrade)


@pytest.mark.platforms("windows")
@pytest.mark.parametrize("old_target", [False, True])
def test_autostart_uses_selected_binary_and_verifies_registration(tmp_path, monkeypatch, old_target):
    """``computer_use.autostart`` is opt-in (#97389): the default is on-demand,
    so exercising the registration path here requires arming the opt-in first."""
    from hermes_cli import tools_config_cua as cua

    binary = str(tmp_path / "User's driver directory" / "cua-driver.exe")
    selected = str(tmp_path / "old-cua-driver.exe") if old_target else binary
    calls = []

    def run(cmd, **kwargs):
        nonlocal selected
        calls.append(cmd)
        if cmd[0] == "schtasks.exe":
            xml = ('<?xml version="1.0" encoding="UTF-16"?>'
                   '<Task xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">'
                   f'<Actions><Exec><Command>{escape(selected)}</Command></Exec></Actions></Task>')
            return SimpleNamespace(returncode=0, stdout=xml.encode("utf-16"), stderr=b"")
        assert "-FilePath $exe" in cmd[-1]
        assert "-ArgumentList @('autostart','enable')" in cmd[-1]
        assert cua._ps_single_quote(binary) in cmd[-1]
        selected = binary
        return SimpleNamespace(returncode=0, stdout="", stderr="")

    monkeypatch.setattr(cua, "_cua_autostart_opt_in", lambda: True)
    monkeypatch.setattr(cua.subprocess, "run", run)
    monkeypatch.setattr(cua.shutil, "which", lambda command: command)
    assert cua._repair_cua_driver_autostart_windows(binary, verbose=False)
    assert len([cmd for cmd in calls if cmd[0] != "schtasks.exe"]) == int(old_target)
    assert all("/XML" in cmd for cmd in calls if cmd[0] == "schtasks.exe")


@pytest.mark.platforms("windows")
def test_autostart_does_not_claim_success_without_registered_task(monkeypatch):
    from hermes_cli import tools_config_cua as cua

    monkeypatch.setattr(cua, "_cua_autostart_opt_in", lambda: True)
    monkeypatch.setattr(cua, "_cua_driver_autostart_registered_windows", lambda binary=None: False)
    monkeypatch.setattr(cua.shutil, "which", lambda command: command)
    monkeypatch.setattr(cua, "_run_text", lambda *a, **kw: SimpleNamespace(returncode=0))
    assert not cua._repair_cua_driver_autostart_windows("cua-driver.exe", verbose=False)


@pytest.mark.platforms("windows")
def test_repair_without_opt_in_spawns_no_powershell(monkeypatch):
    """``computer_use.autostart`` defaults to on-demand (#97389): without the
    opt-in the repair degrades to a no-op — returns True (nothing to repair)
    and spawns no PowerShell at all."""
    from hermes_cli import tools_config_cua as cua

    monkeypatch.setattr(cua, "_cua_driver_autostart_registered_windows", lambda binary=None: False)
    monkeypatch.setattr(cua.shutil, "which", lambda command: AssertionError("resolved a binary"))
    with patch("hermes_cli.config.load_config", return_value={}), \
         patch.object(cua.subprocess, "run", side_effect=AssertionError("spawned PowerShell")), \
         patch.object(cua, "_run_text", side_effect=AssertionError("spawned PowerShell")):
        assert cua._repair_cua_driver_autostart_windows("cua-driver.exe", verbose=False)


@pytest.mark.parametrize("config", [
    {},
    {"computer_use": {}},
    {"computer_use": {"autostart": False}},
])
def test_autostart_opt_in_defaults_to_on_demand(config):
    from hermes_cli import tools_config_cua as cua

    with patch("hermes_cli.config.load_config", return_value=config):
        assert cua._cua_autostart_opt_in() is False


def test_autostart_opt_in_explicit_true_registers():
    from hermes_cli import tools_config_cua as cua

    with patch("hermes_cli.config.load_config",
               return_value={"computer_use": {"autostart": True}}):
        assert cua._cua_autostart_opt_in() is True


def test_autostart_opt_in_unreadable_config_fails_closed():
    from hermes_cli import tools_config_cua as cua

    with patch("hermes_cli.config.load_config", side_effect=OSError("unreadable")):
        assert cua._cua_autostart_opt_in() is False


def test_autostart_registration_ps_command_quotes_paths_with_spaces():
    """Start-Process structured ``-FilePath`` / ``-ArgumentList``: older
    install.ps1 builds interpolated the binary path into a command string,
    which split at the first space."""
    from hermes_cli import tools_config_cua as cua

    path = "C:\\Program Files\\cua driver\\cua-driver.exe"
    ps = cua._cua_autostart_registration_ps_command(path)
    assert "Start-Process -FilePath $exe" in ps
    assert "@('autostart','enable')" in ps
    assert "-Verb RunAs -Wait -PassThru" in ps
    # The path is single-quoted (never interpolated bare into the command
    # string), so spaces cannot split it.
    assert f"$exe = '{path}'" in ps


@pytest.mark.platforms("windows")
@pytest.mark.parametrize("opt_in,expected", [(False, True), (True, False)])
def test_install_ready_task_requirement_follows_the_opt_in(monkeypatch, opt_in, expected):
    """With ``computer_use.autostart`` off (#97389) a missing cua-driver-serve
    logon task is not a repair condition; opted in, it still is."""
    from hermes_cli import tools_config_cua as cua

    monkeypatch.setattr(cua, "_cua_driver_contract_status",
                        lambda *a: {"ready": True, "version": "0.20.0",
                                    "binary": "/x/cua-driver", "reason": ""})
    monkeypatch.setattr(cua, "_cua_driver_autostart_registered_windows",
                        lambda binary=None: False)
    monkeypatch.setattr(cua, "_cua_autostart_opt_in", lambda: opt_in)
    assert cua._cua_driver_install_ready() is expected


@pytest.mark.platforms("windows")
@pytest.mark.parametrize("registered", [False, True])
def test_setup_preserves_host_registration_failure(monkeypatch, registered):
    import pm
    from hermes_cli import tools_config_cua as cua

    monkeypatch.delenv("HERMES_CUA_DRIVER_CMD", raising=False)
    monkeypatch.setattr(pm, "ensure", lambda *a, **kw: None)
    monkeypatch.setattr(cua, "_resolved_cua_driver_cmd", lambda: "cua-driver.exe")
    monkeypatch.setattr(cua, "_cua_driver_contract_status", lambda *a: {"ready": True})
    with patch.object(cua, "_repair_cua_driver_autostart_windows", return_value=registered) as repair:
        assert cua.install_cua_driver(show_installer_progress=False) is registered
    repair.assert_called_once_with("cua-driver.exe", verbose=False)


@pytest.mark.platforms("macos")
def test_setup_refuses_bare_binary_without_required_signed_app(monkeypatch, tmp_path):
    from hermes_cli import tools_config_cua as cua

    driver = tmp_path / "cua-driver"
    driver.write_text("#!/bin/sh\nexit 0\n")
    driver.chmod(0o755)
    monkeypatch.setenv("HERMES_CUA_DRIVER_CMD", str(driver))
    monkeypatch.setattr(cua, "_cua_driver_contract_status", lambda *a: {"ready": True})
    assert not cua.install_cua_driver(show_installer_progress=False)


@pytest.mark.platforms("macos")
def test_setup_registers_only_the_validated_selected_app(monkeypatch, tmp_path):
    from hermes_cli import tools_config_cua as cua
    from tools.computer_use import cua_backend_daemon as daemon

    app = tmp_path / "CuaDriver.app"
    driver = app / "Contents" / "MacOS" / "cua-driver"
    driver.parent.mkdir(parents=True)
    driver.write_text("#!/bin/sh\nexit 0\n")
    driver.chmod(0o755)
    monkeypatch.setenv("HERMES_CUA_DRIVER_CMD", str(driver))
    monkeypatch.setattr(cua, "_cua_driver_contract_status", lambda *a: {"ready": True})
    with patch.object(daemon, "_validate_cua_driver_app_signature") as validate, \
         patch.object(cua, "_run_text", return_value=SimpleNamespace(returncode=0)) as register:
        assert cua.install_cua_driver(show_installer_progress=False)
    validate.assert_called_once_with(str(app))
    assert register.call_args.args[0][-2:] == ["-f", str(app)]


@pytest.mark.platforms("macos")
def test_setup_keeps_permission_guidance(capsys):
    from hermes_cli.tools_config_cua import _print_cua_platform_notes

    _print_cua_platform_notes(False, False, fresh_install=True)
    output = capsys.readouterr().out
    assert "Accessibility" in output
    assert "Screen Recording" in output


@pytest.mark.parametrize("raw,expected", [
    ("cua-driver 0.20.0", "cua-driver 0.20.0"),
    ("banner\nsecond line", "banner"),
    ("\n\n  cua-driver 0.20.0  ", "cua-driver 0.20.0"),
    ("x" * 500, "x" * 120),
    ("", ""),
    ("   \n \n", ""),
])
def test_version_summary(raw, expected):
    from hermes_cli.tools_config_cua import _cua_version_summary

    assert _cua_version_summary(raw) == expected