Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
Check in five dead Datadog log monitors before any delete (#8310)
Aaron Perez6e45f504d507
diff --git a/skyvern/webeye/cdp_download_interceptor.py b/skyvern/webeye/cdp_download_interceptor.pyindex 78d550e12..ddc27fc81 100644--- a/skyvern/webeye/cdp_download_interceptor.py+++ b/skyvern/webeye/cdp_download_interceptor.py@@ -30,6 +30,7 @@ import statimport threadingimport timeimport uuid+from collections import OrderedDictfrom collections.abc import AsyncIterator, Callable, Coroutinefrom contextlib import asynccontextmanagerfrom dataclasses import dataclass@@ -61,6 +62,7 @@ if TYPE_CHECKING:from skyvern.forge.sdk.core.http_request_authorization import RedirectHopAuthorizerLOG = structlog.get_logger()+RECOVERY_MARKER_HEADER = "x-skyvern-recovery-marker"CDP_DOWNLOAD_HTTP_SINK_KIND = "browser.download.http"@@ -131,6 +133,9 @@ STREAM_IO_READ_CHUNK_SIZE = 256 * 1024 # 256 KiB# treated as dead so the extraction aborts instead of holding the lock forever (which would deadlock later# captures and hang teardown's task drain).STREAM_IO_READ_TIMEOUT_SECONDS = 120.0+# Bound same-origin browser fetches used to recover downloads independently of the generic+# browser action timeout; valid authenticated transfers may take longer than five seconds.+DOWNLOAD_RECOVERY_TIMEOUT_MS = 30_000@dataclass@@ -627,6 +632,9 @@ class CDPDownloadInterceptor:- Response download → extract body → save to disk → Fetch.fulfillRequest"""+ _MAX_ACTIVE_RECOVERY_MARKERS = 64+ _MAX_RECOVERY_REQUEST_IDS = 128+def __init__(self,output_dir: str | None = None,@@ -642,6 +650,11 @@ class CDPDownloadInterceptor:self._download_directory_identities: dict[Path, tuple[int, int]] = {}self._proxy_username: str | None = proxy_usernameself._proxy_password: str | None = proxy_password+ self._recovery_marker = uuid.uuid4().hex+ self._active_recovery_markers: set[str] = set()+ # Recovery execution is serialized per interceptor; this tracks markers owned by the+ # encompassing helper call while it retries across pages.+ self._active_recovery_call_markers: set[str] = set()self._network_egress_monitor = network_egress_monitorself._redirect_hop_authorizer = redirect_hop_authorizerself._download_scope = (@@ -651,6 +664,7 @@ class CDPDownloadInterceptor:)self._cdp_sessions: list[CDPSession] = []self._active_request_interceptors: dict[CDPSession, tuple[Page, Callable[[Page], None]]] = {}+ self._recovery_request_ids: OrderedDict[tuple[CDPSession, str], str] = OrderedDict()self._enrolling_pages: list[Page] = []self._enabled = Falseself._download_index = 0@@ -933,6 +947,7 @@ class CDPDownloadInterceptor:)self._artifact_scope_generation += 1self._artifact_scope_valid = True+ self._recovery_marker = uuid.uuid4().hexif dir_changed:self._downloaded_urls.clear()self._reset_download_accounting()@@ -955,6 +970,46 @@ class CDPDownloadInterceptor:def _artifact_scope_is_active(self, generation: int) -> bool:return self._artifact_scope_valid and generation == self._artifact_scope_generation+ def _register_recovery_marker(self, marker: str) -> bool:+ if marker in self._active_recovery_markers:+ return True+ if len(self._active_recovery_markers) >= self._MAX_ACTIVE_RECOVERY_MARKERS:+ LOG.warning("Recovery marker capacity exhausted; denying new recovery")+ return False+ self._active_recovery_markers.add(marker)+ return True++ def _register_recovery_request(self, session: CDPSession, request_id: str, marker: str) -> bool:+ key = (session, request_id)+ if key in self._recovery_request_ids:+ return self._recovery_request_ids[key] == marker+ if len(self._recovery_request_ids) >= self._MAX_RECOVERY_REQUEST_IDS:+ LOG.warning("Recovery request capacity exhausted; denying new recovery")+ return False+ self._recovery_request_ids[key] = marker+ return True++ def _discard_recovery_request(self, session: CDPSession, request_id: str) -> None:+ marker = self._recovery_request_ids.pop((session, request_id), None)+ if (+ marker is not None+ and marker not in self._recovery_request_ids.values()+ and marker not in self._active_recovery_call_markers+ ):+ self._active_recovery_markers.discard(marker)++ def _discard_unowned_recovery_marker(self, marker: str) -> None:+ """Release a marker that was never associated with a paused request."""+ if marker not in self._recovery_request_ids.values() and marker not in self._active_recovery_call_markers:+ self._active_recovery_markers.discard(marker)++ def _drop_session_recovery_state(self, session: CDPSession) -> None:+ for key in [k for k in self._recovery_request_ids if k[0] is session]:+ self._recovery_request_ids.pop(key)+ for marker in tuple(self._active_recovery_markers):+ if marker not in self._recovery_request_ids.values() and marker not in self._active_recovery_call_markers:+ self._active_recovery_markers.discard(marker)+@propertydef download_scope(self) -> str | None:"""Return the currently enrolled run scope for ownership-bound consumers."""@@ -1078,6 +1133,7 @@ class CDPDownloadInterceptor:def _unregister_active_request_interceptor(self, cdp_session: CDPSession) -> None:registration = self._active_request_interceptors.pop(cdp_session, None)+ self._drop_session_recovery_state(cdp_session)if registration is None:returnpage, close_listener = registration@@ -1668,6 +1724,31 @@ class CDPDownloadInterceptor:normalized_filename = normalize_download_filename(response_filename, content_type)if _payload_is_html_login_masquerade(data, content_type, normalized_filename):+ # A browser-context fetch preserves same-origin session/request state; retain the+ # masquerade guard if recovery is unavailable or returns HTML.+ if artifact_scope_generation is None:+ artifact_scope_generation = self._artifact_scope_generation+ recovered = await self._fetch_download_bytes_in_page(url, recovery_allowance_bytes=remaining_run_bytes)+ if not self._artifact_scope_is_active(artifact_scope_generation):+ return+ if recovered is not None and not _body_starts_with_html(recovered):+ # The masquerade bytes were reserved above; release them before reserving the real+ # payload so this attempt is charged against the run-size budget only once.+ self._run_download_bytes -= len(data)+ if not self._reserve_download_bytes(attempt, len(recovered)):+ return+ save_path, filename = self._resolve_save_path(suggested_filename)+ self._atomically_write_bytes(save_path, recovered, artifact_scope_generation)+ LOG.info(+ "CDP download saved (in-page same-origin fetch)",+ filename_fp=diagnostic_fingerprint(filename),+ size=len(recovered),+ save_path_fp=diagnostic_fingerprint(str(save_path)),+ download_index=self._download_index,+ method="in_page_same_origin_fetch",+ )+ self._record_download_saved(attempt)+ returnLOG.error("Direct download returned an HTML page for a non-HTML file; not saving ""(likely an unauthenticated fetch landing on a login/session-gate page)",@@ -1717,6 +1798,60 @@ class CDPDownloadInterceptor:parts.append(f"{name}={value}")return "; ".join(parts)+ async def _fetch_download_bytes_in_page(+ self, url: str, recovery_allowance_bytes: int | None = None+ ) -> bytes | None:+ """Read bytes through a same-origin HTTPS browser-context fetch, failing closed."""+ if self._browser_context is None:+ return None+ if urlparse(url).scheme.lower() != "https":+ return None+ remaining_run_bytes = MAX_RUN_DOWNLOAD_BYTES - self._run_download_bytes+ max_size_bytes = min(+ MAX_FILE_SIZE_BYTES,+ recovery_allowance_bytes if recovery_allowance_bytes is not None else remaining_run_bytes,+ )+ if max_size_bytes < 1:+ return None+ call_owned_recovery_markers: set[str] = set()+ try:+ for page in list(self._browser_context.pages):+ active_session = next(+ (+ session+ for session, (registered_page, _) in self._active_request_interceptors.items()+ if registered_page is page+ ),+ None,+ )+ recovery_marker: str | None = self._recovery_marker if active_session is not None else None+ if recovery_marker is not None:+ if not self._register_recovery_marker(recovery_marker):+ continue+ self._active_recovery_call_markers.add(recovery_marker)+ call_owned_recovery_markers.add(recovery_marker)+ try:+ data = await SkyvernFrame.read_http_url_bytes(+ page=page,+ url=url,+ max_size_bytes=max_size_bytes,+ timeout_ms=DOWNLOAD_RECOVERY_TIMEOUT_MS,+ headers={RECOVERY_MARKER_HEADER: recovery_marker} if recovery_marker is not None else None,+ redirect="error",+ )+ except asyncio.CancelledError:+ raise+ except Exception:+ LOG.debug("same-origin download recovery failed for browser page", exc_info=True)+ continue+ if data is not None and not _body_starts_with_html(data):+ return data+ finally:+ for marker in call_owned_recovery_markers:+ self._active_recovery_call_markers.discard(marker)+ self._discard_unowned_recovery_marker(marker)+ return None+async def _download_blob_url(self,url: str,@@ -1802,11 +1937,44 @@ class CDPDownloadInterceptor:except Exception:passself._page_listener = None- self._accepting_cdp_handlers = False+ 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++ detach_cancellation: asyncio.CancelledError | None = Nonetry:await self._drain_tasks(self._page_enable_tasks)+ except asyncio.CancelledError as cancellation:+ detach_cancellation = cancellation+ try:+ await self._drain_tasks(self._browser_download_tasks)+ except asyncio.CancelledError as cancellation:+ detach_cancellation = detach_cancellation or cancellation++ if browser_session is not None:+ browser_detach_cancellation = await self._detach_sessions(+ (browser_session,), phase="browser CDP session detach"+ )+ if detach_cancellation is None:+ detach_cancellation = browser_detach_cancellation+ self._browser_session = None+ self._browser_context = None++ self._accepting_cdp_handlers = False+ try:await self._drain_tasks(self._cdp_handler_tasks)finally:+ self._recovery_request_ids.clear()+ self._active_recovery_markers.clear()sessions = tuple(self._cdp_sessions)for cdp_session in sessions:self._unregister_active_request_interceptor(cdp_session)@@ -1815,46 +1983,18 @@ class CDPDownloadInterceptor:await cdp_session.send("Fetch.disable")except Exception as error:if _is_stale_interception_error(error):- # Normal teardown usually finds the target already closed/detached- # (SKY-11964); that benign race carries no live interception to leave- # untracked, so it doesn't warrant invalidating the monitor.LOG.debug("CDP Fetch interception was already stale at disable (benign race)",error_type=type(error).__name__,)continue- # Interception may still be live on a session we have already unregistered,- # which would leave requests egressing untracked. Mirror the enable path.self._network_egress_monitor.invalidate()LOG.warning("Failed to disable CDP Fetch interception", error_type=type(error).__name__)- detach_cancellation = await self._detach_sessions(sessions, phase="page CDP session detach")+ page_detach_cancellation = await self._detach_sessions(sessions, phase="page CDP session detach")+ if detach_cancellation is None:+ detach_cancellation = page_detach_cancellationself._cdp_sessions.clear()session_count = len(sessions)-- 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:- browser_detach_cancellation = await self._detach_sessions(- (browser_session,), phase="browser CDP session detach"- )- if detach_cancellation is None:- detach_cancellation = browser_detach_cancellation- self._browser_session = None- self._browser_context = None-if page_context is not None and getattr(page_context, "_skyvern_cdp_download_interceptor", None) is self:page_context._skyvern_cdp_download_interceptor = None # type: ignore[attr-defined]self._page_context = None@@ -2045,10 +2185,31 @@ class CDPDownloadInterceptor:url = event.get("request", {}).get("url", "<unknown>")try:+ response_error_reason = event.get("responseErrorReason")+ if response_status is None and response_error_reason is not None:+ self._discard_recovery_request(cdp_session, request_id)+ await self._fail_request(+ cdp_session,+ request_id,+ error_reason=response_error_reason if isinstance(response_error_reason, str) else "Failed",+ )+ return# Request stage: authorize before continueRequest can put browser credentials on the# wire. A missing, failed, or negative collaborator is unenrolled and fails closed.if response_status is None:request = event.get("request", {})+ raw_request_headers = request.get("headers", {})+ if isinstance(raw_request_headers, list):+ normalized_headers = {+ str(h.get("name", "")).lower(): h.get("value", "")+ for h in raw_request_headers+ if isinstance(h, dict)+ }+ elif isinstance(raw_request_headers, dict):+ normalized_headers = {str(k).lower(): v for k, v in raw_request_headers.items()}+ else:+ normalized_headers = {}+ marker_value = normalized_headers.get(RECOVERY_MARKER_HEADER)try:monitor = self._network_egress_monitorauthorized = monitor is not None and monitor.authorize_request(@@ -2066,13 +2227,45 @@ class CDPDownloadInterceptor:error_reason="BlockedByClient",)return- await cdp_session.send("Fetch.continueRequest", {"requestId": request_id})+ redirected_request_id = event.get("redirectedRequestId")+ marked_recovery = marker_value is not None and marker_value in self._active_recovery_markers+ if redirected_request_id is not None and marked_recovery:+ await self._fail_request(cdp_session, request_id, error_reason="BlockedByClient")+ return+ if marker_value is not None and not marked_recovery:+ await self._fail_request(cdp_session, request_id, error_reason="BlockedByClient")+ return+ continue_params: dict[str, Any] = {"requestId": request_id}+ if marker_value is not None:+ header_items = (+ raw_request_headers.items()+ if isinstance(raw_request_headers, dict)+ else ((h.get("name"), h.get("value")) for h in raw_request_headers if isinstance(h, dict))+ )+ continue_params["headers"] = [+ {"name": str(name), "value": str(value)}+ for name, value in header_items+ if str(name).lower() != RECOVERY_MARKER_HEADER+ ]+ if not self._register_recovery_request(cdp_session, request_id, marker_value):+ await self._fail_request(cdp_session, request_id, error_reason="BlockedByClient")+ return+ try:+ await cdp_session.send("Fetch.continueRequest", continue_params)+ except Exception:+ self._discard_recovery_request(cdp_session, request_id)+ raisereturn# Response stage: check for downloadsraw_response_headers = event.get("responseHeaders", [])response_headers = _parse_headers(raw_response_headers)resource_type = event.get("resourceType", "")+ recovery_key = (cdp_session, request_id)+ recovery_marker = self._recovery_request_ids.get(recovery_key)+ marked_recovery = recovery_marker is not None+ if marked_recovery:+ self._discard_recovery_request(cdp_session, request_id)LOG.debug("CDP Fetch response paused",@@ -2082,7 +2275,12 @@ class CDPDownloadInterceptor:content_disposition=response_headers.get("content-disposition", ""),)- if is_download_response(response_headers, response_status, resource_type):+ if marked_recovery:+ if 300 <= int(response_status) < 400:+ await self._fail_request(cdp_session, request_id, error_reason="BlockedByClient")+ else:+ await self._continue_response(cdp_session, request_id)+ elif is_download_response(response_headers, response_status, resource_type):LOG.info("CDP download response detected",resource_type=resource_type,diff --git a/skyvern/webeye/utils/page.py b/skyvern/webeye/utils/page.pyindex 964bef64c..ff89b7abf 100644--- a/skyvern/webeye/utils/page.py+++ b/skyvern/webeye/utils/page.py@@ -11,7 +11,7 @@ import urllib.parsefrom collections.abc import Awaitable, Callablefrom enum import StrEnumfrom io import BytesIO-from typing import TYPE_CHECKING, Any, NamedTuple+from typing import TYPE_CHECKING, Any, Literal, NamedTupleimport structlogfrom opentelemetry import trace as otel_trace@@ -1014,17 +1014,28 @@ def _close_screenshot_stitch_resources(_SAME_ORIGIN_FETCH_JS = """async (args) => {try {- const { url, maxSizeBytes } = args;- const response = await fetch(url);+ const { url, maxSizeBytes, headers, redirect } = args;+ const response = await fetch(url, { headers: headers || {}, redirect: redirect || 'follow' });if (!response.ok) {return { ok: false, status: response.status };}- const blob = await response.blob();- // Reject oversized blobs before serializing them to a data URL, so a huge- // client-side blob can't be read fully into memory / base64-transcoded.- if (maxSizeBytes != null && blob.size > maxSizeBytes) {- return { ok: false, error: 'too_large', size: blob.size };+ if (!response.body) return { ok: false, error: 'no_readable_stream' };+ const reader = response.body.getReader();+ const chunks = [];+ let total = 0;+ while (true) {+ const { done, value } = await reader.read();+ if (done) break;+ if (value) {+ total += value.byteLength;+ chunks.push(value);+ if (maxSizeBytes != null && total > maxSizeBytes) {+ await reader.cancel();+ return { ok: false, error: 'too_large', size: total };+ }+ }}+ const blob = new Blob(chunks);return await new Promise((resolve) => {const reader = new FileReader();reader.onloadend = () => {@@ -1644,7 +1655,7 @@ class SkyvernFrame:return None# blob.size is checked in-page against this before the payload is serialized.- blob_arg = {"url": blob_url, "maxSizeBytes": max_size_bytes}+ blob_arg: dict[str, Any] = {"url": blob_url, "maxSizeBytes": max_size_bytes}main_frame = page.main_framefor frame in frames:try:@@ -1707,6 +1718,8 @@ class SkyvernFrame:workflow_run_id: str | None = None,max_size_bytes: int | None = None,timeout_ms: float = SettingsManager.get_settings().BROWSER_ACTION_TIMEOUT_MS,+ headers: dict[str, str] | None = None,+ redirect: Literal["follow", "error"] = "follow",) -> bytes | None:"""Fetch an http(s) URL's bytes via an in-page fetch() inside a same-origin frame.@@ -1728,7 +1741,9 @@ class SkyvernFrame:return None# _SAME_ORIGIN_FETCH_JS is a plain fetch(); reused here for http(s) recovery.- fetch_arg = {"url": url, "maxSizeBytes": max_size_bytes}+ fetch_arg: dict[str, Any] = {"url": url, "maxSizeBytes": max_size_bytes, "redirect": redirect}+ if headers:+ fetch_arg["headers"] = headersmain_frame = page.main_framefor frame in frames:# Route the main frame through the Page so SkyvernFrame.evaluate can attach anydiff --git a/tests/unit/test_cdp_download_interceptor.py b/tests/unit/test_cdp_download_interceptor.pyindex f54a51e9e..d894e6fa4 100644--- a/tests/unit/test_cdp_download_interceptor.py+++ b/tests/unit/test_cdp_download_interceptor.py@@ -99,6 +99,22 @@ def test_successful_scope_rebind_restores_installed_browser_monitor(tmp_path: Paassert interceptor.download_scope == "next"+def test_scope_rebind_retains_recovery_tuples_and_marker_until_request_termination(tmp_path: Path) -> None:+ interceptor = _make_interceptor(+ output_dir=str(tmp_path / "prior"), redirect_hop_authorizer=RunScopedRedirectHopAuthorizer("prior")+ )+ session = MagicMock()+ interceptor._recovery_request_ids[(session, "r")] = interceptor._recovery_marker+ old_marker = interceptor._recovery_marker+ interceptor._active_recovery_markers.add(old_marker)+ interceptor.rebind_download_scope(+ download_dir=str(tmp_path / "next"), redirect_hop_authorizer=RunScopedRedirectHopAuthorizer("next")+ )+ assert interceptor._recovery_request_ids[(session, "r")] == old_marker+ assert interceptor._recovery_marker != old_marker+ assert old_marker in interceptor._active_recovery_markers++def test_invalidated_scope_cannot_publish_in_flight_artifact(tmp_path: Path) -> None:output_dir = tmp_path / "prior"interceptor = _make_interceptor(@@ -170,6 +186,473 @@ async def test_browser_download_event_metadata_is_redacted_from_logs() -> None:assert "suggested_filename_fp" in rendered_logs+ "headers",+ [+ {"x-skyvern-recovery-marker": "TOKEN", "X-Other": "v"},+ [{"name": "X-SKYVERN-RECOVERY-MARKER", "value": "TOKEN"}, {"name": "X-Other", "value": "v"}],+ ],+)+async def test_response_stage_exact_marker_continues_without_download(tmp_path: Path, headers: Any) -> None:+ interceptor = _make_interceptor(output_dir=str(tmp_path))+ interceptor._recovery_marker = "TOKEN"+ interceptor._active_recovery_markers.add("TOKEN")+ session = MagicMock()+ session.send = AsyncMock()+ request_event = {+ "requestId": "r",+ "request": {"method": "GET", "url": "https://x/a", "headers": headers},+ "resourceType": "Document",+ }+ with patch.object(interceptor, "_handle_download", new=AsyncMock()) as handle:+ await interceptor._handle_request_paused(request_event, session)+ assert session.send.await_args_list[-1].args == (+ "Fetch.continueRequest",+ {"requestId": "r", "headers": [{"name": "X-Other", "value": "v"}]},+ )+ response_event = {+ "requestId": "r",+ "responseStatusCode": 200,+ "request": {"url": "https://x/a", "headers": {}},+ "responseHeaders": [{"name": "Content-Type", "value": "application/pdf"}],+ "resourceType": "Document",+ }+ await interceptor._handle_request_paused(response_event, session)+ assert session.send.await_args_list[-1].args == ("Fetch.continueResponse", {"requestId": "r"})+ handle.assert_not_awaited()+ assert not interceptor._recovery_request_ids+++async def test_recovery_request_ids_are_scoped_to_cdp_session(tmp_path: Path) -> None:+ interceptor = _make_interceptor(output_dir=str(tmp_path))+ interceptor._recovery_marker = "TOKEN"+ session_a, session_b = MagicMock(), MagicMock()+ session_a.send = AsyncMock()+ session_b.send = AsyncMock()+ for session in (session_a, session_b):+ await interceptor._handle_request_paused(+ {"requestId": "r", "request": {"url": "https://x/a", "headers": {"x-skyvern-recovery-marker": "TOKEN"}}},+ session,+ )+ # Remove B's marker to model the collision: only A is an authorized recovery.+ interceptor._recovery_request_ids = {(session_a, "r"): "TOKEN"}+ response = {+ "requestId": "r",+ "responseStatusCode": 200,+ "request": {"url": "https://x/a", "headers": {}},+ "responseHeaders": [{"name": "Content-Type", "value": "application/pdf"}],+ "resourceType": "Document",+ }+ with patch.object(interceptor, "_handle_download", new=AsyncMock()) as handle:+ await interceptor._handle_request_paused(response, session_b)+ handle.assert_awaited_once()+ await interceptor._handle_request_paused(response, session_a)+ assert not interceptor._recovery_request_ids+++async def test_recovery_helper_retains_marker_on_timeout_until_request_termination() -> None:+ interceptor = _make_interceptor()+ page, session = MagicMock(), MagicMock()+ interceptor._browser_context = MagicMock(pages=[page])+ interceptor._active_request_interceptors[session] = (page, MagicMock())+ interceptor._recovery_request_ids[(session, "r")] = interceptor._recovery_marker+ interceptor._active_recovery_markers.add(interceptor._recovery_marker)+ with patch.object(mod.SkyvernFrame, "read_http_url_bytes", new=AsyncMock(side_effect=RuntimeError("boom"))):+ assert await interceptor._fetch_download_bytes_in_page("https://x/a") is None+ assert interceptor._recovery_request_ids+ assert interceptor._active_recovery_markers+++async def test_recovery_helper_keeps_marker_authorized_across_page_retries() -> None:+ interceptor = _make_interceptor()+ page1, page2 = MagicMock(), MagicMock()+ session1, session2 = MagicMock(), MagicMock()+ interceptor._browser_context = MagicMock(pages=[page1, page2])+ interceptor._active_request_interceptors.update({session1: (page1, MagicMock()), session2: (page2, MagicMock())})+ marker = interceptor._recovery_marker++ async def read(*, page: Any, **_: Any) -> bytes | None:+ session = session1 if page is page1 else session2+ request_id = "r1" if page is page1 else "r2"+ assert marker in interceptor._active_recovery_markers+ assert interceptor._register_recovery_request(session, request_id, marker)+ interceptor._discard_recovery_request(session, request_id)+ assert marker in interceptor._active_recovery_markers+ return None if page is page1 else b"payload"++ with patch.object(mod.SkyvernFrame, "read_http_url_bytes", side_effect=read):+ assert await interceptor._fetch_download_bytes_in_page("https://x/a") == b"payload"+ assert not interceptor._active_recovery_call_markers+ assert marker not in interceptor._active_recovery_markers+ assert not interceptor._recovery_request_ids+++async def test_recovery_helper_continues_after_html_gate() -> None:+ interceptor = _make_interceptor()+ page1, page2 = MagicMock(), MagicMock()+ interceptor._browser_context = MagicMock(pages=[page1, page2])+ gate = b"<!doctype html><html><body>login</body></html>"+ payload = b"%PDF-1.7"+ with patch.object(mod.SkyvernFrame, "read_http_url_bytes", side_effect=[gate, payload]) as read:+ assert await interceptor._fetch_download_bytes_in_page("https://x/a") == payload+ assert [call.kwargs["page"] for call in read.await_args_list] == [page1, page2]+++async def test_recovery_helper_returns_none_for_only_html_or_none_and_keeps_empty_terminal() -> None:+ interceptor = _make_interceptor()+ page1, page2 = MagicMock(), MagicMock()+ interceptor._browser_context = MagicMock(pages=[page1, page2])+ gate = b"<html><body>login</body></html>"+ with patch.object(mod.SkyvernFrame, "read_http_url_bytes", side_effect=[gate, None]) as read:+ assert await interceptor._fetch_download_bytes_in_page("https://x/a") is None+ assert read.await_count == 2++ interceptor._browser_context = MagicMock(pages=[page1, page2])+ with patch.object(mod.SkyvernFrame, "read_http_url_bytes", side_effect=[b""]) as read:+ assert await interceptor._fetch_download_bytes_in_page("https://x/a") == b""+ assert read.await_count == 1+++async def test_recovery_helper_releases_exact_marker_when_scope_rebinds(tmp_path: Path) -> None:+ interceptor = _make_interceptor(output_dir=str(tmp_path / "prior"))+ page, session = MagicMock(), MagicMock()+ interceptor._browser_context = MagicMock(pages=[page])+ interceptor._active_request_interceptors[session] = (page, MagicMock())+ old_marker = interceptor._recovery_marker+ entered = asyncio.Event()+ release = asyncio.Event()++ async def read(*_args: Any, **_kwargs: Any) -> None:+ entered.set()+ await release.wait()+ return None++ with patch.object(mod.SkyvernFrame, "read_http_url_bytes", new=read):+ task = asyncio.create_task(interceptor._fetch_download_bytes_in_page("https://x/a"))+ await entered.wait()+ interceptor.rebind_download_scope(+ download_dir=str(tmp_path / "next"), redirect_hop_authorizer=RunScopedRedirectHopAuthorizer("next")+ )+ new_marker = interceptor._recovery_marker+ release.set()+ assert await task is None+ assert old_marker not in interceptor._active_recovery_call_markers+ assert old_marker not in interceptor._active_recovery_markers+ assert new_marker not in interceptor._active_recovery_markers+++async def test_recovery_helper_preserves_mapped_old_marker_after_rebind(tmp_path: Path) -> None:+ interceptor = _make_interceptor(output_dir=str(tmp_path / "prior"))+ page, session = MagicMock(), MagicMock()+ interceptor._browser_context = MagicMock(pages=[page])+ interceptor._active_request_interceptors[session] = (page, MagicMock())+ old_marker = interceptor._recovery_marker+ entered = asyncio.Event()+ release = asyncio.Event()++ async def read(*_args: Any, **_kwargs: Any) -> None:+ interceptor._register_recovery_request(session, "r", old_marker)+ entered.set()+ await release.wait()+ return None++ with patch.object(mod.SkyvernFrame, "read_http_url_bytes", new=read):+ task = asyncio.create_task(interceptor._fetch_download_bytes_in_page("https://x/a"))+ await entered.wait()+ interceptor.rebind_download_scope(+ download_dir=str(tmp_path / "next"), redirect_hop_authorizer=RunScopedRedirectHopAuthorizer("next")+ )+ new_marker = interceptor._recovery_marker+ release.set()+ assert await task is None+ assert interceptor._recovery_request_ids[(session, "r")] == old_marker+ assert old_marker in interceptor._active_recovery_markers+ assert new_marker not in interceptor._active_recovery_markers+ interceptor._discard_recovery_request(session, "r")+ assert old_marker not in interceptor._active_recovery_markers+++async def test_timeout_recovery_late_request_response_releases_exact_state(tmp_path: Path) -> None:+ interceptor = _make_interceptor(output_dir=str(tmp_path))+ page, session = MagicMock(), MagicMock()+ session.send = AsyncMock()+ interceptor._browser_context = MagicMock(pages=[page])+ interceptor._active_request_interceptors[session] = (page, MagicMock())+ marker = interceptor._recovery_marker+ gate = asyncio.Event()++ async def timed_out(*_args: Any, **_kwargs: Any) -> None:+ await gate.wait()++ async def timed_out_read(*_args: Any, **_kwargs: Any) -> None:+ assert interceptor._register_recovery_request(session, "r", marker)+ return None++ with patch.object(mod.SkyvernFrame, "read_http_url_bytes", new=timed_out_read):+ assert await interceptor._fetch_download_bytes_in_page("https://x/a") is None+ assert marker in interceptor._active_recovery_markers+ request = {"requestId": "r", "request": {"url": "https://x/a", "headers": {mod.RECOVERY_MARKER_HEADER: marker}}}+ await interceptor._handle_request_paused(request, session)+ assert (session, "r") in interceptor._recovery_request_ids+ next_dir = tmp_path / "next"+ interceptor.rebind_download_scope(+ download_dir=str(next_dir), redirect_hop_authorizer=RunScopedRedirectHopAuthorizer("next")+ )+ with patch.object(interceptor, "_handle_download", new=AsyncMock()) as handle:+ await interceptor._handle_request_paused(+ {+ **request,+ "responseStatusCode": 200,+ "responseHeaders": [{"name": "Content-Type", "value": "application/pdf"}],+ },+ session,+ )+ handle.assert_not_awaited()+ assert (session, "r") not in interceptor._recovery_request_ids+ assert marker not in interceptor._active_recovery_markers+ assert interceptor._run_download_bytes == 0+ assert interceptor._run_download_file_count == 0+++async def test_caller_cancellation_without_mapping_releases_marker_and_fails_late_request() -> None:+ interceptor = _make_interceptor()+ page, session = MagicMock(), MagicMock()+ session.send = AsyncMock()+ interceptor._browser_context = MagicMock(pages=[page])+ interceptor._active_request_interceptors[session] = (page, MagicMock())+ marker = interceptor._recovery_marker+ blocker = asyncio.Event()++ async def blocked(*_args: Any, **_kwargs: Any) -> bytes:+ await blocker.wait()+ return b"x"++ with patch.object(mod.SkyvernFrame, "read_http_url_bytes", new=blocked):+ task = asyncio.create_task(interceptor._fetch_download_bytes_in_page("https://x/a"))+ await asyncio.sleep(0)+ task.cancel()+ with pytest.raises(asyncio.CancelledError):+ await task+ assert marker not in interceptor._active_recovery_markers+ await interceptor._handle_request_paused(+ {"requestId": "r", "request": {"url": "https://x/a", "headers": {mod.RECOVERY_MARKER_HEADER: marker}}}, session+ )+ session.send.assert_awaited_once_with("Fetch.failRequest", {"requestId": "r", "errorReason": "BlockedByClient"})+ assert not interceptor._recovery_request_ids+ assert not [t for t in asyncio.all_tasks() if t is not asyncio.current_task() and not t.done()]+++def test_recovery_caps_and_marker_collisions_preserve_existing_state() -> None:+ interceptor = _make_interceptor()+ session = MagicMock()+ interceptor._recovery_request_ids[(session, "old")] = "old-marker"+ interceptor._active_recovery_markers.add("old-marker")+ interceptor._MAX_RECOVERY_REQUEST_IDS = 1+ assert not interceptor._register_recovery_request(session, "new", "new-marker")+ assert interceptor._recovery_request_ids == {(session, "old"): "old-marker"}+ assert not interceptor._register_recovery_request(session, "old", "different")+ interceptor._MAX_ACTIVE_RECOVERY_MARKERS = 1+ assert not interceptor._register_recovery_marker("new-marker")+++def test_two_requests_sharing_marker_release_on_last_final_response() -> None:+ interceptor = _make_interceptor()+ a, b = MagicMock(), MagicMock()+ interceptor._active_recovery_markers.add("m")+ interceptor._recovery_request_ids = {(a, "1"): "m", (b, "2"): "m"}+ interceptor._discard_recovery_request(a, "1")+ assert "m" in interceptor._active_recovery_markers+ interceptor._discard_recovery_request(b, "2")+ assert "m" not in interceptor._active_recovery_markers+++def test_drop_session_recovery_state_preserves_other_session_marker() -> None:+ interceptor = _make_interceptor()+ a, b = MagicMock(), MagicMock()+ interceptor._active_recovery_markers.update({"a", "shared"})+ interceptor._recovery_request_ids = {(a, "1"): "shared", (a, "2"): "a", (b, "3"): "shared"}+ interceptor._drop_session_recovery_state(a)+ assert interceptor._recovery_request_ids == {(b, "3"): "shared"}+ assert interceptor._active_recovery_markers == {"shared"}+++async def test_marked_redirect_response_discards_mapping_and_fails_closed() -> None:+ interceptor = _make_interceptor()+ session = MagicMock()+ session.send = AsyncMock()+ interceptor._recovery_request_ids[(session, "r")] = "m"+ interceptor._active_recovery_markers.add("m")+ await interceptor._handle_request_paused(+ {+ "requestId": "r",+ "responseStatusCode": 302,+ "request": {"url": "https://x"},+ "responseHeaders": [],+ "resourceType": "Document",+ },+ session,+ )+ assert (session, "r") not in interceptor._recovery_request_ids+ assert session.send.await_args.args == ("Fetch.failRequest", {"requestId": "r", "errorReason": "BlockedByClient"})++[email protected](("mapped", "reason"), [(True, "NameNotResolved"), (False, "Failed")])+async def test_response_error_reason_fails_closed_without_egress_authorization(mapped: bool, reason: str) -> None:+ monitor = MagicMock()+ interceptor = _make_interceptor(network_egress_monitor=monitor)+ session = MagicMock()+ session.send = AsyncMock()+ if mapped:+ interceptor._recovery_request_ids[(session, "r")] = "m"+ interceptor._active_recovery_markers.add("m")+ await interceptor._handle_request_paused(+ {"requestId": "r", "responseErrorReason": "NameNotResolved" if mapped else 42, "request": {"url": "https://x"}},+ session,+ )+ monitor.authorize_request.assert_not_called()+ assert (session, "r") not in interceptor._recovery_request_ids+ assert session.send.await_args.args == ("Fetch.failRequest", {"requestId": "r", "errorReason": reason})+++async def test_request_stage_redirected_request_with_marker_fails_closed() -> None:+ interceptor = _make_interceptor()+ interceptor._active_recovery_markers.add("m")+ session = MagicMock()+ session.send = AsyncMock()+ await interceptor._handle_request_paused(+ {+ "requestId": "new",+ "redirectedRequestId": "old",+ "request": {"url": "https://x", "headers": {mod.RECOVERY_MARKER_HEADER: "m"}},+ },+ session,+ )+ assert session.send.await_args.args == ("Fetch.failRequest", {"requestId": "new", "errorReason": "BlockedByClient"})+++async def test_request_stage_old_active_marker_is_stripped_until_fetch_cleanup(tmp_path: Path) -> None:+ monitor = MagicMock()+ monitor.authorize_request.return_value = True+ interceptor = _make_interceptor(output_dir=str(tmp_path), network_egress_monitor=monitor)+ session = MagicMock()+ session.send = AsyncMock()+ old_marker = interceptor._recovery_marker+ interceptor._active_recovery_markers.add(old_marker)+ interceptor.rebind_download_scope(+ download_dir=str(tmp_path / "next"), redirect_hop_authorizer=RunScopedRedirectHopAuthorizer("next")+ )+ assert interceptor._recovery_marker != old_marker+ event = {"requestId": "r", "request": {"url": "https://x/a", "headers": {mod.RECOVERY_MARKER_HEADER: old_marker}}}+ await interceptor._handle_request_paused(event, session)+ assert session.send.await_args.args == ("Fetch.continueRequest", {"requestId": "r", "headers": []})+ interceptor._active_recovery_markers.remove(old_marker)+ session.send.reset_mock()+ await interceptor._handle_request_paused(event, session)+ assert session.send.await_args.args == ("Fetch.failRequest", {"requestId": "r", "errorReason": "BlockedByClient"})+++async def test_direct_download_recovery_rebind_does_not_mutate_new_scope_accounting(tmp_path: Path) -> None:+ old_dir, new_dir = tmp_path / "old", tmp_path / "new"+ interceptor = _make_interceptor(+ output_dir=str(old_dir), redirect_hop_authorizer=RunScopedRedirectHopAuthorizer("old")+ )+ interceptor._browser_context = TestDirectHttpDownloadAuthAndHtmlGuard._context()+ gate = TestDirectHttpDownloadAuthAndHtmlGuard._LOGIN_HTML+ with patch.object(+ mod.file_api,+ "fetch_file_bytes",+ TestDirectHttpDownloadAuthAndHtmlGuard._guarded_fetch(gate, "text/html", "report.pdf"),+ create=True,+ ):+ old_generation = interceptor._artifact_scope_generation++ async def recover(*_args: Any, **_kwargs: Any) -> bytes:+ interceptor.rebind_download_scope(+ download_dir=str(new_dir), redirect_hop_authorizer=RunScopedRedirectHopAuthorizer("new")+ )+ return b"%PDF recovered"++ with patch.object(interceptor, "_fetch_download_bytes_in_page", side_effect=recover):+ await interceptor._download_url_directly("https://site.example/report.pdf", "report.pdf", old_generation)+ assert not list(old_dir.iterdir()) if old_dir.exists() else True+ assert not list(new_dir.iterdir()) if new_dir.exists() else True+ assert interceptor._run_download_bytes == 0+ assert interceptor._run_download_file_count == 0+ assert interceptor._run_download_bytes >= 0+ assert interceptor._run_download_file_count >= 0+ assert interceptor._active_download_attempts == {}+++async def test_request_stage_exact_marker_unauthorized_fails_closed() -> None:+ monitor = MagicMock()+ monitor.authorize_request.return_value = False+ interceptor = _make_interceptor(network_egress_monitor=monitor)+ interceptor._recovery_marker = "TOKEN"+ session = MagicMock()+ session.send = AsyncMock()+ await interceptor._handle_request_paused(+ {"requestId": "r", "request": {"url": "https://x/a", "headers": {"x-skyvern-recovery-marker": "TOKEN"}}},+ session,+ )+ session.send.assert_awaited_once_with("Fetch.failRequest", {"requestId": "r", "errorReason": "BlockedByClient"})+ assert not interceptor._recovery_request_ids+++async def test_fetch_download_bytes_in_page_marker_only_for_active_page() -> None:+ interceptor = _make_interceptor()+ page = MagicMock()+ interceptor._browser_context = MagicMock(pages=[page])+ interceptor._recovery_marker = "TOKEN"+ with patch.object(mod.SkyvernFrame, "read_http_url_bytes", new=AsyncMock(return_value=b"x")) as read:+ interceptor._active_request_interceptors["p"] = (page, MagicMock())+ assert await interceptor._fetch_download_bytes_in_page("https://x/a") == b"x"+ assert read.await_args.kwargs["headers"] == {mod.RECOVERY_MARKER_HEADER: "TOKEN"}+ assert read.await_args.kwargs["timeout_ms"] == mod.DOWNLOAD_RECOVERY_TIMEOUT_MS++ interceptor._active_request_interceptors.clear()+ with patch.object(mod.SkyvernFrame, "read_http_url_bytes", new=AsyncMock(return_value=b"x")) as read:+ assert await interceptor._fetch_download_bytes_in_page("https://x/a") == b"x"+ assert read.await_args.kwargs["headers"] is None+ assert read.await_args.kwargs["timeout_ms"] == mod.DOWNLOAD_RECOVERY_TIMEOUT_MS+++async def test_response_stage_missing_or_wrong_marker_intercepts_download(tmp_path: Path) -> None:+ interceptor = _make_interceptor(output_dir=str(tmp_path))+ interceptor._recovery_marker = "TOKEN"+ for marker in (None, "WRONG"):+ session = MagicMock()+ session.send = AsyncMock()+ headers = {} if marker is None else {"x-skyvern-recovery-marker": marker}+ event = {+ "requestId": "r",+ "responseStatusCode": 200,+ "request": {"url": "https://x/a", "headers": headers},+ "responseHeaders": [{"name": "Content-Type", "value": "application/pdf"}],+ "resourceType": "Document",+ }+ with patch.object(interceptor, "_handle_download", new=AsyncMock()) as handle:+ await interceptor._handle_request_paused(event, session)+ handle.assert_awaited_once()++class TestIsDownloadResponse:"""Tests for is_download_response()."""@@ -1540,6 +2023,7 @@ class TestCDPDownloadInterceptorProxyAuth:# Only one call: the original continueRequest that failed. No recovery attempt.assert cdp_session.send.call_count == 1assert cdp_session.send.call_args.args[0] == "Fetch.continueRequest"+ assert not interceptor._recovery_request_ids@pytest.mark.asyncioasync def test_malformed_event_missing_request_id(self) -> None:@@ -2905,6 +3389,108 @@ class TestDataUrlDownloadCapture:assert not interceptor._cdp_handler_tasks+ @pytest.mark.asyncio+ async def test_disable_drains_owned_browser_download_before_cdp_teardown(self) -> None:+ interceptor = _make_interceptor()+ started = asyncio.Event()+ release = asyncio.Event()+ marker = interceptor._recovery_marker+ page_session = MagicMock(send=AsyncMock(), detach=AsyncMock())+ browser_session = MagicMock(send=AsyncMock(), detach=AsyncMock())+ interceptor._browser_session = browser_session+ interceptor._cdp_sessions.append(page_session)++ async def blocked_handler(event: dict[str, Any], generation: int) -> None:+ interceptor._active_recovery_markers.add(marker)+ interceptor._active_recovery_call_markers.add(marker)+ interceptor._recovery_request_ids[(page_session, "request-1")] = marker+ started.set()+ await release.wait()+ interceptor._recovery_request_ids.pop((page_session, "request-1"), None)+ interceptor._active_recovery_call_markers.discard(marker)++ with patch.object(interceptor, "_handle_browser_download_serialized", side_effect=blocked_handler):+ interceptor._accepting_browser_downloads = True+ interceptor._schedule_browser_download_handler({"url": "https://example.test/file"})+ await started.wait()+ disabling = asyncio.create_task(interceptor.disable())+ await asyncio.sleep(0)+ assert not disabling.done()+ assert interceptor._accepting_cdp_handlers+ assert marker in interceptor._active_recovery_markers+ assert interceptor._recovery_request_ids[(page_session, "request-1")] == marker+ page_session.send.assert_not_awaited()+ release.set()+ await asyncio.wait_for(disabling, timeout=2)++ assert not interceptor._browser_download_tasks+ assert not interceptor._cdp_handler_tasks+ assert not interceptor._active_recovery_markers+ assert not interceptor._recovery_request_ids+ assert not interceptor._accepting_cdp_handlers+ page_session.send.assert_awaited_once_with("Fetch.disable")++ @pytest.mark.asyncio+ async def test_disable_clears_recorded_recovery_tuple_after_browser_task_terminal_response(self) -> None:+ interceptor = _make_interceptor()+ session = MagicMock(send=AsyncMock())+ marker = interceptor._recovery_marker+ interceptor._active_recovery_markers.add(marker)+ interceptor._recovery_request_ids[(session, "request-1")] = marker+ started = asyncio.Event()+ release = asyncio.Event()++ async def terminal_handler(event: dict[str, Any], generation: int) -> None:+ started.set()+ await release.wait()+ interceptor._recovery_request_ids.pop((session, "request-1"), None)++ with patch.object(interceptor, "_handle_browser_download_serialized", side_effect=terminal_handler):+ interceptor._browser_session = MagicMock(detach=AsyncMock())+ interceptor._accepting_browser_downloads = True+ interceptor._schedule_browser_download_handler({"url": "https://example.test/file"})+ await started.wait()+ disabling = asyncio.create_task(interceptor.disable())+ await asyncio.sleep(0)+ assert interceptor._recovery_request_ids[(session, "request-1")] == marker+ release.set()+ await asyncio.wait_for(disabling, timeout=2)++ assert not interceptor._recovery_request_ids+ assert not interceptor._active_recovery_markers++ @pytest.mark.asyncio+ async def test_disable_cancellation_finishes_owned_drain_and_teardown(self) -> None:+ interceptor = _make_interceptor()+ started = asyncio.Event()+ release = asyncio.Event()++ async def cancellation_safe_handler(event: dict[str, Any], generation: int) -> None:+ started.set()+ try:+ await release.wait()+ except asyncio.CancelledError:+ release.set()+ raise++ with patch.object(interceptor, "_handle_browser_download_serialized", side_effect=cancellation_safe_handler):+ interceptor._browser_session = MagicMock(detach=AsyncMock())+ interceptor._accepting_browser_downloads = True+ interceptor._schedule_browser_download_handler({"url": "https://example.test/file"})+ await started.wait()+ disabling = asyncio.create_task(interceptor.disable())+ await asyncio.sleep(0)+ disabling.cancel()+ with pytest.raises(asyncio.CancelledError):+ await asyncio.wait_for(disabling, timeout=2)++ assert not interceptor._browser_download_tasks+ assert not interceptor._cdp_handler_tasks+ assert interceptor._browser_session is None+ assert interceptor._browser_download_listener is None+ assert not interceptor._active_recovery_markers+ assert not interceptor._recovery_request_ids+class TestDirectHttpDownloadAuthAndHtmlGuard:"""Direct HTTP downloads fail closed without an enrolled backend and reject HTML login masquerades."""@@ -2989,6 +3575,67 @@ class TestDirectHttpDownloadAuthAndHtmlGuard:)assert (tmp_path / "report.pdf").read_bytes() == b"private report"+ @pytest.mark.asyncio+ async def test_html_gate_recovery_uses_post_replacement_run_budget(self, tmp_path: Path) -> None:+ interceptor = _make_interceptor(output_dir=str(tmp_path))+ interceptor._browser_context = self._context()+ gate = self._LOGIN_HTML+ recovered = b"%PDF" + b"R" * (1024 * 1024 - 4)+ interceptor._run_download_bytes = mod.MAX_RUN_DOWNLOAD_BYTES - len(gate) - len(recovered)+ guarded_fetch = self._guarded_fetch(gate, "text/html", "report.pdf")+ in_page = AsyncMock(return_value=recovered)+ with (+ patch.object(mod.file_api, "fetch_file_bytes", guarded_fetch, create=True),+ patch.object(interceptor, "_fetch_download_bytes_in_page", in_page),+ ):+ await interceptor._download_url_directly("https://site.example/report.pdf", "report.pdf")+ in_page.assert_awaited_once_with(+ "https://site.example/report.pdf", recovery_allowance_bytes=len(recovered) + len(gate)+ )+ assert len(list(tmp_path.iterdir())) == 1+ assert next(tmp_path.iterdir()).read_bytes() == recovered+ assert interceptor._browser_download_attempt is None+ assert interceptor._active_download_attempts == {}+ assert interceptor._unsolicited_download_failures == {}+ assert interceptor._run_download_bytes == mod.MAX_RUN_DOWNLOAD_BYTES - len(gate) - len(recovered) + len(+ recovered+ )++ @pytest.mark.asyncio+ async def test_html_gate_empty_recovery_writes_one_zero_byte_artifact(self, tmp_path: Path) -> None:+ interceptor = _make_interceptor(output_dir=str(tmp_path))+ interceptor._browser_context = self._context()+ guarded_fetch = self._guarded_fetch(self._LOGIN_HTML, "text/html", "report.pdf")+ with (+ patch.object(mod.file_api, "fetch_file_bytes", guarded_fetch, create=True),+ patch.object(interceptor, "_fetch_download_bytes_in_page", new=AsyncMock(return_value=b"")) as recovery,+ ):+ await interceptor._download_url_directly("https://site.example/report.pdf", "report.pdf")+ recovery.assert_awaited_once()+ artifacts = list(tmp_path.iterdir())+ assert len(artifacts) == 1+ assert artifacts[0].read_bytes() == b""+ assert interceptor._active_download_attempts == {}+ assert interceptor._run_download_file_count == 1+ assert interceptor._run_download_bytes == 0++ @pytest.mark.asyncio+ async def test_html_gate_none_recovery_fails_without_artifact(self, tmp_path: Path) -> None:+ interceptor = _make_interceptor(output_dir=str(tmp_path))+ interceptor._browser_context = self._context()+ with (+ patch.object(+ mod.file_api,+ "fetch_file_bytes",+ self._guarded_fetch(self._LOGIN_HTML, "text/html", "report.pdf"),+ create=True,+ ),+ patch.object(interceptor, "_fetch_download_bytes_in_page", new=AsyncMock(return_value=None)),+ ):+ await interceptor._download_url_directly("https://site.example/report.pdf", "report.pdf")+ assert list(tmp_path.iterdir()) == []+ assert interceptor._active_download_attempts == {}+@pytest.mark.asyncioasync def test_guarded_download_failure_does_not_log_url_or_exception_secret(self, tmp_path: Path) -> None:interceptor = _make_interceptor(output_dir=str(tmp_path))diff --git a/tests/unit/test_download_file_action_handler.py b/tests/unit/test_download_file_action_handler.pyindex 3fd85a420..dd612ccf9 100644--- a/tests/unit/test_download_file_action_handler.py+++ b/tests/unit/test_download_file_action_handler.py@@ -5145,6 +5145,7 @@ async def test_recover_passes_recovery_timeout_to_read_http_url_bytes(tmp_path:assert result is not Noneassert read_mock.await_args.kwargs["timeout_ms"] == _BLOCKED_INLINE_PDF_RECOVERY_TIMEOUT_SECONDS * 1000+ assert "redirect" not in read_mock.await_args.kwargs@pytest.mark.asynciodiff --git a/tests/unit/test_download_in_page_fetch_recovery_e2e.py b/tests/unit/test_download_in_page_fetch_recovery_e2e.pynew file mode 100644index 000000000..c0c9efa0e--- /dev/null+++ b/tests/unit/test_download_in_page_fetch_recovery_e2e.py@@ -0,0 +1,285 @@+"""E2E regression for same-origin browser-context recovery of a gated download.++Uses real headless Chromium and a local HTTPS server. The fixture verifies browser-context fetch+behavior, not CDP adoption semantics.+"""++from __future__ import annotations++import asyncio+import datetime+import ipaddress+import ssl+import tempfile+import threading+import urllib.parse+import urllib.request+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer+from pathlib import Path+from typing import Any+from unittest.mock import AsyncMock, MagicMock, patch++import pytest+import pytest_asyncio++import skyvern.webeye.cdp_download_interceptor as mod+from skyvern.webeye.utils.page import SkyvernFrame+++def _deps_available() -> bool:+ try:+ import cryptography # noqa: F401+ from playwright.sync_api import sync_playwright++ with sync_playwright() as p:+ return Path(p.chromium.executable_path).exists()+ except Exception:+ return False+++pytestmark = pytest.mark.skipif(+ not _deps_available(),+ reason="Requires Playwright chromium (playwright install chromium) and cryptography",+)+++def _pdf_bytes(name: str) -> bytes:+ """A minimal valid PDF embedding *name*, so a recovered file is distinguishable from the gate page."""+ stream = f"BT /F1 18 Tf 20 100 Td ({name}) Tj ET".encode()+ return (+ b"%PDF-1.4\n"+ b"1 0 obj<</Type/Catalog/Pages 2 0 R>>endobj\n"+ b"2 0 obj<</Type/Pages/Kids[3 0 R]/Count 1>>endobj\n"+ b"3 0 obj<</Type/Page/Parent 2 0 R/MediaBox[0 0 200 200]/Contents 4 0 R>>endobj\n"+ b"4 0 obj<</Length " + str(len(stream)).encode() + b">>stream\n" + stream + b"\nendstream endobj\n"+ b"xref\n0 5\n0000000000 65535 f \ntrailer<</Root 1 0 R/Size 5>>\nstartxref\n0\n%%EOF\n"+ )+++_RECEIPT_PDF = _pdf_bytes("Receipt")+_GATE_HTML = (+ b"<!DOCTYPE html><html><head><title>Sign in</title></head>"+ b"<body><form method='post' action='/login'>session expired</form></body></html>"+)+_LANDING_HTML = b"<!doctype html><html><body>ready</body></html>"+_REDIRECT_FINAL_HITS = 0+_CHUNKED_SERVED = 0+++def _self_signed_cert() -> tuple[str, str]:+ from cryptography import x509+ from cryptography.hazmat.primitives import hashes, serialization+ from cryptography.hazmat.primitives.asymmetric import rsa+ from cryptography.x509.oid import NameOID++ key = rsa.generate_private_key(public_exponent=65537, key_size=2048)+ name = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, "127.0.0.1")])+ now = datetime.datetime.now(datetime.UTC)+ cert = (+ x509.CertificateBuilder()+ .subject_name(name)+ .issuer_name(name)+ .public_key(key.public_key())+ .serial_number(x509.random_serial_number())+ .not_valid_before(now - datetime.timedelta(days=1))+ .not_valid_after(now + datetime.timedelta(days=1))+ .add_extension(x509.SubjectAlternativeName([x509.IPAddress(ipaddress.ip_address("127.0.0.1"))]), critical=False)+ .sign(key, hashes.SHA256())+ )+ tmp = Path(tempfile.mkdtemp())+ cert_path, key_path = tmp / "cert.pem", tmp / "key.pem"+ cert_path.write_bytes(cert.public_bytes(serialization.Encoding.PEM))+ key_path.write_bytes(+ key.private_bytes(+ serialization.Encoding.PEM,+ serialization.PrivateFormat.TraditionalOpenSSL,+ serialization.NoEncryption(),+ )+ )+ return str(cert_path), str(key_path)+++class _Handler(BaseHTTPRequestHandler):+ """Serve PDF bytes to browser-context fetches and an HTML gate to plain clients."""++ def log_message(self, *a: Any) -> None:+ pass++ def do_GET(self) -> None:+ global _REDIRECT_FINAL_HITS, _CHUNKED_SERVED+ if self.headers.get("x-skyvern-recovery-marker") is not None:+ self.send_error(400, "recovery marker must be stripped")+ return+ parsed = urllib.parse.urlparse(self.path)+ if parsed.path == "/redirect.pdf":+ self.send_response(302)+ self.send_header("Location", "/final.pdf")+ self.end_headers()+ return+ if parsed.path == "/final.pdf":+ _REDIRECT_FINAL_HITS += 1+ body = _RECEIPT_PDF+ self.send_response(200)+ self.send_header("Content-Type", "application/pdf")+ self.send_header("Content-Length", str(len(body)))+ self.end_headers()+ self.wfile.write(body)+ return+ if parsed.path == "/chunked.bin":+ payload = b"x" * (256 * 1024)+ self.send_response(200)+ self.send_header("Content-Type", "application/octet-stream")+ self.end_headers()+ try:+ for _ in range(32):+ self.wfile.write(payload)+ self.wfile.flush()+ _CHUNKED_SERVED += len(payload)+ threading.Event().wait(0.005)+ except (BrokenPipeError, ConnectionResetError, ssl.SSLError):+ pass+ return+ if parsed.path == "/empty.bin":+ self.send_response(200)+ self.send_header("Content-Type", "application/octet-stream")+ self.send_header("Content-Length", "0")+ self.end_headers()+ return+ if parsed.path == "/receipt.pdf":+ is_browser = (+ self.headers.get("Sec-Fetch-Site") is not None or self.headers.get("Sec-Fetch-Mode") is not None+ )+ body, ctype = (_RECEIPT_PDF, "application/pdf") if is_browser else (_GATE_HTML, "text/html; charset=utf-8")+ else:+ body, ctype = _LANDING_HTML, "text/html; charset=utf-8"+ self.send_response(200)+ self.send_header("Content-Type", ctype)+ if parsed.path == "/receipt.pdf":+ self.send_header("Content-Disposition", "attachment; filename=receipt.pdf")+ self.send_header("Content-Length", str(len(body)))+ self.end_headers()+ self.wfile.write(body)+++@pytest_asyncio.fixture+async def cdp_https_site():+ """Serve HTTPS and provide a real Chromium context with a page on the origin."""+ from playwright.async_api import async_playwright++ cert_path, key_path = _self_signed_cert()+ server = ThreadingHTTPServer(("127.0.0.1", 0), _Handler)+ ssl_ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)+ ssl_ctx.minimum_version = ssl.TLSVersion.TLSv1_2+ ssl_ctx.load_cert_chain(cert_path, key_path)+ server.socket = ssl_ctx.wrap_socket(server.socket, server_side=True)+ port = server.server_address[1]+ threading.Thread(target=server.serve_forever, daemon=True).start()++ async with async_playwright() as p:+ browser = await p.chromium.launch(+ headless=True,+ args=["--ignore-certificate-errors", "--no-proxy-server", "--proxy-bypass-list=*"],+ proxy={"server": "direct://"},+ )+ context = await browser.new_context(ignore_https_errors=True)+ page = await context.new_page()+ await page.goto(f"https://127.0.0.1:{port}/", wait_until="domcontentloaded")+ try:+ yield context, page, port+ finally:+ await browser.close()+ server.shutdown()+++def _make_interceptor(output_dir: str) -> mod.CDPDownloadInterceptor:+ monitor = MagicMock()+ monitor.authorize_request.return_value = True+ return mod.CDPDownloadInterceptor(+ output_dir=output_dir,+ network_egress_monitor=monitor,+ redirect_hop_authorizer=AsyncMock(),+ )+++async def test_host_client_hits_gate_but_in_page_fetch_gets_pdf(cdp_https_site: Any) -> None:+ """Seam reality: the worker HTTP client lands on the gate; the browser in-page fetch gets the PDF."""+ _context, page, port = cdp_https_site+ url = f"https://127.0.0.1:{port}/receipt.pdf"++ def _host_get() -> bytes:+ insecure = ssl.create_default_context()+ insecure.check_hostname = False+ insecure.verify_mode = ssl.CERT_NONE+ with urllib.request.urlopen(url, context=insecure, timeout=10) as resp:+ return resp.read()++ host_body = await asyncio.to_thread(_host_get)+ assert b"<html" in host_body.lower() and not host_body.startswith(b"%PDF-")++ recovered = await SkyvernFrame.read_http_url_bytes(page=page, url=url, max_size_bytes=10 * 1024 * 1024)+ assert recovered is not None and recovered.startswith(b"%PDF-") and b"(Receipt)" in recovered+++async def test_in_page_fetch_redirect_error_fails_closed(cdp_https_site: Any) -> None:+ global _REDIRECT_FINAL_HITS+ _REDIRECT_FINAL_HITS = 0+ _context, page, port = cdp_https_site+ result = await SkyvernFrame.read_http_url_bytes(page, f"https://127.0.0.1:{port}/redirect.pdf", redirect="error")+ assert result is None+ assert _REDIRECT_FINAL_HITS == 0+++async def test_in_page_fetch_chunked_response_stops_at_cap(cdp_https_site: Any) -> None:+ global _CHUNKED_SERVED+ _CHUNKED_SERVED = 0+ _context, page, port = cdp_https_site+ result = await SkyvernFrame.read_http_url_bytes(page, f"https://127.0.0.1:{port}/chunked.bin", max_size_bytes=1024)+ assert result is None+ assert _CHUNKED_SERVED < 32 * 256 * 1024+++async def test_in_page_fetch_empty_response_is_empty_bytes(cdp_https_site: Any) -> None:+ _context, page, port = cdp_https_site+ assert await SkyvernFrame.read_http_url_bytes(page, f"https://127.0.0.1:{port}/empty.bin") == b""+++async def test_download_url_directly_recovers_gated_download_in_page(cdp_https_site: Any, tmp_path: Path) -> None:+ """Full handler: host fetch returns the HTML masquerade; recovery lands the real PDF in-page."""+ context, page, port = cdp_https_site+ url = f"https://127.0.0.1:{port}/receipt.pdf"++ interceptor = _make_interceptor(str(tmp_path))+ interceptor._browser_context = context+ await interceptor.enable_for_page(page)+ guarded_fetch = AsyncMock(return_value=MagicMock(body=_GATE_HTML, content_type="text/html", filename="receipt.pdf"))+ try:+ with patch.object(mod.file_api, "fetch_file_bytes", guarded_fetch, create=True):+ await interceptor._download_url_directly(url, "receipt.pdf")+ finally:+ await interceptor.disable()++ saved = list(tmp_path.iterdir())+ assert len(saved) == 1, "the gated download was not recovered via the in-page same-origin fetch"+ body = saved[0].read_bytes()+ assert body.startswith(b"%PDF-") and b"(Receipt)" in body+++async def test_no_same_origin_page_stays_fail_closed(cdp_https_site: Any, tmp_path: Path) -> None:+ """Fail-closed: with no same-origin frame, recovery is unavailable and the masquerade failure stands."""+ context, page, port = cdp_https_site+ url = f"https://127.0.0.1:{port}/receipt.pdf"+ await page.goto("about:blank", wait_until="domcontentloaded")++ interceptor = _make_interceptor(str(tmp_path))+ interceptor._browser_context = context+ guarded_fetch = AsyncMock(return_value=MagicMock(body=_GATE_HTML, content_type="text/html", filename="receipt.pdf"))+ with patch.object(mod.file_api, "fetch_file_bytes", guarded_fetch, create=True):+ await interceptor._download_url_directly(url, "receipt.pdf")++ assert list(tmp_path.iterdir()) == []diff --git a/tests/unit/test_read_blob_url_bytes.py b/tests/unit/test_read_blob_url_bytes.pyindex 0b66e99cb..7440c0c61 100644--- a/tests/unit/test_read_blob_url_bytes.py+++ b/tests/unit/test_read_blob_url_bytes.py@@ -194,7 +194,56 @@ async def test_read_http_url_bytes_routes_main_frame_through_skyvern_frame_evalukwargs = eval_mock.await_args.kwargsassert kwargs["frame"] is page # main-frame targets the Page for main-world routingassert kwargs["expression"] == _SAME_ORIGIN_FETCH_JS- assert kwargs["arg"] == {"url": "https://host.example/api/StatementPdf?access_token=x", "maxSizeBytes": 1024}+ assert kwargs["arg"] == {+ "url": "https://host.example/api/StatementPdf?access_token=x",+ "maxSizeBytes": 1024,+ "redirect": "follow",+ }+++async def test_read_http_url_bytes_passes_optional_headers() -> None:+ page = MagicMock()+ main_frame = MagicMock()+ page.main_frame = main_frame+ evaluate = AsyncMock(return_value={"ok": True, "base64": ""})+ with (+ patch(f"{_MOD}._frames_for_origin", return_value=[main_frame]),+ patch.object(SkyvernFrame, "evaluate", evaluate),+ ):+ await SkyvernFrame.read_http_url_bytes(page, "https://host.example/x.pdf", headers={"X-Test": "v"})+ assert evaluate.await_args.kwargs["arg"] == {+ "url": "https://host.example/x.pdf",+ "maxSizeBytes": None,+ "headers": {"X-Test": "v"},+ "redirect": "follow",+ }+ evaluate.reset_mock()+ with (+ patch(f"{_MOD}._frames_for_origin", return_value=[main_frame]),+ patch.object(SkyvernFrame, "evaluate", evaluate),+ ):+ await SkyvernFrame.read_http_url_bytes(page, "https://host.example/x.pdf")+ assert evaluate.await_args.kwargs["arg"] == {+ "url": "https://host.example/x.pdf",+ "maxSizeBytes": None,+ "redirect": "follow",+ }+++async def test_read_http_url_bytes_can_fail_on_redirects_for_recovery() -> None:+ page = MagicMock()+ main_frame = MagicMock()+ page.main_frame = main_frame+ evaluate = AsyncMock(return_value={"ok": False, "error": "redirect_failed"})+ with (+ patch(f"{_MOD}._frames_for_origin", return_value=[main_frame]),+ patch.object(SkyvernFrame, "evaluate", evaluate),+ ):+ result = await SkyvernFrame.read_http_url_bytes(page, "https://host.example/x.pdf", redirect="error")+ assert result is None+ assert evaluate.await_args.kwargs["arg"]["redirect"] == "error"@pytest.mark.asyncio