Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
fix(SKY-7996): release local Playwright driver for remote-CDP browser states (#7084)
Shuchang Zhenga62dbe996f7c
diff --git a/skyvern/forge/sdk/workflow/context_manager.py b/skyvern/forge/sdk/workflow/context_manager.pyindex 6c26975a6..e73c41d4b 100644--- a/skyvern/forge/sdk/workflow/context_manager.py+++ b/skyvern/forge/sdk/workflow/context_manager.py@@ -1684,6 +1684,9 @@ class WorkflowContextManager:self._validate_workflow_run_context(workflow_run_id)return self.workflow_run_contexts[workflow_run_id]+ def remove_workflow_run_context(self, workflow_run_id: str) -> None:+ self.workflow_run_contexts.pop(workflow_run_id, None)+async def register_block_parameters_for_workflow_run(self,workflow_run_id: str,diff --git a/skyvern/forge/sdk/workflow/service.py b/skyvern/forge/sdk/workflow/service.pyindex 83641cdf6..b7d6a47eb 100644--- a/skyvern/forge/sdk/workflow/service.py+++ b/skyvern/forge/sdk/workflow/service.py@@ -6491,10 +6491,15 @@ class WorkflowService:workflow_run_id=workflow_run.workflow_run_id,)- if not need_call_webhook:- return-- await self.execute_workflow_webhook(workflow_run, api_key)+ try:+ if need_call_webhook:+ await self.execute_workflow_webhook(workflow_run, api_key)+ finally:+ # Run contexts hold parameters/secrets/outputs and are keyed per+ # run; without eviction they accumulate for the process lifetime.+ app.WORKFLOW_CONTEXT_MANAGER.remove_workflow_run_context(workflow_run.workflow_run_id)+ for child_workflow_run_id in child_workflow_run_ids:+ app.WORKFLOW_CONTEXT_MANAGER.remove_workflow_run_context(child_workflow_run_id)async def prepare_workflow_webhook(self,diff --git a/skyvern/webeye/browser_state.py b/skyvern/webeye/browser_state.pyindex cbf053a9c..ce547a83e 100644--- a/skyvern/webeye/browser_state.py+++ b/skyvern/webeye/browser_state.py@@ -92,7 +92,7 @@ class BrowserState(Protocol):async def reload_page(self, degradation: bool = False) -> None: ...- async def close(self, close_browser_on_completion: bool = True) -> None: ...+ async def close(self, close_browser_on_completion: bool = True, release_driver: bool | None = None) -> None: ...async def take_fullpage_screenshot(self, file_path: str | None = None) -> bytes: ...diff --git a/skyvern/webeye/real_browser_manager.py b/skyvern/webeye/real_browser_manager.pyindex eeccac892..f116ee891 100644--- a/skyvern/webeye/real_browser_manager.py+++ b/skyvern/webeye/real_browser_manager.py@@ -221,6 +221,7 @@ class RealBrowserManager(BrowserManager):page=None,browser_artifacts=browser_artifacts,browser_cleanup=browser_cleanup,+ release_driver_on_close=browser_address is not None,)def evict_page(self, page_id: str) -> None:@@ -656,7 +657,12 @@ class RealBrowserManager(BrowserManager):# honest signal — it hits ``{task_id}.png`` for standalone tasks# and is a deliberate no-op for workflow tasks.await self._stop_frame_publisher(task_id=task_id)- await browser_state_to_close.close(close_browser_on_completion=close_browser_on_completion)+ # A state backing a persistent session stays cached in the sessions+ # manager for reuse; its driver is released when the session closes.+ await browser_state_to_close.close(+ close_browser_on_completion=close_browser_on_completion,+ release_driver=False if browser_session_id else None,+ )LOG.info("Task is cleaned up")if browser_session_id:@@ -744,7 +750,10 @@ class RealBrowserManager(BrowserManager):# Detach the publisher's CDP session before the Playwright context# closes; otherwise the stale session can race the teardown.await self._stop_frame_publisher(workflow_run_id=workflow_run_id)- await browser_state_to_close.close(close_browser_on_completion=effective_close)+ await browser_state_to_close.close(+ close_browser_on_completion=effective_close,+ release_driver=False if (shared or browser_session_id) else None,+ )if not streams_active:self.pages.pop(workflow_run_id, None)@@ -763,7 +772,10 @@ class RealBrowserManager(BrowserManager):workflow_run_id=workflow_run_id,)try:- await task_browser_state.close(close_browser_on_completion=effective_close)+ await task_browser_state.close(+ close_browser_on_completion=effective_close,+ release_driver=False if (shared or browser_session_id) else None,+ )except Exception:LOG.info("Failed to close the browser state from the task block, might because it's already closed.",diff --git a/skyvern/webeye/real_browser_state.py b/skyvern/webeye/real_browser_state.pyindex 9908943ad..3a599fb8b 100644--- a/skyvern/webeye/real_browser_state.py+++ b/skyvern/webeye/real_browser_state.py@@ -59,6 +59,7 @@ class RealBrowserState(BrowserState):page: Page | None = None,browser_artifacts: BrowserArtifacts = BrowserArtifacts(),browser_cleanup: BrowserCleanupFunc = None,+ release_driver_on_close: bool = False,):self.__page = page# An explicitly selected tab (set by NEW_TAB/SWITCH_TAB). When set, it overrides the@@ -72,6 +73,11 @@ class RealBrowserState(BrowserState):self.browser_context = browser_contextself.browser_artifacts = browser_artifactsself.browser_cleanup = browser_cleanup+ # Stamped for states attached to a caller-provided remote browser+ # (``browser_address``): the local Playwright driver exists solely for+ # this state and must be released on close even when the remote+ # browser is left running.+ self.release_driver_on_close = release_driver_on_close# One-shot callbacks fired first inside ``close()``. Cleared after# firing so re-entry into ``close()`` is safe.self._on_close_callbacks: list[Callable[[], Awaitable[None]]] = []@@ -560,7 +566,14 @@ class RealBrowserState(BrowserState):must_included_tags=must_included_tags,)- async def close(self, close_browser_on_completion: bool = True) -> None:+ async def close(self, close_browser_on_completion: bool = True, release_driver: bool | None = None) -> None:+ # ``release_driver`` decouples the local Playwright driver's lifetime+ # from the remote browser's: callers that retain this state for reuse+ # (persistent sessions, parent/child sharing) must pass False; None+ # defers to ``close_browser_on_completion`` plus the creation-time+ # ``release_driver_on_close`` marker.+ if release_driver is None:+ release_driver = close_browser_on_completion or self.release_driver_on_closeLOG.info("Closing browser state", sampling=True)# Only fire on-close observers on a real teardown. Shared / parent-child# close calls pass ``close_browser_on_completion=False`` to leave the@@ -590,7 +603,7 @@ class RealBrowserState(BrowserState):try:async with asyncio.timeout(BROWSER_CLOSE_TIMEOUT):- if self.pw and close_browser_on_completion:+ if self.pw and release_driver:try:LOG.info("Stopping playwright")await self.pw.stop()diff --git a/tests/unit/test_remote_cdp_driver_release.py b/tests/unit/test_remote_cdp_driver_release.pynew file mode 100644index 000000000..a685f0e4b--- /dev/null+++ b/tests/unit/test_remote_cdp_driver_release.py@@ -0,0 +1,179 @@+"""Local Playwright driver release for remote-CDP browser states.++A ``BrowserState`` created for a caller-provided remote browser+(``browser_address``) is closed with ``close_browser_on_completion=False`` so+the remote browser survives the run — but the per-run local Playwright driver+(a Node subprocess) must still be released, otherwise every such run leaks a+driver process until the service is OOM-killed.++The reuse invariant must hold: states retained for reuse (persistent sessions,+browsers shared across parent/child runs) must NOT have their driver stopped.+"""++from __future__ import annotations++from unittest.mock import AsyncMock, MagicMock++import pytest++from skyvern.webeye.browser_artifacts import BrowserArtifacts+from skyvern.webeye.real_browser_manager import RealBrowserManager+from skyvern.webeye.real_browser_state import RealBrowserState+++def _pw_stub() -> MagicMock:+ pw = MagicMock()+ pw.stop = AsyncMock()+ return pw+++def _context_stub() -> MagicMock:+ context = MagicMock()+ context.close = AsyncMock()+ return context+++async def test_close_stops_driver_for_remote_cdp_state_and_keeps_remote_browser() -> None:+ pw = _pw_stub()+ context = _context_stub()+ state = RealBrowserState(pw=pw, browser_context=context, release_driver_on_close=True)++ await state.close(close_browser_on_completion=False)++ pw.stop.assert_awaited_once()+ context.close.assert_not_awaited()+++async def test_close_keeps_driver_by_default_when_browser_kept() -> None:+ """Persistent-session / shared states rely on close(False) leaving the driver alive."""+ pw = _pw_stub()+ context = _context_stub()+ state = RealBrowserState(pw=pw, browser_context=context)++ await state.close(close_browser_on_completion=False)++ pw.stop.assert_not_awaited()+ context.close.assert_not_awaited()+++async def test_close_release_driver_override_preserves_reuse() -> None:+ """An explicit release_driver=False wins over the creation-time marker."""+ pw = _pw_stub()+ state = RealBrowserState(pw=pw, browser_context=None, release_driver_on_close=True)++ await state.close(close_browser_on_completion=False, release_driver=False)++ pw.stop.assert_not_awaited()+++async def test_close_true_still_stops_driver_and_context() -> None:+ pw = _pw_stub()+ context = _context_stub()+ context.cookies = AsyncMock(return_value=[])+ state = RealBrowserState(pw=pw, browser_context=context, browser_artifacts=BrowserArtifacts())++ await state.close(close_browser_on_completion=True)++ pw.stop.assert_awaited_once()+ context.close.assert_awaited_once()+++async def test_create_browser_state_marks_remote_cdp_states(monkeypatch: pytest.MonkeyPatch) -> None:+ pw = _pw_stub()+ playwright_launcher = MagicMock()+ playwright_launcher.return_value.start = AsyncMock(return_value=pw)+ monkeypatch.setattr("skyvern.webeye.real_browser_manager.async_playwright", playwright_launcher)++ create_browser_context = AsyncMock(return_value=(_context_stub(), BrowserArtifacts(), None))+ monkeypatch.setattr(+ "skyvern.webeye.real_browser_manager.BrowserContextFactory.create_browser_context",+ create_browser_context,+ )++ remote_state = await RealBrowserManager._create_browser_state(browser_address="http://192.0.2.10:9222")+ local_state = await RealBrowserManager._create_browser_state()++ assert isinstance(remote_state, RealBrowserState)+ assert isinstance(local_state, RealBrowserState)+ assert remote_state.release_driver_on_close is True+ assert local_state.release_driver_on_close is False+++def _fake_browser_state() -> MagicMock:+ state = MagicMock()+ state.close = AsyncMock()+ state.browser_context = None+ state.browser_artifacts = BrowserArtifacts()+ return state+++async def test_cleanup_for_task_keeps_driver_for_persistent_session() -> None:+ manager = RealBrowserManager()+ state = _fake_browser_state()+ manager.pages["tsk_1"] = state++ await manager.cleanup_for_task(+ "tsk_1",+ close_browser_on_completion=False,+ browser_session_id="session_1",+ organization_id="org_1",+ )++ state.close.assert_awaited_once_with(close_browser_on_completion=False, release_driver=False)+++async def test_cleanup_for_task_lets_state_decide_without_persistent_session() -> None:+ manager = RealBrowserManager()+ state = _fake_browser_state()+ manager.pages["tsk_1"] = state++ await manager.cleanup_for_task("tsk_1", close_browser_on_completion=False)++ state.close.assert_awaited_once_with(close_browser_on_completion=False, release_driver=None)+++async def test_cleanup_for_workflow_run_keeps_driver_while_shared() -> None:+ manager = RealBrowserManager()+ state = _fake_browser_state()+ manager.pages["wr_child"] = state+ manager.pages["tsk_1"] = state+ manager.pages["wr_parent"] = state++ await manager.cleanup_for_workflow_run(+ "wr_child",+ ["tsk_1"],+ close_browser_on_completion=False,+ )++ # Both the workflow-run-level close and the task-level close observe the+ # parent's surviving reference and must not release the shared driver.+ for call in state.close.await_args_list:+ assert call.kwargs["release_driver"] is False+ assert "wr_parent" in manager.pages+++async def test_cleanup_for_workflow_run_final_close_lets_state_decide() -> None:+ manager = RealBrowserManager()+ state = _fake_browser_state()+ manager.pages["wr_1"] = state+ manager.pages["tsk_1"] = state++ await manager.cleanup_for_workflow_run(+ "wr_1",+ ["tsk_1"],+ close_browser_on_completion=False,+ )++ final_call = state.close.await_args_list[-1]+ assert final_call.kwargs["release_driver"] is None+ assert "wr_1" not in manager.pages+ assert "tsk_1" not in manager.pagesdiff --git a/tests/unit/test_workflow_run_context_eviction.py b/tests/unit/test_workflow_run_context_eviction.pynew file mode 100644index 000000000..2f3c4e75f--- /dev/null+++ b/tests/unit/test_workflow_run_context_eviction.py@@ -0,0 +1,72 @@+"""``workflow_run_contexts`` must be evicted when a workflow run is cleaned up.++Each entry holds the run's parameters, secrets, and outputs; without eviction+the dict grows for the life of the process.+"""++from __future__ import annotations++from unittest.mock import AsyncMock, MagicMock++import pytest++from skyvern.forge import app+from skyvern.forge.sdk.workflow.context_manager import WorkflowContextManager+from skyvern.forge.sdk.workflow.service import WorkflowService+++def _context_manager_with(run_ids: list[str]) -> WorkflowContextManager:+ manager = WorkflowContextManager.__new__(WorkflowContextManager)+ manager.workflow_run_contexts = {run_id: MagicMock() for run_id in run_ids}+ return manager+++def test_remove_workflow_run_context_evicts_and_is_idempotent() -> None:+ manager = _context_manager_with(["wr_1"])++ manager.remove_workflow_run_context("wr_1")+ assert "wr_1" not in manager.workflow_run_contexts++ # Removing an unknown / already-removed run must not raise.+ manager.remove_workflow_run_context("wr_1")+ manager.remove_workflow_run_context("wr_never_seen")+++async def test_clean_up_workflow_evicts_run_and_child_contexts(monkeypatch: pytest.MonkeyPatch) -> None:+ service = WorkflowService()+ context_manager = _context_manager_with(["wr_parent", "wr_child", "wr_other"])+ monkeypatch.setattr(app, "WORKFLOW_CONTEXT_MANAGER", context_manager)++ monkeypatch.setattr("skyvern.forge.sdk.workflow.service.analytics.capture", MagicMock(), raising=False)+ monkeypatch.setattr(service, "get_tasks_by_workflow_run_id", AsyncMock(return_value=[]))++ child_run = MagicMock()+ child_run.workflow_run_id = "wr_child"+ monkeypatch.setattr(+ app.DATABASE.workflow_runs,+ "get_workflow_runs_by_parent_workflow_run_id",+ AsyncMock(return_value=[child_run]),+ raising=False,+ )+ monkeypatch.setattr(app.BROWSER_MANAGER, "cleanup_for_workflow_run", AsyncMock(return_value=None), raising=False)+ monkeypatch.setattr(app.ARTIFACT_MANAGER, "wait_for_upload_aiotasks", AsyncMock(), raising=False)+ monkeypatch.setattr(app.STORAGE, "save_downloaded_files", AsyncMock(), raising=False)++ workflow = MagicMock()+ workflow.persist_browser_session = False+ workflow_run = MagicMock()+ workflow_run.workflow_run_id = "wr_parent"+ workflow_run.organization_id = "org_1"+ workflow_run.browser_address = None+ workflow_run.status = "completed"++ await service.clean_up_workflow(+ workflow=workflow,+ workflow_run=workflow_run,+ need_call_webhook=False,+ )++ assert "wr_parent" not in context_manager.workflow_run_contexts+ assert "wr_child" not in context_manager.workflow_run_contexts+ assert "wr_other" in context_manager.workflow_run_contexts