Skip to content

Enterprise agent platform for building, deploying, and operating AI teammates.

11.9 KB
Raw Blame
from __future__ import annotations

from types import SimpleNamespace
from typing import Any

import pytest

from xagent.core.computer.native_browser import (
    LOCAL_BROWSER_TASK_EXTENSION,
)
from xagent.core.task_runtime import (
    TaskRuntimeClientError,
    TaskRuntimeContext,
    TaskRuntimeContribution,
    merge_task_runtime_contributions,
)
from xagent.core.tools.adapters.vibe.browser_tools import (
    _has_computer_runtime,
    create_browser_tools,
)
from xagent.web.models.task import Task
from xagent.web.models.user import User
from xagent.web.services.local_browser_runtime import (
    LocalBrowserTaskRuntimeProvider,
    register_local_browser_runtime,
    unregister_local_browser_runtime,
)
from xagent.web.services.task_runtime import (
    agent_config_with_task_extension_bindings,
    register_task_extension,
    registered_task_extensions,
    unregister_task_extension,
)


class FakeSession:
    def __init__(self, *, task: Any, user: Any) -> None:
        self.task = task
        self.user = user
        self.model: Any = None
        self.closed = False
        self.committed = False

    def query(self, model: Any) -> FakeSession:
        self.model = model
        return self

    def filter(self, *_args: Any) -> FakeSession:
        return self

    def first(self) -> Any:
        if self.model is Task:
            return self.task
        if self.model is User:
            return self.user
        raise AssertionError(f"unexpected query model: {self.model}")

    def close(self) -> None:
        self.closed = True

    def commit(self) -> None:
        self.committed = True


def make_context(
    *,
    bound: bool,
    admin: bool,
    workspace: Any = object(),
    extension: str = LOCAL_BROWSER_TASK_EXTENSION,
):
    agent_config = (
        agent_config_with_task_extension_bindings({}, [extension]) if bound else {}
    )
    sessions: list[FakeSession] = []
    task = SimpleNamespace(id=7, user_id=3, agent_config=agent_config)
    user = SimpleNamespace(id=3, is_admin=admin)

    def session_factory() -> FakeSession:
        session = FakeSession(task=task, user=user)
        sessions.append(session)
        return session

    return (
        TaskRuntimeContext(
            task_id=7,
            user_id=3,
            source="internal",
            session_factory=session_factory,
            workspace=workspace,
        ),
        sessions,
    )


def test_local_browser_registration_is_explicit_and_lifespan_scoped() -> None:
    unregister_task_extension(LOCAL_BROWSER_TASK_EXTENSION)
    try:
        register_local_browser_runtime()
        register_local_browser_runtime()
        assert registered_task_extensions().count(LOCAL_BROWSER_TASK_EXTENSION) == 1

        unregister_local_browser_runtime()
        assert LOCAL_BROWSER_TASK_EXTENSION not in registered_task_extensions()
    finally:
        unregister_task_extension(LOCAL_BROWSER_TASK_EXTENSION)


def test_local_browser_registration_rejects_a_foreign_provider_collision() -> None:
    unregister_task_extension(LOCAL_BROWSER_TASK_EXTENSION)
    try:
        register_task_extension(
            LOCAL_BROWSER_TASK_EXTENSION,
            LocalBrowserTaskRuntimeProvider(),
        )

        with pytest.raises(ValueError, match="already registered"):
            register_local_browser_runtime()
    finally:
        unregister_task_extension(LOCAL_BROWSER_TASK_EXTENSION)


