Skip to content

The agent that grows with you

25.7 KB
Raw Blame
"""GW-23 (#134889): per-profile browser scope edges left after CLI-9.

A multiplexed gateway serves every profile from one process; a live ``/browser connect`` endpoint,
a harness daemon's runtime and tmp dirs, and a browser session belong to ONE profile.
"""
import contextlib
import threading

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_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


@pytest.fixture
def profiles(tmp_path, monkeypatch):
    a, b = tmp_path / "a", tmp_path / "b"
    a.mkdir()
    b.mkdir()
    monkeypatch.delenv("BROWSER_CDP_URL", raising=False)
    monkeypatch.setattr(bs_cdp, "_live_overrides", {})
    return a, b


def _in_bare_thread(fn):
    """Run ``fn`` on a stdlib thread started WITHOUT the caller's copied context."""
    out = {}
    t = threading.Thread(target=lambda: out.setdefault("v", fn()))
    t.start()
    t.join(5)
    return out["v"]


def test_a_bare_thread_on_a_multiplexed_gateway_never_resolves_the_launch_profiles_override(profiles, monkeypatch):
    """No profile scope bound on a multiplexed gateway: the launch profile's live endpoint is NOT the
    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):
        bs_cdp.set_live_cdp_override("http://127.0.0.1:9401")
    monkeypatch.setattr(secret_scope, "_MULTIPLEX_ACTIVE", True)
    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 bs_cdp.live_cdp_override() == "http://127.0.0.1:9401"


def test_single_profile_bare_thread_keeps_the_process_override(profiles):
    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 -------------------------------------

_LONGEST_NAME = "n" * 64  # browser_harness/_ipc.py _NAME_RE: [A-Za-z0-9_-]{1,64}


def _sock_len(runtime_dir: str) -> int:
    """browser_harness/_ipc.py ``_sock_path``: ``<resolved BH_RUNTIME_DIR>/bu-<NAME>.sock`` when
    ``BH_RUNTIME_DIR_SHARED=1`` (pinned against the installed package by the test below)."""
    return len(f"{runtime_dir}/bu-{_LONGEST_NAME}.sock".encode())


def test_installed_harness_names_a_shared_dir_socket_bu_name_sock(tmp_path):
    """The length rule rests on the installed harness's stem: resolved dir + ``bu-<NAME>.sock``."""
    import os
    import subprocess
    import sys
    rt = tmp_path / "rt"
    env = {**os.environ, "BH_RUNTIME_DIR": str(rt), "BH_RUNTIME_DIR_SHARED": "1",
           "BH_TMP_DIR": str(tmp_path / "tmp"), "BH_HOME": str(tmp_path / "home")}
    out = subprocess.run([sys.executable, "-c",
                          f"from browser_harness import _ipc; print(_ipc._sock_path({_LONGEST_NAME!r}))"],
                         env=env, capture_output=True, text=True, check=True).stdout.strip()
    assert out == f"{rt.resolve()}/bu-{_LONGEST_NAME}.sock"


@pytest.mark.parametrize(("platform", "budget"), [("darwin", 103 - 73), ("linux", 107 - 73), ("win32", None)])
def test_the_socket_dir_budget_is_sun_path_minus_a_64_char_session_socket(platform, budget):
    """macOS ``sun_path`` is 104 bytes (103 + NUL), Linux 108; Windows serves over loopback TCP."""
    assert harness_dirs.socket_dir_budget(platform) == budget


def test_a_default_macos_home_does_not_fit_and_the_short_temp_dir_does():
    """Pure length rule with macOS data (no host platform involved): under
    ``~/.config/browser-harness/runtime/p-<hash>`` a 9-letter account left room for ~31-character
    session names; ``/private/tmp/hbh-<12 hex>`` fits a 64-character one."""
    budget = harness_dirs.socket_dir_budget("darwin")
    home = "/Users/alexander/.config/browser-harness/runtime/p-0123456789ab"
    short = "/private/tmp/hbh-0123456789ab"  # no-tmp: ok — a macOS path as data, nothing is written
    assert not harness_dirs.fits_socket_budget(home, budget)
    assert harness_dirs.fits_socket_budget(short, budget) and _sock_len(short) <= 103
    assert harness_dirs.fits_socket_budget("x" * 500, None)  # no sun_path limit


