The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
test(browser): port hybrid routing, orphan reaper, profile scope and Lightpanda tests to browser_session
Teknium4416f6df89ea
diff --git a/tests/tools/test_browser_hybrid_routing.py b/tests/tools/test_browser_hybrid_routing.pyindex b0e0b6659f1..e6fe4d78aea 100644--- a/tests/tools/test_browser_hybrid_routing.py+++ b/tests/tools/test_browser_hybrid_routing.py@@ -2,78 +2,85 @@When a cloud browser provider (Browserbase / Browser-Use / Firecrawl) isconfigured globally, ``browser.auto_local_for_private_urls`` (default True)-causes ``browser_navigate`` to transparently spawn a local Chromium sidecar-for URLs whose host resolves to a private/loopback/LAN address, while-public URLs continue to hit the cloud session in the same conversation.+routes a ``browser_exec`` call whose code carries a URL whose host resolves to a+private/loopback/LAN address to a local Chromium sidecar (the ``::local`` session+key), while public URLs continue to hit the cloud session in the same conversation.-These tests cover the routing decision layer — session_key selection,-sidecar detection, last-active-session tracking, and the config toggle.-The downstream session creation is covered by test_browser_cloud_fallback.py.+These tests cover the routing decision layer — session_key selection, sidecar+detection, task ownership, and sidecar-aware cleanup. The downstream session+creation is covered by test_browser_cloud_fallback.py."""+from types import SimpleNamespacefrom unittest.mock import Mockimport pytest-from tools import browser_tool-from tools import browser_tool_lifecycle as bt_lifecycle-from tools import browser_tool_session as bt_session-from tools import browser_tool_cloud as bt_cloud+from tools import browser_launcher+from tools import browser_session as bs+from tools import browser_session_cloud as bs_cloud+from tools import browser_session_lifecycle as lifecycle+from tools import browser_use_cli as bu++_LOCAL_CDP = "ws://127.0.0.1:9444/devtools/browser/sidecar"@pytest.fixture(autouse=True)def _reset_routing_state(monkeypatch):"""Clear module-level caches so each test starts clean."""- monkeypatch.setattr(browser_tool, "_active_sessions", {})- monkeypatch.setattr(browser_tool, "_last_active_session_key", {})- monkeypatch.setattr(browser_tool, "_cached_cloud_provider", None)- monkeypatch.setattr(browser_tool, "_cloud_provider_resolved", False)- monkeypatch.setattr(browser_tool, "_auto_local_for_private_urls_resolved", False)- monkeypatch.setattr(browser_tool, "_cached_auto_local_for_private_urls", True)- monkeypatch.setattr("tools.browser_tool_lifecycle._start_browser_cleanup_thread", lambda: None)- monkeypatch.setattr("tools.browser_tool_lifecycle._update_session_activity", lambda t: None)- # Default: no CDP override, no Camofox- monkeypatch.setattr("tools.browser_tool_cdp._get_cdp_override", lambda: None)- monkeypatch.setattr(browser_tool, "_is_camofox_mode", lambda: False)+ monkeypatch.setattr(bs, "_active_sessions", {})+ monkeypatch.setattr("tools.browser_session_lifecycle.start_cleanup_thread", lambda: None)+ monkeypatch.setattr("tools.browser_session_lifecycle.update_session_activity", lambda t: None)+ monkeypatch.setattr(bs_cloud, "auto_local_for_private_urls", lambda: True)+ # Default: no CDP override+ monkeypatch.setattr("tools.browser_session_cdp.get_cdp_override", lambda: None)+ monkeypatch.setattr("tools.browser_session_cdp.get_cdp_override_raw", lambda: "")+ monkeypatch.setattr(bs, "browser_in_sandbox", lambda: False)+ monkeypatch.setattr(browser_launcher, "launch_chromium",+ lambda key, **kw: (SimpleNamespace(cdp_url=_LOCAL_CDP, pid=4242), None))+++def _exec_session_key(task_id, url: str) -> str:+ """The session key browser_exec routes a call carrying ``url`` to."""+ verdict = bu._code_url_verdict(f'new_tab("{url}")')+ return bu._backend_cache_key(task_id, sidecar=verdict.local_sidecar)class TestNavigationSessionKey:- """Tests for _navigation_session_key URL-based routing decisions."""+ """URL-based routing decisions for a browser_exec call."""def test_public_url_uses_bare_task_id(self, monkeypatch):"""Public URL with cloud provider configured → bare task_id (cloud)."""- monkeypatch.setattr(bt_cloud, "_get_cloud_provider", lambda: Mock())- key = browser_tool._navigation_session_key("default", "https://github.com/x/y")+ monkeypatch.setattr(bs_cloud, "get_cloud_provider", lambda: Mock())+ key = _exec_session_key("default", "https://github.com/x/y")assert key == "default"def test_localhost_routes_to_local_sidecar(self, monkeypatch):"""``localhost`` URL → ``::local`` suffix when cloud configured + flag on."""- monkeypatch.setattr(bt_cloud, "_get_cloud_provider", lambda: Mock())- key = browser_tool._navigation_session_key("default", "http://localhost:3000/")+ monkeypatch.setattr(bs_cloud, "get_cloud_provider", lambda: Mock())+ key = _exec_session_key("default", "http://localhost:3000/")assert key == "default::local"def test_rfc1918_lan_routes_to_local_sidecar(self, monkeypatch):- monkeypatch.setattr(bt_cloud, "_get_cloud_provider", lambda: Mock())- key = browser_tool._navigation_session_key("default", "http://192.168.1.50:8000/")+ monkeypatch.setattr(bs_cloud, "get_cloud_provider", lambda: Mock())+ key = _exec_session_key("default", "http://192.168.1.50:8000/")assert key == "default::local"def test_none_task_id_defaults(self, monkeypatch):- """``None`` task_id resolves to 'default'."""- monkeypatch.setattr(bt_cloud, "_get_cloud_provider", lambda: Mock())- key = browser_tool._navigation_session_key(None, "http://localhost:3000/")- assert key == "default::local"+ """``None`` task_id resolves to browser_exec's default key."""+ monkeypatch.setattr(bs_cloud, "get_cloud_provider", lambda: Mock())+ key = _exec_session_key(None, "http://localhost:3000/")+ assert key == "browser-exec-default::local"class TestSessionKeyHelpers:- def test_last_session_key_drops_mismatched_owner_metadata(self, monkeypatch):+ def test_task_lookup_ignores_another_tasks_sidecar(self, monkeypatch):"""Explicit ownership metadata prevents retargeting to another task's session."""- last_active = {"default": "other-task::local"}- monkeypatch.setattr(browser_tool, "_last_active_session_key", last_active)monkeypatch.setattr(- browser_tool,+ bs,"_active_sessions",{"other-task::local": {@@ -84,12 +91,11 @@ class TestSessionKeyHelpers:},)- assert browser_tool._last_session_key("default") == "default"- assert last_active == {}+ assert bs.session_for_task("default") == {}class TestHybridRoutingSessionCreation:- """_get_session_info must force a local session when the key carries ``::local``."""+ """get_session_info must force a local session when the key carries ``::local``."""def test_local_sidecar_key_skips_cloud_provider(self, monkeypatch):"""A ``::local``-suffixed key creates a local session even when cloud is set."""@@ -99,14 +105,14 @@ class TestHybridRoutingSessionCreation:"bb_session_id": "bb_xxx","cdp_url": "wss://fake.browserbase.com/ws",}- monkeypatch.setattr(bt_cloud, "_get_cloud_provider", lambda: provider)- monkeypatch.setattr("tools.browser_tool_cdp._ensure_cdp_supervisor", lambda t: None)+ monkeypatch.setattr(bs_cloud, "get_cloud_provider", lambda: provider)+ monkeypatch.setattr("tools.browser_session_cdp.ensure_cdp_supervisor", lambda t: None)- session = bt_session._get_session_info("default::local")+ session = bs.get_session_info("default::local")assert provider.create_session.call_count == 0assert session["bb_session_id"] is None- assert session["cdp_url"] is None+ assert session["cdp_url"] == _LOCAL_CDPassert session["features"]["local"] is Trueassert session["session_key"] == "default::local"assert session["owner_task_id"] == "default"@@ -119,11 +125,11 @@ class TestHybridRoutingSessionCreation:"bb_session_id": "bb_123","cdp_url": "wss://real.browserbase.com/ws",}- monkeypatch.setattr(bt_cloud, "_get_cloud_provider", lambda: provider)- monkeypatch.setattr("tools.browser_tool_cdp._ensure_cdp_supervisor", lambda t: None)- monkeypatch.setattr("tools.browser_tool_cdp._resolve_cdp_override", lambda u: u)+ monkeypatch.setattr(bs_cloud, "get_cloud_provider", lambda: provider)+ monkeypatch.setattr("tools.browser_session_cdp.ensure_cdp_supervisor", lambda t: None)+ monkeypatch.setattr("tools.browser_session_cdp.resolve_cdp_override", lambda u: u)- session = bt_session._get_session_info("default")+ session = bs.get_session_info("default")assert provider.create_session.call_count == 1assert session["bb_session_id"] == "bb_123"@@ -141,24 +147,19 @@ class TestCleanupHybridSessions:def _fake_cleanup_one(key):reaped.append(key)- monkeypatch.setattr(bt_lifecycle, "_cleanup_single_browser_session", _fake_cleanup_one)+ monkeypatch.setattr(lifecycle, "cleanup_single_session", _fake_cleanup_one)monkeypatch.setattr(- browser_tool,+ bs,"_active_sessions",{"default": {"session_name": "cloud_sess"},"default::local": {"session_name": "local_sess"},},)- monkeypatch.setattr(- browser_tool, "_last_active_session_key", {"default": "default::local"}- )- bt_lifecycle.cleanup_browser("default")+ lifecycle.cleanup_browser("default")assert set(reaped) == {"default", "default::local"}- # last-active pointer dropped- assert "default" not in browser_tool._last_active_session_keydef test_cleanup_sidecar_directly_keeps_primary(self, monkeypatch):@@ -168,22 +169,16 @@ class TestCleanupHybridSessions:def _fake_cleanup_one(key):reaped.append(key)- monkeypatch.setattr(bt_lifecycle, "_cleanup_single_browser_session", _fake_cleanup_one)+ monkeypatch.setattr(lifecycle, "cleanup_single_session", _fake_cleanup_one)monkeypatch.setattr(- browser_tool,+ bs,"_active_sessions",{"default": {"session_name": "cloud_sess"},"default::local": {"session_name": "local_sess"},},)- monkeypatch.setattr(- browser_tool, "_last_active_session_key", {"default": "default::local"}- )- bt_lifecycle.cleanup_browser("default::local")+ lifecycle.cleanup_browser("default::local")assert reaped == ["default::local"]- # The cleaned sidecar must not remain the recorded owner; otherwise a- # later click/snapshot could resurrect it instead of using the primary.- assert "default" not in browser_tool._last_active_session_keydiff --git a/tests/tools/test_browser_lightpanda.py b/tests/tools/test_browser_lightpanda.pyindex 21e8d601e2f..9e718ac8d40 100644--- a/tests/tools/test_browser_lightpanda.py+++ b/tests/tools/test_browser_lightpanda.py@@ -1,450 +1,108 @@-"""Tests for Lightpanda engine support in browser_tool.py."""+"""Tests for the Lightpanda engine (``browser.engine: lightpanda``) in the browser session layer."""import jsonimport osfrom unittest.mock import MagicMock, patchimport pytest-from tools import browser_tool_lifecycle as bt_lifecycle-from tools import browser_tool_lightpanda_fallback as bt_lightpanda_fallback-from tools import browser_tool_session as bt_session-from tools import browser_tool_install as bt_install-from tools import browser_tool_cloud as bt_cloud-from tools import browser_tool_cdp as bt_cdp+from tools import browser_launcher as launcher+from tools import browser_lightpanda as lp+from tools import browser_session as bs+from tools import browser_session_cdp as bs_cdp+from tools import browser_session_cloud as bs_cloud+from tools import browser_session_lifecycle as lifecycle# ---------------------------------------------------------------------------# Helpers# ----------------------------------------------------------------------------def _reset_engine_cache():- """Reset the module-level engine cache so tests start clean."""- import tools.browser_tool as bt- bt._cached_browser_engine = None- bt._browser_engine_resolved = False--@pytest.fixture(autouse=True)def _clean_engine_cache():- """Reset engine cache before and after each test."""- _reset_engine_cache()+ """Reset the per-profile config memo (engine included) before and after each test."""+ bs_cloud.reset_caches()yield- _reset_engine_cache()+ bs_cloud.reset_caches()# ----------------------------------------------------------------------------# _get_browser_engine+# get_browser_engine# ---------------------------------------------------------------------------class TestGetBrowserEngine:- """Test engine resolution from config and env vars."""+ """Test engine resolution from config."""def test_config_lightpanda(self):"""Config browser.engine = 'lightpanda' is respected."""- from tools.browser_tool_cloud import _get_browser_enginecfg = {"browser": {"engine": "lightpanda"}}with patch("hermes_cli.config.read_raw_config", return_value=cfg):- assert _get_browser_engine() == "lightpanda"--+ assert bs_cloud.get_browser_engine() == "lightpanda"# ----------------------------------------------------------------------------# _should_inject_engine+# Lightpanda never needs local Chromium# ----------------------------------------------------------------------------class TestShouldInjectEngine:- """Test whether --engine flag is injected based on mode."""-- def test_auto_never_injects(self):- from tools.browser_tool_cloud import _should_inject_engine- assert _should_inject_engine("auto") is False-- def test_lightpanda_injects_in_local_mode(self):- from tools.browser_tool_cloud import _should_inject_engine- with patch("tools.browser_tool._is_camofox_mode", return_value=False), \- patch("tools.browser_tool_cdp._get_cdp_override", return_value=""), \- patch("tools.browser_tool_cloud._get_cloud_provider", return_value=None):- assert _should_inject_engine("lightpanda") is True-- def test_chrome_injects_in_local_mode(self):- from tools.browser_tool_cloud import _should_inject_engine- with patch("tools.browser_tool._is_camofox_mode", return_value=False), \- patch("tools.browser_tool_cdp._get_cdp_override", return_value=""), \- patch("tools.browser_tool_cloud._get_cloud_provider", return_value=None):- assert _should_inject_engine("chrome") is True-- def test_no_inject_in_camofox_mode(self):- from tools.browser_tool_cloud import _should_inject_engine- with patch("tools.browser_tool._is_camofox_mode", return_value=True):- assert _should_inject_engine("lightpanda") is False-- def test_no_inject_with_cdp_override(self):- from tools.browser_tool_cloud import _should_inject_engine- with patch("tools.browser_tool._is_camofox_mode", return_value=False), \- patch("tools.browser_tool_cdp._get_cdp_override_raw", return_value="ws://localhost:9222"):- assert _should_inject_engine("lightpanda") is False---# ----------------------------------------------------------------------------# _needs_lightpanda_fallback-# -----------------------------------------------------------------------------class TestNeedsLightpandaFallback:- """Test fallback detection for Lightpanda results."""-- def test_non_lightpanda_never_falls_back(self):- from tools.browser_tool_lightpanda_fallback import _needs_lightpanda_fallback- result = {"success": False, "error": "timeout"}- assert _needs_lightpanda_fallback("chrome", "open", result) is False- assert _needs_lightpanda_fallback("auto", "open", result) is False-- def test_failed_command_triggers_fallback(self):- from tools.browser_tool_lightpanda_fallback import _needs_lightpanda_fallback- result = {"success": False, "error": "page.goto: Timeout"}- assert _needs_lightpanda_fallback("lightpanda", "open", result) is True--- def test_empty_snapshot_triggers_fallback(self):- from tools.browser_tool_lightpanda_fallback import _needs_lightpanda_fallback- result = {"success": True, "data": {"snapshot": ""}}- assert _needs_lightpanda_fallback("lightpanda", "snapshot", result) is True--- def test_unknown_command_does_not_trigger_fallback(self):- """Commands not in the whitelist should not trigger fallback."""- from tools.browser_tool_lightpanda_fallback import _needs_lightpanda_fallback- result = {"success": False, "error": "nope"}- assert _needs_lightpanda_fallback("lightpanda", "some_future_cmd", result) is False---# ----------------------------------------------------------------------------# Config integration-# ---------------------------------------------------------------------------+class _FakeServer:+ def __init__(self, port=4321, alive=True):+ self.port = port+ self.cdp_url = f"http://127.0.0.1:{port}"+ self._alive = alive+ def is_alive(self):+ return self._aliveclass TestLightpandaRequirements:- """Lightpanda should expose browser tools without local Chromium."""-- def test_lightpanda_local_mode_does_not_require_chromium(self):-- with patch("tools.browser_tool._is_camofox_mode", return_value=False), \- patch("tools.browser_tool_cdp._get_cdp_override", return_value=""), \- patch("tools.browser_tool_install._find_agent_browser", return_value="/usr/bin/agent-browser"), \- patch("tools.browser_tool_cloud._get_cloud_provider", return_value=None), \- patch("tools.browser_tool_cloud._get_browser_engine", return_value="lightpanda"), \- patch("tools.browser_tool_install._chromium_installed", return_value=False):- assert bt_install.check_browser_requirements() is True-- def test_chrome_local_mode_still_requires_chromium(self):-- with patch("tools.browser_tool._is_camofox_mode", return_value=False), \- patch("tools.browser_tool_cdp._get_cdp_override", return_value=""), \- patch("tools.browser_tool_install._find_agent_browser", return_value="/usr/bin/agent-browser"), \- patch("tools.browser_tool_cloud._get_cloud_provider", return_value=None), \- patch("tools.browser_tool_cloud._get_browser_engine", return_value="auto"), \- patch("tools.browser_tool_install._chromium_installed", return_value=False):- assert bt_install.check_browser_requirements() is False---# ----------------------------------------------------------------------------# cleanup_all_browsers resets engine cache-# -------------------------------------------------------------------------------# ----------------------------------------------------------------------------# Chrome fallback behavior-# -----------------------------------------------------------------------------class TestChromeFallback:- """Chrome fallback must hand off from Lightpanda without leaking engine policy."""--- def test_chrome_fallback_injects_required_sandbox_args(self, tmp_path):-- captured_envs = []- mock_proc = MagicMock()- mock_proc.wait.return_value = None- mock_proc.returncode = 1-- def capture_popen(_cmd, **kwargs):- captured_envs.append(kwargs["env"])- return mock_proc-- # Keep the fallback's socket dir under this test's private tmp_path.- # Using the real shared tmpdir raced concurrent orphan reapers from- # sibling pytest processes (atexit _emergency_cleanup_all_sessions),- # which rmtree'd the fresh pidless dir mid-command — the CI flake- # this test kept hitting before the reaper grace fix.- with patch("tools.browser_tool_session._run_browser_command", return_value={- "success": True, "data": {"url": "https://example.com/"}- }), \- patch("tools.browser_tool._socket_safe_tmpdir", return_value=str(tmp_path)), \- patch("tools.browser_tool_install._find_agent_browser", return_value="/usr/bin/agent-browser"), \- patch("tools.browser_tool_install._chromium_installed", return_value=True), \- patch("tools.browser_tool_session._needs_chromium_sandbox_bypass", return_value=True), \- patch("subprocess.Popen", side_effect=capture_popen):- result = bt_lightpanda_fallback._run_chrome_fallback_command(- "task1", "screenshot", [], timeout=30- )-- assert result["success"] is False- assert captured_envs- assert all(- env.get("AGENT_BROWSER_ARGS") == "--no-sandbox,--disable-dev-shm-usage"- for env in captured_envs- )---# ----------------------------------------------------------------------------# fallback warning annotation-# -----------------------------------------------------------------------------class TestLightpandaFallbackWarning:- """Verify Chrome fallback results are annotated for users."""-- def test_fallback_result_gets_user_visible_warning(self):- from tools.browser_tool_lightpanda_fallback import _annotate_lightpanda_fallback-- result = {"success": True, "data": {"snapshot": "- heading \"Hello\" [ref=e1]"}}- annotated = _annotate_lightpanda_fallback(- result,- "Lightpanda returned an empty/too-short snapshot; retried with Chrome.",- )-- assert annotated["browser_engine"] == "chrome"- assert "Lightpanda fallback" in annotated["fallback_warning"]- assert annotated["browser_engine_fallback"] == {- "from": "lightpanda",- "to": "chrome",- "reason": "Lightpanda returned an empty/too-short snapshot; retried with Chrome.",- }- assert annotated["data"]["fallback_warning"] == annotated["fallback_warning"]- assert annotated["data"]["browser_engine"] == "chrome"--- def test_browser_navigate_surfaces_fallback_warning(self):- import json- import tools.browser_tool as bt+ """Lightpanda should serve browser sessions without local Chromium."""++ def _local(self, monkeypatch, engine_lightpanda):+ monkeypatch.setattr("tools.browser_session_real_profile.real_profile_cdp", lambda: (None, None))+ monkeypatch.setattr(lp, "using_lightpanda_engine", lambda: engine_lightpanda)+ monkeypatch.setattr(bs_cloud, "is_local_backend", lambda: True)+ monkeypatch.setattr(bs, "browser_in_sandbox", lambda: False)+ monkeypatch.setattr(launcher, "chromium_ready", lambda: (False, "Chromium browser is missing."))+ monkeypatch.setattr(lp, "launch_lightpanda", lambda name, **kw: (_FakeServer(), None))++ def test_lightpanda_local_mode_does_not_require_chromium(self, monkeypatch):+ self._local(monkeypatch, engine_lightpanda=True)+ monkeypatch.setattr(launcher, "launch_chromium",+ lambda *a, **kw: pytest.fail("Lightpanda must not launch Chromium"))+ info = bs._create_local_session("task-1")+ assert info["features"] == {"local": True, "lightpanda": True}- result = bt_lightpanda_fallback._annotate_lightpanda_fallback(- {"success": True, "data": {"title": "Fallback OK", "url": "https://example.com/"}},- "synthetic Lightpanda failure; retried with Chrome.",- )+ def test_chrome_local_mode_still_requires_chromium(self, monkeypatch):+ self._local(monkeypatch, engine_lightpanda=False)+ with pytest.raises(RuntimeError, match="Chromium browser is missing"):+ bs._create_local_session("task-1")- with patch("tools.browser_tool_cloud._is_local_backend", return_value=True), \- patch("tools.browser_tool_cloud._get_cloud_provider", return_value=None), \- patch("tools.browser_tool_session._get_session_info", return_value={- "session_name": "test", "_first_nav": False, "features": {"local": True, "proxies": True}- }), \- patch("tools.browser_tool_session._run_browser_command", side_effect=[- result,- {"success": True, "data": {"snapshot": "- heading \"Fallback OK\" [ref=e1]", "refs": {"e1": {}}}},- ]):- response = json.loads(bt.browser_navigate("https://example.com", task_id="warn-test"))-- assert response["success"] is True- assert response["browser_engine"] == "chrome"- assert "Lightpanda fallback" in response["fallback_warning"]- assert response["browser_engine_fallback"]["from"] == "lightpanda"- assert response["browser_engine_fallback"]["to"] == "chrome"- bt._last_active_session_key.pop("warn-test", None)--- def test_browser_vision_lightpanda_response_has_structured_fallback(self, tmp_path):- import json- import tools.browser_tool as bt-- chrome_shot = tmp_path / "chrome-structured.png"- chrome_shot.write_bytes(b"\x89PNG" + b"0" * 128)-- class _Msg:- content = "Example Domain screenshot"-- class _Choice:- message = _Msg()-- class _Response:- choices = [_Choice()]-- with patch("tools.browser_tool_cloud._get_browser_engine", return_value="lightpanda"), \- patch("tools.browser_tool_cloud._should_inject_engine", return_value=True), \- patch("tools.browser_tool_lightpanda_fallback._chrome_fallback_screenshot", return_value={- "success": True, "data": {"path": str(chrome_shot)}- }), \- patch("hermes_constants.get_hermes_dir", return_value=tmp_path), \- patch("agent.auxiliary_client.call_llm", return_value=_Response()):- response = json.loads(bt.browser_vision("what is this?", task_id="vision-structured"))-- assert response["success"] is True- assert response["browser_engine"] == "chrome"- assert response["browser_engine_fallback"]["from"] == "lightpanda"- assert response["browser_engine_fallback"]["to"] == "chrome"- assert response["browser_engine_fallback"]["reason"]# ----------------------------------------------------------------------------# _engine_override parameter+# Hybrid ::local sidecar honours the engine# ---------------------------------------------------------------------------class TestEngineOverride:- """Verify _engine_override bypasses the cached engine."""-- @patch("tools.browser_tool_session._get_session_info")- @patch("tools.browser_tool_install._find_agent_browser", return_value="/usr/bin/agent-browser")- @patch("tools.browser_tool_cloud._is_local_mode", return_value=True)- @patch("tools.browser_tool_install._chromium_installed", return_value=True)- @patch("tools.browser_tool_cloud._get_cloud_provider", return_value=None)- @patch("tools.browser_tool_cdp._get_cdp_override", return_value="")- @patch("tools.browser_tool._is_camofox_mode", return_value=False)- def test_override_prevents_engine_injection(- self, _camofox, _cdp, _cloud, _chromium, _local, _find, _session- ):- """When _engine_override='auto', --engine flag is NOT injected."""- import tools.browser_tool as bt-- # Set the global cache to lightpanda- bt._cached_browser_engine = "lightpanda"- bt._browser_engine_resolved = True-- _session.return_value = {"session_name": "test-sess"}-- # Track the cmd_parts that Popen receives- captured_cmds = []- mock_proc = MagicMock()- mock_proc.wait.return_value = None- mock_proc.returncode = 0-- def capture_popen(cmd, **kwargs):- captured_cmds.append(cmd)- return mock_proc-- # We need to mock the file operations too- with patch("subprocess.Popen", side_effect=capture_popen), \- patch("os.open", return_value=99), \- patch("os.close"), \- patch("os.unlink"), \- patch("os.makedirs"), \- patch("builtins.open", MagicMock(return_value=MagicMock(- __enter__=MagicMock(return_value=MagicMock(read=MagicMock(return_value='{"success": true, "data": {}}'))),- __exit__=MagicMock(return_value=False),- ))), \- patch("tools.interrupt.is_interrupted", return_value=False), \- patch("tools.browser_tool_lifecycle._write_owner_pid"):- bt_session._run_browser_command("task1", "snapshot", [], _engine_override="auto")-- # Should NOT contain "--engine" since override is "auto"- assert len(captured_cmds) == 1- assert "--engine" not in captured_cmds[0]-- @patch("tools.browser_tool_session._get_session_info")- @patch("tools.browser_tool_install._find_agent_browser", return_value="/usr/bin/agent-browser")- @patch("tools.browser_tool_cloud._is_local_mode", return_value=True)- @patch("tools.browser_tool_install._chromium_installed", return_value=True)- @patch("tools.browser_tool_cloud._get_cloud_provider", return_value=None)- @patch("tools.browser_tool_cdp._get_cdp_override", return_value="")- @patch("tools.browser_tool._is_camofox_mode", return_value=False)- def test_no_override_uses_cached_engine(- self, _camofox, _cdp, _cloud, _chromium, _local, _find, _session- ):- """Lightpanda gets neither auto-injected nor inherited Chrome arguments."""- import tools.browser_tool as bt-- bt._cached_browser_engine = "lightpanda"- bt._browser_engine_resolved = True-- _session.return_value = {"session_name": "test-sess"}-- captured_cmds = []- captured_envs = []- mock_proc = MagicMock()- mock_proc.wait.return_value = None- mock_proc.returncode = 0-- def capture_popen(cmd, **kwargs):- captured_cmds.append(cmd)- captured_envs.append(kwargs["env"])- return mock_proc-- # Return a substantive snapshot so the LP fallback does NOT trigger.- mock_stdout = '{"success": true, "data": {"snapshot": "- heading \\"Hello\\" [ref=e1]", "refs": {"e1": {}}}}'- with patch("subprocess.Popen", side_effect=capture_popen), \- patch("os.open", return_value=99), \- patch("os.close"), \- patch("os.unlink"), \- patch("os.makedirs"), \- patch("builtins.open", MagicMock(return_value=MagicMock(- __enter__=MagicMock(return_value=MagicMock(read=MagicMock(return_value=mock_stdout))),- __exit__=MagicMock(return_value=False),- ))), \- patch("tools.interrupt.is_interrupted", return_value=False), \- patch("tools.browser_tool_session._needs_chromium_sandbox_bypass", return_value=True), \- patch("tools.browser_tool_lifecycle._write_owner_pid"), \- patch.dict(os.environ, {}, clear=False):- # AppArmor/root detection would normally auto-inject Chromium args.- bt_session._run_browser_command("task1", "snapshot", [])-- # User-supplied current and legacy Chromium knobs must also be removed.- with patch.dict(os.environ, {- "AGENT_BROWSER_ARGS": "--no-sandbox",- "AGENT_BROWSER_CHROME_FLAGS": "--disable-dev-shm-usage",- }):- bt_session._run_browser_command("task1", "snapshot", [])-- assert len(captured_cmds) == 2- for command, environment in zip(captured_cmds, captured_envs):- assert "--engine" in command- engine_idx = command.index("--engine")- assert command[engine_idx + 1] == "lightpanda"- assert "AGENT_BROWSER_ARGS" not in environment- assert "AGENT_BROWSER_CHROME_FLAGS" not in environment-- def test_hybrid_local_sidecar_injects_engine_even_with_cloud_provider(self):- """A task::local sidecar is local even when global cloud config exists."""- import tools.browser_tool as bt-- bt._cached_browser_engine = "lightpanda"- bt._browser_engine_resolved = True- captured_cmds = []++ def test_hybrid_local_sidecar_uses_lightpanda_even_with_cloud_provider(self, monkeypatch):+ """A task::local sidecar is local even when global cloud config exists, so the engine applies."""mock_provider = MagicMock()+ launched = []+ monkeypatch.setattr(bs, "_active_sessions", {})+ monkeypatch.setattr(lifecycle, "start_cleanup_thread", lambda: None)+ monkeypatch.setattr(lifecycle, "update_session_activity", lambda key: None)+ monkeypatch.setattr(bs_cloud, "get_cloud_provider", lambda: mock_provider)+ monkeypatch.setattr(bs_cdp, "get_cdp_override", lambda: "")+ monkeypatch.setattr(lp, "using_lightpanda_engine", lambda: True)+ monkeypatch.setattr(bs_cloud, "is_local_backend", lambda: False)+ monkeypatch.setattr(lp, "launch_lightpanda",+ lambda name, **kw: launched.append(name) or (_FakeServer(), None))- mock_proc = MagicMock()- mock_proc.wait.return_value = None- mock_proc.returncode = 0-- def capture_popen(cmd, **kwargs):- captured_cmds.append(cmd)- return mock_proc-- mock_stdout = json.dumps({- "success": True,- "data": {"snapshot": '- heading "Hello" [ref=e1]', "refs": {"e1": {}}},- })- with patch("tools.browser_tool_session._get_session_info", return_value={"session_name": "local-sidecar"}), \- patch("tools.browser_tool_install._find_agent_browser", return_value="/usr/bin/agent-browser"), \- patch("tools.browser_tool_cloud._is_local_mode", return_value=False), \- patch("tools.browser_tool_install._chromium_installed", return_value=True), \- patch("tools.browser_tool_cloud._get_cloud_provider", return_value=mock_provider), \- patch("tools.browser_tool_cdp._get_cdp_override", return_value=""), \- patch("tools.browser_tool._is_camofox_mode", return_value=False), \- patch("subprocess.Popen", side_effect=capture_popen), \- patch("os.open", return_value=99), \- patch("os.close"), \- patch("os.unlink"), \- patch("os.makedirs"), \- patch("builtins.open", MagicMock(return_value=MagicMock(- __enter__=MagicMock(return_value=MagicMock(read=MagicMock(return_value=mock_stdout))),- __exit__=MagicMock(return_value=False),- ))), \- patch("tools.interrupt.is_interrupted", return_value=False), \- patch("tools.browser_tool_lifecycle._write_owner_pid"):- bt_session._run_browser_command("task::local", "snapshot", [])-- assert len(captured_cmds) == 1- assert "--engine" in captured_cmds[0]- assert captured_cmds[0][captured_cmds[0].index("--engine") + 1] == "lightpanda"+ info = bs.get_session_info("task::local")++ assert len(launched) == 1+ assert info["features"]["lightpanda"] is True+ mock_provider.create_session.assert_not_called()# ---------------------------------------------------------------------------@@ -453,59 +111,43 @@ class TestEngineOverride:class TestLightpandaEngineStatus:def _gates(self, monkeypatch, **overrides):- import tools.browser_tool as bt-gates = dict(- _using_lightpanda_engine=lambda: True,- _get_cdp_override_raw=lambda: "",- _is_camofox_mode=lambda: False,- _get_cloud_provider=lambda: None,- _is_browser_use_cli_mode=lambda: True,- _use_real_profile=lambda: False,+ using_lightpanda_engine=lambda: True,+ get_cdp_override_raw=lambda: "",+ get_cloud_provider=lambda: None,+ use_real_profile=lambda: False,)gates.update(overrides)homes = {- "_using_lightpanda_engine": bt_lightpanda_fallback, "_get_cdp_override_raw": bt_cdp,- "_get_cloud_provider": bt_cloud, "_use_real_profile": bt_cloud,+ "using_lightpanda_engine": lp, "get_cdp_override_raw": bs_cdp,+ "get_cloud_provider": bs_cloud, "use_real_profile": bs_cloud,}for name, fn in gates.items():- monkeypatch.setattr(homes.get(name, bt), name, fn)+ monkeypatch.setattr(homes[name], name, fn)monkeypatch.setattr("tools.browser_use_cli.is_legacy_browser_use_cloud_config", lambda cfg: False)- return btdef test_not_lightpanda(self, monkeypatch):- self._gates(monkeypatch, _using_lightpanda_engine=lambda: False)- assert bt_lightpanda_fallback.lightpanda_engine_status() == (False, "")+ self._gates(monkeypatch, using_lightpanda_engine=lambda: False)+ assert lp.lightpanda_engine_status() == (False, "")- def test_used_in_browser_use_mode(self, monkeypatch):+ def test_used_when_nothing_shadows_it(self, monkeypatch):self._gates(monkeypatch)- used, reason = bt_lightpanda_fallback.lightpanda_engine_status()+ used, reason = lp.lightpanda_engine_status()assert used is Trueassert "lightpanda serve" in reason- def test_used_with_builtin_tools(self, monkeypatch):- self._gates(monkeypatch, _is_browser_use_cli_mode=lambda: False)- used, reason = bt_lightpanda_fallback.lightpanda_engine_status()- assert used is True- assert "--engine lightpanda" in reason-def test_shadowed_by_cdp_override(self, monkeypatch):- self._gates(monkeypatch, _get_cdp_override_raw=lambda: "ws://x")- used, reason = bt_lightpanda_fallback.lightpanda_engine_status()+ self._gates(monkeypatch, get_cdp_override_raw=lambda: "ws://x")+ used, reason = lp.lightpanda_engine_status()assert used is False and "CDP override" in reason- def test_shadowed_by_camofox(self, monkeypatch):- self._gates(monkeypatch, _is_camofox_mode=lambda: True)- used, reason = bt_lightpanda_fallback.lightpanda_engine_status()- assert used is False and "Camofox" in reason-def test_shadowed_by_cloud_provider(self, monkeypatch):provider = MagicMock()provider.display_name = "Browserbase"- self._gates(monkeypatch, _get_cloud_provider=lambda: provider)- used, reason = bt_lightpanda_fallback.lightpanda_engine_status()+ self._gates(monkeypatch, get_cloud_provider=lambda: provider)+ used, reason = lp.lightpanda_engine_status()assert used is False and "Browserbase" in reasondef test_shadowed_by_legacy_browser_use_cloud(self, monkeypatch):@@ -513,12 +155,12 @@ class TestLightpandaEngineStatus:monkeypatch.setattr("tools.browser_use_cli.is_legacy_browser_use_cloud_config", lambda cfg: True)- used, reason = bt_lightpanda_fallback.lightpanda_engine_status()+ used, reason = lp.lightpanda_engine_status()assert used is False and "Browser Use cloud" in reasondef test_shadowed_by_real_profile(self, monkeypatch):- self._gates(monkeypatch, _use_real_profile=lambda: True)- used, reason = bt_lightpanda_fallback.lightpanda_engine_status()+ self._gates(monkeypatch, use_real_profile=lambda: True)+ used, reason = lp.lightpanda_engine_status()assert used is False and "use_real_profile" in reasondef test_real_profile_wins_over_cloud_provider(self, monkeypatch):@@ -528,31 +170,19 @@ class TestLightpandaEngineStatus:provider.display_name = "Browserbase"self._gates(monkeypatch,- _use_real_profile=lambda: True,- _get_cloud_provider=lambda: provider,+ use_real_profile=lambda: True,+ get_cloud_provider=lambda: provider,)- used, reason = bt_lightpanda_fallback.lightpanda_engine_status()+ used, reason = lp.lightpanda_engine_status()assert used is False and "use_real_profile" in reason# ----------------------------------------------------------------------------# Browser Use mode session lifecycle+# Session lifecycle# ----------------------------------------------------------------------------class _FakeServer:- def __init__(self, port=4321, alive=True):- self.port = port- self.cdp_url = f"http://127.0.0.1:{port}"- self._alive = alive-- def is_alive(self):- return self._alive--class TestLightpandaSessionCreation:- def _common(self, monkeypatch, *, bu_mode=True, local_backend=True, launch=None):- import tools.browser_tool as bt-+ def _common(self, monkeypatch, *, local_backend=True, launch=None):calls = []def fake_launch(session_name, *, block_private_networks=False):@@ -561,16 +191,15 @@ class TestLightpandaSessionCreation:return launchreturn _FakeServer(), None- monkeypatch.setattr("tools.browser_tool_real_profile._real_profile_cdp", lambda: (None, None))- monkeypatch.setattr(bt, "_is_browser_use_cli_mode", lambda: bu_mode)- monkeypatch.setattr("tools.browser_tool_lightpanda_fallback._using_lightpanda_engine", lambda: True)- monkeypatch.setattr(bt_cloud, "_is_local_backend", lambda: local_backend)- monkeypatch.setattr("tools.browser_lightpanda.launch_lightpanda", fake_launch)- return bt, calls+ monkeypatch.setattr("tools.browser_session_real_profile.real_profile_cdp", lambda: (None, None))+ monkeypatch.setattr(lp, "using_lightpanda_engine", lambda: True)+ monkeypatch.setattr(bs_cloud, "is_local_backend", lambda: local_backend)+ monkeypatch.setattr(lp, "launch_lightpanda", fake_launch)+ return calls- def test_spawns_lightpanda_in_browser_use_mode(self, monkeypatch):- _bt, calls = self._common(monkeypatch)- info = bt_session._create_local_session("task-1")+ def test_spawns_lightpanda(self, monkeypatch):+ calls = self._common(monkeypatch)+ info = bs._create_local_session("task-1")assert info["session_name"].startswith("lp_")assert info["cdp_url"] == "http://127.0.0.1:4321"assert info["features"] == {"local": True, "lightpanda": True}@@ -578,41 +207,30 @@ class TestLightpandaSessionCreation:assert calls == [(info["session_name"], False)]def test_blocks_private_networks_for_containerised_terminal(self, monkeypatch):- _bt, calls = self._common(monkeypatch, local_backend=False)- bt_session._create_local_session("task-1")+ calls = self._common(monkeypatch, local_backend=False)+ bs._create_local_session("task-1")assert calls[0][1] is True- def test_ignores_engine_outside_browser_use_mode(self, monkeypatch):- _bt, calls = self._common(monkeypatch, bu_mode=False)- info = bt_session._create_local_session("task-1")- assert info["features"] == {"local": True}- assert info["cdp_url"] is None- assert calls == []-def test_launch_failure_raises(self, monkeypatch):- _bt, _ = self._common(monkeypatch, launch=(None, "no lightpanda binary was found"))+ self._common(monkeypatch, launch=(None, "no lightpanda binary was found"))with pytest.raises(RuntimeError, match="no lightpanda binary"):- bt_session._create_local_session("task-1")+ bs._create_local_session("task-1")class TestLightpandaSessionLifecycle:def setup_method(self):- import tools.browser_tool as bt-- self.bt = bt- self.orig_sessions = bt._active_sessions.copy()- self.orig_activity = bt._session_last_activity.copy()- self.orig_cleanup_done = bt._cleanup_done- bt._active_sessions.clear()- bt._session_last_activity.clear()+ self.orig_sessions = bs._active_sessions.copy()+ self.orig_activity = bs._session_last_activity.copy()+ self.orig_cleanup_done = bs._cleanup_done+ bs._active_sessions.clear()+ bs._session_last_activity.clear()def teardown_method(self):- bt = self.bt- bt._active_sessions.clear()- bt._active_sessions.update(self.orig_sessions)- bt._session_last_activity.clear()- bt._session_last_activity.update(self.orig_activity)- bt._cleanup_done = self.orig_cleanup_done+ bs._active_sessions.clear()+ bs._active_sessions.update(self.orig_sessions)+ bs._session_last_activity.clear()+ bs._session_last_activity.update(self.orig_activity)+ bs._cleanup_done = self.orig_cleanup_donedef _seed(self, key="task-1", name="lp_dead"):info = {@@ -621,24 +239,21 @@ class TestLightpandaSessionLifecycle:"cdp_url": "http://127.0.0.1:1","features": {"local": True, "lightpanda": True},}- self.bt._active_sessions[key] = info- self.bt._session_last_activity[key] = 1.0+ bs._active_sessions[key] = info+ bs._session_last_activity[key] = 1.0return infodef test_dead_process_is_detected(self, monkeypatch):info = self._seed()- monkeypatch.setattr("tools.browser_lightpanda.get_server", lambda name: None)- assert bt_session._local_backend_process_dead(info) is True- monkeypatch.setattr(- "tools.browser_lightpanda.get_server", lambda name: _FakeServer(alive=False)- )- assert bt_session._local_backend_process_dead(info) is True- monkeypatch.setattr("tools.browser_lightpanda.get_server", lambda name: _FakeServer())- assert bt_session._local_backend_process_dead(info) is False- assert bt_session._local_backend_process_dead({"features": {"local": True}}) is False+ monkeypatch.setattr(lp, "get_server", lambda name: None)+ assert bs._backend_dead(info) is True+ monkeypatch.setattr(lp, "get_server", lambda name: _FakeServer(alive=False))+ assert bs._backend_dead(info) is True+ monkeypatch.setattr(lp, "get_server", lambda name: _FakeServer())+ assert bs._backend_dead(info) is False+ assert bs._backend_dead({"features": {"local": True}}) is Falsedef test_get_session_info_respawns_dead_lightpanda(self, monkeypatch):- bt = self.btstale = self._seed()fresh = {"session_name": "lp_fresh",@@ -650,84 +265,73 @@ class TestLightpandaSessionLifecycle:def fake_cleanup(key):cleaned.append(key)- bt._active_sessions.pop(key, None)-- monkeypatch.setattr("tools.browser_tool_lifecycle._start_browser_cleanup_thread", lambda: None)- monkeypatch.setattr(- bt, "_browser_session_backend",- lambda key: MagicMock(ensure_healthy=lambda: True),- )- monkeypatch.setattr("tools.browser_lightpanda.get_server", lambda name: None)- monkeypatch.setattr(bt_lifecycle, "_cleanup_single_browser_session", fake_cleanup)- monkeypatch.setattr("tools.browser_tool_cdp._get_cdp_override", lambda: "")- monkeypatch.setattr(bt_cloud, "_get_cloud_provider", lambda: None)- monkeypatch.setattr("tools.browser_tool_session._create_local_session", lambda *a, **k: fresh)+ bs._active_sessions.pop(key, None)++ monkeypatch.setattr(lifecycle, "start_cleanup_thread", lambda: None)+ monkeypatch.setattr(lp, "get_server", lambda name: None)+ monkeypatch.setattr(lifecycle, "cleanup_single_session", fake_cleanup)+ monkeypatch.setattr(bs_cdp, "get_cdp_override", lambda: "")+ monkeypatch.setattr(bs_cloud, "get_cloud_provider", lambda: None)+ monkeypatch.setattr(bs, "_create_local_session", lambda *a, **k: fresh)supervised = []- monkeypatch.setattr("tools.browser_tool_cdp._ensure_cdp_supervisor", supervised.append)+ monkeypatch.setattr(bs_cdp, "ensure_cdp_supervisor", supervised.append)- info = bt_session._get_session_info("task-1")+ info = bs.get_session_info("task-1")assert cleaned == ["task-1"]assert info["session_name"] == "lp_fresh"- assert bt._active_sessions["task-1"]["session_name"] == "lp_fresh"+ assert bs._active_sessions["task-1"]["session_name"] == "lp_fresh"assert info["session_name"] != stale["session_name"]- # Browser Use mode hides the browser_* tools that read supervisor- # state; a Lightpanda session never attaches one.+ # A local (Lightpanda) session never gets the session-layer supervisor;+ # browser_exec attaches one per call.assert supervised == []- def test_cleanup_stops_lightpanda_without_agent_browser_close(self, monkeypatch):- bt = self.bt+ def test_cleanup_stops_lightpanda_without_a_chromium_stop(self, monkeypatch):self._seed()stopped = []- monkeypatch.setattr("tools.browser_lightpanda.stop_lightpanda", stopped.append)- with patch("tools.browser_tool._maybe_stop_recording"), \- patch("tools.browser_tool_session._run_browser_command") as run, \- patch("tools.browser_tool.os.path.exists", return_value=False):- bt_lifecycle.cleanup_browser("task-1")- run.assert_not_called()+ monkeypatch.setattr(lp, "stop_lightpanda", stopped.append)+ with patch("tools.browser_launcher.stop_browser") as chromium_stop:+ lifecycle.cleanup_browser("task-1")+ chromium_stop.assert_not_called()assert stopped == ["lp_dead"]- assert "task-1" not in bt._active_sessions- assert "task-1" not in bt._session_last_activity+ assert "task-1" not in bs._active_sessions+ assert "task-1" not in bs._session_last_activitydef test_emergency_cleanup_stops_all_lightpanda(self, monkeypatch):- bt = self.bt- bt._cleanup_done = False+ bs._cleanup_done = Falsewith patch("tools.browser_lightpanda.stop_all_lightpanda") as stop_all, \- patch("tools.browser_tool_real_profile._terminate_real_profile_chrome"), \- patch("tools.browser_tool_lifecycle.cleanup_all_browsers"), \- patch("tools.browser_tool_lifecycle._reap_orphaned_browser_sessions"):- bt_lifecycle._emergency_cleanup_all_sessions()+ patch("tools.browser_launcher.stop_all_browsers"), \+ patch("tools.browser_session_lifecycle.reap_orphaned_browser_sessions"):+ lifecycle.emergency_cleanup_all_sessions()stop_all.assert_called_once()- def test_orphan_reaper_sweeps_lightpanda_records(self, tmp_path):- with patch("tools.browser_lightpanda.reap_orphaned_lightpanda") as reap, \- patch("tools.browser_tool._socket_safe_tmpdir", return_value=str(tmp_path)):- bt_lifecycle._reap_orphaned_browser_sessions()+ def test_orphan_reaper_sweeps_lightpanda_records(self):+ with patch("tools.browser_lightpanda.reap_orphaned_lightpanda", return_value=0) as reap, \+ patch("tools.browser_launcher.reap_orphaned_browsers", return_value=0):+ lifecycle.reap_orphaned_browser_sessions()reap.assert_called_once()def test_orphan_reaper_survives_non_dict_record(self, tmp_path, monkeypatch):"""A parseable-but-non-object state file is swept like an unreadable one —never an AttributeError that wedges the reaper."""- from tools import browser_lightpandamonkeypatch.setenv("HERMES_HOME", str(tmp_path))- state_dir = browser_lightpanda._state_dir()+ state_dir = lp._state_dir()bad = state_dir / "broken.json"bad.write_text('"not a record"', encoding="utf-8")dead_owner = state_dir / "dead.json"dead_owner.write_text(json.dumps({"owner_pid": 2**22 + 7}), encoding="utf-8")- assert browser_lightpanda.reap_orphaned_lightpanda() == 0+ assert lp.reap_orphaned_lightpanda() == 0assert not bad.exists() and not dead_owner.exists()def test_orphan_sweep_mid_record_write_keeps_the_live_record(self, tmp_path, monkeypatch):"""A sweep running while the owner writes its record must not see a torn (empty) file:it would unlink it as corrupt and the live server would never be reaped after a crash."""from tests.file_write_observer import observe_file_writes- from tools import browser_lightpandamonkeypatch.setenv("HERMES_HOME", str(tmp_path))- server = browser_lightpanda.LightpandaServer("live", 9222, MagicMock(pid=os.getpid()), "x.log")- monkeypatch.setitem(browser_lightpanda._servers, "live", server)- with observe_file_writes(browser_lightpanda.reap_orphaned_lightpanda):- browser_lightpanda._write_record(server)- record = browser_lightpanda._state_dir() / "live.json"+ server = lp.LightpandaServer("live", 9222, MagicMock(pid=os.getpid()), "x.log")+ monkeypatch.setitem(lp._servers, "live", server)+ with observe_file_writes(lp.reap_orphaned_lightpanda):+ lp._write_record(server)+ record = lp._state_dir() / "live.json"assert record.exists()assert json.loads(record.read_text(encoding="utf-8"))["port"] == 9222diff --git a/tests/tools/test_browser_orphan_reaper.py b/tests/tools/test_browser_orphan_reaper.pyindex 8a5808f990a..0f53e7cc8f3 100644--- a/tests/tools/test_browser_orphan_reaper.py+++ b/tests/tools/test_browser_orphan_reaper.py@@ -1,493 +1,207 @@-"""Tests for _reap_orphaned_browser_sessions() — kills orphaned agent-browser-daemons whose Python parent exited without cleaning up."""+"""Tests for the browser orphan reaper: Chromium launched by a Hermes process that exited without+cleaning up is found through the launcher's host-wide records and stopped, but only after its+identity is proven (``tools.browser_launcher.reap_orphaned_browsers``, driven by+``browser_session_lifecycle.reap_orphaned_browser_sessions``)."""+import jsonimport os-import time+from types import SimpleNamespacefrom unittest.mock import patchimport pytest-from tools import browser_tool_lifecycle as bt_lifecycle+from tools import browser_launcher as launcher+from tools import browser_session as bs+from tools import browser_session_lifecycle as lifecycle-def fake_tmpdir(tmp_path):- """Patch _socket_safe_tmpdir to return a temp dir we control."""- with patch("tools.browser_tool._socket_safe_tmpdir", return_value=str(tmp_path)):- yield tmp_path--[email protected](autouse=True)-def _isolate_sessions():- """Ensure _active_sessions is empty for each test."""- import tools.browser_tool as bt- orig = bt._active_sessions.copy()- bt._active_sessions.clear()- yield- bt._active_sessions.clear()- bt._active_sessions.update(orig)---def _make_socket_dir(tmpdir, session_name, pid=None, owner_pid=None):- """Create a fake agent-browser socket directory with optional PID files.-- Args:- tmpdir: base temp directory- session_name: name like "h_abc1234567" or "cdp_abc1234567"- pid: daemon PID to write to <session>.pid (None = no file)- owner_pid: owning hermes PID to write to <session>.owner_pid- (None = no file; tests the legacy path)- """- d = tmpdir / f"agent-browser-{session_name}"- d.mkdir()- if pid is not None:- (d / f"{session_name}.pid").write_text(str(pid))- if owner_pid is not None:- (d / f"{session_name}.owner_pid").write_text(str(owner_pid))- return d+_DEAD_OWNER = 99999+_LIVE_OTHER_OWNER = 88888-class TestReapOrphanedBrowserSessions:- """Tests for the orphan reaper function."""--- def test_stale_dir_without_pid_file_is_removed(self, fake_tmpdir):- """Socket dir with no PID file is cleaned up."""- from tools.browser_tool_lifecycle import _reap_orphaned_browser_sessions- d = _make_socket_dir(fake_tmpdir, "h_abc1234567")- assert d.exists()- with patch(- "tools.browser_tool_lifecycle._socket_dir_idle_seconds",- return_value=10_000,- ):- _reap_orphaned_browser_sessions()- assert not d.exists()-- def test_fresh_dir_without_pid_file_survives_creator_race(self, fake_tmpdir):- """A concurrent reaper must not delete a session still starting."""- from tools.browser_tool_lifecycle import _reap_orphaned_browser_sessions-- d = _make_socket_dir(fake_tmpdir, "h_starting1234")- with patch(- "tools.browser_tool_lifecycle._socket_dir_idle_seconds",- return_value=0.0,- ):- _reap_orphaned_browser_sessions()-- assert d.exists()--- def test_alive_legacy_daemon_is_reaped(self, fake_tmpdir):- """Alive, untracked, legacy (no owner_pid) daemon is reaped.-- Post-#21561 the liveness probe goes through- ``gateway.status._pid_exists`` (which wraps ``psutil.pid_exists``- because ``os.kill(pid, 0)`` is a footgun on Windows — bpo-14484).- With no owner_pid file and no tracked-name entry, the reaper- terminates the daemon (and its process tree) and removes its socket- dir regardless of whether termination succeeded (best-effort- semantics).- """- from tools.browser_tool_lifecycle import _reap_orphaned_browser_sessions+def records(tmp_path, monkeypatch):+ """Host-wide launch records in a temp dir; no real process is ever probed or signalled."""+ path = tmp_path / "records"+ path.mkdir()+ monkeypatch.setattr(launcher, "_records_dir", lambda: path)+ monkeypatch.setattr(launcher, "_browsers", {})+ monkeypatch.setattr(launcher, "_procs", {})+ terminated = []+ monkeypatch.setattr(launcher, "_terminate", lambda pid, start_time, proc: terminated.append(pid))+ return SimpleNamespace(dir=path, terminated=terminated)- d = _make_socket_dir(fake_tmpdir, "h_perm1234567", pid=12345)- terminate_calls = []+def _record(records, *, pid: int, udd: str, owner_pid: int = _DEAD_OWNER, start_time=777,+ ephemeral: bool = True) -> Path:+ path = records.dir / f"rec-{pid}.json"+ path.write_text(json.dumps({"owner_pid": owner_pid, "owner_start_time": None, "pid": pid,+ "start_time": start_time, "user_data_dir": udd, "home_key": "x",+ "ephemeral": ephemeral}))+ return path- def mock_terminate(pid, expected_start=None):- terminate_calls.append(pid)- with patch("gateway.status._pid_exists", return_value=True), \- patch("gateway.status.get_process_start_time", return_value=777), \- patch("tools.browser_tool_lifecycle._verify_reapable_browser_daemon", return_value=True), \- patch("tools.process_registry.ProcessRegistry._terminate_host_pid", side_effect=mock_terminate):- _reap_orphaned_browser_sessions()+def _alive(*pids):+ return lambda pid: pid in pids- assert 12345 in terminate_calls- assert not d.exists()- def test_real_profile_attach_daemon_is_reaped_when_owner_is_dead(self, fake_tmpdir):- """#100855: the shared ``hermes-real-profile`` attach daemon is not ``<prefix>_<hex>``- named, so the reaper's glob never saw it and a wedged daemon + headless Chrome outlived- gateway restarts. Same owner-liveness rule as every other lane: dead owner => reaped."""- import tools.browser_tool as bt- from tools.browser_tool_lifecycle import _reap_orphaned_browser_sessions+class TestReapOrphanedBrowserSessions:+ """Tests for the orphan reaper function."""- d = _make_socket_dir(fake_tmpdir, bt._REAL_PROFILE_SESSION, pid=4242, owner_pid=99999)- terminate_calls = []+ def test_real_profile_browser_is_reaped_when_owner_is_dead_and_its_copy_kept(self, records, tmp_path,+ monkeypatch):+ """#100855: the shared real-profile browser is not ``<prefix>_<hex>`` named, so it must still be+ found. Same owner-liveness rule as every other lane: dead owner => reaped. Its persistent+ profile copy is never deleted by the reap."""+ from tools.browser_session_real_profile import REAL_PROFILE_KEY- def _pid_exists(pid):- return pid == 4242 # daemon alive, owning hermes gone+ copy_dir = tmp_path / REAL_PROFILE_KEY+ copy_dir.mkdir()+ rec = _record(records, pid=4242, udd=str(copy_dir), ephemeral=False)+ monkeypatch.setattr(launcher, "_pid_alive", _alive(4242)) # browser alive, owning hermes gone+ monkeypatch.setattr(launcher, "_start_time", lambda pid: 777)+ monkeypatch.setattr(launcher, "_cmdline_names_dir", lambda pid, udd: True)+ monkeypatch.setattr("tools.browser_lightpanda.reap_orphaned_lightpanda", lambda: 0)- with patch("gateway.status._pid_exists", side_effect=_pid_exists), \- patch("gateway.status.get_process_start_time", return_value=777), \- patch("tools.browser_tool_lifecycle._verify_reapable_browser_daemon", return_value=True), \- patch("tools.process_registry.ProcessRegistry._terminate_host_pid",- side_effect=lambda pid, expected_start=None: terminate_calls.append(pid)):- _reap_orphaned_browser_sessions()+ assert lifecycle.reap_orphaned_browser_sessions() == 1- assert terminate_calls == [4242]- assert not d.exists()+ assert records.terminated == [4242]+ assert not rec.exists()+ assert copy_dir.exists()- def test_unfingerprintable_daemon_is_refused(self, fake_tmpdir):+ def test_unfingerprintable_browser_is_refused(self, records, tmp_path, monkeypatch):"""No start-time fingerprint -> the kill is refused (fail closed).- The reaper reads the PID from a world-writable temp dir; a PID whose- identity cannot be pinned could be recycled between the verify and the- tree-kill, so it must be left alone (and the socket dir kept for a- later sweep).+ A PID whose identity cannot be pinned could be recycled between the verify and the+ tree-kill, so it must be left alone."""- from tools.browser_tool_lifecycle import _reap_orphaned_browser_sessions-- _make_socket_dir(fake_tmpdir, "h_perm7654321", pid=12345)- terminate_calls = []+ _record(records, pid=12345, udd=str(tmp_path / "p"), start_time=None)+ monkeypatch.setattr(launcher, "_pid_alive", _alive(12345))+ monkeypatch.setattr(launcher, "_start_time", lambda pid: None)+ monkeypatch.setattr(launcher, "_cmdline_names_dir", lambda pid, udd: True)- with patch("gateway.status._pid_exists", return_value=True), \- patch("gateway.status.get_process_start_time", return_value=None), \- patch("tools.browser_tool_lifecycle._verify_reapable_browser_daemon", return_value=True), \- patch("tools.process_registry.ProcessRegistry._terminate_host_pid",- side_effect=lambda pid, expected_start=None: terminate_calls.append(pid)):- _reap_orphaned_browser_sessions()+ launcher.reap_orphaned_browsers()- assert terminate_calls == []+ assert records.terminated == []- def test_corrupt_pid_file_is_cleaned(self, fake_tmpdir):- """PID file with non-integer content is cleaned up."""- from tools.browser_tool_lifecycle import _reap_orphaned_browser_sessions+ def test_corrupt_record_is_cleaned(self, records, monkeypatch):+ """A record that is not a JSON object is removed and nothing is signalled."""+ bad = records.dir / "corrupt.json"+ bad.write_text("not-json")+ listed = records.dir / "list.json"+ listed.write_text("[1, 2]")- d = _make_socket_dir(fake_tmpdir, "h_corrupt1234")- (d / "h_corrupt1234.pid").write_text("not-a-number")-- _reap_orphaned_browser_sessions()- assert not d.exists()+ assert launcher.reap_orphaned_browsers() == 0+ assert not bad.exists() and not listed.exists()+ assert records.terminated == []class TestOwnerPidCrossProcess:- """Tests for owner_pid-based cross-process safe reaping.-- The owner_pid file records which hermes process owns a daemon so that- concurrent hermes processes don't reap each other's active browser- sessions. Added to fix orphan accumulation from crashed processes.- """+ """Owner-based cross-process safe reaping: concurrent Hermes processes never reap each other's+ browsers, so orphans from crashed processes are reaped without touching live ones."""- def test_alive_owner_is_not_reaped_even_when_untracked(self, fake_tmpdir):- """Daemon with alive owner_pid is NOT reaped, even if not in our _active_sessions.+ def test_alive_owner_is_not_reaped_even_when_untracked(self, records, tmp_path, monkeypatch):+ """A browser with a live owner is NOT reaped, even though this process does not track it.- This is the core cross-process safety check: Process B scanning while- Process A is using a browser must not kill A's daemon.+ This is the core cross-process safety check: Process B scanning while Process A is using a+ browser must not kill A's browser."""- from tools.browser_tool_lifecycle import _reap_orphaned_browser_sessions-- # Use our own PID as the "owner" — guaranteed alive- d = _make_socket_dir(- fake_tmpdir, "h_alive_owner", pid=12345, owner_pid=os.getpid()- )-- kill_calls = []-- def mock_terminate(pid):- kill_calls.append(pid)-- # Owner alive → reaper skips without ever probing the daemon.- with patch("gateway.status._pid_exists", return_value=True), \- patch("tools.process_registry.ProcessRegistry._terminate_host_pid", side_effect=mock_terminate):- _reap_orphaned_browser_sessions()-- assert 12345 not in kill_calls- assert d.exists()----+ rec = _record(records, pid=12345, udd=str(tmp_path / "p"), owner_pid=_LIVE_OTHER_OWNER)+ monkeypatch.setattr(launcher, "_pid_alive", _alive(12345, _LIVE_OTHER_OWNER))+ monkeypatch.setattr(launcher, "_start_time", lambda pid: 777)+ monkeypatch.setattr(launcher, "_cmdline_names_dir", lambda pid, udd: True)+ assert launcher.reap_orphaned_browsers() == 0+ assert records.terminated == []+ assert rec.exists()class TestReaperIdentityGuard:- """Tests for _verify_reapable_browser_daemon — the #14073 fix.-- The reaper reads daemon PIDs from world-writable, predictably-named temp- dirs. Before tree-killing a live PID it must confirm the process really is- *this* session's agent-browser daemon, defeating planted pid files and- recycled PIDs that would otherwise become an arbitrary same-user DoS.- """+ """The #14073 guard: before signalling a live PID the reaper confirms it really is the recorded+ browser (its argv names the recorded ``--user-data-dir``), defeating planted records and+ recycled PIDs that would otherwise become an arbitrary same-user DoS."""class _FakeProc:- def __init__(self, name="agent-browser", cmdline=None, environ=None,- raise_environ=False):- self._name = name- self._cmdline = cmdline if cmdline is not None else []- self._environ = environ or {}- self._raise_environ = raise_environ-- def name(self):- return self._name+ def __init__(self, cmdline):+ self._cmdline = cmdlinedef cmdline(self):return self._cmdline- def environ(self):- if self._raise_environ:- import psutil- raise psutil.AccessDenied()- return self._environ-- def _run(self, fake_proc, socket_dir, session_name="h_sess123456",- daemon_pid=12345, no_such=False, access_denied=False):+ def _run(self, cmdline, udd, *, no_such=False, access_denied=False):import psutil- from tools.browser_tool_lifecycle import _verify_reapable_browser_daemondef _factory(pid):if no_such:raise psutil.NoSuchProcess(pid)if access_denied:raise psutil.AccessDenied(pid)- return fake_proc+ return self._FakeProc(cmdline)with patch("psutil.Process", side_effect=_factory):- return _verify_reapable_browser_daemon(- daemon_pid, socket_dir, session_name)-- def test_real_daemon_bound_via_cmdline_is_reapable(self):- socket_dir = "/tmp/agent-browser-h_sess123456"- proc = self._FakeProc(- name="agent-browser",- cmdline=["agent-browser", "open", "--session", "h_sess123456",- "--socket-dir", socket_dir],- )- assert self._run(proc, socket_dir) is True-- def test_daemon_bound_via_environ_is_reapable(self):- socket_dir = "/tmp/agent-browser-h_sess123456"- proc = self._FakeProc(- name="agent-browser-linux-x64",- cmdline=["agent-browser-linux-x64", "daemon"], # no dir in cmd- environ={"AGENT_BROWSER_SOCKET_DIR": socket_dir},- )- assert self._run(proc, socket_dir) is True+ return launcher._cmdline_names_dir(12345, udd)+ def test_real_browser_bound_via_cmdline_is_reapable(self):+ udd = "/home/u/.hermes/cache/browser/chromium/abc"+ assert self._run(["chrome", "--remote-debugging-port=0", f"--user-data-dir={udd}"], udd) is Truedef test_recycled_pid_browser_not_bound_to_our_dir_is_refused(self):- """An agent-browser process for a DIFFERENT session must not be reaped.-- Models PID reuse / a concurrent unrelated daemon: it looks like- agent-browser but is bound to another socket dir.- """- socket_dir = "/tmp/agent-browser-h_sess123456"- proc = self._FakeProc(- name="agent-browser",- cmdline=["agent-browser", "open", "--session", "h_OTHER999",- "--socket-dir", "/tmp/agent-browser-h_OTHER999"],- environ={"AGENT_BROWSER_SOCKET_DIR":- "/tmp/agent-browser-h_OTHER999"},- )- assert self._run(proc, socket_dir) is False-- def test_recycled_pid_carrying_only_socket_dir_basename_is_refused(self):- """The socket-dir BASENAME anywhere in argv is not a binding (#116884).-- `agent-browser-<session>` is predictable, so a recycled PID whose argv merely- mentions it (a grep, a shell) must not pass the binding gate; only the full- normalized path as an argv token (or the environ match) binds.- """- socket_dir = "/tmp/agent-browser-h_sess123456"- proc = self._FakeProc(- name="bash",- cmdline=["grep", "agent-browser-h_sess123456", "/var/log/syslog"],- environ={},- )- assert self._run(proc, socket_dir) is False- # Control: the full path as a `--flag=value` token still binds.- bound = self._FakeProc(- name="agent-browser",- cmdline=["agent-browser", "daemon", f"--socket-dir={socket_dir}/"],- )- assert self._run(bound, socket_dir) is True--- def test_planted_pid_survives_full_reaper_path(self, fake_tmpdir):- """End-to-end through the reaper: a planted non-browser PID is spared.-- No owner_pid (legacy path), not tracked, PID 'alive' — but the live- process is `sleep`, not agent-browser, so it must be left alone and the- socket dir retained.- """- from tools.browser_tool_lifecycle import _reap_orphaned_browser_sessions-- d = _make_socket_dir(fake_tmpdir, "h_planted9999", pid=12345)-- terminate_calls = []- proc = self._FakeProc(name="sleep", cmdline=["/bin/sleep", "600"])-- with patch("gateway.status._pid_exists", return_value=True), \- patch("psutil.Process", return_value=proc), \- patch("tools.process_registry.ProcessRegistry._terminate_host_pid",- side_effect=lambda pid: terminate_calls.append(pid)):- _reap_orphaned_browser_sessions()-- assert terminate_calls == [], "planted non-browser PID must not be killed"- assert d.exists(), "socket dir retained for a later sweep"-----def _age_socket_dir(d, seconds):- """Backdate every mtime under ``d`` so it looks idle for ``seconds``."""- old = time.time() - seconds- for p in d.iterdir():- os.utime(p, (old, old))- os.utime(d, (old, old))---class TestSocketDirIdleSeconds:- """Unit tests for the idle-age signal backing the leak escape hatch."""-- def test_missing_dir_returns_none(self, tmp_path):- from tools.browser_tool_lifecycle import _socket_dir_idle_seconds- assert _socket_dir_idle_seconds(str(tmp_path / "nope")) is None--- def test_entry_mtime_beats_stale_dir_mtime(self, tmp_path):- """Rewriting an existing file must count as activity.-- Command names repeat (``_stdout_click`` is rewritten on every click),- and overwriting an existing file does NOT bump the *directory* mtime.- Reading only the directory mtime would therefore report a busy session- as idle and reap it. The reaper must scan entries too.- """- from tools.browser_tool_lifecycle import _socket_dir_idle_seconds- d = tmp_path / "agent-browser-h_reuse"- d.mkdir()- f = d / "_stdout_click"- f.write_text("x")- _age_socket_dir(d, 7200)- assert _socket_dir_idle_seconds(str(d)) > 7000-- f.write_text("y") # rewrite in place — dir mtime stays stale- assert time.time() - os.path.getmtime(d) > 7000, "precondition"- assert _socket_dir_idle_seconds(str(d)) < 5---class TestLeakedDaemonWithLiveOwner:- """Idle-age escape hatch for untracked daemons whose owner is still alive.-- ``owner_alive is True`` alone made a leaked daemon immortal: in-memory- tracking is lost on any exception path between spawn and registration,- yet the owner PID stays up, so the reaper skipped it forever. Observed in- the wild — five agent-browser daemons accumulated over 10 days inside one- long-lived hermes process, pinning ~5 CPU cores and driving load to 100+.-- The daemon-side ``AGENT_BROWSER_IDLE_TIMEOUT_MS`` is not a backstop here:- it does not fire when the daemon itself is wedged (e.g. Chrome's framework- was replaced underneath it by an auto-update).- """-- def test_fresh_untracked_daemon_with_live_owner_is_spared(self, fake_tmpdir):- """Within the grace window, cross-process safety still wins."""- from tools.browser_tool_lifecycle import _reap_orphaned_browser_sessions-- d = _make_socket_dir(- fake_tmpdir, "h_fresh_owner", pid=12345, owner_pid=os.getpid()- )- kill_calls = []-- with patch("gateway.status._pid_exists", return_value=True), \- patch("tools.browser_tool_lifecycle._verify_reapable_browser_daemon", return_value=True), \- patch("tools.process_registry.ProcessRegistry._terminate_host_pid",- side_effect=kill_calls.append):- _reap_orphaned_browser_sessions()-- assert 12345 not in kill_calls- assert d.exists()-- def test_idle_untracked_daemon_with_live_owner_is_reaped(self, fake_tmpdir):- """Past the grace window, an untracked daemon is treated as leaked."""- from tools.browser_tool import BROWSER_ORPHAN_GRACE_SECONDS- from tools.browser_tool_lifecycle import _reap_orphaned_browser_sessions-- d = _make_socket_dir(- fake_tmpdir, "h_leaked_owner", pid=12345, owner_pid=os.getpid()- )- _age_socket_dir(d, BROWSER_ORPHAN_GRACE_SECONDS + 600)- kill_calls = []-- with patch("gateway.status._pid_exists", return_value=True), \- patch("gateway.status.get_process_start_time", return_value=777), \- patch("tools.browser_tool_lifecycle._verify_reapable_browser_daemon", return_value=True), \- patch("tools.process_registry.ProcessRegistry._terminate_host_pid",- side_effect=lambda pid, expected_start=None: kill_calls.append(pid)):- _reap_orphaned_browser_sessions()-- assert 12345 in kill_calls- assert not d.exists()-- def test_tracked_daemon_with_live_owner_is_spared_at_any_age(self, fake_tmpdir):- """A session this process still tracks is never reaped, however old.-- Idle age is a fallback for *lost* bookkeeping, not an override of- bookkeeping that is present and says the session is live.- """- import tools.browser_tool as bt- from tools.browser_tool import BROWSER_ORPHAN_GRACE_SECONDS- from tools.browser_tool_lifecycle import _reap_orphaned_browser_sessions-- d = _make_socket_dir(- fake_tmpdir, "h_tracked_old", pid=12345, owner_pid=os.getpid()- )- _age_socket_dir(d, BROWSER_ORPHAN_GRACE_SECONDS * 10)- bt._active_sessions["task-1"] = {"session_name": "h_tracked_old"}- kill_calls = []-- with patch("gateway.status._pid_exists", return_value=True), \- patch("tools.browser_tool_lifecycle._verify_reapable_browser_daemon", return_value=True), \- patch("tools.process_registry.ProcessRegistry._terminate_host_pid",- side_effect=kill_calls.append):- _reap_orphaned_browser_sessions()-- assert 12345 not in kill_calls- assert d.exists()-- def test_unknown_idle_age_fails_safe(self, fake_tmpdir):- """Unreadable mtime => treat as too young to reap, never guess."""- from tools.browser_tool_lifecycle import _reap_orphaned_browser_sessions-- d = _make_socket_dir(- fake_tmpdir, "h_unknown_age", pid=12345, owner_pid=os.getpid()- )- kill_calls = []-- with patch("gateway.status._pid_exists", return_value=True), \- patch("tools.browser_tool_lifecycle._socket_dir_idle_seconds", return_value=None), \- patch("tools.browser_tool_lifecycle._verify_reapable_browser_daemon", return_value=True), \- patch("tools.process_registry.ProcessRegistry._terminate_host_pid",- side_effect=kill_calls.append):- _reap_orphaned_browser_sessions()-- assert 12345 not in kill_calls- assert d.exists()-- def test_identity_guard_still_gates_the_new_path(self, fake_tmpdir):- """The escape hatch must not bypass _verify_reapable_browser_daemon.-- That guard is the anti-spoof / anti-PID-recycle defense (issue #14073);- an idle daemon is still only reapable if it verifies.- """- from tools.browser_tool import BROWSER_ORPHAN_GRACE_SECONDS- from tools.browser_tool_lifecycle import _reap_orphaned_browser_sessions-- d = _make_socket_dir(- fake_tmpdir, "h_unverified", pid=12345, owner_pid=os.getpid()- )- _age_socket_dir(d, BROWSER_ORPHAN_GRACE_SECONDS + 600)- kill_calls = []-- with patch("gateway.status._pid_exists", return_value=True), \- patch("tools.browser_tool_lifecycle._verify_reapable_browser_daemon", return_value=False), \- patch("tools.process_registry.ProcessRegistry._terminate_host_pid",- side_effect=kill_calls.append):- _reap_orphaned_browser_sessions()-- assert 12345 not in kill_calls- assert d.exists()+ """A Chromium for a DIFFERENT profile dir must not be reaped (PID reuse / an unrelated browser)."""+ udd = "/home/u/.hermes/cache/browser/chromium/abc"+ assert self._run(["chrome", "--user-data-dir=/home/u/.hermes/cache/browser/chromium/OTHER"], udd) is False++ def test_recycled_pid_carrying_only_the_dir_as_a_bare_token_is_refused(self):+ """The dir anywhere in argv is not a binding (#116884): a recycled PID whose argv merely mentions+ it (a grep, a shell) must not pass; only the exact ``--user-data-dir=<dir>`` token binds."""+ udd = "/home/u/.hermes/cache/browser/chromium/abc"+ assert self._run(["grep", udd, "/var/log/syslog"], udd) is False+ assert self._run(["grep", "abc", "/var/log/syslog"], udd) is False+ # Control: the normalized full path as the flag token still binds.+ assert self._run(["chrome", f"--user-data-dir={udd}/"], udd) is True++ def test_unreadable_identity_fails_closed(self):+ udd = "/home/u/.hermes/cache/browser/chromium/abc"+ assert self._run([], udd, no_such=True) is False+ assert self._run([], udd, access_denied=True) is False+++class TestLeakedBrowserOfThisProcess:+ """A record owned by THIS (live) process but no longer tracked by it is a leak: reap it. A browser+ this process still tracks is never reaped, however old."""++ def test_untracked_own_browser_is_reaped(self, records, tmp_path, monkeypatch):+ rec = _record(records, pid=12345, udd=str(tmp_path / "p"), owner_pid=os.getpid())+ monkeypatch.setattr(launcher, "_pid_alive", _alive(12345, os.getpid()))+ monkeypatch.setattr(launcher, "_start_time", lambda pid: 777)+ monkeypatch.setattr(launcher, "_cmdline_names_dir", lambda pid, udd: True)++ assert launcher.reap_orphaned_browsers() == 1+ assert records.terminated == [12345]+ assert not rec.exists()++ def test_tracked_own_browser_is_spared(self, records, tmp_path, monkeypatch):+ udd = str(tmp_path / "p")+ rec = _record(records, pid=12345, udd=udd, owner_pid=os.getpid())+ launcher._browsers["mine"] = launcher.LaunchedBrowser(+ key="mine", pid=12345, start_time=777, cdp_url="ws://127.0.0.1:1/devtools/browser/x",+ http_url="http://127.0.0.1:1", user_data_dir=udd, owned=True, ephemeral=True, home_key="x")+ monkeypatch.setattr(launcher, "_pid_alive", _alive(12345, os.getpid()))+ monkeypatch.setattr(launcher, "_start_time", lambda pid: 777)+ monkeypatch.setattr(launcher, "_cmdline_names_dir", lambda pid, udd: True)++ assert launcher.reap_orphaned_browsers() == 0+ assert records.terminated == []+ assert rec.exists()++ def test_identity_guard_still_gates_the_leak_path(self, records, tmp_path, monkeypatch):+ """The leak path must not bypass the argv identity check."""+ _record(records, pid=12345, udd=str(tmp_path / "p"), owner_pid=os.getpid())+ monkeypatch.setattr(launcher, "_pid_alive", _alive(12345, os.getpid()))+ monkeypatch.setattr(launcher, "_start_time", lambda pid: 777)+ monkeypatch.setattr(launcher, "_cmdline_names_dir", lambda pid, udd: False)++ assert launcher.reap_orphaned_browsers() == 0+ assert records.terminated == []class TestPeriodicOrphanReap:@@ -499,8 +213,6 @@ class TestPeriodicOrphanReap:"""def test_reaper_runs_on_every_interval_not_just_startup(self):- import tools.browser_tool as bt-cycles_to_run = 21reap_calls = []remaining = {"n": cycles_to_run}@@ -508,18 +220,18 @@ class TestPeriodicOrphanReap:def fake_cleanup():remaining["n"] -= 1if remaining["n"] <= 0:- bt._cleanup_running = False+ bs._cleanup_running = False- orig_running = bt._cleanup_running- bt._cleanup_running = True+ orig_running = bs._cleanup_running+ bs._cleanup_running = Truetry:- with patch("tools.browser_tool_lifecycle._reap_orphaned_browser_sessions",+ with patch("tools.browser_session_lifecycle.reap_orphaned_browser_sessions",side_effect=lambda: reap_calls.append(1)), \- patch("tools.browser_tool_lifecycle._cleanup_inactive_browser_sessions",+ patch("tools.browser_session_lifecycle.cleanup_inactive_sessions",side_effect=fake_cleanup), \- patch("tools.browser_tool.time.sleep"):- bt_lifecycle._browser_cleanup_thread_worker()+ patch("tools.browser_session_lifecycle.time.sleep"):+ lifecycle._janitor()finally:- bt._cleanup_running = orig_running+ bs._cleanup_running = orig_runningassert len(reap_calls) > 1, "startup-only reap would give exactly 1"diff --git a/tests/tools/test_browser_profile_live_cdp.py b/tests/tools/test_browser_profile_live_cdp.pyindex 8f17363777f..c8e8cc5c900 100644--- a/tests/tools/test_browser_profile_live_cdp.py+++ b/tests/tools/test_browser_profile_live_cdp.py@@ -9,8 +9,7 @@ import pytestfrom gateway.run import _profile_runtime_scopefrom hermes_constants import hermes_home_key-from tools import browser_tool, browser_tool_cdp as bt_cdp, browser_tool_lifecycle as lifecycle-from tools import browser_tool_session as bt_session+from tools import browser_session as bs, browser_session_cdp as bs_cdp, browser_session_lifecycle as lifecyclefrom tools.browser_supervisor import SUPERVISOR_REGISTRY@@ -21,53 +20,49 @@ def profiles(tmp_path, monkeypatch):b.mkdir()(b / "config.yaml").write_text("browser:\n cdp_url: ws://b.invalid/devtools/browser/PROFILE-B\n")monkeypatch.delenv("BROWSER_CDP_URL", raising=False)- monkeypatch.setattr(bt_cdp, "_live_overrides", {})+ monkeypatch.setattr(bs_cdp, "_live_overrides", {})return a, bdef test_a_live_override_is_this_profiles_alone(profiles, monkeypatch):a, b = profileswith _profile_runtime_scope(a, hydrate_secrets=False):- bt_cdp.set_live_cdp_override("http://127.0.0.1:9333")- assert bt_cdp._get_cdp_override_raw() == "http://127.0.0.1:9333"+ bs_cdp.set_live_cdp_override("http://127.0.0.1:9333")+ assert bs_cdp.get_cdp_override_raw() == "http://127.0.0.1:9333"with _profile_runtime_scope(b, hydrate_secrets=False):- assert bt_cdp.live_cdp_override() == ""- assert bt_cdp._get_cdp_override_raw().endswith("/PROFILE-B")+ assert bs_cdp.live_cdp_override() == ""+ assert bs_cdp.get_cdp_override_raw().endswith("/PROFILE-B")with _profile_runtime_scope(a, hydrate_secrets=False):- bt_cdp.set_live_cdp_override(None)- assert bt_cdp._get_cdp_override_raw() == ""+ bs_cdp.set_live_cdp_override(None)+ assert bs_cdp.get_cdp_override_raw() == ""def test_disconnect_falls_back_to_this_profiles_own_env_never_the_launch_env(profiles, monkeypatch):"""After a disconnect the BROWSER_CDP_URL tier is the profile's own ``.env``; the launch process's``os.environ`` value belongs to the launch profile and must not reach a served one."""from tui_gateway.server import _resolve_browser_cdp_url # bound onto server.py globals- from tools.browser_camofox import is_camofox_modea, b = profiles(b / ".env").write_text("BROWSER_CDP_URL=http://127.0.0.1:7777\n")monkeypatch.setenv("BROWSER_CDP_URL", "http://127.0.0.1:6666") # the launch profile'swith _profile_runtime_scope(b, hydrate_secrets=False):- bt_cdp.set_live_cdp_override("http://127.0.0.1:4444")- assert bt_cdp._get_cdp_override_raw() == "http://127.0.0.1:4444"- bt_cdp.set_live_cdp_override(None)- assert bt_cdp._get_cdp_override_raw() == _resolve_browser_cdp_url() == "http://127.0.0.1:7777"+ bs_cdp.set_live_cdp_override("http://127.0.0.1:4444")+ assert bs_cdp.get_cdp_override_raw() == "http://127.0.0.1:4444"+ bs_cdp.set_live_cdp_override(None)+ assert bs_cdp.get_cdp_override_raw() == _resolve_browser_cdp_url() == "http://127.0.0.1:7777"with _profile_runtime_scope(a, hydrate_secrets=False): # no BROWSER_CDP_URL in A's .env- assert bt_cdp._get_cdp_override_raw() == _resolve_browser_cdp_url() == ""- monkeypatch.setattr("tools.browser_camofox._config_cdp_url", lambda: "")- monkeypatch.setattr("tools.tool_backend_helpers.read_selection", lambda _: "camofox")- assert is_camofox_mode() is True # the launch env's CDP URL does not switch A off Camofox- assert bt_cdp._get_cdp_override_raw() == "http://127.0.0.1:6666" # single-profile: env as before+ assert bs_cdp.get_cdp_override_raw() == _resolve_browser_cdp_url() == ""+ assert bs_cdp.get_cdp_override_raw() == "http://127.0.0.1:6666" # single-profile: env as beforedef test_a_new_session_records_its_profile(profiles, monkeypatch):a, _b = profiles- monkeypatch.setattr(browser_tool, "_active_sessions", {})- monkeypatch.setattr(lifecycle, "_start_browser_cleanup_thread", lambda: None)- monkeypatch.setattr(bt_session, "_create_session_for_key", lambda key, local: {"session_name": "s"})- monkeypatch.setattr(bt_cdp, "_ensure_cdp_supervisor", lambda key: None)+ monkeypatch.setattr(bs, "_active_sessions", {})+ monkeypatch.setattr(lifecycle, "start_cleanup_thread", lambda: None)+ monkeypatch.setattr(bs, "_create_session_for_key", lambda key, force_local: {"session_name": "s"})+ monkeypatch.setattr(bs_cdp, "ensure_cdp_supervisor", lambda key: None)with _profile_runtime_scope(a, hydrate_secrets=False):- info = bt_session._get_session_info("task-a")+ info = bs.get_session_info("task-a")assert info["home_key"] == hermes_home_key(a)@@ -75,13 +70,13 @@ def test_reaping_one_profile_leaves_the_other_profiles_browser_and_supervisor(pra, b = profileskey_a, key_b = hermes_home_key(a), hermes_home_key(b)sessions = {"ta": {"home_key": key_a}, "ta::local": {"home_key": key_a}, "tb": {"home_key": key_b}}- monkeypatch.setattr(browser_tool, "_active_sessions", sessions)+ monkeypatch.setattr(bs, "_active_sessions", sessions)closed = []def close(task_id):closed.append(task_id)sessions.pop(task_id, None)- monkeypatch.setattr(lifecycle, "_cleanup_single_browser_session", close)+ monkeypatch.setattr(lifecycle, "cleanup_single_session", close)stopped = []sup = lambda name: types.SimpleNamespace(stop=lambda: stopped.append(name))monkeypatch.setattr(SUPERVISOR_REGISTRY, "_by_task", {"ta": sup("ta"), "vault-a": sup("vault-a"), "tb": sup("tb")})@@ -113,12 +108,12 @@ cat "$latch"monkeypatch.setattr(bu_cli, "_find_cli", lambda: [str(cli)])monkeypatch.setattr(bu_cli, "_driven_daemons", {})monkeypatch.setattr(bu_cli, "_attach_vault_supervisor", lambda env, task_id: None)- monkeypatch.setattr(bt_cdp, "_resolve_cdp_override", lambda url: url)+ monkeypatch.setattr(bs_cdp, "resolve_cdp_override", lambda url: url)def drive(home, url=None):with _profile_runtime_scope(home, hydrate_secrets=False):if url:- bt_cdp.set_live_cdp_override(url)+ bs_cdp.set_live_cdp_override(url)return json.loads(bu_cli.browser_exec("print(1)", task_id="t"))["output"].strip()assert drive(a, "http://127.0.0.1:9301") == "http://127.0.0.1:9301"@@ -131,7 +126,7 @@ cat "$latch"or real_run(cmd, code, env, timeout))with _profile_runtime_scope(a, hydrate_secrets=False):lifecycle.cleanup_profile_browsers(hermes_home_key(a))- bt_cdp.set_live_cdp_override("http://127.0.0.1:9311")+ bs_cdp.set_live_cdp_override("http://127.0.0.1:9311")assert len(reloads) == 1 # A's reap stops exactly A's daemonassert [home for home in bu_cli._driven_daemons.values()] == [hermes_home_key(b)]assert drive(b) == "http://127.0.0.1:9302" # B's daemon survived A's reapdiff --git a/tests/tools/test_browser_profile_scope_edges.py b/tests/tools/test_browser_profile_scope_edges.pyindex 1e0c651c17f..a9de8e38c99 100644--- a/tests/tools/test_browser_profile_scope_edges.py+++ b/tests/tools/test_browser_profile_scope_edges.py@@ -11,7 +11,7 @@ import pytestfrom agent import secret_scopefrom gateway.run import _profile_runtime_scopefrom hermes_constants import get_hermes_home, hermes_home_key-from tools import browser_tool_cdp as bt_cdp+from tools import browser_session_cdp as bs_cdpfrom tools import browser_harness_dirs as harness_dirsfrom tools.browser_harness_dirs import claim_private_dir as _REAL_CLAIM # conftest stubs it per test@@ -22,7 +22,7 @@ def profiles(tmp_path, monkeypatch):a.mkdir()b.mkdir()monkeypatch.delenv("BROWSER_CDP_URL", raising=False)- monkeypatch.setattr(bt_cdp, "_live_overrides", {})+ monkeypatch.setattr(bs_cdp, "_live_overrides", {})return a, b@@ -40,18 +40,18 @@ def test_a_bare_thread_on_a_multiplexed_gateway_never_resolves_the_launch_profilanswer (``get_secret`` fails closed the same way). A bound scope still sees its own."""launch = get_hermes_home()with _profile_runtime_scope(launch, hydrate_secrets=False):- bt_cdp.set_live_cdp_override("http://127.0.0.1:9401")+ bs_cdp.set_live_cdp_override("http://127.0.0.1:9401")monkeypatch.setattr(secret_scope, "_MULTIPLEX_ACTIVE", True)- assert _in_bare_thread(bt_cdp.live_cdp_override) == ""- assert _in_bare_thread(bt_cdp._get_cdp_override_raw) == ""+ assert _in_bare_thread(bs_cdp.live_cdp_override) == ""+ assert _in_bare_thread(bs_cdp.get_cdp_override_raw) == ""with _profile_runtime_scope(launch, hydrate_secrets=False):- assert bt_cdp.live_cdp_override() == "http://127.0.0.1:9401"+ assert bs_cdp.live_cdp_override() == "http://127.0.0.1:9401"def test_single_profile_bare_thread_keeps_the_process_override(profiles):- bt_cdp.set_live_cdp_override("http://127.0.0.1:9402")- assert _in_bare_thread(bt_cdp.live_cdp_override) == "http://127.0.0.1:9402"- assert hermes_home_key() in bt_cdp._live_overrides+ bs_cdp.set_live_cdp_override("http://127.0.0.1:9402")+ assert _in_bare_thread(bs_cdp.live_cdp_override) == "http://127.0.0.1:9402"+ assert hermes_home_key() in bs_cdp._live_overrides# --- macOS AF_UNIX budget for a served profile's harness sockets -------------------------------------@@ -275,31 +275,30 @@ def test_a_session_that_resolved_the_old_endpoint_during_a_connect_is_closed_not"""``/browser connect`` reaps, publishes the new endpoint, then reaps again. A tool call thatresolved the OLD endpoint before the publish but inserted its session after the second reap keptdriving the old browser. The real ``_browser_connect`` handler runs mid-creation here."""- from tools import browser_tool, browser_tool_lifecycle as lifecycle, browser_tool_session as bt_session+ from tools import browser_session as bs, browser_session_lifecycle as lifecyclefrom tui_gateway import server # binds methods_browser helpers onto server globalsa, _b = profilessessions = {}- monkeypatch.setattr(browser_tool, "_active_sessions", sessions)- monkeypatch.setattr(lifecycle, "_start_browser_cleanup_thread", lambda: None)- monkeypatch.setattr(bt_cdp, "_ensure_cdp_supervisor", lambda key: None)+ monkeypatch.setattr(bs, "_active_sessions", sessions)+ monkeypatch.setattr(lifecycle, "start_cleanup_thread", lambda: None)+ monkeypatch.setattr(bs_cdp, "ensure_cdp_supervisor", lambda key: None)monkeypatch.setattr(server, "_cdp_http_reachable", lambda parsed, timeout=2.0: True)closed = [] # released by object: the stale session is never in ``sessions``- monkeypatch.setattr(lifecycle, "_release_session_backend", lambda task_id, info: closed.append(info["cdp_url"]))- monkeypatch.setattr(bt_session, "_browser_command_preflight", lambda: {"error": "no CLI in this test"})+ monkeypatch.setattr(lifecycle, "release_session_backend", lambda task_id, info: closed.append(info["cdp_url"]))created = []- def create(task_id, local):- url = bt_cdp._get_cdp_override_raw() # resolved before the connect publishes+ def create(task_id, force_local):+ url = bs_cdp.get_cdp_override_raw() # resolved before the connect publishesif not created:assert server._browser_connect("r1", {"url": "http://127.0.0.1:9502"})["result"]["connected"]created.append(url)return {"session_name": f"s{len(created)}", "cdp_url": url}- monkeypatch.setattr(bt_session, "_create_session_for_key", create)+ monkeypatch.setattr(bs, "_create_session_for_key", create)with _profile_runtime_scope(a, hydrate_secrets=False):- bt_cdp.set_live_cdp_override("http://127.0.0.1:9501")- info = bt_session._get_session_info("task-a")+ bs_cdp.set_live_cdp_override("http://127.0.0.1:9501")+ info = bs.get_session_info("task-a")assert info["cdp_url"] == "http://127.0.0.1:9502"assert sessions["task-a"] is infoassert closed == ["http://127.0.0.1:9501"]@@ -307,63 +306,61 @@ def test_a_session_that_resolved_the_old_endpoint_during_a_connect_is_closed_notdef test_a_stale_session_is_closed_without_ever_being_handed_to_a_concurrent_caller(profiles, monkeypatch):"""A session found stale after creation is closed by object, never published first: while its- backend ``close`` runs, a concurrent ``_get_session_info`` for the same key must not find it in+ backend ``close`` runs, a concurrent ``get_session_info`` for the same key must not find it in``_active_sessions`` (it would return a browser that is being closed underneath it)."""- from tools import browser_tool, browser_tool_lifecycle as lifecycle, browser_tool_session as bt_session+ from tools import browser_session as bs, browser_session_lifecycle as lifecyclefrom tui_gateway import servera, _b = profilessessions = {}- monkeypatch.setattr(browser_tool, "_active_sessions", sessions)- monkeypatch.setattr(lifecycle, "_start_browser_cleanup_thread", lambda: None)- monkeypatch.setattr(bt_cdp, "_ensure_cdp_supervisor", lambda key: None)- monkeypatch.setattr(bt_cdp, "_stop_cdp_supervisor", lambda key: None)+ monkeypatch.setattr(bs, "_active_sessions", sessions)+ monkeypatch.setattr(lifecycle, "start_cleanup_thread", lambda: None)+ monkeypatch.setattr(bs_cdp, "ensure_cdp_supervisor", lambda key: None)+ monkeypatch.setattr(bs_cdp, "stop_cdp_supervisor", lambda key: None)monkeypatch.setattr(server, "_cdp_http_reachable", lambda parsed, timeout=2.0: True)- monkeypatch.setattr(bt_session, "_browser_command_preflight", lambda: {"browser_cmd": "agent-browser"})visible_during_close = []-- def dispatch(task_id, info, browser_cmd, command, args, timeout, engine):- if command == "close": # what the existing-session path would hand a concurrent caller now- visible_during_close.append((info["cdp_url"], (sessions.get(task_id) or {}).get("cdp_url")))- return "chrome", {"success": True}- monkeypatch.setattr(bt_session, "_dispatch_browser_command", dispatch)released = []- monkeypatch.setattr(lifecycle, "_release_session_backend", lambda task_id, info: released.append(info["cdp_url"]))++ def release(task_id, info): # the backend close: what a concurrent caller would be handed now+ visible_during_close.append((info["cdp_url"], (sessions.get(task_id) or {}).get("cdp_url")))+ released.append(info["cdp_url"])+ monkeypatch.setattr(lifecycle, "release_session_backend", release)created = []- def create(task_id, local):- url = bt_cdp._get_cdp_override_raw()+ def create(task_id, force_local):+ url = bs_cdp.get_cdp_override_raw()if not created:assert server._browser_connect("r1", {"url": "http://127.0.0.1:9512"})["result"]["connected"]created.append(url)return {"session_name": f"s{len(created)}", "cdp_url": url, "bb_session_id": None}- monkeypatch.setattr(bt_session, "_create_session_for_key", create)+ monkeypatch.setattr(bs, "_create_session_for_key", create)with _profile_runtime_scope(a, hydrate_secrets=False):- bt_cdp.set_live_cdp_override("http://127.0.0.1:9511")- info = bt_session._get_session_info("task-a")+ bs_cdp.set_live_cdp_override("http://127.0.0.1:9511")+ info = bs.get_session_info("task-a")assert visible_during_close == [("http://127.0.0.1:9511", None)]assert released == ["http://127.0.0.1:9511"]assert info["cdp_url"] == "http://127.0.0.1:9512" and sessions["task-a"] is infodef test_another_profiles_connect_does_not_invalidate_this_profiles_new_session(profiles, monkeypatch):- from tools import browser_tool, browser_tool_lifecycle as lifecycle, browser_tool_session as bt_session+ from tools import browser_session as bs, browser_session_lifecycle as lifecyclea, b = profilessessions = {}- monkeypatch.setattr(browser_tool, "_active_sessions", sessions)- monkeypatch.setattr(lifecycle, "_start_browser_cleanup_thread", lambda: None)- monkeypatch.setattr(bt_cdp, "_ensure_cdp_supervisor", lambda key: None)+ monkeypatch.setattr(bs, "_active_sessions", sessions)+ monkeypatch.setattr(lifecycle, "start_cleanup_thread", lambda: None)+ monkeypatch.setattr(bs_cdp, "ensure_cdp_supervisor", lambda key: None)closed = []- monkeypatch.setattr(lifecycle, "_cleanup_single_browser_session", closed.append)+ monkeypatch.setattr(lifecycle, "cleanup_single_session", closed.append)+ monkeypatch.setattr(lifecycle, "release_session_backend", lambda task_id, info: closed.append(task_id))- def create(task_id, local):+ def create(task_id, force_local):with _profile_runtime_scope(b, hydrate_secrets=False):- bt_cdp.set_live_cdp_override("http://127.0.0.1:9601")+ bs_cdp.set_live_cdp_override("http://127.0.0.1:9601")return {"session_name": "s", "cdp_url": "x"}- monkeypatch.setattr(bt_session, "_create_session_for_key", create)+ monkeypatch.setattr(bs, "_create_session_for_key", create)with _profile_runtime_scope(a, hydrate_secrets=False):- info = bt_session._get_session_info("task-a")+ info = bs.get_session_info("task-a")assert sessions == {"task-a": info} and closed == []@@ -379,7 +376,7 @@ def test_a_browser_exec_that_routed_to_the_old_endpoint_during_a_connect_reloadsmonkeypatch.setattr(bu_cli, "_driven_daemons", {})monkeypatch.setattr(bu_cli, "_find_cli", lambda: ["browser-harness"])monkeypatch.setattr(bu_cli, "_attach_vault_supervisor", lambda env, task_id: None)- monkeypatch.setattr(bt_cdp, "_resolve_cdp_override", lambda raw: raw)+ monkeypatch.setattr(bs_cdp, "resolve_cdp_override", lambda raw: raw)monkeypatch.setattr(server, "_cdp_http_reachable", lambda parsed, timeout=2.0: True)latched = {} # like browser-harness: one daemon per identity latches BU_CDP_URL; --reload stops it@@ -404,7 +401,7 @@ def test_a_browser_exec_that_routed_to_the_old_endpoint_during_a_connect_reloadsimport jsonwith _profile_runtime_scope(a, hydrate_secrets=False):- bt_cdp.set_live_cdp_override("http://127.0.0.1:9701")+ bs_cdp.set_live_cdp_override("http://127.0.0.1:9701")first = json.loads(bu_cli.browser_exec("print(1)", task_id="t1"))assert connects[0]["result"]["connected"]nxt = json.loads(bu_cli.browser_exec("print(1)", task_id="t1"))@@ -424,7 +421,7 @@ def test_a_connect_that_lands_while_browser_exec_spawns_its_daemon_reloads_it(prmonkeypatch.setattr(bu_cli, "_driven_daemons", {})monkeypatch.setattr(bu_cli, "_find_cli", lambda: ["browser-harness"])monkeypatch.setattr(bu_cli, "_attach_vault_supervisor", lambda env, task_id: None)- monkeypatch.setattr(bt_cdp, "_resolve_cdp_override", lambda raw: raw)+ monkeypatch.setattr(bs_cdp, "resolve_cdp_override", lambda raw: raw)monkeypatch.setattr(server, "_cdp_http_reachable", lambda parsed, timeout=2.0: True)latched, connects = {}, []@@ -439,7 +436,7 @@ def test_a_connect_that_lands_while_browser_exec_spawns_its_daemon_reloads_it(prreturn subprocess.CompletedProcess(cmd, 0, str(latched.get(ident)), "")monkeypatch.setattr(bu_cli, "_run_cli_killing_process_group", run)with _profile_runtime_scope(a, hydrate_secrets=False):- bt_cdp.set_live_cdp_override("http://127.0.0.1:9711")+ bs_cdp.set_live_cdp_override("http://127.0.0.1:9711")json.loads(bu_cli.browser_exec("print(1)", task_id="t1"))assert connects[0]["result"]["connected"]nxt = json.loads(bu_cli.browser_exec("print(1)", task_id="t1"))