The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""CLI-9 (#134889): a live ``/browser connect`` belongs to ONE profile on a multiplexed gateway.
The override map is keyed by ``hermes_home_key()``; browser sessions and CDP supervisors remember
the profile that created them, so reaping one profile's browsers never closes another's.
"""
import types
import pytest
from gateway.run import _profile_runtime_scope
from hermes_constants import hermes_home_key
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
@pytest.fixture
def profiles(tmp_path, monkeypatch):
a, b = tmp_path / "a", tmp_path / "b"
a.mkdir()
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(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):
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 bs_cdp.live_cdp_override() == ""
assert bs_cdp.get_cdp_override_raw().endswith("/PROFILE-B")
with _profile_runtime_scope(a, hydrate_secrets=False):
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
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):
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 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(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 = bs.get_session_info("task-a")
assert info["home_key"] == hermes_home_key(a)
def test_reaping_one_profile_leaves_the_other_profiles_browser_and_supervisor(profiles, monkeypatch):
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(bs, "_active_sessions", sessions)
closed = []
def close(task_id):
closed.append(task_id)
sessions.pop(task_id, None)
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")})
monkeypatch.setattr(SUPERVISOR_REGISTRY, "_home_by_task", {"ta": key_a, "vault-a": key_a, "tb": key_b})
lifecycle.cleanup_profile_browsers(key_a)
assert sorted(closed) == ["ta", "ta::local"] and list(sessions) == ["tb"]
assert sorted(stopped) == ["ta", "vault-a"] and list(SUPERVISOR_REGISTRY._by_task) == ["tb"]
def test_each_profile_drives_and_reaps_its_own_harness_daemon(profiles, monkeypatch, tmp_path):
"""The harness names a daemon by BU_NAME alone (unnamed exec: ``default``) and reuses a live one, so
with one shared runtime dir B's exec drove A's connected browser and A's reap stopped B's daemon."""
import json
import stat
from tools import browser_use_cli as bu_cli
a, b = profiles
shared = tmp_path / "harness-runtime"
cli = tmp_path / "browser-harness" # one daemon per (runtime dir, BU_NAME) latches its first endpoint
cli.write_text(f'''#!/bin/sh
dir="${{BH_RUNTIME_DIR:-{shared}}}"; mkdir -p "$dir"; latch="$dir/bu-${{BU_NAME:-default}}"
if [ "${{1:-}}" = "--reload" ]; then rm -f "$latch"; exit 0; fi
cat > /dev/null
[ -f "$latch" ] || echo "$BU_CDP_URL" > "$latch"
cat "$latch"
''')
cli.chmod(cli.stat().st_mode | stat.S_IXUSR)
monkeypatch.setenv("BH_RUNTIME_DIR", str(shared))
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(bs_cdp, "resolve_cdp_override", lambda url: url)
def drive(home, url=None):
with _profile_runtime_scope(home, hydrate_secrets=False):
if 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"
assert drive(b, "http://127.0.0.1:9302") == "http://127.0.0.1:9302" # B's own daemon, not A's
assert drive(a) == "http://127.0.0.1:9301"
reloads = []
real_run = bu_cli._run_cli_killing_process_group
monkeypatch.setattr(bu_cli, "_run_cli_killing_process_group",
lambda cmd, code, env, timeout: reloads.append(env.get("BH_RUNTIME_DIR"))
or real_run(cmd, code, env, timeout))
with _profile_runtime_scope(a, hydrate_secrets=False):
lifecycle.cleanup_profile_browsers(hermes_home_key(a))
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
assert drive(a) == "http://127.0.0.1:9311" # A respawned on its new endpoint