Skip to content

The agent that grows with you

test(browser): port hybrid routing, orphan reaper, profile scope and Lightpanda tests to browser_session

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