mirror of
https://github.com/pewdiepie-archdaemon/odysseus.git
synced 2026-10-06 15:02:20 +02:00
Alexandre Teixeira
255bff1f76
A batch whose open succeeded but whose later command failed was recorded as a failed navigation, so a following observation was wrongly labelled stale. Use the per-command rows; when the outcome cannot be determined, treat the page as unknown instead of claiming either result.
620 lines
24 KiB
Python
620 lines
24 KiB
Python
"""Wave 5A browser lifecycle: ownership, cleanup, recovery and freshness."""
|
|
|
|
import asyncio
|
|
import json
|
|
import os
|
|
import shutil
|
|
import signal
|
|
import tempfile
|
|
import time
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
|
|
from core import platform_compat
|
|
import src.agent_tools.web_tools as web_tools
|
|
from src import browser_lifecycle
|
|
from src.agent_tools.web_tools import PrivateBrowserTool
|
|
|
|
|
|
def _fake_proc(root: Path, pid: int, *, ppid: int, pgid: int, sid: int, cmdline: str, state: str = "S") -> None:
|
|
entry = root / str(pid)
|
|
entry.mkdir(parents=True)
|
|
(entry / "stat").write_text(f"{pid} (x y) {state} {ppid} {pgid} {sid} 0 0 0")
|
|
(entry / "cmdline").write_bytes(cmdline.replace(" ", "\0").encode())
|
|
|
|
|
|
@pytest.fixture
|
|
def fake_procfs(monkeypatch, tmp_path):
|
|
proc = tmp_path / "proc"
|
|
proc.mkdir()
|
|
monkeypatch.setattr(platform_compat, "PROC_ROOT", proc)
|
|
killed: list[tuple[int, int]] = []
|
|
|
|
def _kill(pid, sig):
|
|
entry = proc / str(pid)
|
|
if not entry.exists():
|
|
raise ProcessLookupError(pid)
|
|
killed.append((pid, sig))
|
|
shutil.rmtree(entry)
|
|
|
|
monkeypatch.setattr(browser_lifecycle.os, "kill", _kill)
|
|
return proc, killed
|
|
|
|
|
|
def _browser_tree(proc: Path, profile: Path, *, daemon: int = 500, extra_sid: int = 900) -> None:
|
|
_fake_proc(proc, daemon, ppid=1, pgid=daemon, sid=daemon, cmdline="/x/agent-browser-linux-x64")
|
|
_fake_proc(proc, daemon + 1, ppid=daemon, pgid=daemon + 1, sid=daemon,
|
|
cmdline=f"chrome --no-sandbox --user-data-dir={profile}")
|
|
_fake_proc(proc, daemon + 2, ppid=daemon + 1, pgid=daemon + 1, sid=daemon, cmdline="chrome --type=renderer")
|
|
_fake_proc(proc, extra_sid, ppid=1, pgid=extra_sid, sid=extra_sid, cmdline="chrome --type=renderer")
|
|
|
|
|
|
def test_runtime_root_follows_agent_browser_resolution(monkeypatch, tmp_path) -> None:
|
|
for name in ("AGENT_BROWSER_SOCKET_DIR", "XDG_RUNTIME_DIR"):
|
|
monkeypatch.delenv(name, raising=False)
|
|
assert browser_lifecycle.runtime_root({"HOME": str(tmp_path)}) == tmp_path / ".agent-browser"
|
|
assert browser_lifecycle.runtime_root(
|
|
{"HOME": str(tmp_path), "XDG_RUNTIME_DIR": "/run/x"}
|
|
) == Path("/run/x/agent-browser")
|
|
assert browser_lifecycle.runtime_root(
|
|
{"XDG_RUNTIME_DIR": "/run/x", "AGENT_BROWSER_SOCKET_DIR": "/s"}
|
|
) == Path("/s")
|
|
|
|
|
|
def test_live_daemon_owns_its_whole_session_and_nothing_else(fake_procfs, tmp_path) -> None:
|
|
proc, _ = fake_procfs
|
|
_browser_tree(proc, tmp_path / "agent-browser-chrome-a")
|
|
|
|
assert browser_lifecycle.browser_tree(500) == [500, 501, 502]
|
|
|
|
|
|
def test_orphaned_tree_is_claimed_only_through_its_browser_profile(fake_procfs, tmp_path) -> None:
|
|
proc, _ = fake_procfs
|
|
_browser_tree(proc, tmp_path / "agent-browser-chrome-a")
|
|
shutil.rmtree(proc / "500")
|
|
# A reused pid's session without an agent-browser profile is not ours.
|
|
_fake_proc(proc, 700, ppid=1, pgid=700, sid=500, cmdline="bash")
|
|
|
|
assert browser_lifecycle.browser_tree(500) == [501, 502]
|
|
|
|
|
|
def test_forced_cleanup_kills_tree_and_removes_owned_resources(fake_procfs, tmp_path) -> None:
|
|
proc, killed = fake_procfs
|
|
root = tmp_path / "rt"
|
|
root.mkdir()
|
|
profile = tmp_path / "agent-browser-chrome-a"
|
|
profile.mkdir()
|
|
(profile / "Default").mkdir()
|
|
for suffix in browser_lifecycle.RUNTIME_SUFFIXES:
|
|
(root / f"ody-k{suffix}").write_text("500")
|
|
(root / "ody-other.pid").write_text("900")
|
|
_browser_tree(proc, profile)
|
|
|
|
receipt = browser_lifecycle.force_cleanup(root, "ody-k")
|
|
|
|
assert [pid for pid, _ in killed] == [501, 502, 500]
|
|
assert all(sig == signal.SIGKILL for _, sig in killed)
|
|
assert receipt.verified and receipt.killed == 3 and receipt.removed_profiles == 1
|
|
assert not profile.exists()
|
|
assert sorted(p.name for p in root.iterdir()) == ["ody-other.pid"]
|
|
assert (proc / "900").exists()
|
|
|
|
|
|
def test_forced_cleanup_without_procfs_never_kills_unverified_processes(monkeypatch, tmp_path) -> None:
|
|
monkeypatch.setattr(platform_compat, "PROC_ROOT", tmp_path / "missing")
|
|
monkeypatch.setattr(browser_lifecycle.os, "kill", lambda *a: pytest.fail("killed"))
|
|
root = tmp_path / "rt"
|
|
root.mkdir()
|
|
(root / "ody-k.pid").write_text("4242")
|
|
|
|
live = browser_lifecycle.force_cleanup(root, "ody-k", pid_alive=lambda pid: True)
|
|
assert not live.verified and (root / "ody-k.pid").exists()
|
|
|
|
dead = browser_lifecycle.force_cleanup(root, "ody-k", pid_alive=lambda pid: False)
|
|
assert dead.verified and not (root / "ody-k.pid").exists()
|
|
|
|
|
|
class _Proc:
|
|
"""Fake agent-browser CLI client driven by a per-test behaviour."""
|
|
|
|
def __init__(self, command, kwargs, behaviour):
|
|
self.command = list(command)
|
|
self.kwargs = kwargs
|
|
self.behaviour = behaviour
|
|
self.returncode = None
|
|
self.pid = None
|
|
|
|
async def communicate(self, stdin=None):
|
|
rc, out = await self.behaviour(self.command)
|
|
self.returncode = rc
|
|
target = self.kwargs.get("stdout")
|
|
if hasattr(target, "write"):
|
|
target.write(out.encode())
|
|
return None, None
|
|
return out.encode(), b""
|
|
|
|
async def wait(self):
|
|
await self.communicate()
|
|
return self.returncode
|
|
|
|
def kill(self):
|
|
self.returncode = -9
|
|
|
|
|
|
@pytest.fixture
|
|
def browser_env(monkeypatch, tmp_path):
|
|
monkeypatch.setattr(web_tools.shutil, "which", lambda name: "/usr/bin/agent-browser")
|
|
monkeypatch.setattr(PrivateBrowserTool, "_AUTO_SCREENSHOT_ACTIONS", set())
|
|
monkeypatch.setattr("src.tool_execution.get_active_workspace", lambda: str(tmp_path))
|
|
monkeypatch.setenv("XDG_RUNTIME_DIR", str(tmp_path / "xdg"))
|
|
swept = []
|
|
monkeypatch.setattr(PrivateBrowserTool, "_terminate_owned_chrome", staticmethod(lambda env: swept.append(env)))
|
|
cleaned = []
|
|
|
|
def _cleanup(env, session_id=None):
|
|
cleaned.append(session_id)
|
|
return {"method": "forced", "verified": True}
|
|
|
|
monkeypatch.setattr(PrivateBrowserTool, "_terminate_owned_daemon", staticmethod(_cleanup))
|
|
calls = []
|
|
state = {"behaviour": None}
|
|
|
|
async def _spawn(*command, **kwargs):
|
|
calls.append(list(command))
|
|
return _Proc(command, kwargs, state["behaviour"])
|
|
|
|
monkeypatch.setattr(asyncio, "create_subprocess_exec", _spawn)
|
|
return state, calls, cleaned, swept
|
|
|
|
|
|
def _run(payload, ctx):
|
|
return asyncio.run(PrivateBrowserTool().execute(json.dumps(payload), ctx))
|
|
|
|
|
|
def test_timeout_cleans_only_this_sessions_browser(browser_env) -> None:
|
|
state, calls, cleaned, swept = browser_env
|
|
|
|
async def _hang(command):
|
|
raise asyncio.TimeoutError()
|
|
|
|
state["behaviour"] = _hang
|
|
result = _run({"action": "open", "url": "https://example.com"}, {"session_id": "s-timeout"})
|
|
|
|
assert result["exit_code"] == 1 and "timed out" in result["error"]
|
|
assert cleaned == ["s-timeout"]
|
|
assert swept == [], "a per-session timeout must not sweep other sessions' Chrome"
|
|
lifecycle = result["browser_lifecycle"]
|
|
assert lifecycle["state"] == "timed_out"
|
|
assert lifecycle["cleanup"]["verified"] is True
|
|
assert [stage["stage"] for stage in lifecycle["stages"]] == ["open", "forced_cleanup"]
|
|
assert sum(1 for call in calls if "open" in call) == 1, "remote opens are never retried"
|
|
|
|
|
|
def test_launch_failure_is_reported_and_cleaned(browser_env) -> None:
|
|
state, _, cleaned, _ = browser_env
|
|
|
|
async def _no_sandbox(command):
|
|
return 1, ("Chrome exited early (exit code: unknown) without writing DevToolsActivePort\n"
|
|
"FATAL: No usable sandbox!")
|
|
|
|
state["behaviour"] = _no_sandbox
|
|
result = _run({"action": "open", "url": "https://example.com"}, {"session_id": "s-launch"})
|
|
|
|
assert result["exit_code"] == 1
|
|
assert "could not launch the browser" in result["error"]
|
|
assert cleaned == ["s-launch"]
|
|
assert result["browser_lifecycle"]["state"] == "launch_failed"
|
|
assert result["browser_lifecycle"]["navigation_generation"] == 0
|
|
|
|
|
|
def test_observation_after_failed_navigation_is_marked_stale(browser_env) -> None:
|
|
state, _, _, _ = browser_env
|
|
|
|
async def _behaviour(command):
|
|
if command[-2:] == ["open", "https://good.example/"]:
|
|
return 0, "✓ Good\n https://good.example/\n"
|
|
if "open" in command:
|
|
return 1, "net::ERR_NAME_NOT_RESOLVED"
|
|
return 0, '- heading "Good page" [ref=e1]'
|
|
|
|
state["behaviour"] = _behaviour
|
|
ctx = {"session_id": "s-stale"}
|
|
opened = _run({"action": "open", "url": "https://good.example/"}, ctx)
|
|
assert opened["browser_lifecycle"]["navigation_generation"] == 1
|
|
assert opened["browser_lifecycle"]["page_url"] == "https://good.example/"
|
|
|
|
failed = _run({"action": "open", "url": "https://bad.example/"}, ctx)
|
|
assert failed["exit_code"] == 1
|
|
assert failed["browser_lifecycle"]["state"] == "navigation_failed"
|
|
|
|
observed = _run({"action": "snapshot"}, ctx)
|
|
assert observed["output"].startswith("[Browser lifecycle: the most recent navigation to https://bad.example/ failed")
|
|
assert "shows https://good.example/ (navigation #1)" in observed["output"]
|
|
assert observed["browser_lifecycle"]["stale_observation"] is True
|
|
|
|
_run({"action": "open", "url": "https://good.example/"}, ctx)
|
|
fresh = _run({"action": "snapshot"}, ctx)
|
|
assert not fresh["output"].startswith("[Browser lifecycle")
|
|
assert "stale_observation" not in fresh["browser_lifecycle"]
|
|
|
|
|
|
def test_sessionless_call_gets_its_own_browser_and_closes_it(browser_env, monkeypatch) -> None:
|
|
state, calls, cleaned, _ = browser_env
|
|
monkeypatch.setattr(PrivateBrowserTool, "_owned_daemon_exists", staticmethod(lambda env, session: True))
|
|
|
|
async def _ok(command):
|
|
return 0, "✓ T\n https://example.com/\n"
|
|
|
|
state["behaviour"] = _ok
|
|
first = _run({"action": "open", "url": "https://example.com/"}, {})
|
|
second = _run({"action": "open", "url": "https://example.com/"}, {})
|
|
|
|
sessions = [call[call.index("--session") + 1] for call in calls if "--session" in call]
|
|
assert all(session.startswith("ody-") for session in sessions)
|
|
assert len({sessions[0], sessions[-1]}) == 2, "sessionless calls must not share a browser"
|
|
assert any(call[-1] == "close" for call in calls)
|
|
assert first["browser_lifecycle"]["ownership"] == "ephemeral"
|
|
assert first["browser_lifecycle"]["cleanup"]["graceful_close"] is True
|
|
assert first["browser_lifecycle"]["state"] == "closed"
|
|
assert len(cleaned) == 2
|
|
assert not web_tools._ACTIVE_BROWSER_SESSIONS.intersection(sessions)
|
|
assert not any(browser_lifecycle.registered(s) for s in sessions)
|
|
assert second["exit_code"] == 0
|
|
|
|
|
|
def test_actions_on_one_session_are_serialized(browser_env) -> None:
|
|
state, _, _, _ = browser_env
|
|
active = {"now": 0, "peak": 0}
|
|
|
|
async def _slow(command):
|
|
active["now"] += 1
|
|
active["peak"] = max(active["peak"], active["now"])
|
|
await asyncio.sleep(0.02)
|
|
active["now"] -= 1
|
|
return 0, '- heading "x"'
|
|
|
|
state["behaviour"] = _slow
|
|
|
|
async def _both():
|
|
tool = PrivateBrowserTool()
|
|
await asyncio.gather(
|
|
tool.execute(json.dumps({"action": "snapshot"}), {"session_id": "s-lock"}),
|
|
tool.execute(json.dumps({"action": "snapshot"}), {"session_id": "s-lock"}),
|
|
)
|
|
|
|
asyncio.run(_both())
|
|
assert active["peak"] == 1
|
|
|
|
|
|
def test_cancellation_stops_clients_and_cleans_the_session(browser_env, monkeypatch) -> None:
|
|
state, calls, cleaned, _ = browser_env
|
|
terminated = []
|
|
|
|
async def _forever(command):
|
|
await asyncio.sleep(3600)
|
|
|
|
state["behaviour"] = _forever
|
|
monkeypatch.setattr(
|
|
PrivateBrowserTool, "_terminate_subprocess",
|
|
staticmethod(lambda proc: terminated.append(proc.command)),
|
|
)
|
|
|
|
async def _cancel():
|
|
task = asyncio.create_task(PrivateBrowserTool().execute(
|
|
json.dumps({"action": "open", "url": "https://example.com"}),
|
|
{"session_id": "s-cancel"},
|
|
))
|
|
while not calls:
|
|
await asyncio.sleep(0.01)
|
|
task.cancel()
|
|
with pytest.raises(asyncio.CancelledError):
|
|
await task
|
|
|
|
asyncio.run(_cancel())
|
|
|
|
assert terminated and terminated[0][-1] == "https://example.com"
|
|
assert cleaned == ["s-cancel"]
|
|
key = web_tools._scoped_browser_session("odysseus-ui", "s-cancel")
|
|
assert browser_lifecycle.registered(key).state == "cancelled"
|
|
|
|
|
|
def test_local_open_recovery_is_single_and_inside_the_deadline(browser_env, monkeypatch, tmp_path) -> None:
|
|
state, calls, cleaned, _ = browser_env
|
|
page = tmp_path / "page.html"
|
|
page.write_text("<title>x</title>")
|
|
|
|
async def _hang(command):
|
|
raise asyncio.TimeoutError()
|
|
|
|
state["behaviour"] = _hang
|
|
payload = {"action": "open", "url": "/workspace/page.html", "_odysseus_browser_retry": True}
|
|
result = _run(payload, {"session_id": "s-retry"})
|
|
|
|
opens = [call for call in calls if call[-1] == page.as_uri()]
|
|
assert len(opens) == 2, "a model-supplied retry flag must not change recovery"
|
|
assert result["browser_lifecycle"]["recovery_attempts"] == 1
|
|
assert cleaned == ["s-retry", "s-retry"]
|
|
|
|
calls.clear()
|
|
monkeypatch.setattr(PrivateBrowserTool, "_RECOVERY_BUDGET_S", 0)
|
|
exhausted = _run({"action": "open", "url": "/workspace/page.html", "timeout_ms": 1000}, {"session_id": "s-budget"})
|
|
assert len([call for call in calls if call[-1] == page.as_uri()]) == 1
|
|
assert "recovery_attempts" not in exhausted["browser_lifecycle"]
|
|
|
|
|
|
def test_research_reader_passes_its_timeout_to_the_browser(monkeypatch) -> None:
|
|
from src.research_navigator import ResearchNavigator
|
|
|
|
seen = {}
|
|
|
|
async def _execute(self, content, ctx):
|
|
seen.update(json.loads(content))
|
|
return {"output": "", "exit_code": 1}
|
|
|
|
monkeypatch.setattr(PrivateBrowserTool, "execute", _execute)
|
|
navigator = ResearchNavigator.__new__(ResearchNavigator)
|
|
navigator._progress = None
|
|
navigator.session_id = "r"
|
|
asyncio.run(navigator.browser_read("https://example.com", timeout=12))
|
|
|
|
assert seen["timeout_ms"] == 12000
|
|
|
|
|
|
# Real browser: open/extract a local HTML page, then prove the cleanup paths
|
|
# leave no process, profile or runtime file behind.
|
|
|
|
def _real_browser():
|
|
binary = shutil.which("agent-browser") or PrivateBrowserTool._local_agent_browser_binary()
|
|
chrome = web_tools._browser_executable_candidates()
|
|
if not binary or not chrome or not platform_compat.has_procfs():
|
|
return None
|
|
return binary, str(chrome[0])
|
|
|
|
|
|
REAL = _real_browser()
|
|
real_browser = pytest.mark.skipif(REAL is None, reason="agent-browser and Chromium are not installed")
|
|
|
|
|
|
@pytest.fixture
|
|
def real_runtime(monkeypatch, tmp_path):
|
|
# agent-browser's Unix socket path must stay under ~103 bytes.
|
|
runtime = Path(tempfile.mkdtemp(prefix="abt", dir="/tmp"))
|
|
workspace = tmp_path / "ws"
|
|
workspace.mkdir()
|
|
monkeypatch.setattr("src.tool_execution.get_active_workspace", lambda: str(workspace))
|
|
monkeypatch.setattr(web_tools.shutil, "which", lambda name: REAL[0] if name == "agent-browser" else shutil.which(name))
|
|
env = {
|
|
"XDG_RUNTIME_DIR": str(runtime),
|
|
"TMPDIR": str(runtime / "tmp"),
|
|
"AGENT_BROWSER_EXECUTABLE_PATH": REAL[1],
|
|
"AGENT_BROWSER_IDLE_TIMEOUT_MS": "60000",
|
|
# Hosts that restrict unprivileged user namespaces cannot start
|
|
# Chrome's sandbox. Test-only; production launch flags are unchanged.
|
|
"AGENT_BROWSER_ARGS": "--no-sandbox",
|
|
}
|
|
(runtime / "tmp").mkdir()
|
|
yield workspace, runtime, env
|
|
for pid_file in (runtime / "agent-browser").glob("*.pid"):
|
|
browser_lifecycle.force_cleanup(runtime / "agent-browser", pid_file.stem)
|
|
shutil.rmtree(runtime, ignore_errors=True)
|
|
|
|
|
|
def _owned_processes(runtime: Path) -> list[int]:
|
|
owned = []
|
|
for entry in platform_compat.PROC_ROOT.iterdir():
|
|
if not entry.name.isdigit():
|
|
continue
|
|
try:
|
|
text = (entry / "cmdline").read_bytes().decode(errors="replace")
|
|
except OSError:
|
|
continue
|
|
if str(runtime) in text:
|
|
owned.append(int(entry.name))
|
|
return owned
|
|
|
|
|
|
@real_browser
|
|
def test_real_local_page_open_extract_and_ephemeral_cleanup(real_runtime) -> None:
|
|
workspace, runtime, env = real_runtime
|
|
(workspace / "page.html").write_text(
|
|
"<html><head><title>Lifecycle</title></head><body><h1>Fresh heading</h1></body></html>"
|
|
)
|
|
|
|
result = _run(
|
|
{"action": "batch", "commands": [["open", "/workspace/page.html"], ["snapshot"]]},
|
|
{"subproc_env": env},
|
|
)
|
|
|
|
assert result["exit_code"] == 0, result
|
|
assert "Fresh heading" in result["output"]
|
|
lifecycle = result["browser_lifecycle"]
|
|
assert lifecycle["ownership"] == "ephemeral"
|
|
assert lifecycle["navigation_generation"] == 1
|
|
assert lifecycle["state"] == "closed" and lifecycle["page_url"] == ""
|
|
assert lifecycle["closed_page_url"].endswith("/page.html")
|
|
assert lifecycle["cleanup"]["verified"] is True
|
|
assert [stage["stage"] for stage in lifecycle["stages"]] == ["batch", "close"]
|
|
time.sleep(0.5)
|
|
assert _owned_processes(runtime) == []
|
|
assert list((runtime / "agent-browser").glob("ody-*")) == []
|
|
assert list((runtime / "tmp").glob("agent-browser-chrome-*")) == []
|
|
|
|
|
|
@real_browser
|
|
def test_real_retained_session_survives_then_forced_cleanup_leaves_nothing(real_runtime) -> None:
|
|
workspace, runtime, env = real_runtime
|
|
(workspace / "a.html").write_text("<title>A</title><h1>Alpha</h1>")
|
|
ctx = {"session_id": "retained", "subproc_env": env}
|
|
|
|
opened = _run({"action": "open", "url": "/workspace/a.html"}, ctx)
|
|
assert opened["exit_code"] == 0, opened
|
|
observed = _run({"action": "snapshot"}, ctx)
|
|
assert "Alpha" in observed["output"]
|
|
assert observed["browser_lifecycle"]["ownership"] == "retained"
|
|
assert _owned_processes(runtime), "a retained session keeps its browser"
|
|
|
|
receipt = PrivateBrowserTool._terminate_owned_daemon(dict(os.environ, **env), "retained")
|
|
|
|
assert receipt["verified"] is True and receipt["killed"] >= 2
|
|
assert receipt["removed_profiles"] == 1
|
|
assert _owned_processes(runtime) == []
|
|
assert list((runtime / "agent-browser").glob("ody-*")) == []
|
|
|
|
|
|
@real_browser
|
|
def test_real_cancellation_leaves_no_browser(real_runtime) -> None:
|
|
workspace, runtime, env = real_runtime
|
|
(workspace / "slow.html").write_text("<title>S</title><h1>Slow</h1>")
|
|
ctx = {"session_id": "cancelled", "subproc_env": env}
|
|
assert _run({"action": "open", "url": "/workspace/slow.html"}, ctx)["exit_code"] == 0
|
|
|
|
async def _cancel_wait():
|
|
task = asyncio.create_task(PrivateBrowserTool().execute(
|
|
json.dumps({"action": "wait", "timeout_ms": 30000}), ctx,
|
|
))
|
|
await asyncio.sleep(1.5)
|
|
task.cancel()
|
|
with pytest.raises(asyncio.CancelledError):
|
|
await task
|
|
|
|
asyncio.run(_cancel_wait())
|
|
time.sleep(0.5)
|
|
assert _owned_processes(runtime) == []
|
|
assert list((runtime / "agent-browser").glob("ody-*")) == []
|
|
|
|
|
|
def test_browser_mcp_call_is_bounded_and_never_replayed(monkeypatch) -> None:
|
|
from src.mcp_manager import McpManager
|
|
|
|
manager = McpManager()
|
|
calls = []
|
|
|
|
class _Session:
|
|
async def call_tool(self, name, arguments):
|
|
calls.append(name)
|
|
await asyncio.sleep(3600)
|
|
|
|
manager._sessions["builtin_browser"] = _Session()
|
|
monkeypatch.setenv("ODYSSEUS_BROWSER_MCP_CALL_TIMEOUT_S", "0.05")
|
|
|
|
result = asyncio.run(manager.call_tool(
|
|
"mcp__builtin_browser__browser_navigate", {"url": "https://example.com"}
|
|
))
|
|
|
|
assert result["exit_code"] == 1
|
|
assert "timed out after 0.05s and was not retried" in result["error"]
|
|
assert calls == ["browser_navigate"]
|
|
|
|
|
|
def test_read_url_navigates_and_extracts_in_one_observation(browser_env) -> None:
|
|
state, calls, _, _ = browser_env
|
|
|
|
async def _batch(command):
|
|
return 0, json.dumps([
|
|
{"command": ["open", "https://example.com/"], "success": True,
|
|
"result": {"title": "Example", "url": "https://example.com/final"}},
|
|
{"command": ["get", "text", "body"], "success": True,
|
|
"result": {"text": "Example body"}},
|
|
])
|
|
|
|
state["behaviour"] = _batch
|
|
result = _run({"action": "read", "url": "https://example.com/"}, {"session_id": "s-read"})
|
|
|
|
assert calls[-1][-2:] == ["batch", "--json"]
|
|
assert result["exit_code"] == 0
|
|
assert result["output"] == "Example\nhttps://example.com/final\n\nExample body"
|
|
assert result["browser_lifecycle"]["page_url"] == "https://example.com/final"
|
|
|
|
|
|
def test_read_url_without_extracted_text_is_a_failure(browser_env) -> None:
|
|
state, _, _, _ = browser_env
|
|
|
|
async def _no_text(command):
|
|
return 0, json.dumps([
|
|
{"success": True, "result": {"url": "https://example.com/"}},
|
|
{"success": False, "error": "Timeout waiting for body", "result": None},
|
|
])
|
|
|
|
state["behaviour"] = _no_text
|
|
result = _run({"action": "read", "url": "https://example.com/"}, {"session_id": "s-read-fail"})
|
|
|
|
assert result["exit_code"] == 1
|
|
assert "Timeout waiting for body" in result["error"]
|
|
assert result["browser_lifecycle"]["state"] == "navigation_failed"
|
|
|
|
|
|
@real_browser
|
|
def test_real_read_url_extracts_text_after_navigation(real_runtime) -> None:
|
|
import functools
|
|
import http.server
|
|
import threading
|
|
|
|
workspace, runtime, env = real_runtime
|
|
(workspace / "doc.html").write_text("<title>Doc</title><h1>Served heading</h1><p>Body text</p>")
|
|
handler = functools.partial(http.server.SimpleHTTPRequestHandler, directory=str(workspace))
|
|
server = http.server.ThreadingHTTPServer(("127.0.0.1", 0), handler)
|
|
thread = threading.Thread(target=server.serve_forever, daemon=True)
|
|
thread.start()
|
|
try:
|
|
url = f"http://127.0.0.1:{server.server_address[1]}/doc.html"
|
|
result = _run({"action": "read", "url": url}, {"subproc_env": env})
|
|
finally:
|
|
server.shutdown()
|
|
server.server_close()
|
|
|
|
assert result["exit_code"] == 0, result
|
|
assert result["output"].startswith(f"Doc\n{url}")
|
|
assert "Served heading" in result["output"] and "Body text" in result["output"]
|
|
assert result["browser_lifecycle"]["closed_page_url"] == url
|
|
assert result["browser_lifecycle"]["cleanup"]["verified"] is True
|
|
time.sleep(0.5)
|
|
assert _owned_processes(runtime) == []
|
|
|
|
|
|
def test_selector_read_is_an_observation_not_a_navigation() -> None:
|
|
assert PrivateBrowserTool._navigation_target(
|
|
"read", {"selector": "#main", "url": "https://elsewhere.example/"}
|
|
) == ""
|
|
assert PrivateBrowserTool._navigation_target(
|
|
"batch", {"commands": [["open", "file:///a.html"], ["snapshot"], ["open", "file:///b.html"]]}
|
|
) == "file:///b.html"
|
|
|
|
|
|
def test_batch_navigation_outcome_comes_from_its_rows(browser_env) -> None:
|
|
state, _, _, _ = browser_env
|
|
responses = {}
|
|
|
|
async def _batch(command):
|
|
if command[-2:] == ["batch", "--json"]:
|
|
return responses["batch"]
|
|
return 0, '- heading "x"'
|
|
|
|
state["behaviour"] = _batch
|
|
ctx = {"session_id": "s-batch"}
|
|
|
|
# The open succeeded; a later click failing must not mark it failed.
|
|
responses["batch"] = (1, json.dumps([
|
|
{"command": ["open", "https://a.example/"], "success": True,
|
|
"result": {"url": "https://a.example/landing"}},
|
|
{"command": ["click", "@e9"], "success": False, "error": "no element"},
|
|
]))
|
|
result = _run({"action": "batch", "commands": [["open", "https://a.example/"], ["click", "@e9"]]}, ctx)
|
|
assert result["browser_lifecycle"]["page_url"] == "https://a.example/landing"
|
|
assert result["browser_lifecycle"]["state"] == "ready"
|
|
assert "stale_observation" not in _run({"action": "snapshot"}, ctx)["browser_lifecycle"]
|
|
|
|
responses["batch"] = (1, json.dumps([
|
|
{"command": ["open", "https://b.example/"], "success": False, "error": "net::ERR"},
|
|
]))
|
|
failed = _run({"action": "batch", "commands": [["open", "https://b.example/"]]}, ctx)
|
|
assert failed["browser_lifecycle"]["state"] == "navigation_failed"
|
|
note = _run({"action": "snapshot"}, ctx)["output"]
|
|
assert "shows https://a.example/landing (navigation #1), not https://b.example/" in note
|
|
|
|
responses["batch"] = (1, "daemon connection lost")
|
|
_run({"action": "batch", "commands": [["open", "https://c.example/"]]}, ctx)
|
|
unknown = _run({"action": "snapshot"}, ctx)
|
|
assert "outcome of the most recent navigation to https://c.example/ is unknown" in unknown["output"]
|
|
assert unknown["browser_lifecycle"]["page_url"] == ""
|