def test_local_browser_create_requires_enablement_admin_and_valid_target(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    provider = LocalBrowserTaskRuntimeProvider()
    context, sessions = make_context(bound=True, admin=True)
    monkeypatch.delenv("XAGENT_NATIVE_BROWSER_ENABLED", raising=False)

    with pytest.raises(TaskRuntimeClientError, match="disabled") as disabled:
        provider.on_task_created(context, {})
    assert disabled.value.status_code == 403

    monkeypatch.setenv("XAGENT_NATIVE_BROWSER_ENABLED", "true")
    non_admin, _ = make_context(bound=True, admin=False)
    with pytest.raises(TaskRuntimeClientError, match="administrators"):
        provider.on_task_created(non_admin, {})

    with pytest.raises(TaskRuntimeClientError, match="explicitly selected"):
        provider.on_task_created(context, {})

    provider.on_task_created(
        context,
        {
            "pid": 100,
            "window_id": 20,
            "application": "Google Chrome",
            "title": "Inbox",
        },
    )
    assert sessions[-1].committed is True

    with pytest.raises(TaskRuntimeClientError, match="perception_mode"):
        provider.on_task_created(
            context,
            {
                "pid": 100,
                "window_id": 20,
                "application": "Google Chrome",
                "perception_mode": "hidden_dom_fallback",
            },
        )

    with pytest.raises(TaskRuntimeClientError, match="only accepts Google Chrome"):
        provider.on_task_created(
            context,
            {
                "pid": 100,
                "window_id": 20,
                "application": "Music",
            },
        )

    monkeypatch.setenv("XAGENT_NATIVE_BROWSER_APP_NAME", "Terminal")
    with pytest.raises(TaskRuntimeClientError, match="supported browser"):
        provider.on_task_created(
            context,
            {
                "pid": 100,
                "window_id": 20,
                "application": "Terminal",
            },
        )


@pytest.mark.parametrize(
    ("configuration", "message"),
    [
        ({"window_id": 20, "application": "Google Chrome"}, "requires pid"),
        (
            {"pid": None, "window_id": 20, "application": "Google Chrome"},
            "requires pid and window_id",
        ),
        (
            {"pid": 100, "application": "Google Chrome"},
            "requires pid and window_id",
        ),
        (
            {"pid": True, "window_id": 20, "application": "Google Chrome"},
            "must be integers",
        ),
        (
            {"pid": "100", "window_id": 20, "application": "Google Chrome"},
            "must be integers",
        ),
        (
            {"pid": 100, "window_id": 20.0, "application": "Google Chrome"},
            "must be integers",
        ),
    ],
)
def test_local_browser_rejects_missing_or_non_integer_window_identity(
    monkeypatch: pytest.MonkeyPatch,
    configuration: dict[str, Any],
    message: str,
) -> None:
    monkeypatch.setenv("XAGENT_NATIVE_BROWSER_ENABLED", "true")
    provider = LocalBrowserTaskRuntimeProvider()
    context, _ = make_context(bound=True, admin=True)

    with pytest.raises(TaskRuntimeClientError, match=message):
        provider.on_task_created(context, configuration)


def test_local_browser_contributes_standard_computer_tool_only_when_bound(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    monkeypatch.setenv("XAGENT_NATIVE_BROWSER_ENABLED", "true")
    provider = LocalBrowserTaskRuntimeProvider()
    unbound, _ = make_context(bound=False, admin=True)
    assert provider.build_runtime(unbound) is None

    bound, sessions = make_context(bound=True, admin=True)
    provider.on_task_created(
        bound,
        {
            "pid": 100,
            "window_id": 20,
            "application": "Google Chrome",
        },
    )
    contribution = provider.build_runtime(bound)

    assert isinstance(contribution, TaskRuntimeContribution)
    assert [tool.name for tool in contribution.tools] == ["computer"]
    assert contribution.preferred_input_modalities == ("image",)
    assert "not a browser extension or remote relay" in (contribution.environment or "")
    assert sessions[-1].closed is True


@pytest.mark.asyncio
async def test_bound_local_browser_fails_closed_after_admin_demotion(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    monkeypatch.setenv("XAGENT_NATIVE_BROWSER_ENABLED", "true")
    provider = LocalBrowserTaskRuntimeProvider()
    context, sessions = make_context(bound=True, admin=True)
    provider.on_task_created(
        context,
        {
            "pid": 100,
            "window_id": 20,
            "application": "Google Chrome",
        },
    )
    sessions[-1].user.is_admin = False

    contribution = provider.build_runtime(context)

    assert isinstance(contribution, TaskRuntimeContribution)
    assert [tool.name for tool in contribution.tools] == ["computer"]
    assert (
        await create_browser_tools(
            SimpleNamespace(
                get_browser_tools_enabled=lambda: True,
                get_task_runtime_contribution=lambda: merge_task_runtime_contributions(
                    {LOCAL_BROWSER_TASK_EXTENSION: contribution}
                ),
            )
        )
        == []
    )
    result = await contribution.tools[0].run_json_async({})
    assert result["success"] is False
    assert "authorization was revoked" in result["error"]
    assert provider.public_metadata(context) == {
        "kind": "local_browser",
        "enabled": False,
        "reason": "authorization_revoked",
        "perception_mode": "auto",
        "control_transport": "native_accessibility",
    }


@pytest.mark.asyncio
async def test_local_browser_rechecks_admin_before_environment_creation(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    monkeypatch.setenv("XAGENT_NATIVE_BROWSER_ENABLED", "true")
    provider = LocalBrowserTaskRuntimeProvider()
    context, sessions = make_context(bound=True, admin=True)
    provider.on_task_created(
        context,
        {
            "pid": 100,
            "window_id": 20,
            "application": "Google Chrome",
        },
    )
    contribution = provider.build_runtime(context)
    assert isinstance(contribution, TaskRuntimeContribution)

    sessions[-1].user.is_admin = False
    result = await contribution.tools[0].run_json_async({})

    assert result["success"] is False
    assert "no longer an Xagent administrator" in result["error"]


@pytest.mark.asyncio
async def test_local_browser_binding_suppresses_colliding_playwright_family() -> None:
    contribution = merge_task_runtime_contributions(
        {
            LOCAL_BROWSER_TASK_EXTENSION: TaskRuntimeContribution(
                tools=(SimpleNamespace(name="computer"),)
            )
        }
    )
    config = SimpleNamespace(
        get_browser_tools_enabled=lambda: True,
        get_task_runtime_contribution=lambda: contribution,
    )

    assert await create_browser_tools(config) == []


def test_unbound_local_browser_provider_does_not_suppress_playwright() -> None:
    contribution = merge_task_runtime_contributions(
        {LOCAL_BROWSER_TASK_EXTENSION: None}
    )

    assert _has_computer_runtime(contribution) is False


def test_whitespace_padded_computer_name_suppresses_playwright() -> None:
    contribution = merge_task_runtime_contributions(
        {
            "out_of_tree_browser": TaskRuntimeContribution(
                tools=(SimpleNamespace(name=" computer "),)
            )
        }
    )

    assert _has_computer_runtime(contribution) is True


@pytest.mark.asyncio
async def test_out_of_tree_computer_runtime_suppresses_playwright_family() -> None:
    contribution = merge_task_runtime_contributions(
        {
            "out_of_tree_browser": TaskRuntimeContribution(
                tools=(SimpleNamespace(name="computer"),)
            )
        }
    )
    config = SimpleNamespace(
        get_browser_tools_enabled=lambda: True,
        get_task_runtime_contribution=lambda: contribution,
    )

    assert _has_computer_runtime(contribution) is True
    assert await create_browser_tools(config) == []


def test_local_browser_public_metadata_is_bound_task_only(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    monkeypatch.setenv("XAGENT_NATIVE_BROWSER_ENABLED", "true")
    provider = LocalBrowserTaskRuntimeProvider()
    unbound, _ = make_context(bound=False, admin=True)
    bound, _ = make_context(bound=True, admin=True)

    assert provider.public_metadata(unbound) is None
    assert provider.public_metadata(bound) == {
        "kind": "local_browser",
        "enabled": True,
        "perception_mode": "auto",
        "control_transport": "native_accessibility",
    }