Skip to content

Automate browser based workflows with AI

fix: reap browser sessions whose runnable owner type cannot be resolved (#8027)

Aaron Perez2ce677109fc8
diff --git a/skyvern/webeye/browser_manager.py b/skyvern/webeye/browser_manager.py
index 140f770be..cea59d89e 100644
--- a/skyvern/webeye/browser_manager.py
+++ b/skyvern/webeye/browser_manager.py
@@ -60,6 +60,11 @@ class BrowserManager(Protocol):
organization_id: str | None = None,
) -> BrowserState: ...
+ def live_session_runnable_ids(self) -> set[str]:
+ """Runnables holding a persistent session in this process — leased, or mid-acquisition — i.e.
+ still running here. An implementation that tracks none reports none and is never protected."""
+ return set()
+
async def cleanup_for_script(
self,
script_id: str,
diff --git a/skyvern/webeye/default_persistent_sessions_manager.py b/skyvern/webeye/default_persistent_sessions_manager.py
index 8cca469bb..f67f8f112 100644
--- a/skyvern/webeye/default_persistent_sessions_manager.py
+++ b/skyvern/webeye/default_persistent_sessions_manager.py
@@ -752,11 +752,18 @@ class DefaultPersistentSessionsManager(PersistentSessionsManager):
A run that dies before release_browser_session leaves runnable_id set forever; treating a
terminal or missing owner as inactive lets the normal timeout+grace gate reclaim the session
- instead of skipping it forever. Owners we can't authoritatively resolve — an unrecognized
- runnable type or a lookup failure — are treated as active, so a reap never races a run we
- can't prove is gone."""
+ instead of skipping it forever. A resolvable owner whose lookup fails is treated as active,
+ so a reap never races a run we could have proven live but couldn't reach.
+
+ A runnable type we have no lookup for can't be resolved either way, so the only liveness
+ signal left is process-local: a runnable holding a session here — mid-acquisition or leased —
+ is still running (nothing renews a standalone script's session, so its run can outlive the
+ timeout). Once that ends at the run's terminal boundary the session falls through to the
+ caller's own gate — timeout+grace in the reaper, a terminal row in reconcile — rather than
+ staying protected forever. A new runnable type that occupies a session must therefore either
+ be resolvable here or report itself live there, or its runs are reaped mid-flight."""
if runnable_type not in (RunType.workflow_run, PBS_TASK_RUNNABLE_TYPE):
- return True
+ return runnable_id in app.BROWSER_MANAGER.live_session_runnable_ids()
try:
if runnable_type == PBS_TASK_RUNNABLE_TYPE:
owner = await self.database.tasks.get_task(runnable_id, organization_id=organization_id)
@@ -862,7 +869,7 @@ class DefaultPersistentSessionsManager(PersistentSessionsManager):
# cleanup — never yank a browser out from under a live task/workflow. But close only sets
# completed_at/status without clearing runnable_id, and a completed row is invisible to
# reap_expired_sessions, so resolve the owner the same way the reaper does and skip only a
- # still-live/unknown owner; a terminal/missing owner falls through to reclaim below.
+ # still-live owner; a terminal/missing/unresolvable owner falls through to reclaim below.
if (
db_session is not None
and db_session.runnable_id is not None
diff --git a/skyvern/webeye/real_browser_manager.py b/skyvern/webeye/real_browser_manager.py
index 4b02c9204..b02361561 100644
--- a/skyvern/webeye/real_browser_manager.py
+++ b/skyvern/webeye/real_browser_manager.py
@@ -239,6 +239,10 @@ class RealBrowserManager(BrowserManager):
# The runnable identity accepted by begin_session, carried unchanged into teardown. Cleanup
# reads this lease instead of reconstructing identity from Task/Workflow fields.
self._persistent_session_leases: dict[str, _PersistentSessionLease] = {}
+ # Runnables between begin_session and their lease. Occupancy is published first and occupy
+ # does not extend the session's timeout, so without this a reused-but-expired session is
+ # unprotected for the whole attach.
+ self._acquiring_session_runnables: set[str] = set()
# CDP frame publishers keyed by stream key (``{wr}.png`` / ``{task}.png``).
self._frame_publishers: dict[str, CDPFramePublisher] = {}
# Serializes the check/create/start/store/register sequence in
@@ -286,6 +290,9 @@ class RealBrowserManager(BrowserManager):
if lease is not None and self._persistent_session_leases.get(run_id) is lease:
self._persistent_session_leases.pop(run_id, None)
+ def live_session_runnable_ids(self) -> set[str]:
+ return set(self._persistent_session_leases) | self._acquiring_session_runnables
+
async def _start_frame_publisher(
self,
*,
@@ -1364,46 +1371,52 @@ class RealBrowserManager(BrowserManager):
raise MissingOrganizationForBrowserSession(browser_session_id)
if not script_id:
raise MissingBrowserStateForBrowserSession(browser_session_id)
- raw_generation_id = await app.PERSISTENT_SESSIONS_MANAGER.begin_session(
- browser_session_id=browser_session_id,
- runnable_type="script",
- runnable_id=script_id,
- organization_id=organization_id,
- )
- expected_runnable_generation_id = raw_generation_id if isinstance(raw_generation_id, str) else None
- if context is not None:
- context.browser_session_runnable_id = script_id
- context.browser_session_runnable_generation_id = expected_runnable_generation_id
- download_run_id = resolve_run_download_id(skyvern_context.current(), fallback_run_id=script_id) or script_id
- LOG.info(
- "Getting browser state for script",
- browser_session_id=browser_session_id,
- )
- browser_state = await app.PERSISTENT_SESSIONS_MANAGER.get_browser_state(
- browser_session_id,
- **{
- "organization_id": organization_id,
- "expected_runnable_id": script_id,
- "download_run_id": download_run_id,
- **(
- {"expected_runnable_generation_id": expected_runnable_generation_id}
- if expected_runnable_generation_id is not None
- else {}
- ),
- },
- )
- if browser_state is None:
- # Fail closed: a cold/evicted session has no reusable state. Silently creating a local
- # browser below would produce an unregistered state that terminal cleanup misclassifies as
- # a reusable persistent session (keyed off browser_session_id) and leaks instead of closes.
- raise MissingBrowserStateForBrowserSession(browser_session_id)
- self._persistent_session_leases[script_id] = _PersistentSessionLease(
- session_id=browser_session_id,
- organization_id=organization_id,
- runnable_id=script_id,
- runnable_generation_id=expected_runnable_generation_id,
- browser_state=browser_state,
- )
+ self._acquiring_session_runnables.add(script_id)
+ try:
+ raw_generation_id = await app.PERSISTENT_SESSIONS_MANAGER.begin_session(
+ browser_session_id=browser_session_id,
+ runnable_type="script",
+ runnable_id=script_id,
+ organization_id=organization_id,
+ )
+ expected_runnable_generation_id = raw_generation_id if isinstance(raw_generation_id, str) else None
+ if context is not None:
+ context.browser_session_runnable_id = script_id
+ context.browser_session_runnable_generation_id = expected_runnable_generation_id
+ download_run_id = (
+ resolve_run_download_id(skyvern_context.current(), fallback_run_id=script_id) or script_id
+ )
+ LOG.info(
+ "Getting browser state for script",
+ browser_session_id=browser_session_id,
+ )
+ browser_state = await app.PERSISTENT_SESSIONS_MANAGER.get_browser_state(
+ browser_session_id,
+ **{
+ "organization_id": organization_id,
+ "expected_runnable_id": script_id,
+ "download_run_id": download_run_id,
+ **(
+ {"expected_runnable_generation_id": expected_runnable_generation_id}
+ if expected_runnable_generation_id is not None
+ else {}
+ ),
+ },
+ )
+ if browser_state is None:
+ # Fail closed: a cold/evicted session has no reusable state. Silently creating a local
+ # browser below would produce an unregistered state that terminal cleanup misclassifies as
+ # a reusable persistent session (keyed off browser_session_id) and leaks instead of closes.
+ raise MissingBrowserStateForBrowserSession(browser_session_id)
+ self._persistent_session_leases[script_id] = _PersistentSessionLease(
+ session_id=browser_session_id,
+ organization_id=organization_id,
+ runnable_id=script_id,
+ runnable_generation_id=expected_runnable_generation_id,
+ browser_state=browser_state,
+ )
+ finally:
+ self._acquiring_session_runnables.discard(script_id)
page = await browser_state.get_working_page()
if not page:
LOG.warning("Browser state has no page to run the script", script_id=script_id)
@@ -1478,13 +1491,11 @@ class RealBrowserManager(BrowserManager):
# Best-effort per the "errors are logged, not raised" contract: a release failure must not
# escape cleanup and mask the script's own exception (this runs in run_script's finally).
try:
- released = await self._release_persistent_session(
+ await self._release_persistent_session(
browser_session_id,
organization_id,
session_lease,
)
- if released:
- self._discard_session_lease(script_id, session_lease)
LOG.info("Released browser session", browser_session_id=browser_session_id)
except Exception:
LOG.warning(
@@ -1493,6 +1504,11 @@ class RealBrowserManager(BrowserManager):
browser_session_id=browser_session_id,
exc_info=True,
)
+ finally:
+ # This is the script's only cleanup call, so a retained lease is never retried —
+ # it just reads as "still running" to the reaper's lease gate and pins the
+ # session. Drop it either way and leave the occupied row to the reaper.
+ self._discard_session_lease(script_id, session_lease)
elif browser_session_id:
LOG.warning("Organization ID not specified, cannot release browser session", script_id=script_id)
return browser_state_to_close
diff --git a/tests/unit/test_persistent_session_reaper.py b/tests/unit/test_persistent_session_reaper.py
index 2229f4995..2088d80e2 100644
--- a/tests/unit/test_persistent_session_reaper.py
+++ b/tests/unit/test_persistent_session_reaper.py
@@ -2,6 +2,7 @@
Chromium + record_video ffmpeg encoders don't leak."""
import asyncio
+from collections.abc import Iterator
from datetime import datetime, timedelta, timezone
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock, patch
@@ -12,10 +13,30 @@ from skyvern.forge.sdk.workflow.models.workflow import WorkflowRunStatus
from skyvern.schemas.run_enums import RunType
from skyvern.webeye import default_persistent_sessions_manager as manager_mod
from skyvern.webeye.default_persistent_sessions_manager import BrowserSession, DefaultPersistentSessionsManager
+from skyvern.webeye.real_browser_manager import RealBrowserManager, _PersistentSessionLease
MODULE = "skyvern.webeye.default_persistent_sessions_manager"
[email protected](autouse=True)
+def browser_manager() -> Iterator[RealBrowserManager]:
+ """The reaper reads in-process session leases off app.BROWSER_MANAGER, and the real app proxy
+ raises unless a ForgeApp was started. Yielding the manager lets a test register a live lease."""
+ manager = RealBrowserManager()
+ with patch.object(manager_mod, "app", SimpleNamespace(BROWSER_MANAGER=manager)):
+ yield manager
+
+
+def _lease(browser_manager: RealBrowserManager, runnable_id: str, session_id: str) -> None:
+ """Register the lease production writes when a runnable acquires a persistent session."""
+ browser_manager._persistent_session_leases[runnable_id] = _PersistentSessionLease(
+ session_id=session_id,
+ organization_id="org_test",
+ runnable_id=runnable_id,
+ browser_state=MagicMock(),
+ )
+
+
def _make_manager(uncompleted_sessions: list, owned_ids: list[str] | None = None) -> DefaultPersistentSessionsManager:
DefaultPersistentSessionsManager.instance = None
DefaultPersistentSessionsManager._browser_sessions = {}
@@ -25,8 +46,11 @@ def _make_manager(uncompleted_sessions: list, owned_ids: list[str] | None = None
db.browser_sessions = MagicMock()
db.browser_sessions.get_uncompleted_persistent_browser_sessions = AsyncMock(return_value=uncompleted_sessions)
db.workflow_runs = MagicMock()
+ db.tasks = MagicMock()
# Default: the owning run row is gone (stale). Tests that need a live/terminal owner override this.
+ # Both owner lookups are real AsyncMocks so an assert_not_awaited() on them can actually fail.
db.workflow_runs.get_workflow_run = AsyncMock(return_value=None)
+ db.tasks.get_task = AsyncMock(return_value=None)
manager = DefaultPersistentSessionsManager(database=db)
# Register the browsers this process "holds" — the reaper only touches these.
held = owned_ids if owned_ids is not None else [s.persistent_browser_session_id for s in uncompleted_sessions]
@@ -55,6 +79,28 @@ def _session(
)
+def _real_session(
+ session_id: str,
+ started_minutes_ago: float | None,
+ timeout_minutes: int | None,
+ runnable_id: str | None = None,
+ runnable_type: str | None = None,
+) -> SimpleNamespace:
+ """A row carrying only the fields the reaper reads. A MagicMock row auto-creates whatever
+ attribute a gate checks, which makes a guard test pass without the guard existing."""
+ started_at = None
+ if started_minutes_ago is not None:
+ started_at = datetime.now(timezone.utc) - timedelta(minutes=started_minutes_ago)
+ return SimpleNamespace(
+ persistent_browser_session_id=session_id,
+ organization_id="org_test",
+ started_at=started_at,
+ timeout_minutes=timeout_minutes,
+ runnable_id=runnable_id,
+ runnable_type=runnable_type,
+ )
+
+
def _workflow_run(status: WorkflowRunStatus) -> MagicMock:
# Real WorkflowRunStatus so .is_final() runs the production logic, not a mocked truth value.
return MagicMock(status=status)
@@ -223,16 +269,18 @@ async def test_does_not_reap_terminal_owned_session_before_expiry() -> None:
@pytest.mark.asyncio
-async def test_protects_expired_session_with_unknown_runnable_type() -> None:
- # A runnable_id set with a runnable_type the reaper can't authoritatively resolve stays protected:
- # no broad age-only fallback, so this is left to its owner's teardown rather than reaped.
[email protected]("unresolvable_type", ["script", "task_v2", None])
+async def test_reaps_expired_session_with_unresolvable_runnable_type(unresolvable_type: str | None) -> None:
+ # An owner type the reaper can't resolve (script today, any new runnable type tomorrow) used to
+ # pin its session forever: no owner lookup exists, so it was treated as live on every pass. It
+ # now gets no liveness protection and falls through to the ordinary timeout+grace gate.
sessions = [
- _session(
- "pbs_unknown",
+ _real_session(
+ "pbs_unresolvable",
started_minutes_ago=180,
timeout_minutes=60,
- runnable_id="tsk_unknown",
- runnable_type="task_v2",
+ runnable_id="s_dead",
+ runnable_type=unresolvable_type,
)
]
manager = _make_manager(sessions)
@@ -240,8 +288,131 @@ async def test_protects_expired_session_with_unknown_runnable_type() -> None:
await manager.reap_expired_sessions()
- manager.close_session.assert_not_awaited()
+ manager.close_session.assert_awaited_once_with("org_test", "pbs_unresolvable")
+ # No per-type liveness semantics were invented: neither known-owner lookup was attempted.
manager.database.workflow_runs.get_workflow_run.assert_not_awaited()
+ manager.database.tasks.get_task.assert_not_awaited()
+
+
+async def test_protects_expired_session_leased_by_a_live_in_process_runnable(
+ browser_manager: RealBrowserManager,
+) -> None:
+ # Nothing renews a standalone script's session, so a script running longer than its session
+ # timeout would lose its browser mid-run — the case workflow_run/task owners survive via their
+ # liveness lookup. The lease this process holds is that signal for an unresolvable owner.
+ sessions = [
+ _real_session(
+ "pbs_leased",
+ started_minutes_ago=180,
+ timeout_minutes=60,
+ runnable_id="s_running",
+ runnable_type="script",
+ )
+ ]
+ manager = _make_manager(sessions)
+ manager.close_session = AsyncMock()
+ _lease(browser_manager, "s_running", "pbs_leased")
+
+ await manager.reap_expired_sessions()
+
+ manager.close_session.assert_not_awaited()
+
+
+async def test_protects_expired_session_while_a_runnable_is_still_acquiring_it(
+ browser_manager: RealBrowserManager,
+) -> None:
+ # begin_session publishes occupancy before the lease exists, so an expired session being reused
+ # would otherwise be reapable for the whole attach and fail the run it was just handed to.
+ sessions = [
+ _real_session(
+ "pbs_attaching",
+ started_minutes_ago=180,
+ timeout_minutes=60,
+ runnable_id="s_attaching",
+ runnable_type="script",
+ )
+ ]
+ manager = _make_manager(sessions)
+ manager.close_session = AsyncMock()
+ browser_manager._acquiring_session_runnables.add("s_attaching")
+
+ await manager.reap_expired_sessions()
+
+ manager.close_session.assert_not_awaited()
+
+
+async def test_reaps_expired_session_once_its_lease_is_released(browser_manager: RealBrowserManager) -> None:
+ # The lease is dropped at the run's terminal boundary, which is what makes the protection above
+ # self-clearing rather than the indefinite protection this PR removes.
+ sessions = [
+ _real_session(
+ "pbs_released",
+ started_minutes_ago=180,
+ timeout_minutes=60,
+ runnable_id="s_done",
+ runnable_type="script",
+ )
+ ]
+ manager = _make_manager(sessions)
+ manager.close_session = AsyncMock()
+ _lease(browser_manager, "s_done", "pbs_released")
+
+ await manager.reap_expired_sessions()
+ manager.close_session.assert_not_awaited()
+
+ browser_manager._persistent_session_leases.pop("s_done")
+ await manager.reap_expired_sessions()
+
+ manager.close_session.assert_awaited_once_with("org_test", "pbs_released")
+
+
+async def test_lease_does_not_protect_a_session_owned_by_a_terminal_workflow_run(
+ browser_manager: RealBrowserManager,
+) -> None:
+ # Resolvable owners keep their existing contract: the DB verdict decides, and a lingering lease
+ # for a terminal run must not start protecting a session the reaper already reclaims today.
+ sessions = [
+ _real_session(
+ "pbs_wr_dead",
+ started_minutes_ago=180,
+ timeout_minutes=60,
+ runnable_id="wr_dead",
+ runnable_type=RunType.workflow_run,
+ )
+ ]
+ manager = _make_manager(sessions)
+ manager.database.workflow_runs.get_workflow_run = AsyncMock(return_value=_workflow_run(WorkflowRunStatus.failed))
+ manager.close_session = AsyncMock()
+ _lease(browser_manager, "wr_dead", "pbs_wr_dead")
+
+ await manager.reap_expired_sessions()
+
+ manager.close_session.assert_awaited_once_with("org_test", "pbs_wr_dead")
+
+
+async def test_does_not_reap_unresolvable_owner_before_timeout() -> None:
+ # The fall-through hands unresolvable owners to the timeout+grace gate, not to an unconditional
+ # reap: still inside its window, a script-owned session is untouched.
+ sessions = [
+ _real_session(
+ "pbs_script_live",
+ started_minutes_ago=1,
+ timeout_minutes=60,
+ runnable_id="s_live",
+ runnable_type="script",
+ )
+ ]
+ manager = _make_manager(sessions)
+ manager.close_session = AsyncMock()
+
+ await manager.reap_expired_sessions()
+
+ manager.close_session.assert_not_awaited()
@pytest.mark.asyncio
@@ -563,21 +734,52 @@ async def test_reconcile_reclaims_completed_row_whose_owning_run_is_dead() -> No
@pytest.mark.asyncio
-async def test_reconcile_protects_completed_row_with_unknown_owner_type() -> None:
- # An owner we can't authoritatively resolve (unrecognized runnable type) is treated as active, so
- # reconcile never reclaims a session we can't prove is unowned — same fail-safe as the reaper.
+async def test_reconcile_reclaims_completed_row_with_unresolvable_owner_type() -> None:
+ # Same fall-through as the reaper: an owner type we can't resolve no longer protects the row, so a
+ # completed row left occupied by a script run is reclaimed instead of leaking its local state.
manager = _make_manager([], owned_ids=[])
- _hold_local_session(manager, "pbs_unknown_owner")
- row = _completed_row("pbs_unknown_owner")
- row.runnable_id = "task_1"
- row.runnable_type = "task_run"
+ _hold_local_session(manager, "pbs_unresolvable_owner")
+ row = SimpleNamespace(
+ persistent_browser_session_id="pbs_unresolvable_owner",
+ organization_id="org_test",
+ completed_at=datetime.now(timezone.utc),
+ status="completed",
+ runnable_id="s_dead",
+ runnable_type="script",
+ should_export_profile=lambda: True,
+ )
+ manager.database.browser_sessions.get_persistent_browser_session = AsyncMock(return_value=row)
+ manager._release_local_browser_session = AsyncMock()
+
+ await manager.reconcile_local_sessions()
+
+ manager._release_local_browser_session.assert_awaited_once_with(
+ "org_test", "pbs_unresolvable_owner", export_profile=True
+ )
+
+
+async def test_reconcile_leaves_active_row_with_unresolvable_owner_type() -> None:
+ # Reconcile's own gate still governs after the fall-through: a live, uncompleted row is left to
+ # ordinary expiration even though its owner type is unresolvable.
+ manager = _make_manager([], owned_ids=[])
+ _hold_local_session(manager, "pbs_unresolvable_live")
+ row = SimpleNamespace(
+ persistent_browser_session_id="pbs_unresolvable_live",
+ organization_id="org_test",
+ completed_at=None,
+ status="running",
+ runnable_id="s_live",
+ runnable_type="script",
+ should_export_profile=lambda: True,
+ )
manager.database.browser_sessions.get_persistent_browser_session = AsyncMock(return_value=row)
manager._release_local_browser_session = AsyncMock()
await manager.reconcile_local_sessions()
manager._release_local_browser_session.assert_not_awaited()
- assert "pbs_unknown_owner" in manager._browser_sessions
+ assert "pbs_unresolvable_live" in manager._browser_sessions
@pytest.mark.asyncio
diff --git a/tests/unit/test_real_browser_manager.py b/tests/unit/test_real_browser_manager.py
index fda95d793..55e55c3ae 100644
--- a/tests/unit/test_real_browser_manager.py
+++ b/tests/unit/test_real_browser_manager.py
@@ -12,6 +12,7 @@ from unittest.mock import AsyncMock, MagicMock, patch
import pytest
+from skyvern.exceptions import MissingBrowserStateForBrowserSession
from skyvern.forge.sdk.artifact.storage.recording_test_helpers import fake_prepared_recording
from skyvern.forge.sdk.core import skyvern_context
from skyvern.forge.sdk.core.skyvern_context import SkyvernContext
@@ -1081,6 +1082,105 @@ async def test_public_workflow_cleanup_installs_closing_tombstone_before_first_a
assert attached is False
+async def test_script_acquisition_reports_a_live_session_before_the_lease_exists() -> None:
+ # begin_session publishes occupancy, but the lease only lands once the attach returns — and occupy
+ # does not extend started_at/timeout_minutes. A reused session already past timeout+grace would
+ # therefore sit occupied-but-unleased for the whole attach, and the reaper (which reads liveness
+ # from this manager) would reap it out from under the run.
+ manager = RealBrowserManager()
+ pbs_state = MagicMock()
+ pbs_state.get_working_page = AsyncMock(return_value=None)
+ pbs_state.get_or_create_page = AsyncMock()
+ during_attach: list[set[str]] = []
+
+ async def _begin_session(**kwargs: object) -> str:
+ during_attach.append(manager.live_session_runnable_ids())
+ return "gen_attach"
+
+ async def _get_browser_state(*args: object, **kwargs: object) -> MagicMock:
+ during_attach.append(manager.live_session_runnable_ids())
+ return pbs_state
+
+ with patch("skyvern.webeye.real_browser_manager.app") as mock_app:
+ configure_browser_context_acquired_hook(mock_app)
+ mock_app.PERSISTENT_SESSIONS_MANAGER.begin_session = AsyncMock(side_effect=_begin_session)
+ mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(side_effect=_get_browser_state)
+
+ await manager.get_or_create_for_script(
+ script_id="s_attach",
+ browser_session_id="pbs_attach",
+ organization_id="org_test",
+ )
+
+ assert during_attach == [{"s_attach"}, {"s_attach"}]
+ # The lease takes over with no gap once the attach completes.
+ assert manager._persistent_session_leases["s_attach"].runnable_id == "s_attach"
+ assert manager.live_session_runnable_ids() == {"s_attach"}
+
+
+async def test_failed_script_acquisition_leaves_no_live_session_behind() -> None:
+ # A cold/evicted session fails closed. The in-flight marker must not outlive the attempt, or a run
+ # that never started would protect the session from the reaper forever.
+ manager = RealBrowserManager()
+
+ with patch("skyvern.webeye.real_browser_manager.app") as mock_app:
+ configure_browser_context_acquired_hook(mock_app)
+ mock_app.PERSISTENT_SESSIONS_MANAGER.begin_session = AsyncMock(return_value="gen_cold")
+ mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=None)
+
+ with pytest.raises(MissingBrowserStateForBrowserSession):
+ await manager.get_or_create_for_script(
+ script_id="s_cold",
+ browser_session_id="pbs_cold",
+ organization_id="org_test",
+ )
+
+ assert manager.live_session_runnable_ids() == set()
+
+
+ "release_outcome",
+ [{"return_value": False}, {"side_effect": RuntimeError("db unreachable")}],
+ ids=["cas_miss", "raises"],
+)
+async def test_script_cleanup_drops_lease_even_when_release_fails(
+ monkeypatch: pytest.MonkeyPatch,
+ release_outcome: dict,
+) -> None:
+ # Unlike a workflow run, a script's cleanup runs once at run_script's terminal boundary, so
+ # nothing re-invokes it to retry a failed release — retaining the lease can only strand it. The
+ # reaper reads that lease as "still running" and would skip the session forever, so drop the
+ # lease either way and leave the still-occupied row to the reaper.
+ script_id = "s_release_failed"
+ manager = RealBrowserManager()
+ browser_state = MagicMock()
+ browser_state.browser_artifacts.traces_dir = None
+ browser_state.close = AsyncMock(return_value=False)
+ manager.pages[script_id] = browser_state
+ manager._persistent_session_leases[script_id] = _PersistentSessionLease(
+ session_id="pbs_release_failed",
+ organization_id="org_test",
+ runnable_id=script_id,
+ browser_state=browser_state,
+ )
+ sessions = MagicMock()
+ sessions.release_browser_session = AsyncMock(**release_outcome)
+ monkeypatch.setattr(real_browser_manager, "app", MagicMock(PERSISTENT_SESSIONS_MANAGER=sessions))
+
+ await manager.cleanup_for_script(
+ script_id,
+ close_browser_on_completion=False,
+ browser_session_id="pbs_release_failed",
+ organization_id="org_test",
+ )
+
+ assert script_id not in manager._persistent_session_leases
+ sessions.release_browser_session.assert_awaited_once()
+
+
@pytest.mark.asyncio
async def test_public_workflow_cleanup_retains_owner_lease_until_release_succeeds(
monkeypatch: pytest.MonkeyPatch,