Skip to content

Automate browser based workflows with AI

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.py
index 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.py
index 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.py
index 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.py
index 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.py
index 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_context
self.browser_artifacts = browser_artifacts
self.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_close
LOG.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.py
new file mode 100644
index 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.pages
diff --git a/tests/unit/test_workflow_run_context_eviction.py b/tests/unit/test_workflow_run_context_eviction.py
new file mode 100644
index 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