The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
test(browser): port session-layer tests (cloud, expiry, cleanup, headed, PM) to browser_session
Tekniumcece24c01847
diff --git a/tests/tools/test_browser_cleanup.py b/tests/tools/test_browser_cleanup.pyindex 70e10824858..b7d57ef2a4e 100644--- a/tests/tools/test_browser_cleanup.py+++ b/tests/tools/test_browser_cleanup.py@@ -1,89 +1,60 @@-"""Regression tests for browser session cleanup and screenshot recovery."""+"""Regression tests for browser session cleanup (tools/browser_session_lifecycle.py)."""+import sysfrom unittest.mock import patch-from tools import browser_tool_lifecycle as bt_lifecycle--class TestScreenshotPathRecovery:- def test_extracts_standard_absolute_path(self):- from tools.browser_tool_snapshot import _extract_screenshot_path_from_text-- assert (- _extract_screenshot_path_from_text("Screenshot saved to /tmp/foo.png")- == "/tmp/foo.png"- )-- def test_extracts_quoted_absolute_path(self):- from tools.browser_tool_snapshot import _extract_screenshot_path_from_text-- assert (- _extract_screenshot_path_from_text(- "Screenshot saved to '/Users/david/.hermes/browser_screenshots/shot.png'"- )- == "/Users/david/.hermes/browser_screenshots/shot.png"- )+from tools import browser_session as bs+from tools import browser_session_lifecycle as lifecycleclass TestBrowserCleanup:def setup_method(self):- from tools import browser_tool-- self.browser_tool = browser_tool- self.orig_active_sessions = browser_tool._active_sessions.copy()- self.orig_session_last_activity = browser_tool._session_last_activity.copy()- self.orig_recording_sessions = browser_tool._recording_sessions.copy()- self.orig_cleanup_done = browser_tool._cleanup_done+ self.orig_active_sessions = bs._active_sessions.copy()+ self.orig_session_last_activity = bs._session_last_activity.copy()+ self.orig_cleanup_done = bs._cleanup_donedef teardown_method(self):- self.browser_tool._active_sessions.clear()- self.browser_tool._active_sessions.update(self.orig_active_sessions)- self.browser_tool._session_last_activity.clear()- self.browser_tool._session_last_activity.update(self.orig_session_last_activity)- self.browser_tool._recording_sessions.clear()- self.browser_tool._recording_sessions.update(self.orig_recording_sessions)- self.browser_tool._cleanup_done = self.orig_cleanup_done+ bs._active_sessions.clear()+ bs._active_sessions.update(self.orig_active_sessions)+ bs._session_last_activity.clear()+ bs._session_last_activity.update(self.orig_session_last_activity)+ bs._cleanup_done = self.orig_cleanup_donedef test_cleanup_browser_clears_tracking_state(self):- browser_tool = self.browser_tool- browser_tool._active_sessions["task-1"] = {+ bs._active_sessions["task-1"] = {"session_name": "sess-1","bb_session_id": None,+ "launcher_key": "task-1",+ "features": {"local": True},}- browser_tool._session_last_activity["task-1"] = 123.0+ bs._session_last_activity["task-1"] = 123.0- with (- patch("tools.browser_tool._maybe_stop_recording") as mock_stop,- patch(- "tools.browser_tool_session._run_browser_command",- return_value={"success": True},- ) as mock_run,- patch("tools.browser_tool.os.path.exists", return_value=False),- ):- bt_lifecycle.cleanup_browser("task-1")+ with patch("tools.browser_launcher.stop_browser") as mock_stop:+ lifecycle.cleanup_browser("task-1")- assert "task-1" not in browser_tool._active_sessions- assert "task-1" not in browser_tool._session_last_activity+ assert "task-1" not in bs._active_sessions+ assert "task-1" not in bs._session_last_activitymock_stop.assert_called_once_with("task-1")- assert mock_run.call_args.args[:2] == ("task-1", "close")def test_emergency_cleanup_clears_all_tracking_state(self):- browser_tool = self.browser_tool- browser_tool._cleanup_done = False- browser_tool._active_sessions["task-1"] = {"session_name": "sess-1"}- browser_tool._active_sessions["task-2"] = {"session_name": "sess-2"}- browser_tool._session_last_activity["task-1"] = 1.0- browser_tool._session_last_activity["task-2"] = 2.0- browser_tool._recording_sessions.update({"task-1", "task-2"})+ bs._cleanup_done = False+ bs._active_sessions["task-1"] = {"session_name": "sess-1"}+ bs._active_sessions["task-2"] = {"session_name": "sess-2"}+ bs._session_last_activity["task-1"] = 1.0+ bs._session_last_activity["task-2"] = 2.0- with patch("tools.browser_tool_lifecycle.cleanup_all_browsers") as mock_cleanup_all:- bt_lifecycle._emergency_cleanup_all_sessions()+ with (+ patch("tools.browser_session_lifecycle.cleanup_all_browsers") as mock_cleanup_all,+ patch("tools.browser_session_lifecycle.reap_orphaned_browser_sessions") as mock_reap,+ ):+ lifecycle.emergency_cleanup_all_sessions()mock_cleanup_all.assert_called_once_with()- assert browser_tool._active_sessions == {}- assert browser_tool._session_last_activity == {}- assert browser_tool._recording_sessions == set()- assert browser_tool._cleanup_done is True+ mock_reap.assert_called_once_with()+ assert bs._active_sessions == {}+ assert bs._session_last_activity == {}+ assert bs._cleanup_done is Trueclass TestInactivityJanitorMultiplex:@@ -91,29 +62,27 @@ class TestInactivityJanitorMultiplex:def setup_method(self):from agent import secret_scope- from tools import browser_tool- self.bt = browser_toolself.saved = {- name: getattr(browser_tool, name).copy()+ name: getattr(bs, name).copy()for name in ("_active_sessions", "_session_last_activity",- "_session_owner_homes", "_cleanup_failures", "_recording_sessions",+ "_session_owner_homes", "_cleanup_failures",)}- self.orig_timeout = browser_tool.BROWSER_SESSION_INACTIVITY_TIMEOUT- browser_tool.BROWSER_SESSION_INACTIVITY_TIMEOUT = 0+ self.orig_timeout = bs.BROWSER_SESSION_INACTIVITY_TIMEOUT+ bs.BROWSER_SESSION_INACTIVITY_TIMEOUT = 0for name in self.saved:- getattr(browser_tool, name).clear()+ getattr(bs, name).clear()secret_scope.set_multiplex_active(True)def teardown_method(self):from agent import secret_scopesecret_scope.set_multiplex_active(False)- self.bt.BROWSER_SESSION_INACTIVITY_TIMEOUT = self.orig_timeout+ bs.BROWSER_SESSION_INACTIVITY_TIMEOUT = self.orig_timeoutfor name, saved in self.saved.items():- live = getattr(self.bt, name)+ live = getattr(bs, name)live.clear()live.update(saved)@@ -124,97 +93,84 @@ class TestInactivityJanitorMultiplex:)monkeypatch.setenv("HERMES_HOME", str(tmp_path))- monkeypatch.delenv("CAMOFOX_URL", raising=False)+ monkeypatch.delenv("BROWSER_USE_API_KEY", raising=False)monkeypatch.delenv("BROWSER_CDP_URL", raising=False)p1 = tmp_path / "profiles" / "p1"p1.mkdir(parents=True)- (p1 / ".env").write_text("CAMOFOX_URL=http://127.0.0.1:1\n", encoding="utf-8")+ (p1 / ".env").write_text("BROWSER_USE_API_KEY=p1-key\n", encoding="utf-8")# Profile p1's turn opens the session; the janitor later runs unscoped.home_tok = set_hermes_home_override(str(p1))scope_tok = secret_scope.set_secret_scope(secret_scope.build_profile_secret_scope(p1))try:- bt_lifecycle._update_session_activity("t1")- self.bt._active_sessions["t1"] = {"session_name": "s1", "bb_session_id": None}+ lifecycle.update_session_activity("t1")+ bs._active_sessions["t1"] = {"session_name": "s1", "bb_session_id": None,+ "launcher_key": "t1", "features": {"local": True}}finally:secret_scope.reset_secret_scope(scope_tok)reset_hermes_home_override(home_tok)- self.bt._session_last_activity["t1"] -= 10+ bs._session_last_activity["t1"] -= 10seen = {}- def fake_close(task_id, cmd, args, timeout=None):+ def fake_stop(launcher_key):seen["home"] = str(get_hermes_home())- seen["url"] = secret_scope.get_secret("CAMOFOX_URL")- return {"success": True}+ seen["key"] = secret_scope.get_secret("BROWSER_USE_API_KEY")- with (- patch("tools.browser_tool_session._run_browser_command", side_effect=fake_close),- patch("tools.browser_camofox._delete", return_value={}),- patch("tools.browser_tool.os.path.exists", return_value=False),- ):- bt_lifecycle._cleanup_inactive_browser_sessions()+ with patch("tools.browser_launcher.stop_browser", side_effect=fake_stop):+ lifecycle.cleanup_inactive_sessions()- assert seen == {"home": str(p1), "url": "http://127.0.0.1:1"}- assert "t1" not in self.bt._session_last_activity- assert "t1" not in self.bt._active_sessions- assert "t1" not in self.bt._session_owner_homes+ assert seen == {"home": str(p1), "key": "p1-key"}+ assert "t1" not in bs._session_last_activity+ assert "t1" not in bs._active_sessions+ assert "t1" not in bs._session_owner_homesdef test_repeated_failures_force_reap_and_close_cloud_session(self):from unittest.mock import MagicMock- self.bt._active_sessions["t1"] = {"session_name": "s1", "bb_session_id": "bb-1"}- self.bt._session_last_activity["t1"] = 1.0+ bs._active_sessions["t1"] = {"session_name": "s1", "bb_session_id": "bb-1"}+ bs._session_last_activity["t1"] = 1.0provider = MagicMock()with (- patch("tools.browser_tool_lifecycle.cleanup_browser", side_effect=RuntimeError("boom")),- patch("tools.browser_tool_cloud._get_cloud_provider", return_value=provider),- patch("tools.browser_tool.os.path.exists", return_value=False),+ patch("tools.browser_session_lifecycle.cleanup_single_session", side_effect=RuntimeError("boom")),+ patch("tools.browser_session_cloud.get_cloud_provider", return_value=provider),):- for _ in range(self.bt.MAX_INACTIVITY_CLEANUP_FAILURES - 1):- bt_lifecycle._cleanup_inactive_browser_sessions()+ for _ in range(bs.MAX_INACTIVITY_CLEANUP_FAILURES - 1):+ lifecycle.cleanup_inactive_sessions()# An activity touch must NOT reset the failure budget.- bt_lifecycle._update_session_activity("t1")- self.bt._session_last_activity["t1"] = 1.0- assert self.bt._cleanup_failures["t1"] == self.bt.MAX_INACTIVITY_CLEANUP_FAILURES - 1- assert "t1" in self.bt._active_sessions+ lifecycle.update_session_activity("t1")+ bs._session_last_activity["t1"] = 1.0+ assert bs._cleanup_failures["t1"] == bs.MAX_INACTIVITY_CLEANUP_FAILURES - 1+ assert "t1" in bs._active_sessionsprovider.close_session.assert_not_called()- bt_lifecycle._cleanup_inactive_browser_sessions()+ lifecycle.cleanup_inactive_sessions()provider.close_session.assert_called_once_with("bb-1")- assert "t1" not in self.bt._active_sessions- assert "t1" not in self.bt._session_last_activity- assert "t1" not in self.bt._cleanup_failures+ assert "t1" not in bs._active_sessions+ assert "t1" not in bs._session_last_activity+ assert "t1" not in bs._cleanup_failuresclass TestAtexitStopSwallowsInterrupt:def test_second_ctrl_c_during_join_does_not_propagate(self, monkeypatch):"""A second Ctrl+C while the atexit hook waits on the janitor must not escape as atraceback (#10764): the thread is a daemon, the interpreter is already exiting."""- from tools import browser_toolclass _InterruptedJoin:def join(self, timeout=None):raise KeyboardInterrupt- monkeypatch.setattr(browser_tool, "_cleanup_thread", _InterruptedJoin())- monkeypatch.setattr(browser_tool, "_cleanup_running", True)- bt_lifecycle._stop_browser_cleanup_thread() # must not raise- assert browser_tool._cleanup_running is False---class TestAtexitOriginUnimportable:- def test_hooks_stay_silent_when_origin_fresh_import_fails(self, monkeypatch):- """Mid-`hermes update` the on-disk tree can be half-new (new config.py importing- a name the old utils.py lacks yet); the fresh import in origin_module then raises- and the atexit hooks must stay silent (#112437)."""- import tools.browser_tool_origin as origin_mod+ monkeypatch.setattr(bs, "_cleanup_thread", _InterruptedJoin())+ monkeypatch.setattr(bs, "_cleanup_running", True)+ lifecycle.stop_cleanup_thread() # must not raise+ assert bs._cleanup_running is False- def _boom(_depth=2):- raise ImportError("cannot import name 'file_signature' from 'utils'")- monkeypatch.setattr(origin_mod, "origin_module", _boom)- bt_lifecycle._emergency_cleanup_all_sessions() # must not raise- bt_lifecycle._stop_browser_cleanup_thread() # must not raise+class TestAtexitLifecycleUnimportable:+ def test_hook_stays_silent_when_lifecycle_import_fails(self, monkeypatch):+ """Mid-`hermes update` the on-disk tree can be half-new, so the atexit hook's import of+ the lifecycle module raises; the hook must stay silent (#112437)."""+ monkeypatch.setitem(sys.modules, "tools.browser_session_lifecycle", None) # import -> ImportError+ bs._atexit_cleanup() # must not raisediff --git a/tests/tools/test_browser_cloud_fallback.py b/tests/tools/test_browser_cloud_fallback.pyindex 33948752f60..fe87978871a 100644--- a/tests/tools/test_browser_cloud_fallback.py+++ b/tests/tools/test_browser_cloud_fallback.py@@ -1,29 +1,31 @@"""Tests for cloud browser provider runtime fallback to local Chromium.-Covers the fallback logic in _get_session_info() when a cloud provider+Covers the fallback logic in ``browser_session.get_session_info()`` when a cloud provideris configured but fails at runtime (issue #10883)."""-import logging+from types import SimpleNamespacefrom unittest.mock import Mock-import pytest+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_tool-from tools import browser_tool_session as bt_session-from tools import browser_tool_cloud as bt_cloud+_LOCAL_CDP = "ws://127.0.0.1:9333/devtools/browser/local"def _reset_session_state(monkeypatch):- """Clear caches so each test starts fresh."""- monkeypatch.setattr(browser_tool, "_active_sessions", {})- monkeypatch.setattr(browser_tool, "_cached_cloud_provider", None)- monkeypatch.setattr(browser_tool, "_cloud_provider_resolved", False)- monkeypatch.setattr("tools.browser_tool_lifecycle._start_browser_cleanup_thread", lambda: None)- monkeypatch.setattr("tools.browser_tool_lifecycle._update_session_activity", lambda t: None)+ """Clear caches so each test starts fresh; the local browser is a stub launcher browser."""+ 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("tools.browser_session_cdp.ensure_cdp_supervisor", lambda task_id: None)+ 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))class TestCloudProviderRuntimeFallback:- """Tests for _get_session_info cloud → local fallback."""+ """Tests for get_session_info cloud -> local fallback."""def test_cloud_failure_falls_back_to_local(self, monkeypatch):"""When cloud provider.create_session raises, fall back to local."""@@ -31,26 +33,26 @@ class TestCloudProviderRuntimeFallback:provider = Mock()provider.create_session.side_effect = RuntimeError("401 Unauthorized")- monkeypatch.setattr(bt_cloud, "_get_cloud_provider", lambda: provider)- monkeypatch.setattr("tools.browser_tool_cdp._get_cdp_override", lambda: None)+ monkeypatch.setattr(bs_cloud, "get_cloud_provider", lambda: provider)+ monkeypatch.setattr("tools.browser_session_cdp.get_cdp_override", lambda: None)- session = bt_session._get_session_info("task-1")+ session = bs.get_session_info("task-1")assert session["fallback_from_cloud"] is Trueassert "401 Unauthorized" in session["fallback_reason"]assert session["fallback_provider"] == "Mock"assert session["features"]["local"] is True- assert session["cdp_url"] is None+ assert session["cdp_url"] == _LOCAL_CDPdef test_no_provider_uses_local_directly(self, monkeypatch):"""When no cloud provider is configured, local mode is used with no fallback markers."""_reset_session_state(monkeypatch)- monkeypatch.setattr(bt_cloud, "_get_cloud_provider", lambda: None)- monkeypatch.setattr("tools.browser_tool_cdp._get_cdp_override", lambda: None)+ monkeypatch.setattr(bs_cloud, "get_cloud_provider", lambda: None)+ monkeypatch.setattr("tools.browser_session_cdp.get_cdp_override", lambda: None)- session = bt_session._get_session_info("task-4")+ session = bs.get_session_info("task-4")assert session["features"]["local"] is Trueassert "fallback_from_cloud" not in session@@ -62,10 +64,10 @@ class TestCloudProviderRuntimeFallback:provider = Mock()provider.create_session.return_value = None- monkeypatch.setattr(bt_cloud, "_get_cloud_provider", lambda: provider)- monkeypatch.setattr("tools.browser_tool_cdp._get_cdp_override", lambda: None)+ monkeypatch.setattr(bs_cloud, "get_cloud_provider", lambda: provider)+ monkeypatch.setattr("tools.browser_session_cdp.get_cdp_override", lambda: None)- session = bt_session._get_session_info("task-7")+ session = bs.get_session_info("task-7")assert session["fallback_from_cloud"] is Trueassert "invalid session" in session["fallback_reason"]diff --git a/tests/tools/test_browser_cloud_provider_cache.py b/tests/tools/test_browser_cloud_provider_cache.pyindex a37d8412e39..83c44e0ee43 100644--- a/tests/tools/test_browser_cloud_provider_cache.py+++ b/tests/tools/test_browser_cloud_provider_cache.py@@ -1,4 +1,4 @@-"""Tests for ``_get_cloud_provider()`` caching policy.+"""Tests for ``browser_session_cloud.get_cloud_provider()`` caching policy.Regression coverage for issue #22324: a transient ``None`` from the resolvermust not be cached for the lifetime of the process. Cache only when:@@ -14,17 +14,22 @@ from unittest.mock import Mockimport pytest-from tools import browser_tool-from tools import browser_tool_cloud as bt_cloud+from hermes_constants import hermes_home_key+from tools import browser_session_cloud as bs_cloud@pytest.fixture(autouse=True)def _reset_resolver_state(monkeypatch):- monkeypatch.setattr(browser_tool, "_cached_cloud_provider", None)- monkeypatch.setattr(browser_tool, "_cloud_provider_resolved", False)+ monkeypatch.setattr(bs_cloud, "_cached_providers", {})yield+def _resolution_cached() -> bool:+ """Whether the active profile has a cached provider resolution."""+ scope = hermes_home_key()+ return any(key[0] == scope for key in bs_cloud._cached_providers)++class TestCloudProviderCachePolicy:def test_cache_is_isolated_by_hermes_home(self, tmp_path, monkeypatch):from hermes_constants import (@@ -45,8 +50,8 @@ class TestCloudProviderCachePolicy:resolutions.append(home)return providers[home]- monkeypatch.setattr("tools.browser_tool_cloud._ensure_browser_plugins_loaded", lambda: None)- monkeypatch.setattr("tools.browser_tool_cloud._registry_get_browser_provider", resolve)+ monkeypatch.setattr("tools.browser_session_cloud._ensure_browser_plugins_loaded", lambda: None)+ monkeypatch.setattr("agent.browser_registry.get_provider", resolve)home_a = tmp_path / "browser-a"home_b = tmp_path / "browser-b"providers[str(home_a)] = Mock(name="provider-a")@@ -55,7 +60,7 @@ class TestCloudProviderCachePolicy:def resolve_for(home):token = set_hermes_home_override(home)try:- return bt_cloud._get_cloud_provider()+ return bs_cloud.get_cloud_provider()finally:reset_hermes_home_override(token)@@ -101,13 +106,13 @@ class TestCloudProviderCachePolicy:"hermes_cli.config.read_raw_config",lambda: {"browser": {"cloud_provider": "cache-replacement"}},)- monkeypatch.setattr("tools.browser_tool_cloud._ensure_browser_plugins_loaded", lambda: None)+ monkeypatch.setattr("tools.browser_session_cloud._ensure_browser_plugins_loaded", lambda: None)token = set_hermes_home_override(home)try:browser_registry.register_provider(first, scope=home)- assert bt_cloud._get_cloud_provider() is first+ assert bs_cloud.get_cloud_provider() is firstbrowser_registry.register_provider(second, scope=home)- assert bt_cloud._get_cloud_provider() is second+ assert bs_cloud.get_cloud_provider() is secondfinally:current = browser_registry.snapshot_registration("cache-replacement", scope=home@@ -172,14 +177,14 @@ class TestCloudProviderCachePolicy:"hermes_cli.config.read_raw_config",lambda: {"browser": {"cloud_provider": "cache-race"}},)- monkeypatch.setattr("tools.browser_tool_cloud._ensure_browser_plugins_loaded", lambda: None)- monkeypatch.setattr("tools.browser_tool_cloud._registry_get_browser_provider", racing_get)+ monkeypatch.setattr("tools.browser_session_cloud._ensure_browser_plugins_loaded", lambda: None)+ monkeypatch.setattr("agent.browser_registry.get_provider", racing_get)browser_registry.register_provider(first, scope=home)def resolve():token = set_hermes_home_override(home)try:- return bt_cloud._get_cloud_provider()+ return bs_cloud.get_cloud_provider()finally:reset_hermes_home_override(token)@@ -206,15 +211,15 @@ class TestCloudProviderCachePolicy:lambda: {"browser": {"cloud_provider": "local"}},)- assert bt_cloud._get_cloud_provider() is None- assert browser_tool._cloud_provider_resolved is True+ assert bs_cloud.get_cloud_provider() is None+ assert _resolution_cached() is True# Even if config later changes, the cache stays.monkeypatch.setattr("hermes_cli.config.read_raw_config",lambda: {"browser": {"cloud_provider": "browser-use"}},)- assert bt_cloud._get_cloud_provider() is None+ assert bs_cloud.get_cloud_provider() is Nonedef test_no_credentials_yet_does_not_cache_none(self, monkeypatch):@@ -235,16 +240,16 @@ class TestCloudProviderCachePolicy:"plugins.browser.browserbase.provider.BrowserbaseBrowserProvider", lambda: bb_unconfigured)- assert bt_cloud._get_cloud_provider() is None- assert browser_tool._cloud_provider_resolved is False+ assert bs_cloud.get_cloud_provider() is None+ assert _resolution_cached() is False# Credentials self-heal — next call must retry and pick up the provider.healed = Mock(name="healed-provider")healed.is_available.return_value = Truemonkeypatch.setattr("plugins.browser.browser_use.provider.BrowserUseBrowserProvider", lambda: healed)- assert bt_cloud._get_cloud_provider() is healed- assert browser_tool._cloud_provider_resolved is True+ assert bs_cloud.get_cloud_provider() is healed+ assert _resolution_cached() is Truedef test_explicit_provider_instantiation_failure_does_not_cache(@@ -254,17 +259,17 @@ class TestCloudProviderCachePolicy:def exploding_factory(name):raise RuntimeError("missing dependency")- monkeypatch.setattr("tools.browser_tool_cloud._ensure_browser_plugins_loaded", lambda: None)- monkeypatch.setattr("tools.browser_tool_cloud._registry_get_browser_provider", exploding_factory)+ monkeypatch.setattr("tools.browser_session_cloud._ensure_browser_plugins_loaded", lambda: None)+ monkeypatch.setattr("agent.browser_registry.get_provider", exploding_factory)monkeypatch.setattr("hermes_cli.config.read_raw_config",lambda: {"browser": {"cloud_provider": "browser-use"}},)- with caplog.at_level(logging.WARNING, logger="tools.browser_tool"):- assert bt_cloud._get_cloud_provider() is None+ with caplog.at_level(logging.WARNING, logger="tools.browser_session_cloud"):+ assert bs_cloud.get_cloud_provider() is None- assert browser_tool._cloud_provider_resolved is False+ assert _resolution_cached() is Falseassert any("browser-use" in r.message and r.levelno == logging.WARNINGfor r in caplog.recordsdiff --git a/tests/tools/test_browser_env_loopback_no_proxy.py b/tests/tools/test_browser_env_loopback_no_proxy.pyindex 322de3ab982..9059630e30c 100644--- a/tests/tools/test_browser_env_loopback_no_proxy.py+++ b/tests/tools/test_browser_env_loopback_no_proxy.py@@ -9,14 +9,14 @@ for loopback URLs only.import pytest-import tools.browser_tool as bt+import tools.browser_session as bsfrom agent.proxy_bypass import add_loopback_no_proxy, loopback_connect_kwargs, loopback_request_kwargs@pytest.fixturedef stub_sanitized_env(monkeypatch):"""Replace the credential-scrub layer with a fixed dict so the test sees exactly what- ``_build_browser_env`` adds on top."""+ ``build_browser_env`` adds on top."""from tools.environments import localholder = {}monkeypatch.setattr(local, "hermes_subprocess_env", lambda inherit_credentials=False: dict(holder))@@ -25,7 +25,7 @@ def stub_sanitized_env(monkeypatch):def test_browser_env_appends_loopback_to_operator_no_proxy(stub_sanitized_env):stub_sanitized_env["NO_PROXY"] = "git.internal, 10.0.0.0/8"- env = bt._build_browser_env()+ env = bs.build_browser_env()assert env["NO_PROXY"] == "git.internal,10.0.0.0/8,127.0.0.1,localhost,::1"assert env["no_proxy"] == "127.0.0.1,localhost,::1"diff --git a/tests/tools/test_browser_headed_mode.py b/tests/tools/test_browser_headed_mode.pyindex d34c702d351..13696db7889 100644--- a/tests/tools/test_browser_headed_mode.py+++ b/tests/tools/test_browser_headed_mode.py@@ -1,21 +1,17 @@-"""Tests for headed browser mode: config/env resolution, --headed injection,-and the per-turn cleanup skip that keeps headed sessions alive between turns.+"""Tests for headed browser mode: config resolution, the headed local launch, and the per-turn+cleanup skip that keeps headed sessions alive between turns.Salvaged from PR #24064 (fixes #11020 lead bug)."""from types import SimpleNamespace-from unittest.mock import MagicMock, patch+from unittest.mock import patchimport pytest-from tools import browser_tool_session as bt_session--def _reset_headed_cache():- """Reset the module-level headed-mode cache so tests start clean."""- import tools.browser_tool as bt- bt._cached_headed_mode = None- bt._headed_mode_resolved = False+from tools import browser_launcher as launcher+from tools import browser_session as bs+from tools import browser_session_cloud as bs_cloud@pytest.fixture(autouse=True)@@ -25,22 +21,21 @@ def _clean_headed_cache(monkeypatch, tmp_path):monkeypatch.setattr(Path, "home", lambda: tmp_path)monkeypatch.setenv("HERMES_HOME", str(tmp_path / ".hermes"))monkeypatch.setenv("HERMES_RUNTIME_DIR", str(tmp_path / "tools"))- _reset_headed_cache()+ bs_cloud.reset_caches()yield- _reset_headed_cache()+ bs_cloud.reset_caches()# ----------------------------------------------------------------------------# _is_headed_mode resolution+# is_headed_mode resolution# ---------------------------------------------------------------------------class TestIsHeadedMode:def test_config_true(self):- from tools.browser_tool_cloud import _is_headed_modecfg = {"browser": {"headed": True}}with patch("hermes_cli.config.read_raw_config", return_value=cfg):- assert _is_headed_mode() is True+ assert bs_cloud.is_headed_mode() is True@@ -57,7 +52,7 @@ class TestCleanupTaskResourcesHeadedSkip:def test_headless_still_cleans_browser(self):from agent.chat_completion_helpers import cleanup_task_resourceswith (- patch("tools.browser_tool_cloud._is_headed_mode", return_value=False),+ patch("tools.browser_session_cloud.is_headed_mode", return_value=False),patch("run_agent.cleanup_vm"),patch("run_agent.cleanup_browser") as mock_cb,patch(@@ -69,11 +64,27 @@ class TestCleanupTaskResourcesHeadedSkip:mock_cb.assert_called_once_with("task-x")+ def test_headed_skips_browser_cleanup(self):+ """A headed session survives the turn; the inactivity reaper closes it when idle."""+ from agent.chat_completion_helpers import cleanup_task_resources+ with (+ patch("tools.browser_session_cloud.is_headed_mode", return_value=True),+ patch("run_agent.cleanup_vm"),+ patch("run_agent.cleanup_browser") as mock_cb,+ patch(+ "agent.chat_completion_helpers.is_persistent_env",+ return_value=False,+ ),+ ):+ cleanup_task_resources(_make_agent(), "task-x")+ mock_cb.assert_not_called()++def test_headed_does_not_skip_vm_cleanup(self):"""Headed mode only affects the browser; VM teardown is untouched."""from agent.chat_completion_helpers import cleanup_task_resourceswith (- patch("tools.browser_tool_cloud._is_headed_mode", return_value=True),+ patch("tools.browser_session_cloud.is_headed_mode", return_value=True),patch("run_agent.cleanup_vm") as mock_vm,patch("run_agent.cleanup_browser"),patch(@@ -86,80 +97,53 @@ class TestCleanupTaskResourcesHeadedSkip:# ----------------------------------------------------------------------------# --headed flag injection in local mode+# Headed local launch vs cloud sessions# ----------------------------------------------------------------------------class TestHeadedFlagInjection:- def _run_and_capture(self, bt):- """Run a snapshot command with Popen mocked; return captured argv."""- 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-- mock_stdout = (- '{"success": true, "data": {"snapshot": '- '"- heading \\"Hi\\" [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_lifecycle._write_owner_pid"):- bt_session._run_browser_command("task1", "snapshot", [], _engine_override="auto")- return captured_cmds-- @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_headed_flag_added_in_local_mode(- self, _camofox, _cdp, _cloud, _chromium, _local, _find, _session- ):- import tools.browser_tool as bt- bt._cached_headed_mode = True- bt._headed_mode_resolved = True- _session.return_value = {"session_name": "test-sess"}-- captured = self._run_and_capture(bt)- assert len(captured) == 1- assert "--headed" in captured[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_headed_flag_not_added_in_cloud_mode(- self, _camofox, _cdp, _cloud, _chromium, _local, _find, _session- ):- """Cloud (CDP) sessions never get --headed — it's a local-only flag."""- import tools.browser_tool as bt- bt._cached_headed_mode = True- bt._headed_mode_resolved = True- _session.return_value = {- "session_name": "test-sess",- "cdp_url": "wss://example.invalid/cdp",- }-- captured = self._run_and_capture(bt)+class TestHeadedLaunch:+ @pytest.mark.platforms("posix")+ def test_headed_window_in_local_mode(self, monkeypatch, tmp_path):+ """browser.headed + a display: the local Chromium launches without --headless."""+ monkeypatch.setattr(bs_cloud, "is_headed_mode", lambda: True)+ monkeypatch.setattr(bs_cloud, "chromium_args", list)+ monkeypatch.setattr(launcher, "needs_chromium_sandbox_bypass", lambda: False)+ captured = []++ class _Proc:+ pid = 4321++ def poll(self):+ return 1++ def capture_spawn(argv, env, user_data_dir):+ captured.append(argv)+ return _Proc()++ monkeypatch.setattr(launcher, "_spawn", capture_spawn)+ monkeypatch.setattr(launcher, "_start_time", lambda pid: None)+ monkeypatch.setattr(launcher, "_terminate", lambda pid, start_time, proc: None)+ launcher.launch_chromium("headed", executable="chromium", user_data_dir=str(tmp_path / "udd"),+ env={"DISPLAY": ":1"}, timeout=1)+assert len(captured) == 1- assert "--headed" not in captured[0]- assert "--cdp" in captured[0]+ assert not any(arg.startswith("--headless") for arg in captured[0])+++ def test_headed_not_applied_in_cloud_mode(self, monkeypatch):+ """Cloud (CDP) sessions never launch a local (headed) Chromium: headed is a local-only knob."""+ monkeypatch.setattr(bs_cloud, "is_headed_mode", lambda: True)+ monkeypatch.setattr("tools.browser_session_cdp.get_cdp_override", lambda: "")+ provider = SimpleNamespace(create_session=lambda key: {+ "session_name": "cloud", "bb_session_id": "bb-1",+ "cdp_url": "wss://example.invalid/devtools/browser/cloud", "features": {},+ })+ monkeypatch.setattr(bs_cloud, "get_cloud_provider", lambda: provider)+ monkeypatch.setattr(launcher, "launch_chromium",+ lambda *a, **kw: pytest.fail("a cloud session must not launch local Chromium"))+ screen = []+ monkeypatch.setattr(bs, "ensure_screen_for_headed_chromium", lambda: screen.append(1))++ session = bs._create_session_for_key("task1", force_local=False)++ assert session["cdp_url"] == "wss://example.invalid/devtools/browser/cloud"+ assert screen == []diff --git a/tests/tools/test_browser_lightpanda_serve.py b/tests/tools/test_browser_lightpanda_serve.pyindex ba88ead1cfb..b54d49c3971 100644--- a/tests/tools/test_browser_lightpanda_serve.py+++ b/tests/tools/test_browser_lightpanda_serve.py@@ -68,20 +68,20 @@ class TestFindBinary:def test_prefers_path(self, tmp_path, monkeypatch):exe = _exe(tmp_path / "bin" / "lightpanda")monkeypatch.setenv("PATH", str(tmp_path / "bin"))- monkeypatch.setattr("tools.browser_tool_install._merge_browser_path", lambda p: p)+ monkeypatch.setattr(lp, "merge_sane_path", lambda p: p)assert lp.find_lightpanda_binary() == str(exe)@pytest.mark.platforms("posix")def test_falls_back_to_home_candidates(self, tmp_path, monkeypatch):monkeypatch.setenv("PATH", str(tmp_path / "empty"))- monkeypatch.setattr("tools.browser_tool_install._merge_browser_path", lambda p: p)+ monkeypatch.setattr(lp, "merge_sane_path", lambda p: p)exe = _exe(tmp_path / ".lightpanda" / "lightpanda")monkeypatch.setattr(lp, "_home_candidates", lambda: [exe])assert lp.find_lightpanda_binary() == str(exe)def test_none_when_absent(self, tmp_path, monkeypatch):monkeypatch.setenv("PATH", str(tmp_path / "empty"))- monkeypatch.setattr("tools.browser_tool_install._merge_browser_path", lambda p: p)+ monkeypatch.setattr(lp, "merge_sane_path", lambda p: p)assert lp.find_lightpanda_binary() is None@pytest.mark.platforms("windows")diff --git a/tests/tools/test_browser_pm.py b/tests/tools/test_browser_pm.pyindex 4b279f25b6c..a5ee8976ee3 100644--- a/tests/tools/test_browser_pm.py+++ b/tests/tools/test_browser_pm.py@@ -1,17 +1,28 @@-"""Browser consumers use real PM facts, not ambient npm caches."""+"""Browser consumers use real PM facts, not ambient caches: the launcher's Chromium is PM's pinned+Chromium (or the user's explicit override), acquired through PM at most once per process."""import jsonimport osimport sys+import timefrom pathlib import Pathimport pytestimport pmfrom pm import paths-from tools import browser_tool as bt-from tools import browser_tool_install as install-from tools import browser_tool_session as session+from tools import browser_launcher as launcher++[email protected](autouse=True)+def _no_chromium_download(monkeypatch):+ """Overrides the tools/conftest.py pin: these tests exercise the REAL one-shot auto-install, so the+ download boundary itself is the guard. Every test that permits acquisition replaces+ ``pm.client._request`` with a fake publish; any other route to it fails the test."""+ import pm.client++ monkeypatch.setattr(pm.client, "_request", lambda *a, **kw: pytest.fail("unexpected PM acquisition"))+ yield@pytest.fixture@@ -24,12 +35,10 @@ def browser_store(tmp_path, monkeypatch):monkeypatch.setenv("HERMES_RUNTIME_DIR", str(store))monkeypatch.setenv("HERMES_DISABLE_LAZY_INSTALLS", "1")monkeypatch.setenv("PATH", "")- monkeypatch.setattr(bt, "_SANE_PATH_DIRS", ())- monkeypatch.setattr(install, "_discover_homebrew_node_dirs", lambda: ())monkeypatch.delenv("AGENT_BROWSER_EXECUTABLE_PATH", raising=False)monkeypatch.delenv("PLAYWRIGHT_BROWSERS_PATH", raising=False)monkeypatch.delenv("TERMUX_VERSION", raising=False)- monkeypatch.setattr(bt, "_chromium_autoinstall_attempted", False)+ monkeypatch.setattr(launcher, "_autoinstall_attempted", False)lock = pm.Lockfile(paths.lockfile_path())target = pm.current_target()@@ -60,53 +69,16 @@ def browser_store(tmp_path, monkeypatch):def test_unrecorded_playwright_cache_is_not_a_pm_browser(browser_store):home, _, _ = browser_store(home / ".cache" / "ms-playwright" / "chromium-1234").mkdir(parents=True)- assert install._chromium_installed() is False---def test_doctor_fix_publishes_and_reads_the_pm_browser(browser_store, monkeypatch):- from hermes_cli import doctor_tools- import pm.client-- _, _, publish = browser_store- monkeypatch.setenv("PATH", "")- requests = []-- def request(operation, payload, **kwargs):- # Only the worker/download boundary is replaced; selection, admission,- # facts and environment composition are the actual PM implementation.- requests.append((operation, payload))- publish("chromium")- publish("agent-browser")-- monkeypatch.setattr(pm.client, "_request", request)- assert doctor_tools._check_agent_browser(False) is False- assert requests == []- assert doctor_tools._check_agent_browser(True) is True- assert requests == [("ensure", {"name": "agent-browser", "explicit": True})]---def test_missing_browser_refuses_lazy_install_even_with_npx(browser_store, monkeypatch, tmp_path):- _, store, _ = browser_store- bin_dir = tmp_path / "bin"- bin_dir.mkdir()- npx = bin_dir / ("npx.exe" if os.name == "nt" else "npx")- npx.write_bytes(b"not an agent-browser installation")- npx.chmod(0o755)- monkeypatch.setenv("PATH", str(bin_dir))- with pytest.raises(FileNotFoundError, match="agent-browser CLI not found"):- install._find_agent_browser(validate=False)- with pytest.raises(FileNotFoundError, match="[Ll]azy|[Aa]utomatic|disabled"):- install._find_agent_browser()- assert not store.exists()+ assert launcher.chromium_ready()[0] is Falsedef test_late_pm_install_is_visible_without_cache_reset(browser_store, monkeypatch):_, _, publish = browser_storemonkeypatch.setenv("PATH", "")- with pytest.raises(FileNotFoundError):- install._find_agent_browser()- binary = publish("agent-browser")- assert install._find_agent_browser() == str(binary)+ assert launcher.chromium_ready()[0] is False+ binary = publish("chromium")+ assert launcher.chromium_ready() == (True, "")+ assert launcher._resolve_executable() == str(binary)def test_execution_acquires_missing_browser_through_pm(browser_store, monkeypatch):@@ -115,61 +87,46 @@ def test_execution_acquires_missing_browser_through_pm(browser_store, monkeypatc_, _, publish = browser_storemonkeypatch.setenv("PATH", "")monkeypatch.setenv("HERMES_DISABLE_LAZY_INSTALLS", "0")+ monkeypatch.setattr(launcher, "running_in_docker", lambda: False)assert pm.lazy_installs_allowed()requests = []def request(operation, payload, **kwargs):requests.append((operation, payload))publish("chromium")- publish("agent-browser")monkeypatch.setattr(pm.client, "_request", request)- result = install._find_agent_browser()- installed = pm.installed_package("agent-browser")- assert installed is not None and result == str(installed.binary)- assert requests == [("ensure", {"name": "agent-browser", "explicit": False})]- assert install._chromium_installed()+ assert launcher.chromium_ready() == (True, "")+ installed = pm.installed_package("chromium")+ assert installed is not None and launcher._resolve_executable() == str(installed.binary)+ assert requests == [("ensure", {"name": "chromium", "explicit": False})]def test_termux_ownership_policy_never_provisions(browser_store, monkeypatch):# Exercise the real environment policy, not an emulated Android binary.- from hermes_cli import doctor_tools-monkeypatch.setenv("TERMUX_VERSION", "test")monkeypatch.setenv("PATH", "")monkeypatch.setenv("HERMES_DISABLE_LAZY_INSTALLS", "0")- monkeypatch.setattr(install, "_running_in_docker", lambda: False)- monkeypatch.setattr(bt, "_chromium_autoinstall_attempted", False)+ monkeypatch.setattr(launcher, "running_in_docker", lambda: False)def forbidden(*args, **kwargs):pytest.fail("Termux browser installation is externally owned")monkeypatch.setattr(pm, "ensure", forbidden)- with pytest.raises(FileNotFoundError, match="npm install -g agent-browser"):- install._find_agent_browser()- assert install._maybe_autoinstall_chromium() is False- assert doctor_tools._check_agent_browser(True) is False+ assert launcher._maybe_autoinstall_chromium() is False+ assert launcher.chromium_ready()[0] is Falsedef test_cdp_override_does_not_require_pm_browser(browser_store, monkeypatch):- monkeypatch.setenv("BROWSER_CDP_URL", "ws://127.0.0.1:9222/devtools/browser/test")- monkeypatch.setattr(bt, "_is_browser_use_cli_mode", lambda: False)- monkeypatch.setattr(bt, "_is_camofox_mode", lambda: False)- assert install.check_browser_requirements() is True+ from tools import browser_session-[email protected]("posix")-def test_external_browser_on_path_remains_supported_without_pm(browser_store, monkeypatch, tmp_path):- _, store, _ = browser_store- bin_dir = tmp_path / "external browser"- bin_dir.mkdir()- binary = bin_dir / "agent-browser"- binary.write_text(f"#!{sys.executable}\nprint('external-agent-browser')\n")- binary.chmod(0o755)- monkeypatch.setenv("PATH", str(bin_dir))- assert install._find_agent_browser(validate=False) == str(binary)- assert install._find_agent_browser() == str(binary)- assert not store.exists()+ monkeypatch.setenv("BROWSER_CDP_URL", "ws://127.0.0.1:9222/devtools/browser/test")+ monkeypatch.setattr(launcher, "launch_chromium",+ lambda *a, **kw: pytest.fail("a CDP override must not launch a local Chromium"))+ session = browser_session._create_session_for_key("cdp-task", force_local=False)+ assert session["cdp_url"] == "ws://127.0.0.1:9222/devtools/browser/test"+ assert session["features"] == {"cdp_override": True}+ assert launcher.chromium_ready()[0] is Falsedef test_historical_warmer_is_inert(monkeypatch):@@ -189,117 +146,59 @@ def test_external_chromium_override_survives_pm_composition(browser_store, monkeoverride = tmp_path / "user browser"override.write_bytes(b"external")monkeypatch.setenv("AGENT_BROWSER_EXECUTABLE_PATH", str(override))- assert install._chromium_installed()- assert session._agent_browser_command_env(str(tmp_path))["AGENT_BROWSER_EXECUTABLE_PATH"] == str(override)---def test_restricted_path_discovers_external_browser_without_execution(browser_store, monkeypatch, tmp_path):- _, store, _ = browser_store- external_bin = tmp_path / "external-homebrew" / "bin"- external_bin.mkdir(parents=True)- binary = external_bin / ("agent-browser.exe" if os.name == "nt" else "agent-browser")- binary.write_bytes(b"external browser; presence check must not execute")- binary.chmod(0o755)- monkeypatch.setenv("PATH", str(tmp_path / "empty-path"))- monkeypatch.setattr(bt, "_SANE_PATH_DIRS", (str(external_bin),))+ assert launcher.chromium_ready() == (True, "")+ assert launcher._resolve_executable() == str(override)- def forbidden(*args, **kwargs):- pytest.fail("passive external browser discovery must not execute or install")- monkeypatch.setattr("subprocess.Popen", forbidden)- monkeypatch.setattr(pm, "ensure", forbidden)- assert install._find_agent_browser(validate=False) == str(binary)- assert not store.exists()---def test_pm_browser_wins_over_legacy_and_ambient_installs(browser_store, monkeypatch):- home, store, publish = browser_store- binary = publish("agent-browser")- publish("chromium")- legacy = home / "node_modules" / ".bin"- legacy.mkdir(parents=True)- external = legacy / ("agent-browser.exe" if os.name == "nt" else "agent-browser")- external.write_bytes(b"legacy browser")- external.chmod(0o755)- monkeypatch.setenv("PATH", str(legacy))- before = (store / "facts.json").read_bytes()- assert install._find_agent_browser(validate=False) == str(binary)- assert (store / "facts.json").read_bytes() == before+_FAKE_PM_CHROMIUM = """#!{python}+import json, os, sys, time+udd = next(a.split("=", 1)[1] for a in sys.argv if a.startswith("--user-data-dir="))+with open(os.path.join(udd, "child.json"), "w") as f:+ json.dump({{"argv": sys.argv, "env": dict(os.environ)}}, f)+with open(os.path.join(udd, "DevToolsActivePort"), "w") as f:+ f.write("45679\\n/devtools/browser/pm-fixture\\n")+time.sleep(600)+"""@pytest.mark.platforms("posix")[email protected]_system_guard_bypass # the fake PM Chromium is this test's own childdef test_exact_pm_child_receives_composed_scrubbed_environment(browser_store, monkeypatch, tmp_path):- _, store, publish = browser_store- binary = publish("agent-browser", f"#!{sys.executable}\n" + '''import json, os, sys-print(json.dumps({"argv": sys.argv, "env": dict(os.environ)}))-''')- chromium = publish("chromium")+ _, _, publish = browser_store+ chromium = publish("chromium", _FAKE_PM_CHROMIUM.format(python=sys.executable))+ records = tmp_path / "records"+ records.mkdir()+ monkeypatch.setattr(launcher, "_records_dir", lambda: records)+ monkeypatch.setattr(launcher, "needs_chromium_sandbox_bypass", lambda: False)+ monkeypatch.setattr("tools.browser_session_cloud.chromium_args", list)+ monkeypatch.setattr("tools.browser_session_cloud.is_headed_mode", lambda: False)monkeypatch.setenv("PATH", str(tmp_path / "hostile-path"))- system_bin = tmp_path / "external-system-bin"- system_bin.mkdir()- monkeypatch.setattr(bt, "_SANE_PATH_DIRS", (str(system_bin),))monkeypatch.setenv("OPENAI_API_KEY", "must-not-reach-browser")monkeypatch.setenv("BROWSERBASE_API_KEY", "browser-provider-key")before = dict(os.environ)- socket_dir = tmp_path / "session"- socket_dir.mkdir()- command = install._find_agent_browser(validate=False)- env = session._agent_browser_command_env(str(socket_dir))- proc = session._popen_agent_browser([command, "--json", "get", "url"], env, str(socket_dir), "probe")- assert proc.wait(timeout=10) == 0- output, error = session._read_command_output_files(str(socket_dir / "_stdout_probe"), str(socket_dir / "_stderr_probe"))- assert error == ""- child = json.loads(output)- assert Path(child["argv"][0]) == binary- assert child["argv"][1:] == ["--json", "get", "url"]- assert child["env"]["AGENT_BROWSER_EXECUTABLE_PATH"] == str(chromium)- assert child["env"]["PLAYWRIGHT_BROWSERS_PATH"] == str(store)- assert child["env"]["PATH"].split(os.pathsep)[0] == str(binary.parent)- assert str(system_bin) in child["env"]["PATH"].split(os.pathsep)[1:]+ browser, err = launcher.launch_chromium("pm-child", timeout=10)+ try:+ assert err is None+ child_file = Path(browser.user_data_dir, "child.json")+ deadline = time.monotonic() + 5+ while not child_file.exists() and time.monotonic() < deadline:+ time.sleep(0.05)+ child = json.loads(child_file.read_text())+ finally:+ launcher.stop_browser("pm-child")+ assert Path(child["argv"][0]) == chromiumassert "OPENAI_API_KEY" not in child["env"]- assert child["env"]["BROWSERBASE_API_KEY"] == "browser-provider-key"- assert child["env"]["AGENT_BROWSER_SOCKET_DIR"] == str(socket_dir)+ assert "BROWSERBASE_API_KEY" not in child["env"]assert dict(os.environ) == before[email protected]("posix")-def test_runtime_and_chrome_fallback_launch_the_same_pm_binary(browser_store, monkeypatch, tmp_path):- from tools import browser_tool_cloud as cloud- from tools import browser_tool_lightpanda_fallback as fallback-- _, _, publish = browser_store- binary = publish("agent-browser", f"#!{sys.executable}\n" + '''import json, os, sys-print(json.dumps({"success": True, "data": {- "url": "https://example.com/", "argv": sys.argv,- "browser": os.environ.get("AGENT_BROWSER_EXECUTABLE_PATH")-}}))-''')- chromium = publish("chromium")- monkeypatch.setenv("PATH", "")- monkeypatch.setattr(bt, "_socket_safe_tmpdir", lambda: str(tmp_path))- monkeypatch.setattr(cloud, "_is_local_mode", lambda: True)- monkeypatch.setattr(cloud, "_get_browser_engine", lambda: "auto")- monkeypatch.setattr(cloud, "_is_headed_mode", lambda: False)- monkeypatch.setattr(session, "_get_session_info", lambda task_id: {"session_name": "fixture", "cdp_url": None})- monkeypatch.setattr("tools.interrupt.is_interrupted", lambda: False)-- direct = session._run_browser_command("fixture", "get", ["url"])- chrome = fallback._run_chrome_fallback_command("fixture", "get", ["url"], timeout=10)- for result in (direct, chrome):- assert result["success"] is True- assert result["data"]["argv"][0] == str(binary)- assert result["data"]["browser"] == str(chromium)- assert direct["data"]["argv"][1:3] == ["--session", "fixture"]- assert chrome["data"]["argv"][1:3] == ["--engine", "chrome"]--@pytest.mark.parametrize("fails", [False, True])def test_chromium_autoinstall_is_one_shot(browser_store, monkeypatch, fails):import pm.client_, _, publish = browser_storemonkeypatch.setenv("HERMES_DISABLE_LAZY_INSTALLS", "0")- monkeypatch.setattr(install, "_running_in_docker", lambda: False)+ monkeypatch.setattr(launcher, "running_in_docker", lambda: False)calls = []def request(operation, payload, **kwargs):@@ -309,8 +208,8 @@ def test_chromium_autoinstall_is_one_shot(browser_store, monkeypatch, fails):publish("chromium")monkeypatch.setattr(pm.client, "_request", request)- assert install._maybe_autoinstall_chromium() is (not fails)- assert install._maybe_autoinstall_chromium() is (not fails)+ assert launcher.chromium_ready()[0] is (not fails)+ assert launcher.chromium_ready()[0] is (not fails)assert calls == [("ensure", {"name": "chromium", "explicit": False})]@@ -318,7 +217,7 @@ def test_chromium_autoinstall_is_one_shot(browser_store, monkeypatch, fails):def test_chromium_acquisition_policy(browser_store, monkeypatch, policy, tmp_path):import pm.client- monkeypatch.setattr(install, "_running_in_docker", lambda: policy == "docker")+ monkeypatch.setattr(launcher, "running_in_docker", lambda: policy == "docker")monkeypatch.setenv("HERMES_DISABLE_LAZY_INSTALLS", "1" if policy == "disabled" else "0")if policy == "termux":monkeypatch.setenv("TERMUX_VERSION", "test")@@ -326,30 +225,21 @@ def test_chromium_acquisition_policy(browser_store, monkeypatch, policy, tmp_patoverride = tmp_path / "external-chrome"override.touch()monkeypatch.setenv("AGENT_BROWSER_EXECUTABLE_PATH", str(override))- assert install._chromium_installed()+ assert launcher._resolve_executable() == str(override)override.unlink()- assert not install._chromium_installed()+ assert launcher._resolve_executable() is Nonemonkeypatch.setattr(pm.client, "_request", lambda *a, **kw: pytest.fail("forbidden acquisition"))- assert not install._maybe_autoinstall_chromium()-+ assert not launcher._maybe_autoinstall_chromium()[email protected]("backend", ["local", "camofox", "cdp"])-def test_browser_readiness_ignores_ambient_chromium(browser_store, monkeypatch, backend):- from tools import browser_tool_cloud, browser_tool_lightpanda_fallback+def test_browser_readiness_ignores_ambient_chromium(browser_store, monkeypatch):home, _, publish = browser_store- publish("agent-browser")(home / "chromium_headless_shell-1234").mkdir()monkeypatch.setenv("PLAYWRIGHT_BROWSERS_PATH", str(home))ambient = home / ("chromium.exe" if os.name == "nt" else "chromium")ambient.touch()ambient.chmod(0o755)monkeypatch.setenv("PATH", str(home))- monkeypatch.setattr(bt, "_is_browser_use_cli_mode", lambda: False)- monkeypatch.setattr(bt, "_is_camofox_mode", lambda: backend == "camofox")- monkeypatch.setattr(browser_tool_cloud, "_get_cloud_provider", lambda: None)- monkeypatch.setattr(browser_tool_lightpanda_fallback, "_using_lightpanda_engine", lambda: False)- monkeypatch.setenv("BROWSER_CDP_URL", "ws://example.test/cdp" if backend == "cdp" else "")- assert install.check_browser_requirements() is (backend != "local")+ assert launcher.chromium_ready()[0] is Falsepublish("chromium")- assert install.check_browser_requirements()\ No newline at end of file+ assert launcher.chromium_ready()[0] is Truediff --git a/tests/tools/test_browser_use_harness.py b/tests/tools/test_browser_use_harness.pyindex 0b7ee787ce5..adaaab08a54 100644--- a/tests/tools/test_browser_use_harness.py+++ b/tests/tools/test_browser_use_harness.py@@ -27,22 +27,22 @@ def test_harness_runs_on_an_interpreter_without_its_own_site_packages(monkeypatc@pytest.mark.platforms("posix", "windows")def test_browser_exec_child_environment(tmp_path, monkeypatch):- from tools import browser_tool_session, browser_supervisor+ from tools import browser_session, browser_supervisorprobe = tmp_path / "probe.py"probe.write_text("import json, os, sys\n""print(json.dumps({'argv': sys.argv, 'stdin': sys.stdin.read(), 'env': dict(os.environ)}))\n",encoding="utf-8")monkeypatch.setattr(bu, "_find_cli", lambda: [sys.executable, str(probe)])- monkeypatch.setattr("hermes_cli.config.read_raw_config", lambda: {"browser": {"backend": "browser-use"}})- monkeypatch.setattr("tools.browser_tool_cdp._get_cdp_override", lambda: "")- monkeypatch.setattr("tools.browser_tool_cdp._resolve_cdp_override", lambda url: url)- monkeypatch.setattr("tools.browser_tool_cloud._get_cloud_provider", lambda: None)- monkeypatch.setattr("tools.browser_tool_lightpanda_fallback._using_lightpanda_engine", lambda: False)- def local_browser(task_id, command, args, **kwargs):- assert (task_id, command, args) == ("bu-named-research", "get", ["cdp-url"])- return {"success": True, "data": {"cdpUrl": "ws://127.0.0.1:47000/private"}}- monkeypatch.setattr(browser_tool_session, "_run_browser_command", local_browser)+ monkeypatch.setattr("hermes_cli.config.read_raw_config", lambda: {"browser": {}})+ monkeypatch.setattr("tools.browser_session_cdp.get_cdp_override", lambda: "")+ monkeypatch.setattr("tools.browser_session_cdp.resolve_cdp_override", lambda url: url)+ monkeypatch.setattr("tools.browser_session_cloud.get_cloud_provider", lambda: None)+ monkeypatch.setattr("tools.browser_lightpanda.using_lightpanda_engine", lambda: False)+ def local_browser(cache_key):+ assert cache_key == "bu-named-research"+ return {"cdp_url": "ws://127.0.0.1:47000/private", "features": {"local": True}}+ monkeypatch.setattr(browser_session, "get_session_info", local_browser)attached = []monkeypatch.setattr(browser_supervisor.SUPERVISOR_REGISTRY, "get_or_start",lambda task_id, cdp_url, **kw: attached.append((task_id, cdp_url)))@@ -50,18 +50,19 @@ def test_browser_exec_child_environment(tmp_path, monkeypatch):monkeypatch.setenv("PYTHONHOME", "/wrong-python")monkeypatch.setenv("OPENAI_API_KEY", "must-not-leak")monkeypatch.setenv("BROWSERBASE_API_KEY", "browser-key")+ monkeypatch.setenv("BROWSER_USE_API_KEY", "bu-key")monkeypatch.setenv("KEEP_BROWSER_PROBE", "kept")monkeypatch.delenv("ANONYMIZED_TELEMETRY", raising=False)result = json.loads(bu.browser_exec("print('payload')", session="research", task_id="owner"))assert result["success"], resultchild = json.loads(result["output"])assert child["stdin"] == "print('payload')"- for key in ("PYTHONHOME", "OPENAI_API_KEY", "_HERMES_BU_PRIVATE_BROWSER"):+ for key in ("PYTHONHOME", "OPENAI_API_KEY", "BROWSERBASE_API_KEY", "_HERMES_BU_PRIVATE_BROWSER"):assert key not in child["env"]assert child["env"].get("PYTHONPATH") == bu._harness_site_dir()assert child["env"]["BU_NAME"] == "research"assert child["env"]["BU_CDP_WS"] == "ws://127.0.0.1:47000/private"assert child["env"]["ANONYMIZED_TELEMETRY"] == "false"- assert child["env"]["BROWSERBASE_API_KEY"] == "browser-key"+ assert child["env"]["BROWSER_USE_API_KEY"] == "bu-key"assert child["env"]["KEEP_BROWSER_PROBE"] == "kept"assert attached == [("owner", "ws://127.0.0.1:47000/private")]diff --git a/tests/tools/test_browser_use_session_expiry.py b/tests/tools/test_browser_use_session_expiry.pyindex 93af4ea079d..136888d67fe 100644--- a/tests/tools/test_browser_use_session_expiry.py+++ b/tests/tools/test_browser_use_session_expiry.py@@ -2,17 +2,18 @@from unittest.mock import Mock-from tools import browser_toolfrom plugins.browser.browser_use import provider as browser_use_provider-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_clouddef _isolate_browser_state(monkeypatch):- monkeypatch.setattr(browser_tool, "_active_sessions", {})- monkeypatch.setattr(browser_tool, "_session_last_activity", {})- monkeypatch.setattr("tools.browser_tool_lifecycle._start_browser_cleanup_thread", lambda: None)- monkeypatch.setattr("tools.browser_tool_cdp._ensure_cdp_supervisor", lambda task_id: None)+ monkeypatch.setattr(bs, "_active_sessions", {})+ monkeypatch.setattr(bs, "_session_last_activity", {})+ monkeypatch.setattr(bs, "_session_owner_homes", {})+ monkeypatch.setattr("tools.browser_session_lifecycle.start_cleanup_thread", lambda: None)+ monkeypatch.setattr("tools.browser_session_cdp.ensure_cdp_supervisor", lambda task_id: None)def test_browser_use_preserves_provider_timeout(monkeypatch):@@ -51,11 +52,11 @@ def test_live_cloud_session_is_reused(monkeypatch):"cdp_url": "ws://browser-use.example/devtools/browser/1","expires_at": "2999-01-01T00:05:00Z",}- browser_tool._active_sessions["task-1"] = existing+ bs._active_sessions["task-1"] = existingprovider = Mock()- monkeypatch.setattr(bt_cloud, "_get_cloud_provider", lambda: provider)+ monkeypatch.setattr(bs_cloud, "get_cloud_provider", lambda: provider)- session = bt_session._get_session_info("task-1")+ session = bs.get_session_info("task-1")assert session is existingprovider.create_session.assert_not_called()@@ -63,13 +64,13 @@ def test_live_cloud_session_is_reused(monkeypatch):def test_expired_cloud_session_is_replaced_without_reusing_dead_cdp(monkeypatch):_isolate_browser_state(monkeypatch)- browser_tool._active_sessions["task-1"] = {+ bs._active_sessions["task-1"] = {"session_name": "expired","bb_session_id": "browser-session-old","cdp_url": "ws://browser-use.example/devtools/browser/old","expires_at": "2020-01-01T00:05:00Z",}- browser_tool._session_last_activity["task-1"] = 1.0+ bs._session_last_activity["task-1"] = 1.0provider = Mock()provider.create_session.return_value = {@@ -78,18 +79,17 @@ def test_expired_cloud_session_is_replaced_without_reusing_dead_cdp(monkeypatch)"cdp_url": "ws://browser-use.example/devtools/browser/new","expires_at": "2999-01-01T00:05:00Z",}- monkeypatch.setattr(bt_cloud, "_get_cloud_provider", lambda: provider)- monkeypatch.setattr("tools.browser_tool_cdp._get_cdp_override", lambda: "")- monkeypatch.setattr("tools.browser_tool_cdp._stop_cdp_supervisor", Mock())- monkeypatch.setattr(browser_tool, "_maybe_stop_recording", Mock())- monkeypatch.setattr(bt_session, "_run_browser_command", Mock())- monkeypatch.setattr(browser_tool.os.path, "exists", lambda path: False)+ monkeypatch.setattr(bs_cloud, "get_cloud_provider", lambda: provider)+ monkeypatch.setattr("tools.browser_session_cdp.get_cdp_override", lambda: "")+ monkeypatch.setattr("tools.browser_session_cdp.stop_cdp_supervisor", Mock())+ local_stop = Mock()+ monkeypatch.setattr(browser_launcher, "stop_browser", local_stop)- session = bt_session._get_session_info("task-1")+ session = bs.get_session_info("task-1")assert session["bb_session_id"] == "browser-session-new"- assert browser_tool._active_sessions["task-1"] is session- assert "task-1" in browser_tool._session_last_activity+ assert bs._active_sessions["task-1"] is session+ assert "task-1" in bs._session_last_activityprovider.close_session.assert_called_once_with("browser-session-old")provider.create_session.assert_called_once_with("task-1")- bt_session._run_browser_command.assert_not_called()+ local_stop.assert_not_called()diff --git a/tests/tools/test_browser_windows_headless.py b/tests/tools/test_browser_windows_headless.pyindex 8556259581c..9b2d0e9d40b 100644--- a/tests/tools/test_browser_windows_headless.py+++ b/tests/tools/test_browser_windows_headless.py@@ -1,116 +1,67 @@"""Regression for #64867: local Chromium stays headless on Windows Desktop.-Windows Desktop opened a blank top-level window during local browser automation:-the agent-browser daemon inherits the launch environment, so anything that-resolves its ``--headed`` setting to a window turns local mode's documented-"zero-cost headless Chromium" into a visible browser over the Desktop chat.--The option builder is pure in ``(options, is_windows)`` so the invariant is-testable on any host (root AGENTS.md); the wiring tests run only where the-behaviour lives, on the Windows lane.+Windows Desktop opened a blank top-level window during local browser automation: anything that+resolves the launch to headed turns local mode's documented "zero-cost headless Chromium" into a+visible browser over the Desktop chat. ``browser_launcher._resolve_headed`` keeps Windows headless+unless ``browser.headed`` is on, and the launch argv carries ``--headless=new``. These run only where+the behaviour lives, on the Windows lane (the Linux display rule is covered in test_browser_launcher.py)."""from pathlib import Path-from unittest.mock import MagicMock, patchimport pytest+from tools import browser_launcher as launcher+@pytest.fixture(autouse=True)def _isolated_home(monkeypatch, tmp_path):monkeypatch.setattr(Path, "home", lambda: tmp_path)monkeypatch.setenv("HERMES_HOME", str(tmp_path / ".hermes"))monkeypatch.setenv("HERMES_RUNTIME_DIR", str(tmp_path / "tools"))- monkeypatch.delenv("AGENT_BROWSER_HEADED", raising=False)+ monkeypatch.setattr("tools.browser_session_cloud.chromium_args", list)yield-# ----------------------------------------------------------------------------# windows_headless_browser_options (pure, runs on every host)-# -----------------------------------------------------------------------------from tools.browser_tool_session import windows_headless_browser_options---def test_windows_pins_headless_for_local_launch():- env = {"PATH": "/usr/bin", "AGENT_BROWSER_SOCKET_DIR": "/tmp/s"}- pinned = windows_headless_browser_options(env, is_windows=True)- assert pinned["AGENT_BROWSER_HEADED"] == "false"- assert pinned["PATH"] == "/usr/bin"- assert pinned["AGENT_BROWSER_SOCKET_DIR"] == "/tmp/s"- # Pure: the caller's dict (shared _build_browser_env output) is never mutated.- assert "AGENT_BROWSER_HEADED" not in env---def test_non_windows_options_unchanged():- env = {"PATH": "/usr/bin"}- assert windows_headless_browser_options(env, is_windows=False) == env- assert "AGENT_BROWSER_HEADED" not in env[email protected]("windows")+def test_windows_stays_headless_unless_headed_is_configured(monkeypatch):+ monkeypatch.setattr("tools.browser_session_cloud.is_headed_mode", lambda: False)+ assert launcher._resolve_headed(None, {"PATH": "C:/Windows"}) is False+ argv = launcher.build_chromium_argv("chrome.exe", "C:/p", packaged=True, headed=False)+ assert "--headless=new" in argv-def test_explicit_headed_setting_is_never_overridden():- for value in ("true", "1", "yes"):- env = {"AGENT_BROWSER_HEADED": value}- assert windows_headless_browser_options(env, is_windows=True) == env[email protected]("windows")+def test_explicit_headed_setting_is_never_overridden(monkeypatch):+ # Windows always has a desktop session: an opted-in headed launch needs no DISPLAY.+ monkeypatch.setattr("tools.browser_session_cloud.is_headed_mode", lambda: True)+ assert launcher._resolve_headed(None, {}) is True+ assert launcher._resolve_headed(True, {}) is True-# ----------------------------------------------------------------------------# Wiring: local (non-CDP) session commands carry the pin into the daemon env.-# Windows-only by nature — the guard is a no-op on other hosts.-# ---------------------------------------------------------------------------[email protected]("windows")+def test_local_launch_argv_is_headless(monkeypatch, tmp_path):+ """A local launch's real argv carries --headless=new and no headed window (#64867)."""+ monkeypatch.setattr("tools.browser_session_cloud.is_headed_mode", lambda: False)+ monkeypatch.setattr(launcher, "needs_chromium_sandbox_bypass", lambda: False)+ captured = []-HEADLESS_SNAPSHOT_STDOUT = (- '{"success": true, "data": {"snapshot": '- '"- heading \\\\"Hi\\\\" [ref=e1]", "refs": {"e1": {}}}}'-)+ class _Proc:+ pid = 4321+ def poll(self):+ return 1[email protected]("windows")-@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_local_command_env_pins_headed_false(- _camofox, _cdp, _cloud, _chromium, _local, _find, _session-):- """A local session's daemon env pins AGENT_BROWSER_HEADED=false (#64867)."""- import tools.browser_tool as bt- import tools.browser_tool_session as bt_session-- bt._cached_headed_mode = False- bt._headed_mode_resolved = True- _session.return_value = {"session_name": "test-sess"}+ def capture_spawn(argv, env, user_data_dir):+ captured.append(argv)+ return _Proc()- captured = []- mock_proc = MagicMock()- mock_proc.wait.return_value = None- mock_proc.returncode = 0-- def capture_popen(cmd, **kwargs):- captured.append((cmd, kwargs.get("env")))- return mock_proc-- 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=HEADLESS_SNAPSHOT_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("task1", "snapshot", [], _engine_override="auto")+ monkeypatch.setattr(launcher, "_spawn", capture_spawn)+ monkeypatch.setattr(launcher, "_start_time", lambda pid: None)+ monkeypatch.setattr(launcher, "_terminate", lambda pid, start_time, proc: None)+ browser, err = launcher.launch_chromium("win-headless", executable="chrome.exe",+ user_data_dir=str(tmp_path / "udd"), env={}, timeout=1)+ assert browser is None and "exited" in err # the fake exits at once; only the argv mattersassert len(captured) == 1- cmd, env = captured[0]- assert env.get("AGENT_BROWSER_HEADED") == "false"- # The pin must not contradict the argv: headless local commands carry no --headed.- assert "--headed" not in cmd+ assert "--headless=new" in captured[0]diff --git a/tests/tools/test_managed_browserbase_and_modal.py b/tests/tools/test_managed_browserbase_and_modal.pyindex 6af897bd9be..1c6419c5dd8 100644--- a/tests/tools/test_managed_browserbase_and_modal.py+++ b/tests/tools/test_managed_browserbase_and_modal.py@@ -221,11 +221,10 @@ def test_browser_use_explicit_local_mode_stays_local_even_when_managed_gateway_i})with patch.dict(os.environ, env, clear=True):- _load_tool_module("tools.browser_tool", "browser_tool.py")- browser_tool_cloud = sys.modules["tools.browser_tool_cloud"]+ browser_session_cloud = _load_tool_module("tools.browser_session_cloud", "browser_session_cloud.py")- local_mode = browser_tool_cloud._is_local_mode()- provider = browser_tool_cloud._get_cloud_provider()+ local_mode = browser_session_cloud.is_local_mode()+ provider = browser_session_cloud.get_cloud_provider()assert local_mode is Trueassert provider is Nonediff --git a/tests/tools/test_strict_provider_selection.py b/tests/tools/test_strict_provider_selection.pyindex 02d12fba67c..4ce0c58bbff 100644--- a/tests/tools/test_strict_provider_selection.py+++ b/tests/tools/test_strict_provider_selection.py@@ -280,41 +280,6 @@ class TestBrowserUseStrictSelection:assert config["api_key"] == "bu-key"-# ----------------------------------------------------------------------------# Camofox: selection over env var-# ------------------------------------------------------------------------------class TestCamofoxSelection:- def test_camofox_selection_activates_mode(self, monkeypatch):- from tools import browser_camofox as bc-- monkeypatch.delenv("BROWSER_CDP_URL", raising=False)- with patch.object(bc, "_config_cdp_url", return_value=""), \- patch("tools.tool_backend_helpers.read_selection", return_value="camofox"):- assert bc.is_camofox_mode() is True-- def test_other_selection_beats_camofox_url_env(self, monkeypatch):- """CAMOFOX_URL is the ADDRESS, not the choice: an explicit different- browser selection wins."""- from tools import browser_camofox as bc-- monkeypatch.delenv("BROWSER_CDP_URL", raising=False)- with patch.object(bc, "_config_cdp_url", return_value=""), \- patch.object(bc, "get_camofox_url", return_value="http://localhost:9377"), \- patch("tools.tool_backend_helpers.read_selection", return_value="local"):- assert bc.is_camofox_mode() is False-- def test_never_configured_env_url_still_activates(self, monkeypatch):- from tools import browser_camofox as bc-- monkeypatch.delenv("BROWSER_CDP_URL", raising=False)- with patch.object(bc, "_config_cdp_url", return_value=""), \- patch.object(bc, "get_camofox_url", return_value="http://localhost:9377"), \- patch("tools.tool_backend_helpers.read_selection", return_value=None):- assert bc.is_camofox_mode() is True--# ---------------------------------------------------------------------------# tools_config writers: one provider string per row, no use_gateway writes# ---------------------------------------------------------------------------