feat(runtime): bind browser resources to authority

tests/test_browser_identity_transport.py

@@ -0,0 +1,158 @@
+import asyncio
+import json
+from types import SimpleNamespace
+
+import pytest
+
+from src import browser_identity as browser
+from src.agent_runtime.resources import ResourceIdentityError
+from tests.test_browser_resource_identity import producer, observed, authority
+from tests.test_runtime_resource_integration import approval_for, dispatch
+
+
+@pytest.mark.parametrize("phase", ["timeout", "cancel", "spawn_cancel"])
+async def test_client_is_killed_before_resend_deadline_without_retry(monkeypatch, phase):
+    calls = []
+    class Child:
+        returncode = None
+        killed = False
+        async def wait(self):
+            if self.killed:
+                self.returncode = -9
+                return -9
+            await asyncio.Future()
+        def kill(self): self.killed = True
+    child = Child()
+    started, release = asyncio.Event(), asyncio.Event()
+    async def spawn(*args, **kwargs):
+        calls.append(args); started.set()
+        if phase == "spawn_cancel": await release.wait()
+        return child
+    monkeypatch.setattr(browser.asyncio, "create_subprocess_exec", spawn)
+    original = asyncio.wait_for
+    async def bounded(awaitable, timeout):
+        assert timeout == browser.CLIENT_DEADLINE_S and timeout < 30
+        return await original(awaitable, .01 if phase == "timeout" else timeout)
+    monkeypatch.setattr(browser.asyncio, "wait_for", bounded)
+    task = asyncio.create_task(browser.run_client(["trusted-producer", "session", "info"], env={}, cwd="/"))
+    await started.wait()
+    if phase != "timeout": task.cancel()
+    release.set()
+    with pytest.raises((asyncio.TimeoutError, asyncio.CancelledError)): await task
+    assert child.killed and len(calls) == 1
+
+
+async def test_sidecar_allowlist_has_no_enable_mutation_or_arbitrary_cdp():
+    client = browser.CDPSidecar("ws://127.0.0.1:1234/devtools/browser/12345678-1234-1234-1234-123456789abc")
+    for method in ("Page.enable", "Runtime.evaluate", "Page.navigate", "Target.closeTarget", "Browser.close"):
+        with pytest.raises(ValueError): await client.call(method)
+
+
+@pytest.mark.parametrize("envelope", [[], None, {"id": True, "result": {}}, {"id": "1", "result": {}}, {"id": 1, "error": {}, "result": {}}])
+async def test_sidecar_rejects_malformed_identity_envelopes(monkeypatch, envelope):
+    client = browser.CDPSidecar("ws://127.0.0.1:1234/devtools/browser/12345678-1234-1234-1234-123456789abc")
+    async def send(*args): pass
+    async def receive(): return envelope
+    monkeypatch.setattr(client, "_send", send)
+    monkeypatch.setattr(client, "_message", receive)
+    with pytest.raises(ResourceIdentityError):
+        await client.call("Target.getTargets")
+
+
+@pytest.mark.parametrize("field", ["namespace", "runtimeError", "restoreKey"])
+async def test_missing_nullable_lifecycle_fields_are_not_valid_observations(producer, field):
+    record = await observed(producer)
+    info = await record.command("session", "info")
+    del (info["runtime"] if field == "restoreKey" else info)[field]
+    with pytest.raises(ResourceIdentityError): browser.daemon_observation(record, info)
+
+
+async def test_observation_cancellation_while_waiting_for_lock_invalidates_session(producer):
+    record = await observed(producer)
+    await record.lock.acquire()
+    task = asyncio.create_task(browser.observe_registered(record))
+    await asyncio.sleep(0)
+    task.cancel()
+    with pytest.raises(asyncio.CancelledError): await task
+    record.lock.release()
+    assert record.session is None and record.pages == ()
+
+
+@pytest.mark.parametrize("args", [{"action": "click", "page": "t1"}, {"action": "batch", "commands": [["click", "e1"]]}])
+async def test_central_dispatch_cannot_bypass_page_denial(producer, args):
+    await observed(producer)
+    current = authority()
+    producer.calls.clear(); producer.cdp_calls.clear()
+    _, result = await dispatch(current, "private_browser", json.dumps(args))
+    assert result["failure_kind"] == browser.PAGE_FAILURE and result["executed"] is False
+    assert not producer.calls and not producer.cdp_calls
+
+
+@pytest.mark.parametrize("replacement", ["browser", "daemon"])
+async def test_exact_approval_revalidates_before_claim(producer, replacement):
+    record = await observed(producer)
+    current = authority()
+    content = '{"action":"session_info"}'
+    approval = approval_for(current, "private_browser", content)
+    if replacement == "daemon":
+        producer.pid += 1
+    else:
+        record._endpoint = "ws://127.0.0.1:1234/devtools/browser/87654321-1234-1234-1234-123456789abc"
+    _, result = await dispatch(current, "private_browser", content, approval)
+    assert result["exit_code"] == 1 and not approval._claimed
+    assert record.session is None and record.pages == ()
+
+
+async def test_metadata_revalidation_never_auto_launches_or_calls_get_cdp_url(producer):
+    await observed(producer)
+    current = authority()
+    producer.calls.clear()
+    _, result = await dispatch(current, "private_browser", '{"action":"session_info"}')
+    assert result["exit_code"] == 0
+    assert producer.calls and all(command == ("session", "info") for command in producer.calls)
+
+
+@pytest.mark.parametrize("status", ["EOF", "connection reset", "EAGAIN", "read timeout"])
+async def test_page_failures_never_enter_producer_internal_retry_path(producer, status, monkeypatch):
+    async def forbidden(*args, **kwargs):
+        pytest.fail("Producer retry hazard reached: " + status)
+    monkeypatch.setattr(browser, "run_client", forbidden)
+    producer.calls.clear()
+    from src.agent_tools.web_tools import PrivateBrowserTool
+    result = await PrivateBrowserTool().execute('{"action":"wait","page":"t1","timeout_ms":120000}', {})
+    assert result["executed"] is False and result["retryable"] is False
+    assert producer.calls == []
+
+
+async def test_page_scoped_child_still_cannot_execute_even_matching_observation(producer):
+    await observed(producer)
+    from dataclasses import replace
+    parent = replace(authority(), browser_sessions=())
+    child = parent.intersect(authority())
+    _, result = await dispatch(child, "private_browser", '{"action":"click","page":"t1","ref":"e1"}')
+    assert result["failure_kind"] == browser.PAGE_FAILURE and result["executed"] is False
+
+
+async def test_observed_url_or_alias_change_is_not_resource_authority(producer):
+    record = await observed(producer)
+    from dataclasses import replace
+    original = record.pages[0]
+    metadata = replace(original, resolved_alias="t99", observed_url="https://different.example")
+    assert original.authority_key() == metadata.authority_key()
+    metadata.validate()
+
+
+def test_raw_global_playwright_and_native_backend_are_not_substitutable():
+    from src.agent_runtime.resources import ExternalResource
+    from src.agent_runtime.authority import ExactOperation
+    assert not browser.native_browser(ExactOperation.normalize("private_browser", '{"action":"session_info"}'),
+        ExternalResource("mcp", "endpoint", "server", "tool", "epoch"))
+
+
+@pytest.mark.parametrize("tool", ["browser_click", "browser_snapshot", "browser_evaluate", "browser_navigate", "browser_run_code"])
+async def test_raw_mcp_browser_execution_cannot_evade_disabled_page_contract(tool):
+    from src.agent_runtime.authority import RequestAuthority, OperationGrant
+    name = "mcp__builtin_browser__" + tool
+    current = RequestAuthority("request", "alice", "thread", "", (OperationGrant(name),))
+    _, result = await dispatch(current, name, '{}')
+    assert result["failure_kind"] == browser.PAGE_FAILURE and result["executed"] is False