Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
Probe inherited-browser transport liveness before reusing a page-less browser (#7997)
LawyZheng6467bc19f804
diff --git a/skyvern/webeye/real_browser_manager.py b/skyvern/webeye/real_browser_manager.pyindex 425acd6f0..4fad9462f 100644--- a/skyvern/webeye/real_browser_manager.py+++ b/skyvern/webeye/real_browser_manager.py@@ -54,6 +54,69 @@ def _is_cached_cdp_drop_error(exc: FailedToNavigateToUrl) -> bool:return any(needle in message for needle in _CACHED_CDP_DROP_ERROR_SUBSTRINGS)+# A bounded, read-only probe confirms an inherited browser's transport is really alive before+# the same-context (#14311) recovery runs new_page() on it. Kept small so the rare page-less+# inheritance path never stalls; a live cookies() round-trip returns well under this.+_INHERITED_BROWSER_LIVENESS_PROBE_TIMEOUT_SECONDS = 5.0++# Closed-transport signatures matched by message substring and by type NAME, never by imported+# class identity: scripts/patch_browser.sh rewrites playwright -> patchright for the agent image+# but not for cloud/persistent_browsers, so the two packages expose distinct TargetClosedError+# classes (see skyvern/webeye/cdp_frame_publisher.py for the same name-based matching).+_CLOSED_TRANSPORT_ERROR_SUBSTRINGS = (+ "Connection closed while reading from the driver",+ "Target page, context or browser has been closed",+ "Target closed",+ "Browser closed",+)+_CLOSED_TRANSPORT_ERROR_TYPE_NAMES = ("TargetClosedError",)+++def _is_closed_transport_error(exc: BaseException) -> bool:+ if type(exc).__name__ in _CLOSED_TRANSPORT_ERROR_TYPE_NAMES:+ return True+ message = str(exc)+ return any(needle in message for needle in _CLOSED_TRANSPORT_ERROR_SUBSTRINGS)+++async def _inherited_browser_transport_alive(browser_state: BrowserState) -> bool:+ """Truthfully classify an inherited, page-less browser as connected before same-context recovery.++ ``is_connected()`` only inspects cached client-side flags, so a driver/CDP transport that died+ with no I/O since (a long sequential-gate wait, a reaped remote browser, a NAT/LB idle timeout,+ a TCP half-close) still reports connected. Confirm with one bounded, read-only round-trip:+ a genuinely live tab-less context answers and is reused (preserving cookies/session), while a+ dead transport is classified disconnected here and routed to the existing fresh-browser path,+ instead of crashing the #14311 ``new_page()`` recovery with+ "Connection closed while reading from the driver" (SKY-13389).+ """+ if not browser_state.is_connected():+ return False+ context = browser_state.browser_context+ if context is None:+ return False+ try:+ async with asyncio.timeout(_INHERITED_BROWSER_LIVENESS_PROBE_TIMEOUT_SECONDS):+ await context.cookies()+ except (asyncio.CancelledError, KeyboardInterrupt, SystemExit):+ # Process-control signals are never a browser-liveness verdict — propagate untouched.+ raise+ except (asyncio.TimeoutError, TimeoutError):+ LOG.info("Inherited browser liveness probe timed out; treating browser as disconnected")+ return False+ except Exception as exc:+ # Only a genuinely closed transport counts as disconnected; anything else is an unexpected+ # programming error that must not be silently swallowed into a fresh-browser fallback.+ if _is_closed_transport_error(exc):+ LOG.info(+ "Inherited browser liveness probe hit a closed transport; treating browser as disconnected",+ error=str(exc),+ )+ return False+ raise+ return True++async def _rebind_pbs_download_dir(browser_state: BrowserState,workflow_run: WorkflowRun,@@ -573,11 +636,13 @@ class RealBrowserManager(BrowserManager):# browser here. This early-return path skips get_or_create_page, so returning a# page-less state would fail the run's first browser block with a missing page.working_page = await browser_state.get_working_page()- if working_page is None and browser_state.is_connected():+ if working_page is None and await _inherited_browser_transport_alive(browser_state):# The inherited browser is still live but its last valid tab was closed# (e.g. a use_parent_browser_session child whose prior run closed the last# page). Recreate a page in the SAME context so the child keeps the parent's# cookies/session, instead of orphaning the live browser and starting fresh.+ # Liveness is actively probed (not just is_connected()'s cached flags) so a+ # transport that died while idle falls through to a fresh browser (SKY-13389).LOG.info("Inherited parent browser is live but has no working page; recreating a page in the same context",workflow_run_id=workflow_run_id,diff --git a/tests/unit/test_real_browser_manager.py b/tests/unit/test_real_browser_manager.pyindex 1e6d5f59d..9c2e9262c 100644--- a/tests/unit/test_real_browser_manager.py+++ b/tests/unit/test_real_browser_manager.py@@ -6,6 +6,7 @@ behind `if not browser_session_id:`, causing PBS workflow runs to skip the cacheon every call and re-invoke navigate_to_url() on every step."""+import asynciofrom unittest.mock import AsyncMock, MagicMock, patchimport pytest@@ -233,6 +234,9 @@ async def test_child_run_recovers_live_inherited_browser_without_page() -> None:live_state = MagicMock()live_state.get_working_page = AsyncMock(side_effect=[None, MagicMock()])live_state.is_connected = MagicMock(return_value=True)+ # A genuinely live tab-less context answers the bounded read-only liveness probe.+ live_state.browser_context = MagicMock()+ live_state.browser_context.cookies = AsyncMock(return_value=[])live_state.get_or_create_page = AsyncMock()manager.pages["wfr_parent"] = live_state@@ -255,6 +259,189 @@ async def test_child_run_recovers_live_inherited_browser_without_page() -> None:assert manager.pages["wfr_parent"] is live_state+class _FakeDriverClosedError(Exception):+ """Production-shaped closed-transport error: a dead Playwright/Patchright driver pipe+ surfaces this message on the first round-trip after the connection silently died."""+++class TargetClosedError(Exception):+ """Named to match Playwright/Patchright ``TargetClosedError`` by type name only.++ ``scripts/patch_browser.sh`` rewrites playwright -> patchright for the agent image but not+ for ``cloud/persistent_browsers``, so closed-transport classification must match by type+ name/message, never by imported class identity.+ """+++async def test_child_run_does_not_adopt_inherited_browser_with_dead_transport() -> None:+ """SKY-13389: ``is_connected()`` only reads cached client-side flags, so an inherited browser+ whose driver/CDP transport died while idle (a long sequential-gate wait, a reaped remote+ browser, a TCP half-close) still reports connected. Taking the #14311 same-context recovery+ then runs ``new_page()`` on a dead transport and crashes the run with+ "Connection closed while reading from the driver". The manager must actively probe the+ transport before same-context recovery and, on a dead transport, evict + create a fresh+ browser instead.+ """+ manager = RealBrowserManager()+ # Inherited parent-key browser: page-less, reports connected (cached false positive),+ # but every real round-trip over its dead driver raises the closed-transport error.+ dead_state = MagicMock()+ dead_state.get_working_page = AsyncMock(return_value=None)+ dead_state.is_connected = MagicMock(return_value=True)+ dead_state.browser_context = MagicMock()+ dead_state.browser_context.cookies = AsyncMock(+ side_effect=_FakeDriverClosedError("BrowserContext.cookies: Connection closed while reading from the driver")+ )+ # If the pre-fix #14311 path is taken, new_page() inside get_or_create_page raises the same+ # error and crashes the run (reproducing the production crash signature).+ dead_state.get_or_create_page = AsyncMock(+ side_effect=_FakeDriverClosedError("BrowserContext.new_page: Connection closed while reading from the driver")+ )+ manager.pages["wfr_parent"] = dead_state++ workflow_run = make_workflow_run("wfr_child", parent_workflow_run_id="wfr_parent")+ fresh_state = MagicMock()+ fresh_state.get_or_create_page = AsyncMock()++ with patch.object(manager, "_create_browser_state", new=AsyncMock(return_value=fresh_state)) as mock_create:+ result = await manager.get_or_create_for_workflow_run(+ workflow_run=workflow_run,+ url="https://example.com",+ browser_session_id=None,+ )++ # A fresh browser is created; the dead browser is never recovered in-place.+ mock_create.assert_awaited_once()+ assert result is fresh_state+ assert result is not dead_state+ dead_state.get_or_create_page.assert_not_awaited()+ assert manager.pages["wfr_child"] is fresh_state+ assert manager.pages["wfr_parent"] is fresh_state+++async def test_child_run_evicts_inherited_browser_when_transport_probe_times_out() -> None:+ """A dead transport can hang rather than error; the bounded probe must time out and classify+ the inherited browser disconnected so the run gets a fresh browser instead of stalling."""+ manager = RealBrowserManager()+ dead_state = MagicMock()+ dead_state.get_working_page = AsyncMock(return_value=None)+ dead_state.is_connected = MagicMock(return_value=True)++ async def _hang(*args: object, **kwargs: object) -> list:+ await asyncio.sleep(1)+ return []++ dead_state.browser_context = MagicMock()+ dead_state.browser_context.cookies = _hang+ dead_state.get_or_create_page = AsyncMock()+ manager.pages["wfr_parent"] = dead_state++ workflow_run = make_workflow_run("wfr_child", parent_workflow_run_id="wfr_parent")+ fresh_state = MagicMock()+ fresh_state.get_or_create_page = AsyncMock()++ with (+ patch.object(real_browser_manager, "_INHERITED_BROWSER_LIVENESS_PROBE_TIMEOUT_SECONDS", 0.01),+ patch.object(manager, "_create_browser_state", new=AsyncMock(return_value=fresh_state)) as mock_create,+ ):+ result = await manager.get_or_create_for_workflow_run(+ workflow_run=workflow_run,+ url="https://example.com",+ browser_session_id=None,+ )++ mock_create.assert_awaited_once()+ assert result is fresh_state+ dead_state.get_or_create_page.assert_not_awaited()+++async def test_child_run_evicts_inherited_browser_on_target_closed_by_name() -> None:+ """Closed-transport is classified by exception type NAME, not imported identity, because+ scripts/patch_browser.sh swaps playwright -> patchright for the agent image only. A+ TargetClosedError from either package (message alone not matching) still evicts + goes fresh."""+ manager = RealBrowserManager()+ dead_state = MagicMock()+ dead_state.get_working_page = AsyncMock(return_value=None)+ dead_state.is_connected = MagicMock(return_value=True)+ dead_state.browser_context = MagicMock()+ dead_state.browser_context.cookies = AsyncMock(side_effect=TargetClosedError("boom"))+ dead_state.get_or_create_page = AsyncMock()+ manager.pages["wfr_parent"] = dead_state++ workflow_run = make_workflow_run("wfr_child", parent_workflow_run_id="wfr_parent")+ fresh_state = MagicMock()+ fresh_state.get_or_create_page = AsyncMock()++ with patch.object(manager, "_create_browser_state", new=AsyncMock(return_value=fresh_state)) as mock_create:+ result = await manager.get_or_create_for_workflow_run(+ workflow_run=workflow_run,+ url="https://example.com",+ browser_session_id=None,+ )++ mock_create.assert_awaited_once()+ assert result is fresh_state+ dead_state.get_or_create_page.assert_not_awaited()+++async def test_child_run_reraises_unexpected_probe_error() -> None:+ """An unexpected (non closed-transport) probe error must propagate, never be silently+ converted into a fresh-browser fallback that could mask a real defect."""+ manager = RealBrowserManager()+ state = MagicMock()+ state.get_working_page = AsyncMock(return_value=None)+ state.is_connected = MagicMock(return_value=True)+ state.browser_context = MagicMock()+ state.browser_context.cookies = AsyncMock(side_effect=ValueError("unexpected probe failure"))+ manager.pages["wfr_parent"] = state++ workflow_run = make_workflow_run("wfr_child", parent_workflow_run_id="wfr_parent")++ with patch.object(manager, "_create_browser_state", new=AsyncMock()) as mock_create:+ with pytest.raises(ValueError, match="unexpected probe failure"):+ await manager.get_or_create_for_workflow_run(+ workflow_run=workflow_run,+ url="https://example.com",+ browser_session_id=None,+ )++ mock_create.assert_not_awaited()+++async def test_inherited_browser_transport_alive_skips_probe_when_already_disconnected() -> None:+ state = MagicMock()+ state.is_connected = MagicMock(return_value=False)+ state.browser_context = MagicMock()+ state.browser_context.cookies = AsyncMock()++ assert await real_browser_manager._inherited_browser_transport_alive(state) is False+ state.browser_context.cookies.assert_not_awaited()+++async def test_inherited_browser_transport_alive_false_when_no_context() -> None:+ state = MagicMock()+ state.is_connected = MagicMock(return_value=True)+ state.browser_context = None++ assert await real_browser_manager._inherited_browser_transport_alive(state) is False+++async def test_inherited_browser_transport_alive_true_when_probe_succeeds() -> None:+ state = MagicMock()+ state.is_connected = MagicMock(return_value=True)+ state.browser_context = MagicMock()+ state.browser_context.cookies = AsyncMock(return_value=[])++ assert await real_browser_manager._inherited_browser_transport_alive(state) is True++def make_task(task_id: str,organization_id: str = "org_test",diff --git a/tests/unit/workflow/test_block_browser_state_recovery.py b/tests/unit/workflow/test_block_browser_state_recovery.pyindex a4302aa9a..1d0d29e57 100644--- a/tests/unit/workflow/test_block_browser_state_recovery.py+++ b/tests/unit/workflow/test_block_browser_state_recovery.py@@ -226,6 +226,18 @@ def test_is_connected_false_when_driver_connection_closed() -> None:assert _state_with_context(context).is_connected() is False+def test_is_connected_true_when_context_browser_is_none() -> None:+ # A CDP-connected context can expose ``browser is None``; is_connected() then reports True from+ # cached impl flags alone, with no transport round-trip. This passive True is exactly why the+ # page-less inheritance seam actively probes the transport before same-context recovery+ # (RealBrowserManager._inherited_browser_transport_alive) rather than trusting is_connected()+ # (SKY-13389).+ context = MagicMock()+ context.browser = None+ context._impl_obj = MagicMock(_close_was_called=False, _closed=False, _connection=MagicMock(_closed_error=None))+ assert _state_with_context(context).is_connected() is True++def _free_port() -> int:with socket.socket() as sock:sock.bind(("127.0.0.1", 0))