Skip to content

Automate browser based workflows with AI

Capture inline data URL downloads as files (#7651)

LawyZheng80da8adec58c
diff --git a/skyvern/constants.py b/skyvern/constants.py
index b6df92a0a..d129d05c5 100644
--- a/skyvern/constants.py
+++ b/skyvern/constants.py
@@ -16,6 +16,10 @@ INPUT_TEXT_TIMEOUT = 120000 # 2 minutes
PAGE_CONTENT_TIMEOUT = 300 # 5 mins
BROWSER_PAGE_CLOSE_TIMEOUT = 5 # 5 seconds
BROWSER_CLOSE_TIMEOUT = 180 # 3 minute
+# Independent budget for disabling the download interceptor during close(). Kept well below
+# BROWSER_CLOSE_TIMEOUT so a stuck/cancellation-resistant download drain is reclaimed quickly
+# and can never consume the budget the paid-provider cleanup phase needs.
+BROWSER_INTERCEPTOR_DISABLE_TIMEOUT = 30 # 30 seconds
BROWSER_DOWNLOAD_MAX_WAIT_TIME = 120 # 2 minute
BROWSER_DOWNLOAD_NO_SIGNAL_GRACE_TIME = 120 # 2 minute
BROWSER_DOWNLOAD_TIMEOUT = 600 # 10 minute
diff --git a/skyvern/forge/agent.py b/skyvern/forge/agent.py
index 30e7a24f7..9523c9fc2 100644
--- a/skyvern/forge/agent.py
+++ b/skyvern/forge/agent.py
@@ -171,7 +171,10 @@ from skyvern.webeye.actions.parse_actions import (
)
from skyvern.webeye.actions.responses import ActionResult, ActionSuccess
from skyvern.webeye.browser_state import BrowserState
-from skyvern.webeye.cdp_download_interceptor import download_filename_from_suffix
+from skyvern.webeye.cdp_download_interceptor import (
+ download_filename_from_suffix,
+ settle_browser_downloads_for_context,
+)
from skyvern.webeye.scraper.scraped_page import ElementTreeFormat, ScrapedPage
from skyvern.webeye.utils.page import SkyvernFrame, build_open_tabs_context
@@ -514,7 +517,11 @@ class ForgeAgent:
)
list_files_after = list_files_after + browser_session_downloaded_files_after
- files_to_rename = list(set(list_files_after) - set(list_files_before))
+ files_to_rename = [
+ file
+ for file in set(list_files_after) - set(list_files_before)
+ if Path(file).suffix != BROWSER_DOWNLOADING_SUFFIX
+ ]
if not files_to_rename:
return []
for file in files_to_rename:
@@ -4797,7 +4804,11 @@ class ForgeAgent:
# Keep both finalize and save inside a single timeout budget so a hung
# finalize call cannot block persistence forever; accept the trade-off
# that a very slow finalize on many files could crowd out save.
+ browser_state = app.BROWSER_MANAGER.get_for_task(task.task_id)
+ browser_context = browser_state.browser_context if browser_state is not None else None
async with asyncio.timeout(SAVE_DOWNLOADED_FILES_TIMEOUT):
+ async with settle_browser_downloads_for_context(browser_context):
+ pass
if download_suffix and list_files_before is not None:
await self._finalize_downloaded_files_for_task(
task,
diff --git a/skyvern/webeye/actions/handler.py b/skyvern/webeye/actions/handler.py
index c423cffb6..3bc654ec1 100644
--- a/skyvern/webeye/actions/handler.py
+++ b/skyvern/webeye/actions/handler.py
@@ -27,6 +27,7 @@ from skyvern.constants import (
BROWSER_DOWNLOAD_MAX_WAIT_TIME,
BROWSER_DOWNLOAD_NO_SIGNAL_GRACE_TIME,
BROWSER_DOWNLOAD_TIMEOUT,
+ BROWSER_DOWNLOADING_SUFFIX,
DROPDOWN_MENU_MAX_DISTANCE,
SKYVERN_ID_ATTR,
)
@@ -146,6 +147,7 @@ from skyvern.webeye.cdp_download_interceptor import (
extract_filename,
is_download_response,
normalize_download_filename,
+ settle_browser_downloads_for_context,
)
from skyvern.webeye.main_world_eval import evaluate_in_main_world
from skyvern.webeye.scraper.scraped_page import (
@@ -2491,13 +2493,29 @@ class ActionHandler:
if not download_event.done():
download_event.set_result(download)
- async def _list_observed_download_files() -> list[str]:
+ def _download_signal_identity(file: str) -> str:
+ return file.removesuffix(BROWSER_DOWNLOADING_SUFFIX)
+
+ async def _list_download_signal_files() -> list[str]:
files = list_files_in_directory(download_dir)
if task.browser_session_id:
- files_in_browser_session = await app.STORAGE.list_downloaded_files_in_browser_session(
+ downloading_files_in_browser_session = await app.STORAGE.list_downloading_files_in_browser_session(
+ organization_id=task.organization_id, browser_session_id=task.browser_session_id
+ )
+ downloaded_files_in_browser_session = await app.STORAGE.list_downloaded_files_in_browser_session(
+ organization_id=task.organization_id, browser_session_id=task.browser_session_id
+ )
+ files = files + downloaded_files_in_browser_session + downloading_files_in_browser_session
+ return files
+
+ async def _list_final_download_files() -> list[str]:
+ files = [
+ file for file in list_files_in_directory(download_dir) if not file.endswith(BROWSER_DOWNLOADING_SUFFIX)
+ ]
+ if task.browser_session_id:
+ files += await app.STORAGE.list_downloaded_files_in_browser_session(
organization_id=task.organization_id, browser_session_id=task.browser_session_id
)
- files = files + files_in_browser_session
return files
async def _drain_and_move_staged_xhr(xhr_fallback_moved_paths: set[str], timeout_seconds: float) -> bool:
@@ -2537,7 +2555,10 @@ class ActionHandler:
if browser_state:
initial_page_count = len(await browser_state.list_valid_pages())
- list_files_before = await _list_observed_download_files()
+ signal_file_identities_before = {
+ _download_signal_identity(file) for file in await _list_download_signal_files()
+ }
+ list_files_before = list(signal_file_identities_before)
LOG.info(
"Number of files in download directory before action",
num_downloaded_files_before=len(list_files_before),
@@ -2592,6 +2613,7 @@ class ActionHandler:
def _remaining_download_wait_seconds() -> float:
return max(0.0, download_wait_deadline - time.monotonic())
+ _download_completion_timeout = task.download_timeout or BROWSER_DOWNLOAD_TIMEOUT
_download_event_grace_seconds = min(
DOWNLOAD_EVENT_ACTIVE_DIR_GRACE_SECONDS, download_wait_hard_timeout_seconds
)
@@ -2684,9 +2706,11 @@ class ActionHandler:
download_triggered = True
break
- list_files_after = await _list_observed_download_files()
+ list_files_after = await _list_download_signal_files()
- if len(list_files_after) > len(list_files_before):
+ if {
+ _download_signal_identity(file) for file in list_files_after
+ } - signal_file_identities_before:
_record_download_signal("download_file_detected")
LOG.info(
"Found new files in download directory after action",
@@ -2718,11 +2742,11 @@ class ActionHandler:
download_dir=download_dir,
workflow_run_id=task.workflow_run_id,
)
- list_files_after = await _list_observed_download_files()
+ list_files_after = await _list_final_download_files()
download_triggered = True
break
if persisted.path is not None:
- list_files_after = await _list_observed_download_files()
+ list_files_after = await _list_final_download_files()
LOG.info(
"Copied captured download event to active run directory",
download_dir=download_dir,
@@ -2841,12 +2865,14 @@ class ActionHandler:
results[-1].download_triggered = True
action.download_triggered = True
- downloaded_file_names, new_file_paths = await _finalize_download_artifacts(
- download_dir=download_dir,
- task=task,
- list_files_before=list_files_before,
- list_observed_download_files=_list_observed_download_files,
- )
+ async with asyncio.timeout(_download_completion_timeout):
+ async with settle_browser_downloads_for_context(page.context):
+ downloaded_file_names, new_file_paths = await _finalize_download_artifacts(
+ download_dir=download_dir,
+ task=task,
+ list_files_before=list_files_before,
+ list_observed_download_files=_list_final_download_files,
+ )
if downloaded_file_names:
results[-1].downloaded_files = action.downloaded_files = downloaded_file_names
if xhr_fallback_moved_paths:
diff --git a/skyvern/webeye/browser_factory.py b/skyvern/webeye/browser_factory.py
index 3b84da223..328575b2e 100644
--- a/skyvern/webeye/browser_factory.py
+++ b/skyvern/webeye/browser_factory.py
@@ -52,7 +52,7 @@ from skyvern.webeye.cdp_connection import (
merge_cdp_connect_headers,
parse_default_cdp_connect_headers,
)
-from skyvern.webeye.cdp_download_interceptor import CDPDownloadInterceptor
+from skyvern.webeye.cdp_download_interceptor import CDPDownloadInterceptor, bind_download_interceptor_to_context
from skyvern.webeye.dialog_handler import set_dialog_handler
from skyvern.webeye.session_cookies import restore_session_cookies
@@ -980,16 +980,8 @@ async def _connect_to_cdp_browser(
except Exception:
LOG.warning("Failed to enable CDP intercept on page", page_url=page.url, exc_info=True)
- # Auto-enable interception on new pages (e.g., target="_blank" links)
- async def _on_new_page(page: Page) -> None:
- try:
- await interceptor.enable_for_page(page)
- except Exception:
- LOG.warning("Failed to enable CDP intercept on new page", page_url=page.url, exc_info=True)
-
- browser_context.on("page", lambda page: asyncio.ensure_future(_on_new_page(page)))
+ await bind_download_interceptor_to_context(interceptor, browser_context)
browser_context._skyvern_cdp_download_active = True # type: ignore[attr-defined]
- browser_context._skyvern_cdp_download_interceptor = interceptor # type: ignore[attr-defined]
LOG.info(
"CDP download interceptor enabled",
download_dir=download_dir,
diff --git a/skyvern/webeye/cdp_download_interceptor.py b/skyvern/webeye/cdp_download_interceptor.py
index 66fdd51e8..67b1262a4 100644
--- a/skyvern/webeye/cdp_download_interceptor.py
+++ b/skyvern/webeye/cdp_download_interceptor.py
@@ -20,11 +20,17 @@ from __future__ import annotations
import asyncio
import base64
+import binascii
+import hashlib
+import inspect
+import os
import re
import ssl
import time
import urllib.request
import uuid
+from collections.abc import AsyncIterator, Coroutine
+from contextlib import asynccontextmanager
from pathlib import Path
from typing import Any
from urllib.parse import unquote, urlparse
@@ -32,10 +38,32 @@ from urllib.parse import unquote, urlparse
import structlog
from playwright.async_api import Browser, BrowserContext, CDPSession, Page
+from skyvern.constants import BROWSER_DOWNLOADING_SUFFIX, BROWSER_INTERCEPTOR_DISABLE_TIMEOUT
from skyvern.webeye.utils.page import SkyvernFrame
LOG = structlog.get_logger()
+_DETACHED_DISABLE_TASKS: set[asyncio.Task[None]] = set()
+
+
+def _retrieve_detached_disable_exception(task: asyncio.Task[None]) -> None:
+ try:
+ if not task.cancelled():
+ error = task.exception()
+ if error is not None:
+ LOG.warning(
+ "Previous CDP download interceptor disable failed after detach",
+ error_type=type(error).__name__,
+ )
+ finally:
+ _DETACHED_DISABLE_TASKS.discard(task)
+
+
+def _own_detached_disable(task: asyncio.Task[None]) -> None:
+ _DETACHED_DISABLE_TASKS.add(task)
+ task.add_done_callback(_retrieve_detached_disable_exception)
+
+
# Chunk size for IO.read streaming
IO_READ_CHUNK_SIZE = 64 * 1024 # 64 KB
@@ -128,6 +156,11 @@ DOWNLOAD_EXTENSION_BY_MIME_TYPE = {
_FILENAME_PATH_SEPARATOR_RE = re.compile(r"[\\/]+")
_FILENAME_CONTROL_CHAR_RE = re.compile(r"[\x00-\x1f\x7f]")
_WINDOWS_DRIVE_RE = re.compile(r"^[A-Za-z]:[\\/]")
+_DATA_URL_TOKEN = r"[!#$%&'*+.^_`|~A-Za-z0-9-]+"
+_DATA_URL_MEDIA_TYPE_RE = re.compile(rf"^{_DATA_URL_TOKEN}/{_DATA_URL_TOKEN}$")
+_DATA_URL_PARAMETER_NAME_RE = re.compile(rf"^{_DATA_URL_TOKEN}$")
+_DATA_URL_MAX_METADATA_LENGTH = 16 * 1024
+_DATA_URL_HASH_CHUNK_SIZE = 64 * 1024
# Substrings that identify a CDP interception which was already resolved/cancelled, or whose
# target/frame detached, before our async handler could respond — a benign race between
@@ -174,6 +207,86 @@ def _download_extension_for_content_type(content_type: str) -> str:
return DOWNLOAD_EXTENSION_BY_MIME_TYPE.get(_normalized_content_type(content_type), "")
+def _download_identity(url: str) -> str:
+ if not url.lower().startswith("data:"):
+ return url
+ digest = hashlib.sha256()
+ for offset in range(0, len(url), _DATA_URL_HASH_CHUNK_SIZE):
+ digest.update(url[offset : offset + _DATA_URL_HASH_CHUNK_SIZE].encode())
+ return f"data:sha256:{digest.hexdigest()}"
+
+
+def _bounded_data_url_comma(url: str) -> int:
+ comma_index = url.find(",", 5, 6 + _DATA_URL_MAX_METADATA_LENGTH)
+ if comma_index < 0 or comma_index == len(url) - 1:
+ raise ValueError("missing or empty payload")
+ _, is_base64 = _parse_data_url_metadata(url, comma_index)
+ max_payload_length = 12 * ((MAX_FILE_SIZE_BYTES + 2) // 3) if is_base64 else 3 * MAX_FILE_SIZE_BYTES
+ if len(url) > comma_index + 1 + max_payload_length:
+ raise ValueError("encoded payload exceeds size limit")
+ return comma_index
+
+
+def _parse_data_url_metadata(url: str, comma_index: int) -> tuple[str, bool]:
+ metadata_length = comma_index - 5
+ if metadata_length > _DATA_URL_MAX_METADATA_LENGTH:
+ raise ValueError("metadata exceeds size limit")
+ metadata = url[5:comma_index]
+ parts = metadata.split(";")
+ media_type = parts[0]
+ if media_type and not _DATA_URL_MEDIA_TYPE_RE.fullmatch(media_type):
+ raise ValueError("invalid media type")
+
+ is_base64 = False
+ for index, part in enumerate(parts[1:], start=1):
+ if part.lower() == "base64":
+ if is_base64 or index != len(parts) - 1:
+ raise ValueError("misplaced or duplicate base64 marker")
+ is_base64 = True
+ continue
+ name, separator, value = part.partition("=")
+ if not separator or not value or not _DATA_URL_PARAMETER_NAME_RE.fullmatch(name):
+ raise ValueError("invalid media type parameter")
+
+ return media_type or "text/plain", is_base64
+
+
+def _percent_decoded_payload_length(url: str, payload_start: int, max_length: int) -> int:
+ decoded_length = 0
+ index = payload_start
+ while index < len(url):
+ character = url[index]
+ if ord(character) > 127:
+ raise ValueError("payload must be ASCII")
+ if character == "%":
+ if index + 2 >= len(url) or not all(
+ char in "0123456789abcdefABCDEF" for char in url[index + 1 : index + 3]
+ ):
+ raise ValueError("invalid percent escape")
+ index += 3
+ else:
+ index += 1
+ decoded_length += 1
+ if decoded_length > max_length:
+ raise ValueError("decoded payload exceeds size limit")
+ return decoded_length
+
+
+def _percent_decode_payload(url: str, payload_start: int, decoded_length: int) -> bytearray:
+ decoded = bytearray()
+ index = payload_start
+ while index < len(url):
+ if url[index] == "%":
+ decoded.append(int(url[index + 1 : index + 3], 16))
+ index += 3
+ else:
+ decoded.append(ord(url[index]))
+ index += 1
+ if len(decoded) != decoded_length:
+ raise ValueError("decoded payload length mismatch")
+ return decoded
+
+
_HTML_FILENAME_EXTENSIONS = frozenset({".html", ".htm", ".xhtml"})
_HTML_START_TAG_RE = re.compile(rb"^<(?:html|head|body)(?:[\t\n\f\r ]|>)")
@@ -393,14 +506,39 @@ class CDPDownloadInterceptor:
self._auth_attempts: dict[str, int] = {}
# Track URLs already downloaded (dedup between Fetch interception and browser download monitor)
self._downloaded_urls: set[str] = set()
+ self._data_download_lock = asyncio.Lock()
+ self._browser_download_monitor_lock = asyncio.Lock()
+ self._browser_download_tasks: set[asyncio.Task[None]] = set()
+ self._browser_download_generation = 0
+ self._accepting_browser_downloads = False
+ self._browser_download_listener: Any | None = None
self._browser_session: CDPSession | None = None
self._browser_context: BrowserContext | None = None
+ self._page_context: BrowserContext | None = None
+ self._page_listener: Any | None = None
+ self._page_enable_tasks: set[asyncio.Task[None]] = set()
+ self._accepting_pages = False
+ self._cdp_handler_tasks: set[asyncio.Task[None]] = set()
+ self._accepting_cdp_handlers = True
def set_download_dir(self, download_dir: str) -> None:
- """Set or update the download directory. Can be called after init when run_id becomes available."""
- self._output_dir = Path(download_dir)
+ """Set or update the download directory. Can be called after init when run_id becomes available.
+
+ On a genuine directory change (persistent/adopted reuse across runs), drop ``_downloaded_urls``:
+ each entry names a file already written into the prior dir, so keeping it would skip an
+ identical download in the new run's dir and leave its artifact missing (SKY-12769). A same-dir
+ rebind keeps the set for idempotency. Synchronous by contract, so the clear needs no lock.
+ """
+ new_output_dir = Path(download_dir)
+ dir_changed = self._output_dir is not None and self._output_dir != new_output_dir
+ self._output_dir = new_output_dir
+ # Clear on the logical scope change, before mkdir: a failing mkdir must not leave the new
+ # scope carrying the prior run's identities, where a same-dir retry (dir_changed=False)
+ # would never clear them.
+ if dir_changed:
+ self._downloaded_urls.clear()
self._output_dir.mkdir(parents=True, exist_ok=True)
- LOG.info("CDP download interceptor download dir set", download_dir=download_dir)
+ LOG.info("CDP download interceptor download dir set", download_dir=download_dir, dir_changed=dir_changed)
def is_monitoring_browser_downloads(self) -> bool:
"""True while the monitor owns the context's setDownloadBehavior binding ({deny, eventsEnabled:True},
@@ -442,6 +580,7 @@ class CDPDownloadInterceptor:
Playwright uses Request-stage interception with handleAuthRequests to receive
proxy 407 challenges via Fetch.authRequired.
"""
+ self._accepting_cdp_handlers = True
cdp_session = await page.context.new_cdp_session(page)
cdp_session.on("Fetch.requestPaused", lambda event: self._on_request_paused(event, cdp_session))
@@ -489,50 +628,146 @@ class CDPDownloadInterceptor:
then downloads the file directly via HTTP using the BrowserContext's
APIRequestContext (which shares cookies and outlives individual pages).
"""
- if self._browser_session is not None:
- LOG.warning("Browser download monitor already enabled, skipping")
- return
+ async with self._browser_download_monitor_lock:
+ if self._browser_session is not None:
+ LOG.warning("Browser download monitor already enabled, skipping")
+ return
- browser_session = await browser.new_browser_cdp_session()
- self._browser_session = browser_session
- self._browser_context = browser_context
-
- # Deny browser-native downloads — we download files ourselves via HTTP.
- # Using "deny" instead of "allowAndName" avoids needing a downloadPath, which is
- # critical for remote CDP browsers: downloadPath is interpreted on the browser's
- # filesystem, not the client's, so a local tempdir path would be invalid.
- # Browser.downloadWillBegin events still fire with eventsEnabled=True, giving us
- # the URL to download directly.
- await browser_session.send(
- "Browser.setDownloadBehavior",
- {"behavior": "deny", "eventsEnabled": True},
+ browser_session = await browser.new_browser_cdp_session()
+ try:
+ # Deny browser-native downloads — we download files ourselves via HTTP.
+ # Using "deny" instead of "allowAndName" avoids needing a downloadPath, which is
+ # critical for remote CDP browsers: downloadPath is interpreted on the browser's
+ # filesystem, not the client's, so a local tempdir path would be invalid.
+ # Browser.downloadWillBegin events still fire with eventsEnabled=True, giving us
+ # the URL to download directly.
+ await browser_session.send(
+ "Browser.setDownloadBehavior",
+ {"behavior": "deny", "eventsEnabled": True},
+ )
+ except BaseException:
+ try:
+ await browser_session.detach()
+ except Exception:
+ pass
+ raise
+
+ def download_listener(event: dict[str, Any]) -> None:
+ self._schedule_browser_download_handler(event)
+
+ browser_session.on("Browser.downloadWillBegin", download_listener)
+ self._browser_session = browser_session
+ self._browser_context = browser_context
+ self._browser_download_listener = download_listener
+ self._accepting_browser_downloads = True
+ LOG.info("Browser download monitor enabled")
+
+ async def bind_to_context(self, browser_context: BrowserContext) -> None:
+ bind_lock = getattr(browser_context, "_skyvern_cdp_download_interceptor_bind_lock", None)
+ if not isinstance(bind_lock, asyncio.Lock):
+ bind_lock = asyncio.Lock()
+ browser_context._skyvern_cdp_download_interceptor_bind_lock = bind_lock # type: ignore[attr-defined]
+
+ async with bind_lock:
+ existing: CDPDownloadInterceptor | None = getattr(
+ browser_context, "_skyvern_cdp_download_interceptor", None
+ )
+ if existing is self and self._page_context is browser_context and self._page_listener is not None:
+ return
+ if existing is not None and existing is not self:
+ await self._disable_for_rebind(existing)
+
+ def page_listener(page: Page) -> None:
+ if not self._accepting_pages:
+ return
+ task = asyncio.create_task(self.enable_for_page(page))
+ self._page_enable_tasks.add(task)
+ task.add_done_callback(self._page_enable_done)
+
+ self._page_context = browser_context
+ self._page_listener = page_listener
+ self._accepting_pages = True
+ browser_context.on("page", page_listener)
+ browser_context._skyvern_cdp_download_interceptor = self # type: ignore[attr-defined]
+
+ async def _disable_for_rebind(self, existing: CDPDownloadInterceptor) -> None:
+ task = asyncio.create_task(existing.disable())
+ try:
+ done, _ = await asyncio.wait({task}, timeout=BROWSER_INTERCEPTOR_DISABLE_TIMEOUT)
+ except BaseException:
+ task.cancel()
+ _own_detached_disable(task)
+ raise
+ if task in done:
+ await task
+ return
+ LOG.warning(
+ "Previous CDP download interceptor disable exceeded rebind budget; detaching",
+ timeout=BROWSER_INTERCEPTOR_DISABLE_TIMEOUT,
)
+ task.cancel()
+ _own_detached_disable(task)
- browser_session.on(
- "Browser.downloadWillBegin",
- lambda event: asyncio.ensure_future(self._handle_browser_download(event)),
- )
- LOG.info("Browser download monitor enabled")
+ def _page_enable_done(self, task: asyncio.Task[None]) -> None:
+ self._page_enable_tasks.discard(task)
+ if task.cancelled():
+ return
+ error = task.exception()
+ if error is not None:
+ LOG.warning("Failed to enable CDP interception for page", error_type=type(error).__name__)
+
+ def _cdp_handler_done(self, task: asyncio.Task[None]) -> None:
+ self._cdp_handler_tasks.discard(task)
+ if task.cancelled():
+ return
+ error = task.exception()
+ if error is not None:
+ LOG.warning("CDP interception handler failed", error_type=type(error).__name__)
+
+ def _browser_download_done(self, task: asyncio.Task[None]) -> None:
+ self._browser_download_tasks.discard(task)
+ if task.cancelled():
+ return
+ error = task.exception()
+ if error is not None:
+ LOG.warning("Browser download handler failed", error_type=type(error).__name__)
+
+ @staticmethod
+ async def _drain_tasks(tasks: set[asyncio.Task[None]]) -> None:
+ snapshot = tuple(tasks)
+ if not snapshot:
+ return
+ try:
+ await asyncio.wait(snapshot)
+ except BaseException:
+ for task in snapshot:
+ task.cancel()
+ raise
async def _handle_browser_download(self, event: dict[str, Any]) -> None:
- """Handle Browser.downloadWillBegin — download the file via HTTP or blob read."""
+ """Handle Browser.downloadWillBegin — save the file from its URL."""
+ is_data_url = False
try:
url = event.get("url", "")
suggested_filename = event.get("suggestedFilename", "")
+ logged_url = url
+ if url.lower().startswith("data:"):
+ logged_url = "data:<payload omitted>"
LOG.info(
"Browser download detected",
- url=url,
+ url=logged_url,
suggested_filename=suggested_filename,
)
if not url:
LOG.warning("Empty download URL, skipping")
return
- # Skip if this exact URL was already captured. Both the Fetch path
- # (_handle_download) and the blob path (_download_blob_url, after a successful save)
- # record URLs here. We record only AFTER a successful save — not before the read — so
- # a transient failure can't block a later retry of the same URL; a rare duplicate
- # downloadWillBegin for the same blob URL is a benign re-save/overwrite.
+ is_data_url = url.lower().startswith("data:")
+ if is_data_url:
+ async with self._data_download_lock:
+ await self._download_data_url(url, suggested_filename)
+ return
+
if url in self._downloaded_urls:
LOG.debug("URL already captured via Fetch, skipping direct download", url=url)
return
@@ -546,9 +781,89 @@ class CDPDownloadInterceptor:
elif url.startswith("http"):
await self._download_url_directly(url, suggested_filename)
else:
- LOG.warning("Download URL scheme not supported, skipping", url=url)
- except Exception:
- LOG.warning("Error handling browser download event", exc_info=True)
+ LOG.warning("Download URL scheme not supported, skipping", scheme=urlparse(url).scheme)
+ except Exception as exc:
+ if is_data_url:
+ LOG.warning("Error handling data URL download event", error_type=type(exc).__name__)
+ else:
+ LOG.warning("Error handling browser download event", exc_info=True)
+
+ async def _run_data_worker(self, function: Any, *args: Any) -> tuple[Any, bool]:
+ worker = asyncio.create_task(asyncio.to_thread(function, *args))
+ try:
+ return await asyncio.shield(worker), False
+ except asyncio.CancelledError:
+ try:
+ return await worker, True
+ except BaseException as worker_error:
+ raise asyncio.CancelledError from worker_error
+
+ async def _download_data_url(self, url: str, suggested_filename: str) -> bool:
+ if not self._output_dir:
+ LOG.warning("No output_dir set, skipping data URL download")
+ return False
+
+ try:
+ comma_index = _bounded_data_url_comma(url)
+ decoded, cancelled = await self._run_data_worker(self._decode_data_url, url, comma_index)
+ download_identity, content_type, data = decoded
+ if cancelled:
+ raise asyncio.CancelledError
+ if download_identity in self._downloaded_urls:
+ LOG.debug("Data URL already captured, skipping", identity=download_identity)
+ return False
+ save_path, filename = self._resolve_save_path(suggested_filename, content_type)
+ _, cancelled = await self._run_data_worker(self._atomically_write_data_url, save_path, data)
+ # A rebind may have cleared the dedupe set and repointed _output_dir while this write
+ # was off-loop. The file published into save_path's dir; only record its identity if
+ # that dir is still the current scope, else it would skip an identical download in the
+ # new run's dir (SKY-12769).
+ if save_path.parent == self._output_dir:
+ self._downloaded_urls.add(download_identity)
+ except (ValueError, binascii.Error, OSError) as exc:
+ LOG.warning("Malformed data URL download, skipping", reason=str(exc))
+ return False
+
+ LOG.info(
+ "CDP download saved (data URL)",
+ filename=filename,
+ content_type=content_type,
+ size=len(data),
+ save_path=str(save_path),
+ download_index=self._download_index,
+ )
+ if cancelled:
+ raise asyncio.CancelledError
+ return True
+
+ def _decode_data_url(self, url: str, comma_index: int) -> tuple[str, str, bytes | bytearray]:
+ content_type, is_base64 = _parse_data_url_metadata(url, comma_index)
+ payload_start = comma_index + 1
+ max_encoded_size = 4 * ((MAX_FILE_SIZE_BYTES + 2) // 3) if is_base64 else MAX_FILE_SIZE_BYTES
+ decoded_length = _percent_decoded_payload_length(url, payload_start, max_encoded_size)
+ percent_decoded = _percent_decode_payload(url, payload_start, decoded_length)
+ data: bytes | bytearray
+ if is_base64:
+ data = base64.b64decode(percent_decoded, validate=True)
+ else:
+ data = percent_decoded
+
+ if not data:
+ raise ValueError("empty decoded payload")
+ if len(data) > MAX_FILE_SIZE_BYTES:
+ raise ValueError("decoded payload exceeds size limit")
+
+ return _download_identity(url), content_type, data
+
+ @staticmethod
+ def _atomically_write_data_url(save_path: Path, data: bytes | bytearray) -> None:
+ temporary_path = save_path.with_name(f"{save_path.name}.{uuid.uuid4().hex}{BROWSER_DOWNLOADING_SUFFIX}")
+ try:
+ with open(temporary_path, "wb") as file:
+ file.write(data)
+ os.replace(temporary_path, save_path)
+ finally:
+ temporary_path.unlink(missing_ok=True)
async def _cookie_header_for_url(self, url: str) -> str:
"""Build a Cookie header from the browser context's cookies applicable to ``url``.
@@ -728,6 +1043,20 @@ class CDPDownloadInterceptor:
async def disable(self) -> None:
"""Disable Fetch interception on all CDP sessions and clean up browser monitor."""
+ self._accepting_pages = False
+ page_context = self._page_context
+ page_listener = self._page_listener
+ if page_context is not None and page_listener is not None:
+ try:
+ page_context.remove_listener("page", page_listener)
+ except Exception:
+ pass
+ self._page_listener = None
+ await self._drain_tasks(self._page_enable_tasks)
+
+ self._accepting_cdp_handlers = False
+ await self._drain_tasks(self._cdp_handler_tasks)
+
session_count = len(self._cdp_sessions)
for cdp_session in self._cdp_sessions:
try:
@@ -736,14 +1065,32 @@ class CDPDownloadInterceptor:
pass
self._cdp_sessions.clear()
- # Clean up browser-level download monitor session
- if self._browser_session:
- try:
- await self._browser_session.detach()
- except Exception:
- pass
+ async with self._browser_download_monitor_lock:
+ self._accepting_browser_downloads = False
+ browser_session = self._browser_session
+ listener = self._browser_download_listener
+ if browser_session is not None and listener is not None:
+ remove_listener = getattr(browser_session, "remove_listener", None)
+ if remove_listener is not None:
+ try:
+ remove_listener("Browser.downloadWillBegin", listener)
+ except Exception:
+ pass
+ self._browser_download_listener = None
+
+ await self._drain_tasks(self._browser_download_tasks)
+
+ if browser_session is not None:
+ try:
+ await browser_session.detach()
+ except Exception:
+ pass
self._browser_session = None
- self._browser_context = None
+ self._browser_context = None
+
+ if page_context is not None and getattr(page_context, "_skyvern_cdp_download_interceptor", None) is self:
+ page_context._skyvern_cdp_download_interceptor = None # type: ignore[attr-defined]
+ self._page_context = None
self._enabled = False
LOG.info(
@@ -752,13 +1099,55 @@ class CDPDownloadInterceptor:
downloads_intercepted=self._download_index,
)
+ @asynccontextmanager
+ async def settle_browser_downloads(self) -> AsyncIterator[None]:
+ """Drain browser downloads to a stable admission snapshot before artifact collection."""
+ async with self._browser_download_monitor_lock:
+ await self._drain_browser_downloads_to_quiescence()
+ try:
+ yield
+ except BaseException:
+ tasks = tuple(self._browser_download_tasks)
+ for task in tasks:
+ task.cancel()
+ if tasks:
+ await asyncio.gather(*tasks, return_exceptions=True)
+ raise
+ else:
+ await self._drain_browser_downloads_to_quiescence()
+
+ async def _drain_browser_downloads_to_quiescence(self) -> None:
+ while True:
+ generation = self._browser_download_generation
+ if self._browser_download_tasks:
+ await asyncio.gather(*tuple(self._browser_download_tasks), return_exceptions=True)
+ await asyncio.sleep(0)
+ if generation == self._browser_download_generation and not self._browser_download_tasks:
+ return
+
+ def _schedule_browser_download_handler(self, event: dict[str, Any]) -> None:
+ if not self._accepting_browser_downloads:
+ return
+ self._browser_download_generation += 1
+ task = asyncio.create_task(self._handle_browser_download(event))
+ self._browser_download_tasks.add(task)
+ task.add_done_callback(self._browser_download_done)
+
def _on_request_paused(self, event: dict[str, Any], cdp_session: CDPSession) -> None:
"""Handle Fetch.requestPaused — schedule async handler with the originating session."""
- asyncio.ensure_future(self._handle_request_paused(event, cdp_session))
+ self._schedule_cdp_handler(self._handle_request_paused(event, cdp_session))
def _on_auth_required(self, event: dict[str, Any], cdp_session: CDPSession) -> None:
"""Handle Fetch.authRequired — schedule async handler with the originating session."""
- asyncio.ensure_future(self._handle_auth_required(event, cdp_session))
+ self._schedule_cdp_handler(self._handle_auth_required(event, cdp_session))
+
+ def _schedule_cdp_handler(self, handler: Coroutine[Any, Any, None]) -> None:
+ if not self._accepting_cdp_handlers:
+ handler.close()
+ return
+ task = asyncio.create_task(handler)
+ self._cdp_handler_tasks.add(task)
+ task.add_done_callback(self._cdp_handler_done)
async def _handle_auth_required(self, event: dict[str, Any], cdp_session: CDPSession) -> None:
"""Handle proxy 407 auth challenges via CDP Fetch.continueWithAuth.
@@ -1090,3 +1479,33 @@ class CDPDownloadInterceptor:
pass
return b"".join(chunks)
+
+
+@asynccontextmanager
+async def settle_browser_downloads_for_context(browser_context: BrowserContext | None) -> AsyncIterator[None]:
+ interceptor: CDPDownloadInterceptor | None = (
+ getattr(browser_context, "_skyvern_cdp_download_interceptor", None) if browser_context is not None else None
+ )
+ if interceptor is None:
+ yield
+ return
+ async with interceptor.settle_browser_downloads():
+ yield
+
+
+async def disable_download_interceptor_for_context(browser_context: BrowserContext | None) -> None:
+ if browser_context is None:
+ return
+ interceptor: CDPDownloadInterceptor | None = getattr(browser_context, "_skyvern_cdp_download_interceptor", None)
+ if interceptor is None:
+ return
+ browser_context._skyvern_cdp_download_interceptor = None # type: ignore[attr-defined]
+ await interceptor.disable()
+
+
+async def bind_download_interceptor_to_context(
+ interceptor: CDPDownloadInterceptor, browser_context: BrowserContext
+) -> None:
+ binding = interceptor.bind_to_context(browser_context)
+ if inspect.isawaitable(binding):
+ await binding
diff --git a/skyvern/webeye/real_browser_state.py b/skyvern/webeye/real_browser_state.py
index dee26e46e..5b55c234b 100644
--- a/skyvern/webeye/real_browser_state.py
+++ b/skyvern/webeye/real_browser_state.py
@@ -11,7 +11,12 @@ import structlog
from playwright.async_api import BrowserContext, Page, Playwright, async_playwright
from skyvern.config import settings
-from skyvern.constants import BROWSER_CLOSE_TIMEOUT, BROWSER_PAGE_CLOSE_TIMEOUT, NAVIGATION_MAX_RETRY_TIME
+from skyvern.constants import (
+ BROWSER_CLOSE_TIMEOUT,
+ BROWSER_INTERCEPTOR_DISABLE_TIMEOUT,
+ BROWSER_PAGE_CLOSE_TIMEOUT,
+ NAVIGATION_MAX_RETRY_TIME,
+)
from skyvern.exceptions import (
EmptyBrowserContext,
FailedToNavigateToUrl,
@@ -26,6 +31,7 @@ from skyvern.webeye.browser_artifacts import BrowserArtifacts
from skyvern.webeye.browser_engine import BrowserEngineSelection
from skyvern.webeye.browser_factory import BrowserCleanupFunc, BrowserContextFactory
from skyvern.webeye.browser_state import BrowserState
+from skyvern.webeye.cdp_download_interceptor import disable_download_interceptor_for_context
from skyvern.webeye.navigation import is_permanent_navigation_error, navigate_with_retry
from skyvern.webeye.scraper import scraper
from skyvern.webeye.scraper.scraped_page import CleanupElementTreeFunc, ScrapedPage, ScrapeExcludeFunc
@@ -87,6 +93,10 @@ class RealBrowserState(BrowserState):
# 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]]] = []
+ # Teardown phases detached because they overran their budget. asyncio only holds tasks
+ # weakly, so a still-pending detached drain would be eligible for GC ("Task was destroyed
+ # but it is pending!"); we own it strongly here until its done-callback discards it.
+ self._detached_teardown_tasks: set[asyncio.Task[None]] = set()
def add_on_close(self, callback: Callable[[], Awaitable[None]]) -> None:
self._on_close_callbacks.append(callback)
@@ -615,32 +625,118 @@ class RealBrowserState(BrowserState):
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
- # browser alive for another run; firing callbacks then would stop the
- # surviving run's publisher and freeze its livestream.
+
+ # Each teardown phase runs in its OWN bounded region so a phase that hangs — a
+ # cancellation-resistant download drain, a stuck context close, a raising callback —
+ # can never consume the budget a later phase needs. In particular the paid-provider
+ # cleanup (Browser Use / Anchor / remote-CDP stop/delete) always gets its own attempt,
+ # even when interceptor disable, cookie persistence, or context close hangs or fails.
+ # Worst-case wall time is the sum of the per-phase budgets:
+ # BROWSER_INTERCEPTOR_DISABLE_TIMEOUT + 3 * BROWSER_CLOSE_TIMEOUT.
if close_browser_on_completion:
- await self._run_on_close_callbacks()
+ if self.browser_context is not None:
+ await self._run_bounded_detachable(
+ disable_download_interceptor_for_context(self.browser_context),
+ BROWSER_INTERCEPTOR_DISABLE_TIMEOUT,
+ "download interceptor disable",
+ )
+ await self._run_bounded_detachable(
+ self._teardown_context(),
+ BROWSER_CLOSE_TIMEOUT,
+ "browser context teardown",
+ )
+ await self._run_browser_cleanup_bounded()
+
+ await self._stop_driver_bounded(release_driver)
+
+ async def _run_bounded_detachable(self, coro: Awaitable[None], timeout: float, description: str) -> None:
+ # Bound a teardown phase WITHOUT relying on cancellation: a stuck download drain or a real
+ # Playwright ``context.close`` blocked by an unresolved paused request can ignore the cancel a
+ # plain ``asyncio.timeout`` delivers. We race the phase against ``timeout`` and, if it does not
+ # finish, best-effort cancel it and move on so the next phase (crucially the paid-provider
+ # cleanup) always runs. The detached phase stays explicitly owned so it is never an orphan.
+ task = asyncio.ensure_future(coro)
+ try:
+ done, _ = await asyncio.wait({task}, timeout=timeout)
+ except BaseException:
+ # close() itself was cancelled; keep owning the phase so it is not orphaned, then re-raise.
+ task.cancel()
+ self._own_detached_task(task, description)
+ raise
+ if task not in done:
+ LOG.warning(
+ "Teardown phase exceeded its budget; detaching so later teardown still runs",
+ phase=description,
+ timeout=timeout,
+ )
+ task.cancel()
+ self._own_detached_task(task, description)
+ return
+ if task.cancelled():
+ return
+ error = task.exception()
+ if error is not None:
+ LOG.warning("Teardown phase failed", phase=description, error_type=type(error).__name__)
+
+ def _own_detached_task(self, task: asyncio.Task[None], description: str) -> None:
+ # A cancellation-resistant phase can outlive close(). We hold a strong reference until it
+ # finishes (asyncio holds tasks only weakly), and the done-callback retrieves its eventual
+ # exception so it is neither an orphan, a GC'd pending task, nor a source of "Task exception
+ # was never retrieved". The strong ref is discarded only after completion.
+ self._detached_teardown_tasks.add(task)
+
+ def _retrieve(finished: asyncio.Task[None]) -> None:
+ try:
+ if finished.cancelled():
+ return
+ error = finished.exception()
+ if error is not None:
+ LOG.debug(
+ "Detached teardown phase raised after detach",
+ phase=description,
+ error_type=type(error).__name__,
+ )
+ finally:
+ self._detached_teardown_tasks.discard(finished)
+
+ task.add_done_callback(_retrieve)
+
+ async def _teardown_context(self) -> None:
+ # Only fire on-close observers on a real teardown. Shared / parent-child close calls pass
+ # ``close_browser_on_completion=False`` to leave the browser alive for another run; firing
+ # callbacks then would stop the surviving run's publisher and freeze its livestream.
+ await self._run_on_close_callbacks()
+ if self.browser_context is None:
+ return
+ LOG.info("Closing browser context and its pages")
+ session_dir = self.browser_artifacts.browser_session_dir if self.browser_artifacts else None
+ try:
+ await persist_session_cookies(self.browser_context, session_dir)
+ except Exception:
+ LOG.warning("Failed to persist session cookies during teardown", exc_info=True)
+ try:
+ await self.browser_context.close()
+ except Exception:
+ LOG.warning("Failed to close browser context", exc_info=True)
+ LOG.info("Main browser context and all its pages are closed")
+
+ async def _run_browser_cleanup_bounded(self) -> None:
+ cleanup = self.browser_cleanup
+ if cleanup is None or self.browser_context is None:
+ return
+ # One-shot: a re-entrant close() must not stop/delete the paid provider twice.
+ self.browser_cleanup = None
try:
async with asyncio.timeout(BROWSER_CLOSE_TIMEOUT):
- if self.browser_context and close_browser_on_completion:
- LOG.info("Closing browser context and its pages")
- session_dir = self.browser_artifacts.browser_session_dir if self.browser_artifacts else None
- await persist_session_cookies(self.browser_context, session_dir)
- try:
- await self.browser_context.close()
- except Exception:
- LOG.warning("Failed to close browser context", exc_info=True)
- LOG.info("Main browser context and all its pages are closed")
- if self.browser_cleanup is not None:
- try:
- await self.browser_cleanup()
- LOG.info("Main browser cleanup is executed")
- except Exception:
- LOG.warning("Failed to execute browser cleanup", exc_info=True)
+ try:
+ await cleanup()
+ LOG.info("Main browser cleanup is executed")
+ except Exception:
+ LOG.warning("Failed to execute browser cleanup", exc_info=True)
except asyncio.TimeoutError:
- LOG.error("Timeout to close browser context, going to stop playwright directly")
+ LOG.error("Timeout executing browser cleanup")
+ async def _stop_driver_bounded(self, release_driver: bool) -> None:
try:
async with asyncio.timeout(BROWSER_CLOSE_TIMEOUT):
if self.pw and release_driver:
diff --git a/tests/unit/test_agent_cleanup_download_suffix.py b/tests/unit/test_agent_cleanup_download_suffix.py
index b30911c66..de8223905 100644
--- a/tests/unit/test_agent_cleanup_download_suffix.py
+++ b/tests/unit/test_agent_cleanup_download_suffix.py
@@ -1,5 +1,6 @@
from __future__ import annotations
+import asyncio
import os
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock, patch
@@ -65,6 +66,35 @@ async def test_finalize_downloaded_files_renames_with_download_suffix(tmp_path)
rename_mock.assert_called_once_with(os.path.join(download_dir, "uuid-file.zip"), "req-123.zip")
+async def test_finalize_excludes_incomplete_file_created_during_discovery(tmp_path) -> None:
+ agent = ForgeAgent()
+ task = _make_task()
+ download_dir = tmp_path / "downloads"
+ download_dir.mkdir()
+ rename_mock = MagicMock()
+
+ with (
+ patch("skyvern.forge.agent.get_path_for_workflow_download_directory", return_value=download_dir),
+ patch(
+ "skyvern.forge.agent.list_files_in_directory",
+ return_value=[str(download_dir / "late.txt.crdownload")],
+ ),
+ patch("skyvern.forge.agent.rename_file", rename_mock),
+ patch("skyvern.forge.agent.skyvern_context.current", return_value=None),
+ ):
+ discovered = await agent._finalize_downloaded_files_for_task(
+ task,
+ organization_id=task.organization_id,
+ download_suffix="req-123",
+ list_files_before=[],
+ randomize_if_missing=False,
+ )
+
+ assert discovered == []
+ rename_mock.assert_not_called()
+
+
@pytest.mark.asyncio
async def test_finalize_skips_rename_for_session_file_already_named_by_suffix(tmp_path) -> None:
# A session download is named at download time by download_suffix, so the watcher syncs it as
@@ -184,7 +214,6 @@ async def test_cleanup_task_finalizes_downloads_before_saving(tmp_path) -> None:
with (
patch("skyvern.forge.agent.analytics.capture"),
- patch("skyvern.forge.agent.otel_trace.get_current_span", return_value=MagicMock()),
patch("skyvern.forge.agent.skyvern_context.current", return_value=None),
patch.object(agent, "_finalize_downloaded_files_for_task", AsyncMock(side_effect=finalize_side_effect)),
patch("skyvern.forge.agent.app") as mock_app,
@@ -203,6 +232,110 @@ async def test_cleanup_task_finalizes_downloads_before_saving(tmp_path) -> None:
assert call_order == ["rename", "save"]
+async def test_cleanup_task_settles_browser_download_before_finalize_and_save(tmp_path) -> None:
+ agent = ForgeAgent()
+ task = _make_task()
+ last_step = MagicMock(step_id="step-1")
+ release = asyncio.Event()
+ handler_published = asyncio.Event()
+ interceptor = MagicMock()
+
+ class _Settle:
+ async def __aenter__(self) -> None:
+ await release.wait()
+ handler_published.set()
+
+ async def __aexit__(self, *args: object) -> None:
+ return None
+
+ interceptor.settle_browser_downloads.return_value = _Settle()
+ browser_context = MagicMock()
+ browser_context._skyvern_cdp_download_interceptor = interceptor
+ browser_state = MagicMock(browser_context=browser_context)
+
+ async def finalize_side_effect(*args: object, **kwargs: object) -> list[str]:
+ assert handler_published.is_set()
+ return ["final.txt"]
+
+ async def save_side_effect(**kwargs: object) -> None:
+ assert handler_published.is_set()
+
+ with (
+ patch("skyvern.forge.agent.analytics.capture"),
+ patch("skyvern.forge.agent.skyvern_context.current", return_value=None),
+ patch.object(agent, "_finalize_downloaded_files_for_task", AsyncMock(side_effect=finalize_side_effect)),
+ patch("skyvern.forge.agent.app") as mock_app,
+ ):
+ mock_app.DATABASE.tasks.get_task = AsyncMock(return_value=task)
+ mock_app.BROWSER_MANAGER.get_for_task.return_value = browser_state
+ mock_app.STORAGE.save_downloaded_files = AsyncMock(side_effect=save_side_effect)
+ cleanup = asyncio.create_task(
+ agent.clean_up_task(
+ task,
+ last_step=last_step,
+ need_final_screenshot=False,
+ download_suffix="req-123",
+ list_files_before=[],
+ )
+ )
+ await asyncio.sleep(0)
+ assert not cleanup.done()
+ release.set()
+ await asyncio.wait_for(cleanup, timeout=2)
+
+ interceptor.settle_browser_downloads.assert_called_once_with()
+
+
+async def test_cleanup_timeout_bounds_browser_download_handler_drain() -> None:
+ agent = ForgeAgent()
+ task = _make_task()
+ last_step = MagicMock(step_id="step-1")
+ never_release = asyncio.Event()
+ interceptor = MagicMock()
+
+ class _HangingSettle:
+ async def __aenter__(self) -> None:
+ await never_release.wait()
+
+ async def __aexit__(self, *args: object) -> None:
+ return None
+
+ interceptor.settle_browser_downloads.return_value = _HangingSettle()
+ browser_context = MagicMock()
+ browser_context._skyvern_cdp_download_interceptor = interceptor
+ browser_state = MagicMock(browser_context=browser_context)
+ finalize = AsyncMock()
+ save = AsyncMock()
+ started_at = asyncio.get_running_loop().time()
+
+ with (
+ patch("skyvern.forge.agent.SAVE_DOWNLOADED_FILES_TIMEOUT", 0.01),
+ patch("skyvern.forge.agent.analytics.capture"),
+ patch("skyvern.forge.agent.skyvern_context.current", return_value=None),
+ patch.object(agent, "_finalize_downloaded_files_for_task", finalize),
+ patch("skyvern.forge.agent.app") as mock_app,
+ ):
+ mock_app.DATABASE.tasks.get_task = AsyncMock(return_value=task)
+ mock_app.BROWSER_MANAGER.get_for_task.return_value = browser_state
+ mock_app.STORAGE.save_downloaded_files = save
+ await asyncio.wait_for(
+ agent.clean_up_task(
+ task,
+ last_step=last_step,
+ need_final_screenshot=False,
+ download_suffix="req-123",
+ list_files_before=[],
+ ),
+ timeout=0.5,
+ )
+
+ assert asyncio.get_running_loop().time() - started_at < 0.2
+ finalize.assert_not_awaited()
+ save.assert_not_awaited()
+
+
@pytest.mark.asyncio
async def test_execute_step_complete_on_download_does_not_double_finalize(tmp_path) -> None:
agent = ForgeAgent()
@@ -264,7 +397,6 @@ async def test_execute_step_complete_on_download_does_not_double_finalize(tmp_pa
with (
patch("skyvern.forge.agent.analytics.capture"),
- patch("skyvern.forge.agent.otel_trace.get_current_span", return_value=MagicMock()),
patch("skyvern.forge.agent.skyvern_context.ensure_context", return_value=MagicMock()),
patch("skyvern.forge.agent.skyvern_context.current", return_value=None),
patch("skyvern.forge.agent.get_path_for_workflow_download_directory", return_value=download_dir),
@@ -384,7 +516,6 @@ async def test_execute_step_reuses_initial_download_baseline_across_recursive_st
with (
patch("skyvern.forge.agent.analytics.capture"),
- patch("skyvern.forge.agent.otel_trace.get_current_span", return_value=MagicMock()),
patch("skyvern.forge.agent.skyvern_context.ensure_context", return_value=MagicMock()),
patch("skyvern.forge.agent.skyvern_context.current", return_value=None),
patch("skyvern.forge.agent.get_path_for_workflow_download_directory", return_value=download_dir),
@@ -566,7 +697,6 @@ async def test_execute_step_complete_on_download_emits_finalize_lineage(tmp_path
with (
patch("skyvern.forge.agent.analytics.capture"),
- patch("skyvern.forge.agent.otel_trace.get_current_span", return_value=MagicMock()),
patch("skyvern.forge.agent.skyvern_context.ensure_context", return_value=real_ctx),
patch("skyvern.forge.agent.skyvern_context.current", return_value=real_ctx),
patch("skyvern.forge.agent.get_path_for_workflow_download_directory", return_value=download_dir),
diff --git a/tests/unit/test_cdp_download_interceptor.py b/tests/unit/test_cdp_download_interceptor.py
index 09306e6f2..aac032dfb 100644
--- a/tests/unit/test_cdp_download_interceptor.py
+++ b/tests/unit/test_cdp_download_interceptor.py
@@ -1,10 +1,17 @@
"""Unit tests for CDPDownloadInterceptor pure functions and proxy auth handling."""
+import asyncio
+import gc
+import threading
+import weakref
from pathlib import Path
+from typing import Any
from unittest.mock import AsyncMock, MagicMock, patch
import pytest
+from structlog.testing import capture_logs
+import skyvern.webeye.cdp_download_interceptor as mod
from skyvern.webeye.cdp_download_interceptor import (
CDPDownloadInterceptor,
_is_stale_interception_error,
@@ -634,6 +641,28 @@ class TestCDPDownloadInterceptorProxyAuth:
assert "Fetch.requestPaused" in event_names
assert "Fetch.authRequired" not in event_names
+ @pytest.mark.asyncio
+ async def test_page_events_do_not_use_browser_download_admission(self) -> None:
+ interceptor = self._make_interceptor(proxy_username="user", proxy_password="pass")
+ cdp_session = self._make_cdp_session()
+ page = MagicMock(url="about:blank")
+ page.context.new_cdp_session = AsyncMock(return_value=cdp_session)
+
+ with (
+ patch.object(interceptor, "_handle_request_paused", new_callable=AsyncMock) as request_handler,
+ patch.object(interceptor, "_handle_auth_required", new_callable=AsyncMock) as auth_handler,
+ ):
+ await interceptor.enable_for_page(page)
+ listeners = {call.args[0]: call.args[1] for call in cdp_session.on.call_args_list}
+ listeners["Fetch.requestPaused"]({"requestId": "request"})
+ listeners["Fetch.authRequired"]({"requestId": "auth"})
+ await asyncio.sleep(0)
+
+ request_handler.assert_awaited_once_with({"requestId": "request"}, cdp_session)
+ auth_handler.assert_awaited_once_with({"requestId": "auth"}, cdp_session)
+ assert not interceptor._accepting_browser_downloads
+ assert interceptor._browser_download_listener is None
+
@pytest.mark.asyncio
async def test_request_stage_continues_request(self) -> None:
"""Request-stage events (no responseStatusCode) should be continued with Fetch.continueRequest."""
@@ -843,8 +872,6 @@ class TestBlobDownloadCapture:
@pytest.mark.asyncio
async def test_blob_download_threads_max_size_and_guards_oversize(self, tmp_path: Path) -> None:
- import skyvern.webeye.cdp_download_interceptor as mod
-
interceptor = CDPDownloadInterceptor(output_dir=str(tmp_path))
interceptor._browser_context = self._context()
read = AsyncMock(return_value=b"x" * 2048) # exceeds the patched limit (defense-in-depth)
@@ -913,6 +940,867 @@ class TestBlobDownloadCapture:
assert list(tmp_path.iterdir()) == []
+class TestDataUrlDownloadCapture:
+ @pytest.mark.asyncio
+ @pytest.mark.parametrize(
+ ("url", "expected_filename", "expected_bytes"),
+ [
+ pytest.param("data:application/pdf;base64,JVBERi0xLjQK", "report.pdf", b"%PDF-1.4\n", id="base64"),
+ pytest.param("data:application/octet-stream;base64,%2Bw==", "report", b"\xfb", id="escaped_base64"),
+ pytest.param("data:text/csv,name%2Cvalue%0Aone%2C1", "report", b"name,value\none,1", id="percent_encoded"),
+ pytest.param(
+ "data:application/pdf;charset=utf-8;base64,JVBERg==",
+ "report.pdf",
+ b"%PDF",
+ id="media_type_parameter",
+ ),
+ pytest.param("data:application/x'foo*`|~;p'k*`|~=v,ok", "report", b"ok", id="rfc_token_characters"),
+ ],
+ )
+ async def test_data_url_download_saved(
+ self, tmp_path: Path, url: str, expected_filename: str, expected_bytes: bytes
+ ) -> None:
+ interceptor = CDPDownloadInterceptor(output_dir=str(tmp_path))
+
+ await interceptor._handle_browser_download({"url": url, "suggestedFilename": "report"})
+
+ saved = list(tmp_path.iterdir())
+ assert len(saved) == 1
+ assert saved[0].name == expected_filename
+ assert saved[0].read_bytes() == expected_bytes
+ assert url not in interceptor._downloaded_urls
+ assert len(interceptor._downloaded_urls) == 1
+ dedupe_key = next(iter(interceptor._downloaded_urls))
+ assert dedupe_key.startswith("data:sha256:")
+ assert len(dedupe_key) == len("data:sha256:") + 64
+
+ @pytest.mark.asyncio
+ async def test_data_url_uses_safe_generated_filename(self, tmp_path: Path) -> None:
+ interceptor = CDPDownloadInterceptor(output_dir=str(tmp_path))
+
+ await interceptor._handle_browser_download(
+ {"url": "data:application/pdf;base64,JVBERg==", "suggestedFilename": "../../report.pdf"}
+ )
+
+ assert [path.name for path in tmp_path.iterdir()] == ["report.pdf"]
+ assert not (tmp_path.parent / "report.pdf").exists()
+
+ @pytest.mark.asyncio
+ @pytest.mark.parametrize(
+ "url",
+ [
+ pytest.param("data:application/pdf;base64,not-valid-@@", id="malformed_base64"),
+ pytest.param("data:text/plain,bad%2payload", id="malformed_percent_encoding"),
+ pytest.param("data:application/pdf;base64,", id="empty_payload"),
+ pytest.param("data:application/pdf", id="missing_comma"),
+ pytest.param("data:application/pdf;base64;charset=x,JVBERg==", id="misordered_base64_metadata"),
+ pytest.param("data:application/pdf;base64;base64,JVBERg==", id="duplicate_base64_metadata"),
+ pytest.param("data:application/pdf;invalid,JVBERg==", id="bare_metadata_token"),
+ ],
+ )
+ async def test_malformed_data_url_does_not_create_artifact(self, tmp_path: Path, url: str) -> None:
+ interceptor = CDPDownloadInterceptor(output_dir=str(tmp_path))
+
+ await interceptor._handle_browser_download({"url": url, "suggestedFilename": "report.pdf"})
+
+ assert list(tmp_path.iterdir()) == []
+ assert url not in interceptor._downloaded_urls
+
+ @pytest.mark.asyncio
+ async def test_duplicate_data_url_event_is_saved_once(self, tmp_path: Path) -> None:
+ interceptor = CDPDownloadInterceptor(output_dir=str(tmp_path))
+ event = {"url": "data:text/plain,hello", "suggestedFilename": "note.txt"}
+
+ await interceptor._handle_browser_download(event)
+ await interceptor._handle_browser_download(event)
+
+ assert [path.name for path in tmp_path.iterdir()] == ["note.txt"]
+ assert (tmp_path / "note.txt").read_bytes() == b"hello"
+
+ @pytest.mark.asyncio
+ async def test_duplicate_data_url_logs_never_include_payload(self, tmp_path: Path) -> None:
+ interceptor = CDPDownloadInterceptor(output_dir=str(tmp_path))
+ payload = "private-inline-payload"
+ event = {"url": f"data:text/plain,{payload}", "suggestedFilename": "note.txt"}
+
+ with capture_logs() as logs:
+ await interceptor._handle_browser_download(event)
+ await interceptor._handle_browser_download(event)
+
+ assert payload not in repr(logs)
+
+ @pytest.mark.asyncio
+ async def test_non_base64_oversize_rejected_before_percent_decode(self, tmp_path: Path) -> None:
+ interceptor = CDPDownloadInterceptor(output_dir=str(tmp_path))
+ with (
+ patch.object(mod, "MAX_FILE_SIZE_BYTES", 4),
+ patch.object(mod, "_percent_decode_payload", wraps=mod._percent_decode_payload) as decode,
+ ):
+ await interceptor._handle_browser_download(
+ {"url": "data:text/plain,abcde", "suggestedFilename": "large.txt"}
+ )
+
+ decode.assert_not_called()
+ assert list(tmp_path.iterdir()) == []
+
+ @pytest.mark.asyncio
+ async def test_concurrent_duplicate_is_reserved_and_failure_can_retry(self, tmp_path: Path) -> None:
+ interceptor = CDPDownloadInterceptor(output_dir=str(tmp_path))
+ event = {"url": "data:text/plain,hello", "suggestedFilename": "note.txt"}
+ started = asyncio.Event()
+ release = asyncio.Event()
+ real_to_thread = asyncio.to_thread
+
+ async def paused_to_thread(function: Any, *args: Any) -> object:
+ started.set()
+ await asyncio.wait_for(release.wait(), timeout=2)
+ return await real_to_thread(function, *args)
+
+ with patch("skyvern.webeye.cdp_download_interceptor.asyncio.to_thread", new=paused_to_thread):
+ first = asyncio.create_task(interceptor._handle_browser_download(event))
+ await asyncio.wait_for(started.wait(), timeout=0.5)
+ duplicate = asyncio.create_task(interceptor._handle_browser_download(event))
+ await asyncio.sleep(0)
+ assert not duplicate.done()
+ release.set()
+ await asyncio.gather(first, duplicate)
+
+ assert [path.name for path in tmp_path.iterdir()] == ["note.txt"]
+
+ retry_interceptor = CDPDownloadInterceptor(output_dir=str(tmp_path / "retry"))
+ with patch.object(retry_interceptor, "_decode_data_url", side_effect=OSError("transient")):
+ await retry_interceptor._handle_browser_download(event)
+ await retry_interceptor._handle_browser_download(event)
+
+ assert (tmp_path / "retry" / "note.txt").read_bytes() == b"hello"
+ assert len(retry_interceptor._downloaded_urls) == 1
+
+ @pytest.mark.asyncio
+ async def test_data_url_over_size_limit_does_not_create_artifact(self, tmp_path: Path) -> None:
+ interceptor = CDPDownloadInterceptor(output_dir=str(tmp_path))
+ url = "data:application/octet-stream;base64,eHh4eHg="
+
+ with patch.object(mod, "MAX_FILE_SIZE_BYTES", 4):
+ await interceptor._handle_browser_download({"url": url, "suggestedFilename": "large.bin"})
+
+ assert list(tmp_path.iterdir()) == []
+ assert url not in interceptor._downloaded_urls
+
+ @staticmethod
+ def _paused_replace() -> tuple[threading.Event, threading.Event, Any]:
+ entered, release = threading.Event(), threading.Event()
+ real_replace = mod.os.replace
+
+ def replace(source: Path, destination: Path) -> None:
+ entered.set()
+ assert release.wait(timeout=2)
+ real_replace(source, destination)
+
+ return entered, release, patch.object(mod.os, "replace", side_effect=replace)
+
+ @pytest.mark.asyncio
+ async def test_data_url_is_atomically_published_from_incomplete_path(self, tmp_path: Path) -> None:
+ interceptor = CDPDownloadInterceptor(output_dir=str(tmp_path))
+ entered_replace, release_replace, replace_patch = self._paused_replace()
+ with replace_patch:
+ task = asyncio.create_task(
+ interceptor._handle_browser_download(
+ {"url": "data:text/plain,complete", "suggestedFilename": "note.txt"}
+ )
+ )
+ assert await asyncio.to_thread(entered_replace.wait, 2)
+ visible = list(tmp_path.iterdir())
+ assert len(visible) == 1
+ assert visible[0].name.startswith("note.txt.")
+ assert visible[0].name.endswith(".crdownload")
+ assert not (tmp_path / "note.txt").exists()
+ release_replace.set()
+ await asyncio.wait_for(task, timeout=2)
+
+ assert [path.name for path in tmp_path.iterdir()] == ["note.txt"]
+
+ @pytest.mark.asyncio
+ async def test_cancellation_drains_publication_before_retry(self, tmp_path: Path) -> None:
+ interceptor = CDPDownloadInterceptor(output_dir=str(tmp_path))
+ event = {"url": "data:text/plain,complete", "suggestedFilename": "note.txt"}
+ entered_replace, release_replace, replace_patch = self._paused_replace()
+ with replace_patch:
+ first = asyncio.create_task(interceptor._handle_browser_download(event))
+ assert await asyncio.to_thread(entered_replace.wait, 2)
+ first.cancel()
+ retry = asyncio.create_task(interceptor._handle_browser_download(event))
+ await asyncio.sleep(0)
+ assert not retry.done()
+ visible = list(tmp_path.iterdir())
+ assert len(visible) == 1
+ assert visible[0].name.endswith(".crdownload")
+ release_replace.set()
+ with pytest.raises(asyncio.CancelledError):
+ await asyncio.wait_for(first, timeout=2)
+ await asyncio.wait_for(retry, timeout=2)
+
+ assert (tmp_path / "note.txt").read_bytes() == b"complete"
+ assert not list(tmp_path.glob("*.crdownload"))
+ assert len(interceptor._downloaded_urls) == 1
+
+ @pytest.mark.asyncio
+ async def test_concurrent_distinct_data_urls_with_same_filename_are_serialized(self, tmp_path: Path) -> None:
+ interceptor = CDPDownloadInterceptor(output_dir=str(tmp_path))
+ first = {"url": "data:text/plain,first", "suggestedFilename": "note.txt"}
+ second = {"url": "data:text/plain,second", "suggestedFilename": "note.txt"}
+
+ await asyncio.wait_for(
+ asyncio.gather(
+ interceptor._handle_browser_download(first),
+ interceptor._handle_browser_download(second),
+ ),
+ timeout=2,
+ )
+
+ assert (tmp_path / "note.txt").read_bytes() in {b"first", b"second"}
+ assert len(interceptor._downloaded_urls) == 2
+ assert not list(tmp_path.glob("*.crdownload"))
+
+ @pytest.mark.asyncio
+ async def test_digest_is_off_loop_and_invalid_shape_rejected_before_digest(self, tmp_path: Path) -> None:
+ interceptor = CDPDownloadInterceptor(output_dir=str(tmp_path))
+ event_loop_thread = threading.get_ident()
+
+ real_identity = mod._download_identity
+ digest_threads: list[int] = []
+
+ def recording_identity(url: str) -> str:
+ digest_threads.append(threading.get_ident())
+ return real_identity(url)
+
+ with patch.object(mod, "_download_identity", side_effect=recording_identity) as identity:
+ await interceptor._handle_browser_download(
+ {"url": "data:text/plain,valid", "suggestedFilename": "valid.txt"}
+ )
+ assert digest_threads and digest_threads[0] != event_loop_thread
+
+ identity.reset_mock()
+ await interceptor._handle_browser_download(
+ {"url": "data:" + "x" * (mod._DATA_URL_MAX_METADATA_LENGTH + 1), "suggestedFilename": "bad.txt"}
+ )
+ identity.assert_not_called()
+
+ @pytest.mark.asyncio
+ async def test_disable_drains_active_browser_download_task(self, tmp_path: Path) -> None:
+ interceptor = CDPDownloadInterceptor(output_dir=str(tmp_path))
+ browser_session = MagicMock()
+ browser_session.send = AsyncMock()
+ browser_session.detach = AsyncMock()
+ browser = MagicMock()
+ browser.new_browser_cdp_session = AsyncMock(return_value=browser_session)
+ browser_context = MagicMock()
+ started = asyncio.Event()
+ release = asyncio.Event()
+
+ async def paused_handler(event: dict[str, Any]) -> None:
+ started.set()
+ await release.wait()
+
+ await interceptor.enable_browser_download_monitor(browser, browser_context)
+ download_listener = browser_session.on.call_args.args[1]
+ with patch.object(interceptor, "_handle_browser_download", side_effect=paused_handler):
+ download_listener({"url": "data:text/plain,x"})
+ await asyncio.wait_for(started.wait(), timeout=0.5)
+ disabling = asyncio.create_task(interceptor.disable())
+ await asyncio.sleep(0)
+ assert not disabling.done()
+ release.set()
+ await asyncio.wait_for(disabling, timeout=2)
+
+ assert not interceptor._browser_download_tasks
+ assert not interceptor._accepting_browser_downloads
+ browser_session.remove_listener.assert_called_once_with("Browser.downloadWillBegin", download_listener)
+
+ @pytest.mark.asyncio
+ async def test_settle_browser_downloads_includes_event_admitted_while_draining(self, tmp_path: Path) -> None:
+ interceptor = CDPDownloadInterceptor(output_dir=str(tmp_path))
+ interceptor._accepting_browser_downloads = True
+ first_started = asyncio.Event()
+ release_first = asyncio.Event()
+ handled_urls: list[str] = []
+
+ async def paused_handler(event: dict[str, Any]) -> None:
+ if not handled_urls:
+ first_started.set()
+ await release_first.wait()
+ handled_urls.append(event["url"])
+
+ with patch.object(interceptor, "_handle_browser_download", side_effect=paused_handler):
+ interceptor._schedule_browser_download_handler({"url": "data:text/plain,ready"})
+ await first_started.wait()
+ entered = asyncio.Event()
+
+ async def collect() -> None:
+ async with interceptor.settle_browser_downloads():
+ entered.set()
+ assert set(handled_urls) == {"data:text/plain,ready", "data:text/plain,late"}
+
+ collecting = asyncio.create_task(collect())
+ await asyncio.sleep(0)
+ assert not entered.is_set()
+ interceptor._schedule_browser_download_handler({"url": "data:text/plain,late"})
+ release_first.set()
+ await asyncio.wait_for(collecting, timeout=2)
+
+ assert interceptor._accepting_browser_downloads
+ assert not interceptor._browser_download_tasks
+
+ @pytest.mark.asyncio
+ async def test_settle_browser_downloads_drains_event_admitted_inside_context(self, tmp_path: Path) -> None:
+ interceptor = CDPDownloadInterceptor(output_dir=str(tmp_path))
+ interceptor._accepting_browser_downloads = True
+ handler_started = asyncio.Event()
+ release_handler = asyncio.Event()
+
+ async def paused_handler(event: dict[str, Any]) -> None:
+ handler_started.set()
+ await release_handler.wait()
+ (tmp_path / "late.txt").write_text(event["url"])
+
+ async def collect() -> None:
+ async with interceptor.settle_browser_downloads():
+ interceptor._schedule_browser_download_handler({"url": "data:text/plain,late"})
+ await handler_started.wait()
+
+ with patch.object(interceptor, "_handle_browser_download", side_effect=paused_handler):
+ collecting = asyncio.create_task(collect())
+ await handler_started.wait()
+ await asyncio.sleep(0)
+ assert not collecting.done()
+ release_handler.set()
+ await asyncio.wait_for(collecting, timeout=2)
+
+ assert (tmp_path / "late.txt").read_text() == "data:text/plain,late"
+ assert not interceptor._browser_download_tasks
+
+ @pytest.mark.asyncio
+ async def test_cancelled_settle_does_not_poison_reused_interceptor(self) -> None:
+ interceptor = CDPDownloadInterceptor()
+ interceptor._accepting_browser_downloads = True
+ first_started = asyncio.Event()
+ never_release = asyncio.Event()
+ second_handled = asyncio.Event()
+
+ async def paused_handler(event: dict[str, Any]) -> None:
+ if event["url"].endswith("first"):
+ first_started.set()
+ await never_release.wait()
+ else:
+ second_handled.set()
+
+ with patch.object(interceptor, "_handle_browser_download", side_effect=paused_handler):
+ interceptor._schedule_browser_download_handler({"url": "data:text/plain,first"})
+ await first_started.wait()
+
+ async def settle() -> None:
+ async with interceptor.settle_browser_downloads():
+ pass
+
+ settling = asyncio.create_task(settle())
+ await asyncio.sleep(0)
+ settling.cancel()
+ with pytest.raises(asyncio.CancelledError):
+ await settling
+
+ interceptor._schedule_browser_download_handler({"url": "data:text/plain,second"})
+ await asyncio.wait_for(second_handled.wait(), timeout=2)
+
+ assert interceptor._accepting_browser_downloads
+
+ @pytest.mark.asyncio
+ async def test_cancelled_settle_body_cancels_admitted_handler_and_remains_reusable(self) -> None:
+ interceptor = CDPDownloadInterceptor()
+ interceptor._accepting_browser_downloads = True
+ first_started = asyncio.Event()
+ second_handled = asyncio.Event()
+
+ async def paused_handler(event: dict[str, Any]) -> None:
+ if event["url"].endswith("first"):
+ first_started.set()
+ await asyncio.Event().wait()
+ else:
+ second_handled.set()
+
+ async def settle() -> None:
+ async with interceptor.settle_browser_downloads():
+ interceptor._schedule_browser_download_handler({"url": "data:text/plain,first"})
+ await first_started.wait()
+ await asyncio.Event().wait()
+
+ with patch.object(interceptor, "_handle_browser_download", side_effect=paused_handler):
+ settling = asyncio.create_task(settle())
+ await first_started.wait()
+ settling.cancel()
+ with pytest.raises(asyncio.CancelledError):
+ await asyncio.wait_for(settling, timeout=2)
+
+ assert not interceptor._browser_download_tasks
+ assert not interceptor._browser_download_monitor_lock.locked()
+ interceptor._schedule_browser_download_handler({"url": "data:text/plain,second"})
+ await asyncio.wait_for(second_handled.wait(), timeout=2)
+
+ assert interceptor._accepting_browser_downloads
+
+ def test_maximum_size_percent_encoded_payload_is_accepted(self, monkeypatch: pytest.MonkeyPatch) -> None:
+ interceptor = CDPDownloadInterceptor()
+ monkeypatch.setattr(mod, "MAX_FILE_SIZE_BYTES", 12)
+ url = "data:text/plain," + "%41" * 12
+
+ comma_index = mod._bounded_data_url_comma(url)
+ _, _, data = interceptor._decode_data_url(url, comma_index)
+
+ assert data == b"A" * 12
+
+ def test_percent_escaped_base64_payload_is_accepted(self, monkeypatch: pytest.MonkeyPatch) -> None:
+ interceptor = CDPDownloadInterceptor()
+ monkeypatch.setattr(mod, "MAX_FILE_SIZE_BYTES", 1)
+ url = "data:text/plain;base64,%51%51%3D%3D"
+
+ comma_index = mod._bounded_data_url_comma(url)
+ _, _, data = interceptor._decode_data_url(url, comma_index)
+
+ assert data == b"A"
+
+ def test_maximum_size_percent_escaped_base64_payload_is_accepted(self, monkeypatch: pytest.MonkeyPatch) -> None:
+ interceptor = CDPDownloadInterceptor()
+ monkeypatch.setattr(mod, "MAX_FILE_SIZE_BYTES", 4)
+ url = "data:text/plain;base64," + "".join(f"%{byte:02X}" for byte in b"QUJDRA==")
+
+ comma_index = mod._bounded_data_url_comma(url)
+ _, _, data = interceptor._decode_data_url(url, comma_index)
+
+ assert data == b"ABCD"
+
+ def test_percent_escaped_base64_decoded_overflow_is_rejected(self, monkeypatch: pytest.MonkeyPatch) -> None:
+ interceptor = CDPDownloadInterceptor()
+ monkeypatch.setattr(mod, "MAX_FILE_SIZE_BYTES", 4)
+ url = "data:text/plain;base64," + "".join(f"%{byte:02X}" for byte in b"QUJDREU=")
+
+ comma_index = mod._bounded_data_url_comma(url)
+ with pytest.raises(ValueError, match="decoded payload exceeds size limit"):
+ interceptor._decode_data_url(url, comma_index)
+
+ @pytest.mark.parametrize(
+ "payload",
+ [
+ pytest.param("%51%51%3", id="malformed_escape"),
+ pytest.param("%51%51%40%40", id="malformed_base64"),
+ ],
+ )
+ def test_malformed_percent_escaped_base64_is_rejected(self, monkeypatch: pytest.MonkeyPatch, payload: str) -> None:
+ interceptor = CDPDownloadInterceptor()
+ monkeypatch.setattr(mod, "MAX_FILE_SIZE_BYTES", 4)
+ url = f"data:text/plain;base64,{payload}"
+
+ comma_index = mod._bounded_data_url_comma(url)
+ with pytest.raises(ValueError):
+ interceptor._decode_data_url(url, comma_index)
+
+ def test_oversized_percent_escaped_base64_rejected_before_decode_allocation(
+ self, monkeypatch: pytest.MonkeyPatch
+ ) -> None:
+ monkeypatch.setattr(mod, "MAX_FILE_SIZE_BYTES", 4)
+ url = "data:text/plain;base64," + "%51" * 9
+
+ with patch.object(mod, "_percent_decoded_payload_length") as decoded_length:
+ with pytest.raises(ValueError, match="encoded payload exceeds size limit"):
+ mod._bounded_data_url_comma(url)
+
+ decoded_length.assert_not_called()
+
+ def test_oversized_percent_payload_rejected_before_decode_allocation(self, monkeypatch: pytest.MonkeyPatch) -> None:
+ interceptor = CDPDownloadInterceptor()
+ monkeypatch.setattr(mod, "MAX_FILE_SIZE_BYTES", 12)
+ url = "data:text/plain," + "A" * 12 + "%41"
+
+ with patch.object(mod, "_percent_decode_payload") as decode:
+ comma_index = mod._bounded_data_url_comma(url)
+ with pytest.raises(ValueError, match="decoded payload exceeds size limit"):
+ interceptor._decode_data_url(url, comma_index)
+
+ decode.assert_not_called()
+
+ @pytest.mark.asyncio
+ async def test_disable_waits_for_racing_browser_monitor_enable(self) -> None:
+ interceptor = CDPDownloadInterceptor()
+ send_started = asyncio.Event()
+ release_send = asyncio.Event()
+ browser_session = MagicMock()
+
+ async def suspended_send(method: str, params: dict[str, Any]) -> None:
+ send_started.set()
+ await release_send.wait()
+
+ browser_session.send = AsyncMock(side_effect=suspended_send)
+ browser_session.detach = AsyncMock()
+ browser = MagicMock()
+ browser.new_browser_cdp_session = AsyncMock(return_value=browser_session)
+
+ enabling = asyncio.create_task(interceptor.enable_browser_download_monitor(browser, MagicMock()))
+ await send_started.wait()
+ disabling = asyncio.create_task(interceptor.disable())
+ await asyncio.sleep(0)
+ assert not disabling.done()
+
+ release_send.set()
+ await asyncio.wait_for(asyncio.gather(enabling, disabling), timeout=2)
+
+ assert interceptor._browser_session is None
+ assert interceptor._browser_context is None
+ assert interceptor._browser_download_listener is None
+ assert not interceptor._accepting_browser_downloads
+ browser_session.detach.assert_awaited_once()
+
+ @pytest.mark.asyncio
+ async def test_browser_monitor_can_reenable_after_disable(self) -> None:
+ interceptor = CDPDownloadInterceptor()
+ first_session = MagicMock(send=AsyncMock(), detach=AsyncMock())
+ second_session = MagicMock(send=AsyncMock(), detach=AsyncMock())
+ browser = MagicMock()
+ browser.new_browser_cdp_session = AsyncMock(side_effect=[first_session, second_session])
+ browser_context = MagicMock()
+
+ await interceptor.enable_browser_download_monitor(browser, browser_context)
+ await interceptor.disable()
+ await interceptor.enable_browser_download_monitor(browser, browser_context)
+
+ assert interceptor._browser_session is second_session
+ assert interceptor._browser_context is browser_context
+ assert interceptor._browser_download_listener is second_session.on.call_args.args[1]
+ assert interceptor._accepting_browser_downloads
+
+ await asyncio.wait_for(interceptor.disable(), timeout=2)
+ assert not interceptor._browser_download_tasks
+ assert not interceptor._accepting_browser_downloads
+
+ @pytest.mark.asyncio
+ async def test_context_binding_owns_new_page_listener_and_tasks(self) -> None:
+ interceptor = CDPDownloadInterceptor()
+ context = MagicMock()
+ context._skyvern_cdp_download_interceptor = None
+ page = MagicMock()
+ started = asyncio.Event()
+ release = asyncio.Event()
+
+ async def paused_enable(new_page: Any) -> None:
+ assert new_page is page
+ started.set()
+ await asyncio.wait_for(release.wait(), timeout=2)
+
+ with patch.object(interceptor, "enable_for_page", side_effect=paused_enable):
+ await interceptor.bind_to_context(context)
+ page_listener = context.on.call_args.args[1]
+ page_listener(page)
+ await asyncio.wait_for(started.wait(), timeout=0.5)
+ disabling = asyncio.create_task(interceptor.disable())
+ await asyncio.sleep(0)
+ assert not disabling.done()
+ release.set()
+ await asyncio.wait_for(disabling, timeout=2)
+
+ context.remove_listener.assert_called_once_with("page", page_listener)
+ assert not interceptor._page_enable_tasks
+ assert context._skyvern_cdp_download_interceptor is None
+
+ @pytest.mark.asyncio
+ async def test_context_rebind_detaches_cancellation_resistant_disable(
+ self, monkeypatch: pytest.MonkeyPatch
+ ) -> None:
+ monkeypatch.setattr(mod, "BROWSER_INTERCEPTOR_DISABLE_TIMEOUT", 0.01)
+ old_interceptor = CDPDownloadInterceptor()
+ new_interceptor = CDPDownloadInterceptor()
+ context = MagicMock()
+ context._skyvern_cdp_download_interceptor = old_interceptor
+ entered_cancel = asyncio.Event()
+ release = asyncio.Event()
+
+ async def stuck_disable() -> None:
+ try:
+ await asyncio.sleep(3600)
+ except asyncio.CancelledError:
+ entered_cancel.set()
+ await asyncio.wait_for(release.wait(), timeout=2)
+ if context._skyvern_cdp_download_interceptor is old_interceptor:
+ context._skyvern_cdp_download_interceptor = None
+ raise RuntimeError("disable failed after detach")
+
+ old_interceptor.disable = stuck_disable # type: ignore[method-assign]
+ unretrieved: list[dict[str, Any]] = []
+ loop = asyncio.get_running_loop()
+ previous_handler = loop.get_exception_handler()
+ loop.set_exception_handler(lambda _loop, context_: unretrieved.append(context_))
+ with capture_logs() as logs:
+ try:
+ await asyncio.wait_for(new_interceptor.bind_to_context(context), timeout=0.5)
+ await asyncio.wait_for(entered_cancel.wait(), timeout=0.5)
+
+ assert context._skyvern_cdp_download_interceptor is new_interceptor
+ assert context.on.call_count == 1
+ assert len(mod._DETACHED_DISABLE_TASKS) == 1
+
+ release.set()
+ callback_finished = asyncio.Event()
+ next(iter(mod._DETACHED_DISABLE_TASKS)).add_done_callback(lambda _: callback_finished.set())
+ await asyncio.wait_for(callback_finished.wait(), timeout=0.5)
+ await asyncio.sleep(0)
+
+ assert mod._DETACHED_DISABLE_TASKS == set()
+ assert context._skyvern_cdp_download_interceptor is new_interceptor
+ finally:
+ loop.set_exception_handler(previous_handler)
+
+ assert not any("never retrieved" in str(item.get("message", "")) for item in unretrieved)
+ matching_logs = [
+ log for log in logs if log.get("event") == "Previous CDP download interceptor disable failed after detach"
+ ]
+ assert matching_logs == [
+ {
+ "error_type": "RuntimeError",
+ "event": "Previous CDP download interceptor disable failed after detach",
+ "log_level": "warning",
+ }
+ ]
+
+ @pytest.mark.asyncio
+ async def test_context_rebind_awaits_fast_disable_before_binding(self) -> None:
+ old_interceptor = CDPDownloadInterceptor()
+ new_interceptor = CDPDownloadInterceptor()
+ context = MagicMock()
+ context._skyvern_cdp_download_interceptor = old_interceptor
+ disabled = False
+
+ async def fast_disable() -> None:
+ nonlocal disabled
+ disabled = True
+
+ old_interceptor.disable = fast_disable # type: ignore[method-assign]
+ await asyncio.wait_for(new_interceptor.bind_to_context(context), timeout=0.5)
+
+ assert disabled
+ assert context._skyvern_cdp_download_interceptor is new_interceptor
+ context.on.assert_called_once()
+ assert mod._DETACHED_DISABLE_TASKS == set()
+
+ @pytest.mark.asyncio
+ async def test_context_rebind_propagates_fast_disable_failure(self) -> None:
+ old_interceptor = CDPDownloadInterceptor()
+ new_interceptor = CDPDownloadInterceptor()
+ context = MagicMock()
+ context._skyvern_cdp_download_interceptor = old_interceptor
+ old_interceptor.disable = AsyncMock(side_effect=RuntimeError("disable failed")) # type: ignore[method-assign]
+
+ with pytest.raises(RuntimeError, match="disable failed"):
+ await asyncio.wait_for(new_interceptor.bind_to_context(context), timeout=0.5)
+
+ assert context._skyvern_cdp_download_interceptor is old_interceptor
+ context.on.assert_not_called()
+ assert mod._DETACHED_DISABLE_TASKS == set()
+
+ @pytest.mark.asyncio
+ async def test_context_rebind_cancellation_owns_old_disable_task(self) -> None:
+ old_interceptor = CDPDownloadInterceptor()
+ new_interceptor = CDPDownloadInterceptor()
+ context = MagicMock()
+ context._skyvern_cdp_download_interceptor = old_interceptor
+ started = asyncio.Event()
+ entered_cancel = asyncio.Event()
+ release = asyncio.Event()
+
+ async def stuck_disable() -> None:
+ started.set()
+ try:
+ await asyncio.sleep(3600)
+ except asyncio.CancelledError:
+ entered_cancel.set()
+ await asyncio.wait_for(release.wait(), timeout=2)
+
+ old_interceptor.disable = stuck_disable # type: ignore[method-assign]
+ binding = asyncio.create_task(new_interceptor.bind_to_context(context))
+ await asyncio.wait_for(started.wait(), timeout=0.5)
+ binding.cancel()
+ with pytest.raises(asyncio.CancelledError):
+ await asyncio.wait_for(binding, timeout=0.5)
+
+ await asyncio.wait_for(entered_cancel.wait(), timeout=0.5)
+ assert len(mod._DETACHED_DISABLE_TASKS) == 1
+ assert context._skyvern_cdp_download_interceptor is old_interceptor
+ context.on.assert_not_called()
+
+ release.set()
+ callback_finished = asyncio.Event()
+ next(iter(mod._DETACHED_DISABLE_TASKS)).add_done_callback(lambda _: callback_finished.set())
+ await asyncio.wait_for(callback_finished.wait(), timeout=0.5)
+ await asyncio.sleep(0)
+ assert mod._DETACHED_DISABLE_TASKS == set()
+
+ @pytest.mark.asyncio
+ async def test_cancelled_rebind_detached_disable_has_external_gc_root(self) -> None:
+ old_interceptor = CDPDownloadInterceptor()
+ context = MagicMock()
+ context._skyvern_cdp_download_interceptor = old_interceptor
+ started = asyncio.Event()
+ entered_cancel = asyncio.Event()
+ release = asyncio.Event()
+
+ async def stuck_disable() -> None:
+ started.set()
+ try:
+ await asyncio.sleep(3600)
+ except asyncio.CancelledError:
+ entered_cancel.set()
+ await asyncio.wait_for(release.wait(), timeout=2)
+
+ old_interceptor.disable = stuck_disable # type: ignore[method-assign]
+ new_interceptor = CDPDownloadInterceptor()
+ new_ref = weakref.ref(new_interceptor)
+ binding = asyncio.create_task(new_interceptor.bind_to_context(context))
+ binding_ref = weakref.ref(binding)
+ await asyncio.wait_for(started.wait(), timeout=0.5)
+ binding.cancel()
+ with pytest.raises(asyncio.CancelledError):
+ await asyncio.wait_for(binding, timeout=0.5)
+ await asyncio.wait_for(entered_cancel.wait(), timeout=0.5)
+
+ detached_ref = weakref.ref(next(iter(mod._DETACHED_DISABLE_TASKS)))
+ del binding
+ del new_interceptor
+ await asyncio.sleep(0)
+ await asyncio.sleep(0)
+ gc.collect()
+
+ assert new_ref() is None
+ assert binding_ref() is None
+ assert detached_ref() is not None
+ assert len(mod._DETACHED_DISABLE_TASKS) == 1
+
+ callback_finished = asyncio.Event()
+ detached_ref().add_done_callback(lambda _: callback_finished.set()) # type: ignore[union-attr]
+ release.set()
+ await asyncio.wait_for(callback_finished.wait(), timeout=0.5)
+ await asyncio.sleep(0)
+ gc.collect()
+
+ assert mod._DETACHED_DISABLE_TASKS == set()
+ assert detached_ref() is None
+
+ @pytest.mark.asyncio
+ async def test_context_binding_same_interceptor_is_idempotent(self) -> None:
+ interceptor = CDPDownloadInterceptor()
+ context = MagicMock()
+ context._skyvern_cdp_download_interceptor = None
+
+ await asyncio.wait_for(interceptor.bind_to_context(context), timeout=0.5)
+ page_listener = context.on.call_args.args[1]
+ await asyncio.wait_for(interceptor.bind_to_context(context), timeout=0.5)
+ await asyncio.wait_for(interceptor.disable(), timeout=0.5)
+
+ context.on.assert_called_once_with("page", page_listener)
+ context.remove_listener.assert_called_once_with("page", page_listener)
+ assert context._skyvern_cdp_download_interceptor is None
+
+ @pytest.mark.asyncio
+ async def test_concurrent_context_rebinds_leave_only_last_listener(self) -> None:
+ old_interceptor = CDPDownloadInterceptor()
+ first_interceptor = CDPDownloadInterceptor()
+ second_interceptor = CDPDownloadInterceptor()
+ context = MagicMock()
+ context._skyvern_cdp_download_interceptor = old_interceptor
+ old_disable_started = asyncio.Event()
+ release_old_disable = asyncio.Event()
+ first_disable_started = asyncio.Event()
+ release_first_disable = asyncio.Event()
+
+ async def paused_old_disable() -> None:
+ old_disable_started.set()
+ await asyncio.wait_for(release_old_disable.wait(), timeout=2)
+
+ original_first_disable = first_interceptor.disable
+
+ async def paused_first_disable() -> None:
+ first_disable_started.set()
+ await asyncio.wait_for(release_first_disable.wait(), timeout=2)
+ await original_first_disable()
+
+ old_interceptor.disable = paused_old_disable # type: ignore[method-assign]
+ first_interceptor.disable = paused_first_disable # type: ignore[method-assign]
+
+ first_binding = asyncio.create_task(first_interceptor.bind_to_context(context))
+ await asyncio.wait_for(old_disable_started.wait(), timeout=0.5)
+ second_binding = asyncio.create_task(second_interceptor.bind_to_context(context))
+ await asyncio.sleep(0)
+ assert not second_binding.done()
+
+ release_old_disable.set()
+ await asyncio.wait_for(first_disable_started.wait(), timeout=0.5)
+ assert context._skyvern_cdp_download_interceptor is first_interceptor
+ first_listener = context.on.call_args_list[0].args[1]
+
+ release_first_disable.set()
+ await asyncio.wait_for(asyncio.gather(first_binding, second_binding), timeout=0.5)
+ second_listener = context.on.call_args_list[1].args[1]
+
+ assert context._skyvern_cdp_download_interceptor is second_interceptor
+ context.remove_listener.assert_called_once_with("page", first_listener)
+ assert first_interceptor._page_listener is None
+ assert not first_interceptor._accepting_pages
+ assert second_interceptor._page_listener is second_listener
+ assert second_interceptor._accepting_pages
+
+ @pytest.mark.asyncio
+ async def test_context_page_enable_failure_is_retrieved_and_logged(self) -> None:
+ interceptor = CDPDownloadInterceptor()
+ context = MagicMock()
+ context._skyvern_cdp_download_interceptor = None
+
+ with (
+ patch.object(interceptor, "enable_for_page", AsyncMock(side_effect=RuntimeError("sensitive detail"))),
+ capture_logs() as logs,
+ ):
+ await interceptor.bind_to_context(context)
+ page_listener = context.on.call_args.args[1]
+ page_listener(MagicMock())
+ await asyncio.sleep(0)
+ await asyncio.sleep(0)
+
+ matching_logs = [log for log in logs if log.get("event") == "Failed to enable CDP interception for page"]
+ assert matching_logs == [
+ {
+ "error_type": "RuntimeError",
+ "event": "Failed to enable CDP interception for page",
+ "log_level": "warning",
+ }
+ ]
+ assert not interceptor._page_enable_tasks
+
+ @pytest.mark.asyncio
+ async def test_disable_drains_admitted_fetch_handler(self) -> None:
+ interceptor = CDPDownloadInterceptor()
+ started = asyncio.Event()
+ release = asyncio.Event()
+ session = MagicMock(send=AsyncMock())
+
+ async def paused_handler(event: dict[str, Any], cdp_session: Any) -> None:
+ assert cdp_session is session
+ started.set()
+ await release.wait()
+
+ with patch.object(interceptor, "_handle_request_paused", side_effect=paused_handler):
+ interceptor._on_request_paused({"requestId": "request-1"}, session)
+ await started.wait()
+ disabling = asyncio.create_task(interceptor.disable())
+ await asyncio.sleep(0)
+ assert not disabling.done()
+ release.set()
+ await asyncio.wait_for(disabling, timeout=2)
+
+ assert not interceptor._cdp_handler_tasks
+
+
class TestDirectHttpDownloadAuthAndHtmlGuard:
"""_download_url_directly falls back from the cookie-sharing Playwright APIRequestContext to a
raw urllib fetch. That fallback must (1) still carry the browser session's cookies, and (2) not
@@ -1183,3 +2071,124 @@ class TestDirectHttpDownloadAuthAndHtmlGuard:
await interceptor._download_url_directly("https://site.example/page", "")
assert len(list(tmp_path.iterdir())) == 1
+
+
+class TestDownloadDirRebindDedup:
+ """SKY-12769: a persistent/adopted interceptor is reused across runs via set_download_dir.
+
+ Each captured URL in _downloaded_urls corresponds to a file already written into the previous
+ _output_dir, so the dedupe set is directory-scoped. A genuine dir change must drop it, or an
+ identical download in the new run's dir is skipped and its artifact goes missing. A same-dir
+ rebind must keep it so repeated events stay idempotent.
+ """
+
+ @pytest.mark.asyncio
+ async def test_data_url_reprocessed_after_dir_change(self, tmp_path: Path) -> None:
+ dir_a = tmp_path / "run_a"
+ dir_b = tmp_path / "run_b"
+ interceptor = CDPDownloadInterceptor(output_dir=str(dir_a))
+ event = {"url": "data:text/plain,hello", "suggestedFilename": "note.txt"}
+
+ await interceptor._handle_browser_download(event)
+ assert (dir_a / "note.txt").read_bytes() == b"hello"
+
+ interceptor.set_download_dir(str(dir_b))
+ await interceptor._handle_browser_download(event)
+ assert (dir_b / "note.txt").read_bytes() == b"hello"
+
+ await interceptor._handle_browser_download(event)
+ assert [path.name for path in dir_b.iterdir()] == ["note.txt"]
+
+ @pytest.mark.asyncio
+ async def test_same_dir_set_preserves_data_url_dedupe(self, tmp_path: Path) -> None:
+ interceptor = CDPDownloadInterceptor(output_dir=str(tmp_path))
+ event = {"url": "data:text/plain,hello", "suggestedFilename": "note.txt"}
+
+ await interceptor._handle_browser_download(event)
+ assert interceptor._download_index == 1
+
+ interceptor.set_download_dir(str(tmp_path))
+ await interceptor._handle_browser_download(event)
+
+ assert interceptor._download_index == 1
+ assert [path.name for path in tmp_path.iterdir()] == ["note.txt"]
+
+ def test_real_dir_change_clears_cross_path_dedupe(self, tmp_path: Path) -> None:
+ interceptor = CDPDownloadInterceptor(output_dir=str(tmp_path / "run_a"))
+ interceptor._downloaded_urls.update(
+ {"https://site.example/report.pdf", "blob:https://site.example/abc", "data:sha256:deadbeef"}
+ )
+
+ interceptor.set_download_dir(str(tmp_path / "run_b"))
+
+ assert interceptor._downloaded_urls == set()
+
+ def test_same_dir_set_preserves_cross_path_dedupe(self, tmp_path: Path) -> None:
+ interceptor = CDPDownloadInterceptor(output_dir=str(tmp_path))
+ seeded = {"https://site.example/report.pdf", "blob:https://site.example/abc"}
+ interceptor._downloaded_urls.update(seeded)
+
+ interceptor.set_download_dir(str(tmp_path))
+
+ assert interceptor._downloaded_urls == seeded
+
+ def test_first_dir_set_from_none_does_not_touch_dedupe(self, tmp_path: Path) -> None:
+ interceptor = CDPDownloadInterceptor()
+ assert interceptor._output_dir is None
+
+ interceptor.set_download_dir(str(tmp_path))
+
+ assert interceptor._downloaded_urls == set()
+ assert interceptor._output_dir == tmp_path
+
+ @pytest.mark.asyncio
+ async def test_in_flight_data_write_does_not_readd_identity_into_new_scope(self, tmp_path: Path) -> None:
+ """A data-URL write that began under dir A but publishes while a rebind to dir B is in flight
+ must not re-insert its identity into dir B's (freshly cleared) dedupe scope — the file landed
+ in dir A, so dir B could otherwise skip an identical download and miss its artifact."""
+ dir_a = tmp_path / "run_a"
+ dir_b = tmp_path / "run_b"
+ interceptor = CDPDownloadInterceptor(output_dir=str(dir_a))
+ event = {"url": "data:text/plain,hello", "suggestedFilename": "note.txt"}
+
+ entered_replace, release_replace, replace_patch = TestDataUrlDownloadCapture._paused_replace()
+ with replace_patch:
+ writing = asyncio.create_task(interceptor._handle_browser_download(event))
+ assert await asyncio.to_thread(entered_replace.wait, 2)
+ interceptor.set_download_dir(str(dir_b))
+ assert interceptor._downloaded_urls == set()
+ release_replace.set()
+ await asyncio.wait_for(writing, timeout=2)
+
+ assert (dir_a / "note.txt").read_bytes() == b"hello"
+ assert interceptor._downloaded_urls == set()
+
+ await interceptor._handle_browser_download(event)
+ assert (dir_b / "note.txt").read_bytes() == b"hello"
+ assert len(interceptor._downloaded_urls) == 1
+
+ await interceptor._handle_browser_download(event)
+ assert [path.name for path in dir_b.iterdir()] == ["note.txt"]
+
+ @pytest.mark.asyncio
+ async def test_mkdir_failure_then_same_dir_retry_clears_stale_dedupe_and_writes(self, tmp_path: Path) -> None:
+ """A failed mkdir during a real dir change must not leave the new scope carrying the prior
+ run's dedupe: the clear happens on scope assignment, before mkdir, so a same-dir retry
+ (dir_changed=False) still starts from an empty set and can write."""
+ interceptor = CDPDownloadInterceptor(output_dir=str(tmp_path / "run_a"))
+ interceptor._downloaded_urls.update({"https://site.example/report.pdf", "data:sha256:deadbeef"})
+ target = tmp_path / "run_b"
+ event = {"url": "data:text/plain,hello", "suggestedFilename": "note.txt"}
+
+ with patch.object(mod.Path, "mkdir", autospec=True, side_effect=OSError("disk full")):
+ with pytest.raises(OSError):
+ interceptor.set_download_dir(str(target))
+
+ assert interceptor._downloaded_urls == set()
+
+ interceptor.set_download_dir(str(target))
+ assert interceptor._downloaded_urls == set()
+
+ await interceptor._handle_browser_download(event)
+ assert (target / "note.txt").read_bytes() == b"hello"
+ assert len(interceptor._downloaded_urls) == 1
diff --git a/tests/unit/test_download_file_action_handler.py b/tests/unit/test_download_file_action_handler.py
index fd1ab317c..6bcf76a91 100644
--- a/tests/unit/test_download_file_action_handler.py
+++ b/tests/unit/test_download_file_action_handler.py
@@ -23,6 +23,7 @@ from skyvern.webeye.actions.handler import (
handle_download_file_action,
)
from skyvern.webeye.actions.responses import ActionFailure, ActionSuccess
+from skyvern.webeye.cdp_download_interceptor import CDPDownloadInterceptor
from skyvern.webeye.scraper.scraped_page import ScrapedPage
from tests.unit.helpers import make_organization, make_step, make_task
@@ -95,6 +96,7 @@ async def _run_false_click_observation(
app_mock = MagicMock()
storage = app_mock.STORAGE
storage.list_downloaded_files_in_browser_session = AsyncMock(return_value=[])
+ storage.list_downloading_files_in_browser_session = AsyncMock(return_value=[])
app_mock.BROWSER_MANAGER.get_for_task.return_value = scraped_page._browser_state
app_mock.DATABASE.workflow_params.create_action = AsyncMock(return_value=action)
@@ -698,6 +700,441 @@ def _make_download_click_context(
return task, step, page, browser_state, scraped_page, action
+async def test_handle_action_timeout_bounds_browser_download_handler_drain(
+ span_exporter: InMemorySpanExporter,
+) -> None:
+ now = datetime.now(UTC)
+ organization = make_organization(now)
+ task, step, page, browser_state, scraped_page, action = _make_download_click_context(
+ now=now,
+ organization=organization,
+ page_url="https://example.com/download",
+ )
+ task.download_timeout = 0.01
+ page.on.side_effect = lambda *args: None
+ interceptor = CDPDownloadInterceptor()
+ interceptor._accepting_browser_downloads = True
+ page.context._skyvern_cdp_download_interceptor = interceptor
+ handler_started = asyncio.Event()
+ never_release = asyncio.Event()
+
+ async def hanging_handler(event: dict[str, object]) -> None:
+ handler_started.set()
+ await never_release.wait()
+
+ with tempfile.TemporaryDirectory() as temp_root:
+ primary_dir = os.path.join(temp_root, "pbs-1")
+ os.makedirs(primary_dir)
+ staging_dir = os.path.join(temp_root, "staging")
+ os.makedirs(staging_dir)
+
+ async def mock_inner_handle_action(*args: object, **kwargs: object) -> list[ActionSuccess]:
+ interceptor._schedule_browser_download_handler({"url": "https://example.com/report.pdf"})
+ await handler_started.wait()
+ with open(os.path.join(primary_dir, "report.pdf"), "wb") as file:
+ file.write(b"ready")
+ return [ActionSuccess()]
+
+ mock_app = MagicMock()
+ mock_app.BROWSER_MANAGER.get_for_task.return_value = browser_state
+ mock_app.DATABASE.workflow_params.create_action = AsyncMock(return_value=action)
+ mock_app.STORAGE = MagicMock()
+ started_at = time.monotonic()
+
+ with (
+ patch.object(ActionHandler, "_handle_action", side_effect=mock_inner_handle_action),
+ patch.object(interceptor, "_handle_browser_download", side_effect=hanging_handler),
+ patch("skyvern.webeye.actions.handler.get_download_dir", return_value=primary_dir),
+ patch("skyvern.webeye.actions.handler.make_temp_directory", return_value=staging_dir),
+ patch(
+ "skyvern.webeye.actions.handler.skyvern_context.current",
+ return_value=MagicMock(run_id="pbs-1", download_suffix=None),
+ ),
+ patch(
+ "skyvern.webeye.actions.handler.check_downloading_files_and_wait_for_download_to_complete",
+ new=AsyncMock(),
+ ),
+ patch("skyvern.webeye.actions.handler.app", mock_app),
+ ):
+ with pytest.raises(TimeoutError):
+ await asyncio.wait_for(
+ ActionHandler.handle_action(
+ scraped_page=scraped_page,
+ task=task,
+ step=step,
+ page=page,
+ action=action,
+ ),
+ timeout=0.5,
+ )
+
+ assert time.monotonic() - started_at < 0.2
+ assert not interceptor._browser_download_tasks
+
+
+async def test_handle_action_download_completion_may_exceed_signal_budget(
+ span_exporter: InMemorySpanExporter,
+) -> None:
+ now = datetime.now(UTC)
+ organization = make_organization(now)
+ task, step, page, browser_state, scraped_page, action = _make_download_click_context(
+ now=now,
+ organization=organization,
+ page_url="https://example.com/download",
+ )
+ task.download_timeout = None
+
+ with tempfile.TemporaryDirectory() as temp_dir:
+
+ async def mock_inner_handle_action(*args: object, **kwargs: object) -> list[ActionSuccess]:
+ with open(os.path.join(temp_dir, "report.pdf"), "wb") as file:
+ file.write(b"ready")
+ return [ActionSuccess()]
+
+ async def slow_download_completion(**kwargs: object) -> None:
+ assert kwargs["timeout"] == 0.2
+ await asyncio.sleep(0.05)
+
+ mock_app = MagicMock()
+ mock_app.BROWSER_MANAGER.get_for_task.return_value = browser_state
+ mock_app.DATABASE.workflow_params.create_action = AsyncMock(return_value=action)
+ mock_app.STORAGE = MagicMock()
+ started_at = time.monotonic()
+
+ with (
+ patch.object(ActionHandler, "_handle_action", side_effect=mock_inner_handle_action),
+ patch("skyvern.webeye.actions.handler.BROWSER_DOWNLOAD_MAX_WAIT_TIME", 0.02),
+ patch("skyvern.webeye.actions.handler.BROWSER_DOWNLOAD_TIMEOUT", 0.2),
+ patch("skyvern.webeye.actions.handler.get_download_dir", return_value=temp_dir),
+ patch("skyvern.webeye.actions.handler.skyvern_context.current", return_value=None),
+ patch(
+ "skyvern.webeye.actions.handler.check_downloading_files_and_wait_for_download_to_complete",
+ new=AsyncMock(side_effect=slow_download_completion),
+ ),
+ patch("skyvern.webeye.actions.handler.app", mock_app),
+ ):
+ results = await asyncio.wait_for(
+ ActionHandler.handle_action(
+ scraped_page=scraped_page,
+ task=task,
+ step=step,
+ page=page,
+ action=action,
+ ),
+ timeout=0.5,
+ )
+
+ elapsed = time.monotonic() - started_at
+
+ assert elapsed >= 0.05
+ assert elapsed < 0.5
+ assert results[-1].download_triggered is True
+ assert results[-1].downloaded_files == ["report.pdf"]
+
+
+async def test_handle_action_crdownload_signal_enters_completion_before_reporting_final_artifact() -> None:
+ now = datetime.now(UTC)
+ organization = make_organization(now)
+ task, step, page, browser_state, scraped_page, action = _make_download_click_context(
+ now=now,
+ organization=organization,
+ page_url="https://example.com/download",
+ )
+ task.download_timeout = 0.05
+
+ with tempfile.TemporaryDirectory() as temp_dir:
+ partial_path = Path(temp_dir) / "report.pdf.crdownload"
+ final_path = Path(temp_dir) / "report.pdf"
+
+ async def mock_inner_handle_action(*args: object, **kwargs: object) -> list[ActionSuccess]:
+ partial_path.write_bytes(b"in progress")
+ return [ActionSuccess()]
+
+ async def complete_download(**kwargs: object) -> None:
+ assert kwargs["timeout"] == task.download_timeout
+ partial_path.rename(final_path)
+
+ mock_app = MagicMock()
+ mock_app.BROWSER_MANAGER.get_for_task.return_value = browser_state
+ mock_app.DATABASE.workflow_params.create_action = AsyncMock(return_value=action)
+ mock_app.STORAGE = MagicMock()
+ settle = AsyncMock(side_effect=complete_download)
+
+ with (
+ patch.object(ActionHandler, "_handle_action", side_effect=mock_inner_handle_action),
+ patch("skyvern.webeye.actions.handler.get_download_dir", return_value=temp_dir),
+ patch("skyvern.webeye.actions.handler.skyvern_context.current", return_value=None),
+ patch(
+ "skyvern.webeye.actions.handler.check_downloading_files_and_wait_for_download_to_complete",
+ new=settle,
+ ),
+ patch("skyvern.webeye.actions.handler.app", mock_app),
+ ):
+ results = await asyncio.wait_for(
+ ActionHandler.handle_action(
+ scraped_page=scraped_page,
+ task=task,
+ step=step,
+ page=page,
+ action=action,
+ ),
+ timeout=0.5,
+ )
+
+ settle.assert_awaited_once()
+ assert results[-1].download_triggered is True
+ assert results[-1].downloaded_files == ["report.pdf"]
+ assert "report.pdf.crdownload" not in results[-1].downloaded_files
+
+
+async def test_handle_action_remote_crdownload_signal_enters_completion_before_reporting_final_artifact() -> None:
+ now = datetime.now(UTC)
+ organization = make_organization(now)
+ task, step, page, browser_state, scraped_page, action = _make_download_click_context(
+ now=now,
+ organization=organization,
+ page_url="https://example.com/download",
+ )
+ task.browser_session_id = "bs-1"
+ task.download_timeout = 0.05
+ existing_partial_uri = "s3://bucket/browser_sessions/bs-1/downloads/existing.pdf.crdownload"
+ new_partial_uri = "s3://bucket/browser_sessions/bs-1/downloads/report.pdf.crdownload"
+ final_uri = "s3://bucket/browser_sessions/bs-1/downloads/report.pdf"
+ downloading_uris = [existing_partial_uri]
+ downloaded_uris: list[str] = []
+
+ async def mock_inner_handle_action(*args: object, **kwargs: object) -> list[ActionSuccess]:
+ downloading_uris.append(new_partial_uri)
+ return [ActionSuccess()]
+
+ async def complete_download(**kwargs: object) -> None:
+ assert kwargs["timeout"] == task.download_timeout
+ downloading_uris.remove(new_partial_uri)
+ downloaded_uris.append(final_uri)
+
+ mock_app = MagicMock()
+ mock_app.BROWSER_MANAGER.get_for_task.return_value = browser_state
+ mock_app.DATABASE.workflow_params.create_action = AsyncMock(return_value=action)
+ mock_app.STORAGE.list_downloaded_files_in_browser_session = AsyncMock(
+ side_effect=lambda **_: downloaded_uris.copy()
+ )
+ mock_app.STORAGE.list_downloading_files_in_browser_session = AsyncMock(
+ side_effect=lambda **_: downloading_uris.copy()
+ )
+ settle = AsyncMock(side_effect=complete_download)
+
+ with tempfile.TemporaryDirectory() as temp_dir:
+ with (
+ patch.object(ActionHandler, "_handle_action", side_effect=mock_inner_handle_action),
+ patch("skyvern.webeye.actions.handler.get_download_dir", return_value=temp_dir),
+ patch("skyvern.webeye.actions.handler.skyvern_context.current", return_value=None),
+ patch(
+ "skyvern.webeye.actions.handler.check_downloading_files_and_wait_for_download_to_complete",
+ new=settle,
+ ),
+ patch("skyvern.webeye.actions.handler.app", mock_app),
+ ):
+ results = await asyncio.wait_for(
+ ActionHandler.handle_action(
+ scraped_page=scraped_page,
+ task=task,
+ step=step,
+ page=page,
+ action=action,
+ ),
+ timeout=0.5,
+ )
+
+ settle.assert_awaited_once()
+ assert results[-1].download_triggered is True
+ assert results[-1].downloaded_files == ["report.pdf"]
+ assert all(not filename.endswith(".crdownload") for filename in results[-1].downloaded_files)
+
+
+async def test_handle_action_preexisting_remote_crdownload_does_not_signal_new_download() -> None:
+ now = datetime.now(UTC)
+ organization = make_organization(now)
+ task, step, page, browser_state, scraped_page, action = _make_download_click_context(
+ now=now,
+ organization=organization,
+ page_url="https://example.com/download",
+ )
+ task.browser_session_id = "bs-1"
+ task.download_timeout = 0.01
+ existing_partial_uri = "s3://bucket/browser_sessions/bs-1/downloads/existing.pdf.crdownload"
+ existing_final_uri = "s3://bucket/browser_sessions/bs-1/downloads/existing.pdf"
+ downloading_uris = [existing_partial_uri]
+ downloaded_uris: list[str] = []
+
+ async def mock_inner_handle_action(*args: object, **kwargs: object) -> list[ActionSuccess]:
+ downloading_uris.remove(existing_partial_uri)
+ downloaded_uris.append(existing_final_uri)
+ return [ActionSuccess()]
+
+ mock_app = MagicMock()
+ mock_app.BROWSER_MANAGER.get_for_task.return_value = browser_state
+ mock_app.DATABASE.workflow_params.create_action = AsyncMock(return_value=action)
+ mock_app.STORAGE.list_downloaded_files_in_browser_session = AsyncMock(
+ side_effect=lambda **_: downloaded_uris.copy()
+ )
+ mock_app.STORAGE.list_downloading_files_in_browser_session = AsyncMock(
+ side_effect=lambda **_: downloading_uris.copy()
+ )
+ settle = AsyncMock()
+
+ with tempfile.TemporaryDirectory() as temp_dir:
+ with (
+ patch.object(ActionHandler, "_handle_action", side_effect=mock_inner_handle_action),
+ patch("skyvern.webeye.actions.handler.get_download_dir", return_value=temp_dir),
+ patch("skyvern.webeye.actions.handler.skyvern_context.current", return_value=None),
+ patch(
+ "skyvern.webeye.actions.handler.check_downloading_files_and_wait_for_download_to_complete",
+ new=settle,
+ ),
+ patch("skyvern.webeye.actions.handler.app", mock_app),
+ ):
+ results = await asyncio.wait_for(
+ ActionHandler.handle_action(
+ scraped_page=scraped_page,
+ task=task,
+ step=step,
+ page=page,
+ action=action,
+ ),
+ timeout=0.5,
+ )
+
+ settle.assert_not_awaited()
+ assert results[-1].download_triggered is False
+ assert results[-1].downloaded_files is None
+
+
+async def test_handle_action_remote_snapshot_captures_partial_transition_before_completed_files() -> None:
+ now = datetime.now(UTC)
+ organization = make_organization(now)
+ task, step, page, browser_state, scraped_page, action = _make_download_click_context(
+ now=now,
+ organization=organization,
+ page_url="https://example.com/download",
+ )
+ task.browser_session_id = "bs-1"
+ task.download_timeout = 0.01
+ existing_partial_uri = "s3://bucket/browser_sessions/bs-1/downloads/existing.pdf.crdownload"
+ existing_final_uri = "s3://bucket/browser_sessions/bs-1/downloads/existing.pdf"
+ downloading_uris = [existing_partial_uri]
+ downloaded_uris: list[str] = []
+ transition_pending = True
+
+ async def list_downloaded_files(**_: object) -> list[str]:
+ nonlocal transition_pending
+ snapshot = downloaded_uris.copy()
+ if transition_pending:
+ transition_pending = False
+ downloading_uris.remove(existing_partial_uri)
+ downloaded_uris.append(existing_final_uri)
+ return snapshot
+
+ mock_app = MagicMock()
+ mock_app.BROWSER_MANAGER.get_for_task.return_value = browser_state
+ mock_app.DATABASE.workflow_params.create_action = AsyncMock(return_value=action)
+ mock_app.STORAGE.list_downloaded_files_in_browser_session = AsyncMock(side_effect=list_downloaded_files)
+ mock_app.STORAGE.list_downloading_files_in_browser_session = AsyncMock(
+ side_effect=lambda **_: downloading_uris.copy()
+ )
+ settle = AsyncMock()
+
+ with tempfile.TemporaryDirectory() as temp_dir:
+ with (
+ patch.object(ActionHandler, "_handle_action", new=AsyncMock(return_value=[ActionSuccess()])),
+ patch("skyvern.webeye.actions.handler.get_download_dir", return_value=temp_dir),
+ patch("skyvern.webeye.actions.handler.skyvern_context.current", return_value=None),
+ patch(
+ "skyvern.webeye.actions.handler.check_downloading_files_and_wait_for_download_to_complete",
+ new=settle,
+ ),
+ patch("skyvern.webeye.actions.handler.app", mock_app),
+ ):
+ results = await asyncio.wait_for(
+ ActionHandler.handle_action(
+ scraped_page=scraped_page,
+ task=task,
+ step=step,
+ page=page,
+ action=action,
+ ),
+ timeout=0.5,
+ )
+
+ settle.assert_not_awaited()
+ assert results[-1].download_triggered is False
+ assert results[-1].downloaded_files is None
+
+
+async def test_handle_action_download_completion_budget_bounds_hanging_settle(
+ span_exporter: InMemorySpanExporter,
+) -> None:
+ now = datetime.now(UTC)
+ organization = make_organization(now)
+ task, step, page, browser_state, scraped_page, action = _make_download_click_context(
+ now=now,
+ organization=organization,
+ page_url="https://example.com/download",
+ )
+ task.download_timeout = None
+
+ with tempfile.TemporaryDirectory() as temp_dir:
+
+ async def mock_inner_handle_action(*args: object, **kwargs: object) -> list[ActionSuccess]:
+ with open(os.path.join(temp_dir, "report.pdf"), "wb") as file:
+ file.write(b"ready")
+ return [ActionSuccess()]
+
+ async def hanging_download_completion(**kwargs: object) -> None:
+ assert kwargs["timeout"] == 0.03
+ await asyncio.Event().wait()
+
+ mock_app = MagicMock()
+ mock_app.BROWSER_MANAGER.get_for_task.return_value = browser_state
+ mock_app.DATABASE.workflow_params.create_action = AsyncMock(return_value=action)
+ mock_app.STORAGE = MagicMock()
+ started_at = time.monotonic()
+
+ with (
+ patch.object(ActionHandler, "_handle_action", side_effect=mock_inner_handle_action),
+ patch("skyvern.webeye.actions.handler.BROWSER_DOWNLOAD_MAX_WAIT_TIME", 0.01),
+ patch("skyvern.webeye.actions.handler.BROWSER_DOWNLOAD_TIMEOUT", 0.03),
+ patch("skyvern.webeye.actions.handler.get_download_dir", return_value=temp_dir),
+ patch("skyvern.webeye.actions.handler.skyvern_context.current", return_value=None),
+ patch(
+ "skyvern.webeye.actions.handler.check_downloading_files_and_wait_for_download_to_complete",
+ new=AsyncMock(side_effect=hanging_download_completion),
+ ),
+ patch("skyvern.webeye.actions.handler.app", mock_app),
+ ):
+ with pytest.raises(TimeoutError):
+ await asyncio.wait_for(
+ ActionHandler.handle_action(
+ scraped_page=scraped_page,
+ task=task,
+ step=step,
+ page=page,
+ action=action,
+ ),
+ timeout=0.5,
+ )
+
+ elapsed = time.monotonic() - started_at
+
+ assert elapsed < 0.2
+
+
def test_remove_download_listener_uses_playwright_remove_listener_when_off_unavailable() -> None:
page = MagicMock(spec=["remove_listener"])
callback = MagicMock()
@@ -1989,6 +2426,22 @@ async def test_handle_action_prefers_observed_file_over_download_event_copy(
page = MagicMock()
page.url = "https://example.com/download"
page.context.browser = None
+ settle_active = False
+ settle_count = 0
+
+ class _Settle:
+ async def __aenter__(self) -> None:
+ nonlocal settle_active, settle_count
+ settle_active = True
+ settle_count += 1
+
+ async def __aexit__(self, *args: object) -> None:
+ nonlocal settle_active
+ settle_active = False
+
+ interceptor = MagicMock()
+ interceptor.settle_browser_downloads.side_effect = _Settle
+ page.context._skyvern_cdp_download_interceptor = interceptor
download_callbacks: dict[str, Callable[[object], None]] = {}
page.on.side_effect = lambda event, callback: download_callbacks.__setitem__(event, callback)
@@ -2030,7 +2483,11 @@ async def test_handle_action_prefers_observed_file_over_download_event_copy(
mock_app.BROWSER_MANAGER.get_for_task.return_value = browser_state
mock_app.DATABASE.workflow_params.create_action = AsyncMock(return_value=action)
mock_app.STORAGE = MagicMock()
- wait_for_downloads = AsyncMock()
+
+ async def assert_wait_inside_settle(**kwargs: object) -> None:
+ assert settle_active
+
+ wait_for_downloads = AsyncMock(side_effect=assert_wait_inside_settle)
with (
patch.object(ActionHandler, "_handle_action", side_effect=mock_inner_handle_action),
@@ -2058,6 +2515,7 @@ async def test_handle_action_prefers_observed_file_over_download_event_copy(
assert action.download_triggered is True
assert action.downloaded_files == results[-1].downloaded_files
assert wait_for_downloads.await_count == 1
+ assert settle_count == 1
download.save_as.assert_not_awaited()
page.off.assert_called_once_with("download", download_callbacks["download"])
span_attrs = _download_wait_span_attrs(span_exporter)
@@ -2923,6 +3381,7 @@ async def test_handle_action_adopted_session_lands_download_via_eager_save(
mock_app.BROWSER_MANAGER.get_for_task.return_value = browser_state
mock_app.DATABASE.workflow_params.create_action = AsyncMock(return_value=action)
mock_app.STORAGE.list_downloaded_files_in_browser_session = AsyncMock(return_value=[])
+ mock_app.STORAGE.list_downloading_files_in_browser_session = AsyncMock(return_value=[])
wait_for_downloads = AsyncMock()
with (
@@ -3028,6 +3487,7 @@ async def test_handle_action_adopted_session_refetches_when_save_as_target_close
mock_app.BROWSER_MANAGER.get_for_task.return_value = browser_state
mock_app.DATABASE.workflow_params.create_action = AsyncMock(return_value=action)
mock_app.STORAGE.list_downloaded_files_in_browser_session = AsyncMock(return_value=[])
+ mock_app.STORAGE.list_downloading_files_in_browser_session = AsyncMock(return_value=[])
wait_for_downloads = AsyncMock()
with (
@@ -3147,6 +3607,7 @@ async def test_handle_action_adopted_session_falls_through_to_session_folder_whe
mock_app.BROWSER_MANAGER.get_for_task.return_value = browser_state
mock_app.DATABASE.workflow_params.create_action = AsyncMock(return_value=action)
mock_app.STORAGE.list_downloaded_files_in_browser_session = AsyncMock(side_effect=storage_side_effect)
+ mock_app.STORAGE.list_downloading_files_in_browser_session = AsyncMock(return_value=[])
wait_for_downloads = AsyncMock()
with (
@@ -3249,6 +3710,7 @@ async def test_handle_action_adopted_session_helper_failure_does_not_short_circu
mock_app.BROWSER_MANAGER.get_for_task.return_value = browser_state
mock_app.DATABASE.workflow_params.create_action = AsyncMock(return_value=action)
mock_app.STORAGE.list_downloaded_files_in_browser_session = AsyncMock(return_value=[])
+ mock_app.STORAGE.list_downloading_files_in_browser_session = AsyncMock(return_value=[])
wait_for_downloads = AsyncMock()
with (
@@ -3361,6 +3823,7 @@ async def test_handle_action_adopted_session_xhr_staging_recovered_when_helper_f
mock_app.BROWSER_MANAGER.get_for_task.return_value = browser_state
mock_app.DATABASE.workflow_params.create_action = AsyncMock(return_value=action)
mock_app.STORAGE.list_downloaded_files_in_browser_session = AsyncMock(return_value=[])
+ mock_app.STORAGE.list_downloading_files_in_browser_session = AsyncMock(return_value=[])
wait_for_downloads = AsyncMock()
with (
diff --git a/tests/unit/test_remote_cdp_driver_release.py b/tests/unit/test_remote_cdp_driver_release.py
index b6a9c775d..b85d15431 100644
--- a/tests/unit/test_remote_cdp_driver_release.py
+++ b/tests/unit/test_remote_cdp_driver_release.py
@@ -13,6 +13,7 @@ browsers shared across parent/child runs) must NOT have their driver stopped.
from __future__ import annotations
import asyncio
+import time
from unittest.mock import AsyncMock, MagicMock, call
import pytest
@@ -26,6 +27,7 @@ from skyvern.webeye.browser_engine import (
BrowserEngineSelection,
BrowserSourceNotSupportedByEngine,
)
+from skyvern.webeye.cdp_download_interceptor import CDPDownloadInterceptor
from skyvern.webeye.real_browser_manager import RealBrowserManager, _EngineSelectionOwner, canonical_run_key
from skyvern.webeye.real_browser_state import RealBrowserState
@@ -39,6 +41,7 @@ def _pw_stub() -> MagicMock:
def _context_stub() -> MagicMock:
context = MagicMock()
context.close = AsyncMock()
+ context._skyvern_cdp_download_interceptor = None
return context
@@ -67,6 +70,87 @@ async def test_close_keeps_driver_by_default_when_browser_kept() -> None:
context.close.assert_not_awaited()
+async def test_close_reused_context_preserves_download_interceptor() -> None:
+ pw = _pw_stub()
+ context = _context_stub()
+ interceptor = MagicMock(disable=AsyncMock())
+ context._skyvern_cdp_download_interceptor = interceptor
+ state = RealBrowserState(pw=pw, browser_context=context)
+
+ await state.close(close_browser_on_completion=False)
+
+ interceptor.disable.assert_not_awaited()
+ assert context._skyvern_cdp_download_interceptor is interceptor
+ context.close.assert_not_awaited()
+
+
+async def test_close_context_disables_download_interceptor_once() -> None:
+ context = _context_stub()
+ context.cookies = AsyncMock(return_value=[])
+ interceptor = MagicMock(disable=AsyncMock())
+ context._skyvern_cdp_download_interceptor = interceptor
+ state = RealBrowserState(pw=_pw_stub(), browser_context=context)
+
+ await state.close(close_browser_on_completion=True)
+ await state.close(close_browser_on_completion=True)
+
+ interceptor.disable.assert_awaited_once()
+
+
+async def test_close_true_timeout_bounds_interceptor_drain_and_cleans_suspended_task(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ pw = _pw_stub()
+ context = _context_stub()
+ interceptor = CDPDownloadInterceptor()
+ interceptor._accepting_browser_downloads = True
+ context._skyvern_cdp_download_interceptor = interceptor
+ started = asyncio.Event()
+ cancelled = asyncio.Event()
+ release = asyncio.Event()
+ cleaned = asyncio.Event()
+
+ async def suspended_handler(event: dict[str, object]) -> None:
+ started.set()
+ try:
+ await asyncio.Event().wait()
+ except asyncio.CancelledError:
+ cancelled.set()
+ await release.wait()
+ finally:
+ cleaned.set()
+
+ monkeypatch.setattr("skyvern.webeye.real_browser_state.BROWSER_INTERCEPTOR_DISABLE_TIMEOUT", 0.05)
+ monkeypatch.setattr("skyvern.webeye.real_browser_state.BROWSER_CLOSE_TIMEOUT", 0.05)
+ monkeypatch.setattr(interceptor, "_handle_browser_download", suspended_handler)
+ interceptor._schedule_browser_download_handler({"url": "https://example.test/download"})
+ await started.wait()
+
+ start = time.monotonic()
+ state = RealBrowserState(pw=pw, browser_context=context)
+ result = await asyncio.wait_for(state.close(True), timeout=0.5)
+ elapsed = time.monotonic() - start
+
+ assert result is None
+ assert elapsed < 0.5
+ await asyncio.wait_for(cancelled.wait(), timeout=0.5)
+ assert not cleaned.is_set()
+ assert len(interceptor._browser_download_tasks) == 1
+ assert context._skyvern_cdp_download_interceptor is None
+ # The bounded interceptor drain is detached independently, so later teardown steps
+ # (context close, driver stop) still run instead of being starved by the stuck drain.
+ context.close.assert_awaited_once()
+ pw.stop.assert_awaited_once()
+
+ release.set()
+ await asyncio.wait_for(cleaned.wait(), timeout=0.5)
+ await asyncio.sleep(0)
+ assert not interceptor._browser_download_tasks
+
+
@pytest.mark.asyncio
async def test_close_release_driver_override_preserves_reuse() -> None:
"""An explicit release_driver=False wins over the creation-time marker."""
@@ -91,6 +175,230 @@ async def test_close_true_still_stops_driver_and_context() -> None:
context.close.assert_awaited_once()
+async def test_close_true_cancellation_resistant_interceptor_disable_still_runs_provider_cleanup(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ # The paid-provider cleanup must still be attempted exactly once even when disabling the
+ # download interceptor is cancellation-resistant (ignores the cancel it receives when its
+ # budget is exhausted). close() must return within an outer watchdog, and the stuck drain
+ # must stay owned (its eventual exception retrieved) rather than orphaned.
+ monkeypatch.setattr("skyvern.webeye.real_browser_state.BROWSER_INTERCEPTOR_DISABLE_TIMEOUT", 0.05)
+ pw = _pw_stub()
+ context = _context_stub()
+ context.cookies = AsyncMock(return_value=[])
+ cleanup = AsyncMock()
+
+ started = asyncio.Event()
+ entered_cancel = asyncio.Event()
+ release = asyncio.Event()
+
+ async def stuck_disable(_ctx: object) -> None:
+ started.set()
+ try:
+ await asyncio.sleep(3600)
+ except asyncio.CancelledError:
+ entered_cancel.set()
+ await release.wait() # cancellation-resistant: ignore the cancel until released
+ raise RuntimeError("drain boom after detach")
+
+ monkeypatch.setattr("skyvern.webeye.real_browser_state.disable_download_interceptor_for_context", stuck_disable)
+
+ unretrieved: list[dict] = []
+ loop = asyncio.get_running_loop()
+ previous_handler = loop.get_exception_handler()
+ loop.set_exception_handler(lambda _loop, context_: unretrieved.append(context_))
+ try:
+ state = RealBrowserState(pw=pw, browser_context=context, browser_cleanup=cleanup)
+ start = time.monotonic()
+ await asyncio.wait_for(state.close(True), timeout=1.0)
+ elapsed = time.monotonic() - start
+
+ assert elapsed < 1.0
+ cleanup.assert_awaited_once() # provider cleanup ran despite the stuck drain
+ context.close.assert_awaited_once()
+ pw.stop.assert_awaited_once()
+
+ await asyncio.wait_for(entered_cancel.wait(), timeout=1.0) # the drain was cancelled (best-effort reclaim)
+ release.set()
+ await asyncio.sleep(0) # let the detached drain finish and its done-callback retrieve the exception
+ await asyncio.sleep(0)
+ finally:
+ loop.set_exception_handler(previous_handler)
+
+ assert not any("never retrieved" in str(c.get("message", "")) for c in unretrieved)
+
+
+async def test_close_true_detached_teardown_task_is_strongly_held_until_completion(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ # A detached, cancellation-resistant teardown phase must be strongly referenced for its whole
+ # remaining life: asyncio only holds tasks weakly, so without an owner set a still-pending drain
+ # could be GC'd ("Task was destroyed but it is pending!"). It must be in the owner set right after
+ # detach and gone only once it actually completes — leaking neither a task nor an exception.
+ monkeypatch.setattr("skyvern.webeye.real_browser_state.BROWSER_INTERCEPTOR_DISABLE_TIMEOUT", 0.05)
+ pw = _pw_stub()
+ context = _context_stub()
+ context.cookies = AsyncMock(return_value=[])
+ cleanup = AsyncMock()
+
+ entered_cancel = asyncio.Event()
+ release = asyncio.Event()
+
+ async def stuck_disable(_ctx: object) -> None:
+ try:
+ await asyncio.sleep(3600)
+ except asyncio.CancelledError:
+ entered_cancel.set()
+ await release.wait() # cancellation-resistant: outlive close()
+ raise RuntimeError("drain boom after detach")
+
+ monkeypatch.setattr("skyvern.webeye.real_browser_state.disable_download_interceptor_for_context", stuck_disable)
+
+ unretrieved: list[dict] = []
+ loop = asyncio.get_running_loop()
+ previous_handler = loop.get_exception_handler()
+ loop.set_exception_handler(lambda _loop, context_: unretrieved.append(context_))
+ try:
+ state = RealBrowserState(pw=pw, browser_context=context, browser_cleanup=cleanup)
+ await asyncio.wait_for(state.close(True), timeout=1.0)
+
+ await asyncio.wait_for(entered_cancel.wait(), timeout=1.0)
+ assert len(state._detached_teardown_tasks) == 1 # detached drain is strongly held while pending
+
+ release.set()
+ detached = next(iter(state._detached_teardown_tasks))
+ await asyncio.wait_for(asyncio.shield(asyncio.gather(detached, return_exceptions=True)), timeout=1.0)
+ await asyncio.sleep(0) # let the done-callback discard the finished task
+
+ assert state._detached_teardown_tasks == set() # discarded only after it actually completed
+ finally:
+ loop.set_exception_handler(previous_handler)
+
+ assert not any("never retrieved" in str(c.get("message", "")) for c in unretrieved)
+
+
+async def test_close_true_context_close_hang_does_not_suppress_provider_cleanup(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ # A hung context close must not starve the paid-provider cleanup: the context-teardown phase is
+ # bounded independently, so cleanup still runs exactly once after the teardown budget elapses.
+ monkeypatch.setattr("skyvern.webeye.real_browser_state.BROWSER_CLOSE_TIMEOUT", 0.05)
+ pw = _pw_stub()
+ context = _context_stub()
+ context.cookies = AsyncMock(return_value=[])
+
+ async def hang(*_a: object, **_k: object) -> None:
+ await asyncio.sleep(3600)
+
+ context.close = AsyncMock(side_effect=hang)
+ cleanup = AsyncMock()
+ state = RealBrowserState(pw=pw, browser_context=context, browser_cleanup=cleanup)
+
+ await asyncio.wait_for(state.close(True), timeout=1.0)
+
+ cleanup.assert_awaited_once()
+ pw.stop.assert_awaited_once()
+
+
+async def test_close_true_persist_cookies_failure_does_not_suppress_provider_cleanup(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ # A raising cookie-persistence step (an "earlier teardown callback raises") must not suppress cleanup.
+ pw = _pw_stub()
+ context = _context_stub()
+ monkeypatch.setattr(
+ "skyvern.webeye.real_browser_state.persist_session_cookies",
+ AsyncMock(side_effect=RuntimeError("persist boom")),
+ )
+ cleanup = AsyncMock()
+ state = RealBrowserState(
+ pw=pw,
+ browser_context=context,
+ browser_artifacts=BrowserArtifacts(browser_session_dir="/tmp/does-not-need-to-exist"),
+ browser_cleanup=cleanup,
+ )
+
+ await state.close(close_browser_on_completion=True)
+
+ cleanup.assert_awaited_once()
+ pw.stop.assert_awaited_once()
+
+
+async def test_close_true_browser_cleanup_exception_is_handled_not_leaked() -> None:
+ # A raising provider cleanup must be caught (best-effort teardown) and must not leak or block driver stop.
+ pw = _pw_stub()
+ context = _context_stub()
+ context.cookies = AsyncMock(return_value=[])
+ cleanup = AsyncMock(side_effect=RuntimeError("cleanup boom"))
+ state = RealBrowserState(pw=pw, browser_context=context, browser_cleanup=cleanup)
+
+ await state.close(close_browser_on_completion=True) # must not raise
+
+ cleanup.assert_awaited_once()
+ pw.stop.assert_awaited_once()
+
+
+async def test_close_true_runs_teardown_phases_in_order() -> None:
+ pw = _pw_stub()
+ context = _context_stub()
+ context.cookies = AsyncMock(return_value=[])
+ cleanup = AsyncMock()
+ interceptor = MagicMock(disable=AsyncMock())
+ context._skyvern_cdp_download_interceptor = interceptor
+ state = RealBrowserState(pw=pw, browser_context=context, browser_cleanup=cleanup)
+
+ order: list[str] = []
+ callback = AsyncMock(side_effect=lambda: order.append("callback"))
+ state.add_on_close(callback)
+ interceptor.disable.side_effect = lambda: order.append("disable_interceptor")
+ context.close.side_effect = lambda: order.append("context_close")
+ cleanup.side_effect = lambda: order.append("browser_cleanup")
+ pw.stop.side_effect = lambda: order.append("stop_driver")
+
+ await state.close(close_browser_on_completion=True)
+
+ assert order == ["disable_interceptor", "callback", "context_close", "browser_cleanup", "stop_driver"]
+
+
+async def test_close_false_preserves_reuse_and_does_not_invoke_cleanup() -> None:
+ pw = _pw_stub()
+ context = _context_stub()
+ interceptor = MagicMock(disable=AsyncMock())
+ context._skyvern_cdp_download_interceptor = interceptor
+ cleanup = AsyncMock()
+ state = RealBrowserState(pw=pw, browser_context=context, browser_cleanup=cleanup)
+
+ await state.close(close_browser_on_completion=False)
+
+ cleanup.assert_not_awaited()
+ interceptor.disable.assert_not_awaited()
+ context.close.assert_not_awaited()
+ pw.stop.assert_not_awaited()
+ assert context._skyvern_cdp_download_interceptor is interceptor
+
+
+async def test_close_true_runs_provider_cleanup_exactly_once_across_reentry() -> None:
+ # Re-entrant close() must not stop/delete the paid provider a second time (avoid double-cleanup).
+ pw = _pw_stub()
+ context = _context_stub()
+ context.cookies = AsyncMock(return_value=[])
+ cleanup = AsyncMock()
+ state = RealBrowserState(pw=pw, browser_context=context, browser_cleanup=cleanup)
+
+ await state.close(close_browser_on_completion=True)
+ await state.close(close_browser_on_completion=True)
+
+ cleanup.assert_awaited_once()
+
+
def _patch_create_browser_state(
monkeypatch: pytest.MonkeyPatch,
pw: MagicMock,