Skip to content

The agent that grows with you

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.py
index 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 sys
from 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 lifecycle
class 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_done
def 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_done
def 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_activity
mock_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 True
class TestInactivityJanitorMultiplex:
@@ -91,29 +62,27 @@ class TestInactivityJanitorMultiplex:
def setup_method(self):
from agent import secret_scope
- from tools import browser_tool
- self.bt = browser_tool
self.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 = 0
for 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_scope
secret_scope.set_multiplex_active(False)
- self.bt.BROWSER_SESSION_INACTIVITY_TIMEOUT = self.orig_timeout
+ bs.BROWSER_SESSION_INACTIVITY_TIMEOUT = self.orig_timeout
for 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"] -= 10
seen = {}
- 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_homes
def 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.0
provider = 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_sessions
provider.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_failures
class 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 a
traceback (#10764): the thread is a daemon, the interpreter is already exiting."""
- from tools import browser_tool
class _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 raise
diff --git a/tests/tools/test_browser_cloud_fallback.py b/tests/tools/test_browser_cloud_fallback.py
index 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 provider
is configured but fails at runtime (issue #10883).
"""
-import logging
+from types import SimpleNamespace
from 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 True
assert "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_CDP
def 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 True
assert "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 True
assert "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.py
index 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 resolver
must not be cached for the lifetime of the process. Cache only when:
@@ -14,17 +14,22 @@ from unittest.mock import Mock
import 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 first
browser_registry.register_provider(second, scope=home)
- assert bt_cloud._get_cloud_provider() is second
+ assert bs_cloud.get_cloud_provider() is second
finally:
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 None
def 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 = True
monkeypatch.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 True
def 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 False
assert any(
"browser-use" in r.message and r.levelno == logging.WARNING
for r in caplog.records
diff --git a/tests/tools/test_browser_env_loopback_no_proxy.py b/tests/tools/test_browser_env_loopback_no_proxy.py
index 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 bs
from agent.proxy_bypass import add_loopback_no_proxy, loopback_connect_kwargs, loopback_request_kwargs
@pytest.fixture
def 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 local
holder = {}
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.py
index 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 patch
import 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_mode
cfg = {"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_resources
with (
- 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_resources
with (
- 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.py
index 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.py
index 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 json
import os
import sys
+import time
from pathlib import Path
import pytest
import pm
from 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 False
def test_late_pm_install_is_visible_without_cache_reset(browser_store, monkeypatch):
_, _, publish = browser_store
monkeypatch.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_store
monkeypatch.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 False
def 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
-
-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 False
def test_historical_warmer_is_inert(monkeypatch):
@@ -189,117 +146,59 @@ def test_external_chromium_override_survives_pm_composition(browser_store, monke
override = 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 child
def 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]) == chromium
assert "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
-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_store
monkeypatch.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_pat
override = 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 None
monkeypatch.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 False
publish("chromium")
- assert install.check_browser_requirements()
\ No newline at end of file
+ assert launcher.chromium_ready()[0] is True
diff --git a/tests/tools/test_browser_use_harness.py b/tests/tools/test_browser_use_harness.py
index 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_supervisor
probe = 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"], result
child = 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.py
index 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_tool
from 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_cloud
def _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"] = existing
provider = 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 existing
provider.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.0
provider = 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_activity
provider.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.py
index 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, patch
import 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
+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
+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.
-# ---------------------------------------------------------------------------
+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
-@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 matters
assert 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.py
index 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 True
assert provider is None
diff --git a/tests/tools/test_strict_provider_selection.py b/tests/tools/test_strict_provider_selection.py
index 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
# ---------------------------------------------------------------------------