Skip to content

Automate browser based workflows with AI

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.py
index 78d550e12..ddc27fc81 100644
--- a/skyvern/webeye/cdp_download_interceptor.py
+++ b/skyvern/webeye/cdp_download_interceptor.py
@@ -30,6 +30,7 @@ import stat
import threading
import time
import uuid
+from collections import OrderedDict
from collections.abc import AsyncIterator, Callable, Coroutine
from contextlib import asynccontextmanager
from dataclasses import dataclass
@@ -61,6 +62,7 @@ if TYPE_CHECKING:
from skyvern.forge.sdk.core.http_request_authorization import RedirectHopAuthorizer
LOG = 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_username
self._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_monitor
self._redirect_hop_authorizer = redirect_hop_authorizer
self._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 = False
self._download_index = 0
@@ -933,6 +947,7 @@ class CDPDownloadInterceptor:
)
self._artifact_scope_generation += 1
self._artifact_scope_valid = True
+ self._recovery_marker = uuid.uuid4().hex
if 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)
+
@property
def 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:
return
page, 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)
+ return
LOG.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:
pass
self._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 = None
try:
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_cancellation
self._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_monitor
authorized = 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)
+ raise
return
# Response stage: check for downloads
raw_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.py
index 964bef64c..ff89b7abf 100644
--- a/skyvern/webeye/utils/page.py
+++ b/skyvern/webeye/utils/page.py
@@ -11,7 +11,7 @@ import urllib.parse
from collections.abc import Awaitable, Callable
from enum import StrEnum
from io import BytesIO
-from typing import TYPE_CHECKING, Any, NamedTuple
+from typing import TYPE_CHECKING, Any, Literal, NamedTuple
import structlog
from 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_frame
for 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"] = headers
main_frame = page.main_frame
for frame in frames:
# Route the main frame through the Page so SkyvernFrame.evaluate can attach any
diff --git a/tests/unit/test_cdp_download_interceptor.py b/tests/unit/test_cdp_download_interceptor.py
index 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: Pa
assert 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 == 1
assert cdp_session.send.call_args.args[0] == "Fetch.continueRequest"
+ assert not interceptor._recovery_request_ids
@pytest.mark.asyncio
async 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.asyncio
async 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.py
index 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 None
assert 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.asyncio
diff --git a/tests/unit/test_download_in_page_fetch_recovery_e2e.py b/tests/unit/test_download_in_page_fetch_recovery_e2e.py
new file mode 100644
index 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.py
index 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_evalu
kwargs = eval_mock.await_args.kwargs
assert kwargs["frame"] is page # main-frame targets the Page for main-world routing
assert 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