@pytest.mark.platforms("macos")
def test_on_macos_a_served_profile_binds_a_64_char_session_socket(profiles, tmp_path, monkeypatch):
    """Real branch: the dir is claimed under the real short root and a 64-character name binds."""
    import os
    import socket
    from tools import browser_use_cli as bu_cli
    a, _b = profiles
    monkeypatch.setattr(harness_dirs, "claim_private_dir", _REAL_CLAIM)  # the real claim, real short root
    env = {"HOME": str(tmp_path / ("u" * 40))}
    with _profile_runtime_scope(a, hydrate_secrets=False):
        harness_dirs.namespace_harness_dirs(env, bu_cli._served_profile_tag())
    path = f"{os.path.realpath(env['BH_RUNTIME_DIR'])}/bu-{_LONGEST_NAME}.sock"
    assert len(path.encode()) <= 103
    s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
    try:
        s.bind(path)
    finally:
        s.close()
        with contextlib.suppress(OSError):
            os.unlink(path)


def _kernel_accepts_sun_path(path: str) -> bool:
    """Ask the kernel ABI whether ``path`` fits ``sun_path``: an unbound dir gives ENOENT, an overlong
    path gives "AF_UNIX path too long" before any filesystem access."""
    import socket
    s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
    try:
        s.bind(path)
    except OSError as e:
        return "too long" not in str(e)
    else:
        import os
        os.unlink(path)
        return True
    finally:
        s.close()


@pytest.mark.platforms("linux")
@pytest.mark.parametrize("user_home", ["/home/teknium", "/home/alexander.smith"])
def test_on_linux_a_served_profiles_64_char_session_socket_fits_sun_path(profiles, monkeypatch, user_home):
    """Linux ``sun_path`` is 108 bytes (107 + NUL). ``~/.config/browser-harness/runtime/p-<hash>`` left
    room for 38-character names at /home/teknium and 30 at /home/alexander.smith, while BU_NAME may be
    64. The served profile gets the same private short dir as on macOS (claim stubbed: no temp-root
    write); the kernel judges the length of the exact path the installed harness binds."""
    import os
    from tools import browser_use_cli as bu_cli
    a, _b = profiles
    claimed = []
    monkeypatch.setattr(harness_dirs, "claim_private_dir", lambda path: claimed.append(path) or True)
    env = {"HOME": user_home}
    with _profile_runtime_scope(a, hydrate_secrets=False):
        harness_dirs.namespace_harness_dirs(env, bu_cli._served_profile_tag())
    sock = f"{env['BH_RUNTIME_DIR']}/bu-{_LONGEST_NAME}.sock"
    assert claimed == [env["BH_RUNTIME_DIR"]]
    assert _sock_len(env["BH_RUNTIME_DIR"]) <= 107 and _kernel_accepts_sun_path(sock), sock
    assert os.path.basename(env["BH_RUNTIME_DIR"]).startswith("hbh-")


@pytest.mark.platforms("linux")
def test_on_linux_a_runtime_dir_that_already_fits_is_kept_and_an_unclaimable_one_stays_long(profiles, monkeypatch):
    from tools import browser_use_cli as bu_cli
    a, _b = profiles
    claimed = []
    monkeypatch.setattr(harness_dirs, "claim_private_dir", lambda path: claimed.append(path) or True)
    env = {"BH_HOME": "/b"}
    with _profile_runtime_scope(a, hydrate_secrets=False):
        harness_dirs.namespace_harness_dirs(env, bu_cli._served_profile_tag())
    assert env["BH_RUNTIME_DIR"].startswith("/b/runtime/p-") and claimed == []
    monkeypatch.setattr(harness_dirs, "claim_private_dir", lambda path: False)  # squatted / not ours
    env = {"HOME": "/home/teknium"}
    with _profile_runtime_scope(a, hydrate_secrets=False):
        harness_dirs.namespace_harness_dirs(env, bu_cli._served_profile_tag())
    assert env["BH_RUNTIME_DIR"].startswith("/home/teknium/.config/browser-harness/runtime/p-")


