Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
Capture inline data URL downloads as files (#7651)
LawyZheng80da8adec58c
diff --git a/skyvern/constants.py b/skyvern/constants.pyindex b6df92a0a..d129d05c5 100644--- a/skyvern/constants.py+++ b/skyvern/constants.py@@ -16,6 +16,10 @@ INPUT_TEXT_TIMEOUT = 120000 # 2 minutesPAGE_CONTENT_TIMEOUT = 300 # 5 minsBROWSER_PAGE_CLOSE_TIMEOUT = 5 # 5 secondsBROWSER_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 secondsBROWSER_DOWNLOAD_MAX_WAIT_TIME = 120 # 2 minuteBROWSER_DOWNLOAD_NO_SIGNAL_GRACE_TIME = 120 # 2 minuteBROWSER_DOWNLOAD_TIMEOUT = 600 # 10 minutediff --git a/skyvern/forge/agent.py b/skyvern/forge/agent.pyindex 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, ActionSuccessfrom 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, ScrapedPagefrom 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 Noneasync with asyncio.timeout(SAVE_DOWNLOADED_FILES_TIMEOUT):+ async with settle_browser_downloads_for_context(browser_context):+ passif 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.pyindex 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_worldfrom 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_sessionreturn filesasync 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 = Truebreak- 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 = Truebreakif 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 = Trueaction.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_namesif xhr_fallback_moved_paths:diff --git a/skyvern/webeye/browser_factory.py b/skyvern/webeye/browser_factory.pyindex 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_contextfrom skyvern.webeye.dialog_handler import set_dialog_handlerfrom 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.pyindex 66fdd51e8..67b1262a4 100644--- a/skyvern/webeye/cdp_download_interceptor.py+++ b/skyvern/webeye/cdp_download_interceptor.py@@ -20,11 +20,17 @@ from __future__ import annotationsimport asyncioimport base64+import binascii+import hashlib+import inspect+import osimport reimport sslimport timeimport urllib.requestimport uuid+from collections.abc import AsyncIterator, Coroutine+from contextlib import asynccontextmanagerfrom pathlib import Pathfrom typing import Anyfrom urllib.parse import unquote, urlparse@@ -32,10 +38,32 @@ from urllib.parse import unquote, urlparseimport structlogfrom playwright.async_api import Browser, BrowserContext, CDPSession, Page+from skyvern.constants import BROWSER_DOWNLOADING_SUFFIX, BROWSER_INTERCEPTOR_DISABLE_TIMEOUTfrom skyvern.webeye.utils.page import SkyvernFrameLOG = 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 streamingIO_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 = Noneself._browser_session: CDPSession | None = Noneself._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 = Truedef 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 receiveproxy 407 challenges via Fetch.authRequired."""+ self._accepting_cdp_handlers = Truecdp_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'sAPIRequestContext (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()+ raiseasync 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 = Falsetry: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:passself._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:+ passself._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 = Noneself._enabled = FalseLOG.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:passreturn 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 bindingdiff --git a/skyvern/webeye/real_browser_state.py b/skyvern/webeye/real_browser_state.pyindex dee26e46e..5b55c234b 100644--- a/skyvern/webeye/real_browser_state.py+++ b/skyvern/webeye/real_browser_state.py@@ -11,7 +11,12 @@ import structlogfrom playwright.async_api import BrowserContext, Page, Playwright, async_playwrightfrom 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 BrowserArtifactsfrom skyvern.webeye.browser_engine import BrowserEngineSelectionfrom skyvern.webeye.browser_factory import BrowserCleanupFunc, BrowserContextFactoryfrom skyvern.webeye.browser_state import BrowserState+from skyvern.webeye.cdp_download_interceptor import disable_download_interceptor_for_contextfrom skyvern.webeye.navigation import is_permanent_navigation_error, navigate_with_retryfrom skyvern.webeye.scraper import scraperfrom 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_closeLOG.info("Closing browser state", sampling=True)- # Only fire on-close observers on a real teardown. Shared / parent-child- # close calls pass ``close_browser_on_completion=False`` to leave the- # 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 = Nonetry: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.pyindex 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 asyncioimport osfrom types import SimpleNamespacefrom 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.asyncioasync 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.asyncioasync 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_pawith (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_stwith (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_pathwith (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.pyindex 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 weakreffrom pathlib import Path+from typing import Anyfrom unittest.mock import AsyncMock, MagicMock, patchimport pytest+from structlog.testing import capture_logs+import skyvern.webeye.cdp_download_interceptor as modfrom skyvern.webeye.cdp_download_interceptor import (CDPDownloadInterceptor,_is_stale_interception_error,@@ -634,6 +641,28 @@ class TestCDPDownloadInterceptorProxyAuth:assert "Fetch.requestPaused" in event_namesassert "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.asyncioasync 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.asyncioasync 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 araw 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) == 1diff --git a/tests/unit/test_download_file_action_handler.py b/tests/unit/test_download_file_action_handler.pyindex 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 CDPDownloadInterceptorfrom skyvern.webeye.scraper.scraped_page import ScrapedPagefrom 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.STORAGEstorage.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_stateapp_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 = interceptordownload_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_statemock_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 Trueassert action.downloaded_files == results[-1].downloaded_filesassert wait_for_downloads.await_count == 1+ assert settle_count == 1download.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_statemock_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_closemock_app.BROWSER_MANAGER.get_for_task.return_value = browser_statemock_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_whemock_app.BROWSER_MANAGER.get_for_task.return_value = browser_statemock_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_circumock_app.BROWSER_MANAGER.get_for_task.return_value = browser_statemock_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_fmock_app.BROWSER_MANAGER.get_for_task.return_value = browser_statemock_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.pyindex 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 annotationsimport asyncio+import timefrom unittest.mock import AsyncMock, MagicMock, callimport pytest@@ -26,6 +27,7 @@ from skyvern.webeye.browser_engine import (BrowserEngineSelection,BrowserSourceNotSupportedByEngine,)+from skyvern.webeye.cdp_download_interceptor import CDPDownloadInterceptorfrom skyvern.webeye.real_browser_manager import RealBrowserManager, _EngineSelectionOwner, canonical_run_keyfrom 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 = Nonereturn 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.asyncioasync 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,