@pytest.mark.platforms("linux")
@pytest.mark.parametrize("via", ["relative", "symlink"])
def test_on_linux_a_short_spelling_of_a_long_runtime_dir_is_measured_resolved(profiles, monkeypatch, tmp_path, via):
    """The harness binds ``Path(BH_RUNTIME_DIR).expanduser().resolve()``: a short relative or symlinked
    spelling of a deep dir still gives an overlong socket, so the length is judged on the resolved path."""
    import os
    from tools import browser_use_cli as bu_cli
    a, _b = profiles
    deep = tmp_path / ("d" * 60)
    deep.mkdir()
    if via == "relative":  # BH_RUNTIME_DIR=rt from a deep working directory
        monkeypatch.chdir(deep)
        base = "rt"
    else:  # a short symlink to a deep dir
        link = tmp_path / "l"
        link.symlink_to(deep)
        monkeypatch.chdir(tmp_path)
        base = "l"
    claimed = []
    monkeypatch.setattr(harness_dirs, "claim_private_dir", lambda path: claimed.append(path) or True)
    env = {"BH_RUNTIME_DIR": base}
    with _profile_runtime_scope(a, hydrate_secrets=False):
        harness_dirs.namespace_harness_dirs(env, bu_cli._served_profile_tag())
    resolved = os.path.realpath(env["BH_RUNTIME_DIR"])
    assert _sock_len(resolved) <= 107, resolved
    assert _kernel_accepts_sun_path(f"{resolved}/bu-{_LONGEST_NAME}.sock")
    assert claimed == [env["BH_RUNTIME_DIR"]]


def test_the_short_socket_dir_is_claimed_only_when_private_and_ours(tmp_path):
    """The short dir sits in a world-writable root: a symlink or another user's/open dir is refused."""
    fresh = tmp_path / "hbh-fresh"
    assert _REAL_CLAIM(str(fresh)) and (fresh.stat().st_mode & 0o777) == 0o700
    assert _REAL_CLAIM(str(fresh))  # ours, 0700: reused
    open_dir = tmp_path / "hbh-open"
    open_dir.mkdir(mode=0o755)
    open_dir.chmod(0o755)
    assert not _REAL_CLAIM(str(open_dir))
    link = tmp_path / "hbh-link"
    link.symlink_to(fresh)
    assert not _REAL_CLAIM(str(link))


# --- per-profile harness tmp dir (screenshots, debug overlays, daemon logs) ---------------------------


def test_each_served_profile_gets_its_own_harness_tmp_dir(profiles, tmp_path):
    """browser_harness/_ipc.py ``_TMP`` (paths.tmp_dir: BH_TMP_DIR, else <home>/tmp) holds ``shot.png``,
    debug-click overlays and ``bu-<NAME>.log``; one shared dir let profile B read A's screenshots."""
    from tools import browser_use_cli as bu_cli
    a, b = profiles
    seen = {}
    for home in (a, b):
        env = {"BH_HOME": str(tmp_path / "bh")}
        with _profile_runtime_scope(home, hydrate_secrets=False):
            harness_dirs.namespace_harness_dirs(env, bu_cli._served_profile_tag())
        assert env.get("BH_TMP_DIR_SHARED") == "1"  # several BU_NAMEs share it: keep bu-<name>.log stems
        seen[home] = env.get("BH_TMP_DIR")
    assert seen[a] and seen[b] and seen[a] != seen[b]
    assert all(str(p).startswith(str(tmp_path / "bh" / "tmp")) for p in seen.values())
    unscoped = {"BH_HOME": str(tmp_path / "bh")}
    harness_dirs.namespace_harness_dirs(unscoped, bu_cli._served_profile_tag())
    assert unscoped == {"BH_HOME": str(tmp_path / "bh")}  # single-profile: unchanged


def test_a_served_profile_under_an_inherited_tmp_dir_nests_inside_it(profiles, tmp_path):
    from tools import browser_use_cli as bu_cli
    a, _b = profiles
    env = {"BH_TMP_DIR": str(tmp_path / "shared-tmp")}
    with _profile_runtime_scope(a, hydrate_secrets=False):
        harness_dirs.namespace_harness_dirs(env, bu_cli._served_profile_tag())
    assert env["BH_TMP_DIR"].startswith(str(tmp_path / "shared-tmp") + "/p-")
    # The runtime dir still derives from the inherited BH_TMP_DIR (harness fallback), not the new one.
    assert env["BH_RUNTIME_DIR"].startswith(str(tmp_path / "shared-tmp") + "/p-")


def test_an_unscoped_shutdown_reload_reaches_the_daemon_with_its_own_tmp_dir(profiles, monkeypatch):
    """The reaper/shutdown runs outside any profile scope; its ``--reload`` must still carry the
    daemon's own tmp dir, or the harness writes that profile's log into the shared one."""
    from tools import browser_use_cli as bu_cli
    a, _b = profiles
    with _profile_runtime_scope(a, hydrate_secrets=False):
        env = {"HOME": "/home/u"}
        harness_dirs.namespace_harness_dirs(env, bu_cli._served_profile_tag())
    key = harness_dirs.daemon_identity({**env, "BU_NAME": "s1"})
    monkeypatch.setattr(bu_cli, "_driven_daemons", {key: hermes_home_key(a)})
    monkeypatch.setattr(bu_cli, "_find_cli", lambda: ["browser-harness"])
    seen = []
    monkeypatch.setattr(bu_cli, "_run_cli_killing_process_group", lambda cmd, code, e, t: seen.append(e))
    bu_cli.stop_harness_daemons()
    assert [(e["BH_TMP_DIR"], e["BH_TMP_DIR_SHARED"], e["BU_NAME"]) for e in seen] == [
        (env["BH_TMP_DIR"], "1", "s1")]


# --- reap/publish race within one profile -----------------------------------------------------------


def test_a_session_that_resolved_the_old_endpoint_during_a_connect_is_closed_not_kept(profiles, monkeypatch):
    """``/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_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(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"]))
    created = []

    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(bs, "_create_session_for_key", create)

    with _profile_runtime_scope(a, hydrate_secrets=False):
        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"]


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
    ``_active_sessions`` (it would return a browser that is being closed underneath it)."""
    from tools import browser_session as bs, browser_session_lifecycle as lifecycle
    from tui_gateway import server

    a, _b = profiles
    sessions = {}
    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)
    visible_during_close = []
    released = []

    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, 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(bs, "_create_session_for_key", create)

    with _profile_runtime_scope(a, hydrate_secrets=False):
        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_session as bs, browser_session_lifecycle as lifecycle
    a, b = profiles
    sessions = {}
    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_session", closed.append)
    monkeypatch.setattr(lifecycle, "release_session_backend", lambda task_id, info: closed.append(task_id))

    def create(task_id, force_local):
        with _profile_runtime_scope(b, hydrate_secrets=False):
            bs_cdp.set_live_cdp_override("http://127.0.0.1:9601")
        return {"session_name": "s", "cdp_url": "x"}
    monkeypatch.setattr(bs, "_create_session_for_key", create)
    with _profile_runtime_scope(a, hydrate_secrets=False):
        info = bs.get_session_info("task-a")
    assert sessions == {"task-a": info} and closed == []


def test_a_browser_exec_that_routed_to_the_old_endpoint_during_a_connect_reloads_its_daemon(profiles, monkeypatch):
    """Browser Use path (the default mode): ``browser_exec`` resolves the live endpoint into
    ``BU_CDP_URL`` before the daemon is recorded. A ``/browser connect`` landing in between reaped
    nothing, and the harness daemon (which latches ``BU_CDP_*`` at spawn) kept the old browser for every
    later call. The real ``_browser_connect`` handler runs between routing and dispatch here."""
    from tools import browser_use_cli as bu_cli
    from tui_gateway import server

    a, _b = profiles
    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(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

    def run(cmd, code, env, timeout):
        import subprocess
        ident = harness_dirs.daemon_identity(env)
        if cmd[-1] == "--reload":
            latched.pop(ident, None)
        else:
            latched.setdefault(ident, env.get("BU_CDP_URL"))
        return subprocess.CompletedProcess(cmd, 0, str(latched.get(ident)), "")
    monkeypatch.setattr(bu_cli, "_run_cli_killing_process_group", run)
    real_route = bu_cli._route_exec
    connects = []

    def route_then_connect(*args, **kw):
        out = real_route(*args, **kw)  # BU_CDP_URL now holds the OLD endpoint
        if not connects:
            connects.append(server._browser_connect("r1", {"url": "http://127.0.0.1:9702"}))
        return out
    monkeypatch.setattr(bu_cli, "_route_exec", route_then_connect)

    import json
    with _profile_runtime_scope(a, hydrate_secrets=False):
        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"))
    assert first["output"] == nxt["output"] == "http://127.0.0.1:9702"


def test_a_connect_that_lands_while_browser_exec_spawns_its_daemon_reloads_it(profiles, monkeypatch):
    """The publish lands after routing, while the CLI spawns the daemon on the old endpoint: the daemon
    is already recorded (connect's reap reloads it) and the post-dispatch generation check reloads it
    too, so the next call respawns it on the new endpoint."""
    import json
    import subprocess
    from tools import browser_use_cli as bu_cli
    from tui_gateway import server

    a, _b = profiles
    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(bs_cdp, "resolve_cdp_override", lambda raw: raw)
    monkeypatch.setattr(server, "_cdp_http_reachable", lambda parsed, timeout=2.0: True)
    latched, connects = {}, []

    def run(cmd, code, env, timeout):
        ident = harness_dirs.daemon_identity(env)
        if cmd[-1] == "--reload":
            latched.pop(ident, None)
            return subprocess.CompletedProcess(cmd, 0, "", "")
        latched.setdefault(ident, env.get("BU_CDP_URL"))
        if not connects:  # mid-spawn: the daemon already latched the old endpoint
            connects.append(server._browser_connect("r1", {"url": "http://127.0.0.1:9712"}))
        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):
        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"))
    assert nxt["output"] == "http://127.0.0.1:9712"


# --- real-profile browser per profile home (one process, many profiles) -----------------------------

@pytest.fixture
def real_profile_launches(tmp_path, monkeypatch):
    """Session + launcher registries isolated; the real-profile and fresh launches register a fake browser
    under whatever key the session layer asks for (what the launcher does), and every stop is recorded."""
    import os
    from tools import browser_launcher as launcher, browser_lightpanda, browser_session as bs
    from tools import browser_session_lifecycle as lifecycle
    from tools.bot_desktop import placement, runtime
    import hermes_cli.browser_connect as bc
    for name in ("_active_sessions", "_session_last_activity", "_session_owner_homes", "_cleanup_failures"):
        monkeypatch.setattr(bs, name, {})
    monkeypatch.setattr(lifecycle, "start_cleanup_thread", lambda: None)
    monkeypatch.setattr(launcher, "_browsers", {})
    monkeypatch.setattr(runtime, "tool_placement", lambda: placement.GATEWAY)
    monkeypatch.setattr(bs, "ensure_screen_for_headed_chromium", lambda: None)
    monkeypatch.setattr(browser_lightpanda, "using_lightpanda_engine", lambda: False)
    monkeypatch.setattr(bc, "detect_default_chromium", lambda system=None: "chrome")
    monkeypatch.setattr(bc, "chromium_executable", lambda name, system=None: "/usr/bin/chrome")
    monkeypatch.setattr(bc, "snapshot_real_profile", lambda name: (str(get_hermes_home() / "rp-copy"), None))
    stopped = []
    monkeypatch.setattr(launcher, "_terminate", lambda pid, start_time, proc: stopped.append(pid))

    def launch(key, **kw):
        port = 9500 + len(launcher._browsers)
        browser = launcher.LaunchedBrowser(
            key=key, pid=os.getpid(), start_time=None, cdp_url=f"ws://127.0.0.1:{port}/devtools/browser/{port}",
            http_url=f"http://127.0.0.1:{port}", user_data_dir=kw.get("user_data_dir") or str(tmp_path / key),
            owned=True, ephemeral=False, home_key=hermes_home_key())
        launcher._browsers[key] = browser
        return browser, None
    monkeypatch.setattr(launcher, "launch_chromium", launch)
    return stopped


def _consent(home, on: bool) -> None:
    (home / "config.yaml").write_text(f"browser:\n  cloud_provider: local\n  use_real_profile: {'true' if on else 'false'}\n",
                                      encoding="utf-8")


def test_a_consent_off_profile_never_stops_another_profiles_real_profile_browser(profiles, real_profile_launches):
    """Profile B (consent off, the default) creating a local session revokes only ITS real-profile browser;
    profile A's keeps serving A's session."""
    from tools import browser_session as bs
    a, b = profiles
    _consent(a, True)
    _consent(b, False)
    with _profile_runtime_scope(a, hydrate_secrets=False):
        info_a = bs.get_session_info("task@a")
        assert info_a["features"].get("real_profile")
    with _profile_runtime_scope(b, hydrate_secrets=False):
        info_b = bs.get_session_info("task@b")
        assert not info_b["features"].get("real_profile")

    assert real_profile_launches == [], "B's consent-off must not terminate A's real-profile browser"
    with _profile_runtime_scope(a, hydrate_secrets=False):
        assert bs._backend_dead(info_a) is False
        assert bs.get_session_info("task@a")["cdp_url"] == info_a["cdp_url"]


def test_a_consenting_profile_never_reuses_another_profiles_real_profile_browser(profiles, real_profile_launches):
    """Two consenting profiles each get their own real-profile browser (their own snapshot, their own cookies)."""
    from tools.browser_session_real_profile import real_profile_cdp
    a, b = profiles
    _consent(a, True)
    _consent(b, True)
    with _profile_runtime_scope(a, hydrate_secrets=False):
        cdp_a, err_a = real_profile_cdp()
    with _profile_runtime_scope(b, hydrate_secrets=False):
        cdp_b, err_b = real_profile_cdp()
    assert err_a is None and err_b is None
    assert cdp_a != cdp_b