Skip to content

Automate browser based workflows with AI

Recover adopted-session blob downloads by reading bytes at the download event (SKY-12621) (#7902)

LawyZhengfbbbca3e7847
diff --git a/skyvern/webeye/actions/handler.py b/skyvern/webeye/actions/handler.py
index b109726d3..04cd34ab9 100644
--- a/skyvern/webeye/actions/handler.py
+++ b/skyvern/webeye/actions/handler.py
@@ -249,6 +249,9 @@ class CustomSelectFamilyOutcome(StrEnum):
DOWNLOAD_EVENT_ACTIVE_DIR_GRACE_SECONDS = 60
DOWNLOAD_IN_FLIGHT_EXTENSION_MAX_SECONDS = 120
DOWNLOAD_IN_FLIGHT_POLL_INTERVAL_SECONDS = 1.0
+# Cap the event-time blob read so a stalled read never consumes the whole download-wait budget;
+# on timeout the save_as + fan-out fallback still gets its chance.
+EAGER_BLOB_READ_TIMEOUT_SECONDS = 5.0
DOWNLOAD_DUPLICATE_STEM_SUFFIX_RE = re.compile(r"(?:\s+\(\d{1,3}\)|_\d{1,3})$")
SELECT_SHADOW_MATCH_APOSTROPHE_RE = re.compile(r"['`‘’]")
SELECT_SHADOW_MATCH_WORD_RE = re.compile(r"\w+")
@@ -764,11 +767,115 @@ def _blob_download_candidate_pages(download: Download, page: Page) -> list[Page]
return candidates
+async def _read_adopted_session_blob_bytes(
+ download: Download,
+ page: Page,
+ workflow_run_id: str | None = None,
+) -> bytes | None:
+ """Read a blob: download's bytes by fanning out over its candidate pages, owner first.
+
+ Returns the bytes from the first page that owns the blob (``b""`` is a valid zero-byte
+ read), or ``None`` when no open page can resolve it.
+ """
+ for candidate in _blob_download_candidate_pages(download, page):
+ blob_bytes = await SkyvernFrame.read_blob_url_bytes(
+ page=candidate,
+ blob_url=download.url,
+ workflow_run_id=workflow_run_id,
+ max_size_bytes=MAX_FILE_SIZE_BYTES,
+ probe=True,
+ )
+ if blob_bytes is not None:
+ return blob_bytes
+ return None
+
+
+class _EagerAdoptedBlobCapture:
+ """Read an adopted-session blob download's bytes the instant the download event fires.
+
+ A blob: URL only resolves inside the document that minted it, and that document is
+ frequently torn down (navigation, ``revokeObjectURL``, tab close) before the ~1s download
+ poll runs ``_save_adopted_session_download`` — so the post-hoc fan-out reads a context in
+ which the owner is already gone. Reading here, at the download event, captures the bytes
+ while the owner is still live. Armed only for adopted/persistent sessions and blob: URLs.
+ """
+
+ def __init__(self, *, enabled: bool, clicked_page: Page, workflow_run_id: str | None) -> None:
+ self._enabled = enabled
+ self._clicked_page = clicked_page
+ self._workflow_run_id = workflow_run_id
+ self._task: asyncio.Task[None] | None = None
+ self._bytes: bytes | None = None
+
+ def maybe_start(self, download: Download) -> None:
+ if not self._enabled or self._task is not None:
+ return
+ if not (download.url or "").startswith("blob:"):
+ return
+ self._task = asyncio.create_task(self._run(download))
+
+ async def _run(self, download: Download) -> None:
+ try:
+ self._bytes = await _read_adopted_session_blob_bytes(
+ download, self._clicked_page, workflow_run_id=self._workflow_run_id
+ )
+ except asyncio.CancelledError:
+ raise
+ except Exception:
+ LOG.debug(
+ "Eager adopted-session blob capture failed",
+ workflow_run_id=self._workflow_run_id,
+ exc_info=True,
+ )
+
+ async def result(self, timeout: float) -> bytes | None:
+ if self._task is None:
+ return None
+ try:
+ # Shield so the timeout unblocks us without tearing the read down mid-flight; on timeout
+ # we then cancel+drain below so save_as/fan-out never run while the read still holds bytes.
+ await asyncio.wait_for(asyncio.shield(self._task), timeout=timeout)
+ except asyncio.TimeoutError:
+ LOG.warning(
+ "Eager adopted-session blob capture did not finish before it was needed",
+ workflow_run_id=self._workflow_run_id,
+ )
+ await self.aclose()
+ except Exception:
+ LOG.debug(
+ "Eager adopted-session blob capture result raised",
+ workflow_run_id=self._workflow_run_id,
+ exc_info=True,
+ )
+ return self._bytes
+
+ async def aclose(self) -> None:
+ task = self._task
+ if task is None or task.done():
+ return
+ task.cancel()
+ try:
+ await task
+ except asyncio.CancelledError:
+ # Swallow the cancellation we requested, but if this coroutine is itself being
+ # cancelled, re-raise so the enclosing timeout/cancel scope still observes it.
+ current = asyncio.current_task()
+ if current is not None and current.cancelling():
+ raise
+ except Exception:
+ LOG.debug(
+ "Eager adopted-session blob capture cleanup raised",
+ workflow_run_id=self._workflow_run_id,
+ exc_info=True,
+ )
+
+
async def _save_adopted_session_download(
download: Download,
page: Page,
download_dir: Path,
workflow_run_id: str | None = None,
+ eager_blob_bytes: bytes | None = None,
) -> Path | None:
"""Land an adopted-session download's bytes into download_dir, returning the file path or None.
@@ -776,6 +883,19 @@ async def _save_adopted_session_download(
deferred save_as runs.
"""
download_target = _download_target_path(download_dir, download.suggested_filename)
+ # Non-empty bytes captured at download-event time (blob owner still alive) win outright: skip
+ # save_as, which returns empty for blobs anyway. A zero-byte eager capture is indistinguishable
+ # from an unreadable one and would be a false success, so fall through to save_as + fan-out
+ # (matching _persist_captured_download's empty-file handling and the CDP interceptor).
+ if download.url.startswith("blob:") and eager_blob_bytes:
+ download_target.write_bytes(eager_blob_bytes)
+ return download_target
+ if download.url.startswith("blob:") and eager_blob_bytes == b"":
+ LOG.warning(
+ "Eager adopted-session blob capture returned zero bytes; falling through to save_as/fan-out",
+ download_dir=str(download_dir),
+ workflow_run_id=workflow_run_id,
+ )
persisted = await _persist_captured_download(
download, target=download_target, timeout=BROWSER_DOWNLOAD_MAX_WAIT_TIME
)
@@ -801,20 +921,13 @@ async def _save_adopted_session_download(
# owns the blob. That document may be a different tab than the one clicked, so
# probe every open page (owner first) rather than reading from ``page`` alone.
if download.url.startswith("blob:"):
- candidate_pages = _blob_download_candidate_pages(download, page)
- blob_bytes: bytes | None = None
- for candidate in candidate_pages:
- blob_bytes = await SkyvernFrame.read_blob_url_bytes(
- page=candidate, blob_url=download.url, workflow_run_id=workflow_run_id, probe=True
- )
- if blob_bytes is not None:
- break
+ blob_bytes = await _read_adopted_session_blob_bytes(download, page, workflow_run_id=workflow_run_id)
if blob_bytes is None:
LOG.warning(
"Adopted-session blob download could not be read from any open page",
download_dir=str(download_dir),
workflow_run_id=workflow_run_id,
- candidate_page_count=len(candidate_pages),
+ candidate_page_count=len(_blob_download_candidate_pages(download, page)),
)
return None
download_target.write_bytes(blob_bytes)
@@ -2773,10 +2886,23 @@ class ActionHandler:
run_id = resolve_run_download_id(context, fallback_run_id=task.workflow_run_id or task.task_id)
download_dir = Path(get_download_dir(run_id=run_id))
download_event: asyncio.Future[Download] = asyncio.get_running_loop().create_future()
+ eager_blob_capture = _EagerAdoptedBlobCapture(
+ enabled=bool(task.browser_session_id),
+ clicked_page=page,
+ workflow_run_id=task.workflow_run_id,
+ )
+ download_popup_callbacks: list[tuple[Page, Callable[[Download], None]]] = []
def _capture_download_event(download: Download) -> None:
if not download_event.done():
download_event.set_result(download)
+ eager_blob_capture.maybe_start(download)
+
+ def _register_download_popup(popup_page: Page) -> None:
+ # A blob download frequently mints its document in a new tab, so the download event
+ # fires on the popup, not the clicked page. Capture there too so the owner is read live.
+ popup_page.on("download", _capture_download_event)
+ download_popup_callbacks.append((popup_page, _capture_download_event))
def _download_signal_identity(file: str) -> str:
return file.removesuffix(BROWSER_DOWNLOADING_SUFFIX)
@@ -2870,6 +2996,10 @@ class ActionHandler:
workflow_run_id=task.workflow_run_id,
)
page.on("download", _capture_download_event)
+ # Popup-owned blob downloads only matter for adopted/persistent sessions; managed sessions
+ # keep their existing single-page download behavior with no popup-download wiring.
+ if task.browser_session_id:
+ page.on("popup", _register_download_popup)
try:
await transient_text_observer.start(scan_initial_visible_state=False)
xhr_capture.enable()
@@ -2970,6 +3100,12 @@ class ActionHandler:
page,
download_dir,
workflow_run_id=task.workflow_run_id,
+ eager_blob_bytes=await eager_blob_capture.result(
+ timeout=min(
+ EAGER_BLOB_READ_TIMEOUT_SECONDS,
+ _remaining_download_wait_seconds(),
+ )
+ ),
)
if saved_path is not None:
download_event_fallback_used = True
@@ -3206,6 +3342,17 @@ class ActionHandler:
)
return results
finally:
+ await eager_blob_capture.aclose()
+ for observed_popup, popup_callback in download_popup_callbacks:
+ try:
+ _remove_download_listener(observed_popup, popup_callback)
+ except Exception:
+ LOG.warning("Failed to remove download popup listener", exc_info=True)
+ if task.browser_session_id:
+ try:
+ _remove_popup_listener(page, _register_download_popup)
+ except Exception:
+ LOG.warning("Failed to remove download popup registrar", exc_info=True)
try:
await transient_text_observer.stop()
finally:
diff --git a/tests/unit/test_adopted_session_download_save.py b/tests/unit/test_adopted_session_download_save.py
index 849c7ea0e..d94ebaa83 100644
--- a/tests/unit/test_adopted_session_download_save.py
+++ b/tests/unit/test_adopted_session_download_save.py
@@ -10,13 +10,18 @@ cannot be used; the helper runs an in-page ``fetch`` from a frame whose origin o
the blob and returns the bytes that way.
"""
+import asyncio
import base64
from pathlib import Path
-from unittest.mock import AsyncMock, MagicMock
+from unittest.mock import AsyncMock, MagicMock, patch
import pytest
-from skyvern.webeye.actions.handler import _save_adopted_session_download
+from skyvern.webeye.actions.handler import (
+ _EagerAdoptedBlobCapture,
+ _read_adopted_session_blob_bytes,
+ _save_adopted_session_download,
+)
PDF_BODY = b"%PDF-1.4\n" + b"x" * 830
@@ -458,3 +463,254 @@ async def test_blob_url_matches_frame_whose_url_is_itself_blob(tmp_path) -> None
assert saved.read_bytes() == PDF_BODY
page.evaluate.assert_awaited_once()
page.main_frame.evaluate.assert_not_awaited()
+
+
+# ---------------------------------------------------------------------------
+# Event-time eager capture (SKY-12621 fix #2). A blob download's owning document is
+# frequently torn down before the ~1s download poll, so the post-hoc fan-out reads a
+# context where the owner is already gone. Bytes captured at the download event must be
+# used outright, and the fan-out kept only as a fallback.
+# ---------------------------------------------------------------------------
+
+
+async def test_eager_blob_bytes_used_even_when_owner_unreadable_at_save_time(tmp_path) -> None:
+ """The pre-captured bytes must persist even though save_as and every open page fail by save time."""
+ download = _download(url=BLOB_URL)
+ download.save_as = AsyncMock(side_effect=AssertionError("save_as must not run when eager bytes exist"))
+ # Owner is gone: no frame can resolve the blob and the context has only the click page.
+ page = _blob_capable_page(_frame(OTHER_ORIGIN_FRAME_URL))
+
+ saved = await _save_adopted_session_download(
+ download, page, tmp_path, workflow_run_id="wr", eager_blob_bytes=PDF_BODY
+ )
+
+ assert saved is not None and saved.exists()
+ assert saved.read_bytes() == PDF_BODY
+ download.save_as.assert_not_awaited()
+ page.main_frame.evaluate.assert_not_awaited()
+ assert sorted(p.name for p in tmp_path.iterdir()) == [saved.name]
+
+
+async def test_eager_capture_reads_popup_owner_page(tmp_path) -> None:
+ """When the blob is minted in a popup tab, the eager read must resolve it from download.page."""
+ download = _download(url=BLOB_URL)
+ owner_frame = _frame(
+ BLOB_ORIGIN_FRAME_URL,
+ evaluate_return={"ok": True, "base64": base64.b64encode(PDF_BODY).decode("ascii")},
+ )
+ owner_popup = _blob_capable_page(owner_frame)
+ download.page = owner_popup
+ clicked_page = _blob_capable_page(_frame(OTHER_ORIGIN_FRAME_URL))
+
+ capture = _EagerAdoptedBlobCapture(enabled=True, clicked_page=clicked_page, workflow_run_id="wr")
+ capture.maybe_start(download)
+ captured = await capture.result(timeout=5)
+
+ assert captured == PDF_BODY
+ owner_frame.evaluate.assert_awaited_once()
+
+
+async def test_eager_none_falls_through_to_save_as_and_fan_out(tmp_path) -> None:
+ """eager_blob_bytes=None must leave the existing save_as + fan-out recovery path intact."""
+ download = _download(url=BLOB_URL)
+ download.save_as.side_effect = Exception("closed")
+ owner_frame = _frame(
+ BLOB_ORIGIN_FRAME_URL,
+ evaluate_return={"ok": True, "base64": base64.b64encode(PDF_BODY).decode("ascii")},
+ )
+ click_page = _blob_capable_page(_frame(OTHER_ORIGIN_FRAME_URL))
+ owner_page = _blob_capable_page(owner_frame)
+ click_page.context.pages = [click_page, owner_page]
+
+ saved = await _save_adopted_session_download(
+ download, click_page, tmp_path, workflow_run_id="wr", eager_blob_bytes=None
+ )
+
+ assert saved is not None and saved.read_bytes() == PDF_BODY
+ download.save_as.assert_awaited_once()
+ owner_frame.evaluate.assert_awaited_once()
+
+
+async def test_eager_zero_byte_bytes_fall_through_to_fallback(tmp_path) -> None:
+ """A zero-byte eager capture is a false success: don't write it, fall through to save_as/fan-out."""
+ download = _download(url=BLOB_URL)
+
+ async def _save(target: object) -> None:
+ Path(str(target)).write_bytes(PDF_BODY)
+
+ download.save_as = AsyncMock(side_effect=_save)
+ page = _blob_capable_page(_frame(OTHER_ORIGIN_FRAME_URL))
+
+ saved = await _save_adopted_session_download(download, page, tmp_path, workflow_run_id="wr", eager_blob_bytes=b"")
+
+ # save_as fallback ran and produced the real artifact; no zero-byte file was persisted as success.
+ download.save_as.assert_awaited_once()
+ assert saved is not None and saved.read_bytes() == PDF_BODY
+ assert sorted(p.name for p in tmp_path.iterdir()) == [saved.name]
+
+
+async def test_non_blob_download_skips_eager_capture(tmp_path) -> None:
+ """A non-blob download must not arm the eager blob reader, and eager bytes are ignored for it."""
+ http_download = _download(url="https://example.com/statement.pdf")
+ capture = _EagerAdoptedBlobCapture(enabled=True, clicked_page=MagicMock(), workflow_run_id="wr")
+ capture.maybe_start(http_download)
+ assert await capture.result(timeout=1) is None
+
+ async def _save(target: object) -> None:
+ Path(str(target)).write_bytes(PDF_BODY)
+
+ http_download.save_as.side_effect = _save
+ page = _page_with_refetch()
+ saved = await _save_adopted_session_download(
+ http_download, page, tmp_path, workflow_run_id="wr", eager_blob_bytes=b"IGNORED"
+ )
+ assert saved is not None and saved.read_bytes() == PDF_BODY
+ http_download.save_as.assert_awaited_once()
+
+
+async def test_eager_capture_disabled_for_managed_session() -> None:
+ """Managed sessions (enabled=False) never arm the eager reader."""
+ download = _download(url=BLOB_URL)
+ capture = _EagerAdoptedBlobCapture(enabled=False, clicked_page=MagicMock(), workflow_run_id="wr")
+ capture.maybe_start(download)
+ assert await capture.result(timeout=1) is None
+
+
+async def test_eager_capture_lifecycle_success_no_leak() -> None:
+ download = _download(url=BLOB_URL)
+ with patch(
+ "skyvern.webeye.actions.handler._read_adopted_session_blob_bytes",
+ AsyncMock(return_value=PDF_BODY),
+ ):
+ capture = _EagerAdoptedBlobCapture(enabled=True, clicked_page=MagicMock(), workflow_run_id="wr")
+ capture.maybe_start(download)
+ assert await capture.result(timeout=5) == PDF_BODY
+ await capture.aclose()
+ assert capture._task is not None and capture._task.done()
+
+
+async def test_eager_capture_lifecycle_timeout_then_cleanup() -> None:
+ download = _download(url=BLOB_URL)
+ started = asyncio.Event()
+
+ async def _hang(*args, **kwargs) -> bytes:
+ started.set()
+ await asyncio.Event().wait()
+ return PDF_BODY
+
+ with patch("skyvern.webeye.actions.handler._read_adopted_session_blob_bytes", _hang):
+ capture = _EagerAdoptedBlobCapture(enabled=True, clicked_page=MagicMock(), workflow_run_id="wr")
+ capture.maybe_start(download)
+ await started.wait()
+ # A short deadline returns None and cancel+drains the read so no read runs concurrently
+ # with save_as/fan-out.
+ assert await capture.result(timeout=0.01) is None
+ assert capture._task is not None and capture._task.done()
+ # aclose is idempotent once result already drained the task.
+ await capture.aclose()
+ assert capture._task.done()
+
+
+async def test_eager_capture_aclose_cancels_before_completion() -> None:
+ download = _download(url=BLOB_URL)
+ started = asyncio.Event()
+
+ async def _hang(*args, **kwargs) -> bytes:
+ started.set()
+ await asyncio.Event().wait()
+ return PDF_BODY
+
+ with patch("skyvern.webeye.actions.handler._read_adopted_session_blob_bytes", _hang):
+ capture = _EagerAdoptedBlobCapture(enabled=True, clicked_page=MagicMock(), workflow_run_id="wr")
+ capture.maybe_start(download)
+ await started.wait()
+ await capture.aclose()
+ assert capture._task is not None and capture._task.cancelled()
+
+
+async def test_eager_capture_aclose_reraises_outer_cancellation() -> None:
+ """aclose must swallow only the cancellation it requested; an outer cancel on the awaiting
+ coroutine must propagate so the enclosing timeout/cancel scope still sees it."""
+ download = _download(url=BLOB_URL)
+ started = asyncio.Event()
+
+ async def _hang(*args, **kwargs) -> bytes:
+ started.set()
+ await asyncio.Event().wait()
+ return PDF_BODY
+
+ with patch("skyvern.webeye.actions.handler._read_adopted_session_blob_bytes", _hang):
+ capture = _EagerAdoptedBlobCapture(enabled=True, clicked_page=MagicMock(), workflow_run_id="wr")
+ capture.maybe_start(download)
+ await started.wait()
+
+ # Request cancellation of this coroutine; it lands on aclose's ``await task`` suspension.
+ this = asyncio.current_task()
+ assert this is not None
+ this.cancel()
+ reraised = False
+ try:
+ await capture.aclose()
+ except asyncio.CancelledError:
+ reraised = True
+ this.uncancel()
+
+ assert reraised, "aclose must propagate an outer cancellation, not swallow it"
+
+
+async def test_read_adopted_session_blob_bytes_prefers_owner_then_fans_out() -> None:
+ """The extracted reader returns the first page that owns the blob, owner (download.page) first."""
+ download = _download(url=BLOB_URL)
+ owner_frame = _frame(
+ BLOB_ORIGIN_FRAME_URL,
+ evaluate_return={"ok": True, "base64": base64.b64encode(PDF_BODY).decode("ascii")},
+ )
+ owner_page = _blob_capable_page(owner_frame)
+ click_page = _blob_capable_page(_frame(OTHER_ORIGIN_FRAME_URL))
+ click_page.context.pages = [click_page, owner_page]
+ download.page = owner_page
+
+ assert await _read_adopted_session_blob_bytes(download, click_page, workflow_run_id="wr") == PDF_BODY
+ owner_frame.evaluate.assert_awaited_once()
+
+
+async def test_read_adopted_session_blob_bytes_passes_memory_cap() -> None:
+ """The reader must cap eager base64 capture with the canonical MAX_FILE_SIZE_BYTES."""
+ from skyvern.webeye.actions.handler import MAX_FILE_SIZE_BYTES
+
+ download = _download(url=BLOB_URL)
+ click_page = _blob_capable_page(_frame(OTHER_ORIGIN_FRAME_URL))
+ with patch(
+ "skyvern.webeye.actions.handler.SkyvernFrame.read_blob_url_bytes",
+ AsyncMock(return_value=PDF_BODY),
+ ) as read_mock:
+ result = await _read_adopted_session_blob_bytes(download, click_page, workflow_run_id="wr")
+
+ assert result == PDF_BODY
+ assert read_mock.await_count >= 1
+ for read_call in read_mock.await_args_list:
+ assert read_call.kwargs["max_size_bytes"] == MAX_FILE_SIZE_BYTES
+
+
+async def test_read_adopted_session_blob_bytes_oversized_returns_none() -> None:
+ """When read_blob_url_bytes rejects an over-cap blob (None), the reader yields None (fallback)."""
+ download = _download(url=BLOB_URL)
+ click_page = _blob_capable_page(_frame(OTHER_ORIGIN_FRAME_URL))
+ with patch(
+ "skyvern.webeye.actions.handler.SkyvernFrame.read_blob_url_bytes",
+ AsyncMock(return_value=None),
+ ):
+ assert await _read_adopted_session_blob_bytes(download, click_page, workflow_run_id="wr") is None
diff --git a/tests/unit/test_download_file_action_handler.py b/tests/unit/test_download_file_action_handler.py
index 7b1a1083b..03fb187e6 100644
--- a/tests/unit/test_download_file_action_handler.py
+++ b/tests/unit/test_download_file_action_handler.py
@@ -22,6 +22,7 @@ from skyvern.webeye.actions.handler import (
ScopedXhrDownloadCapture,
_cleanup_captured_download_popup,
_collect_inline_iframe_src_candidates,
+ _EagerAdoptedBlobCapture,
_looks_like_pdf,
_persist_captured_download,
_recover_blocked_inline_pdf_download,
@@ -1756,6 +1757,8 @@ async def test_handle_action_download_no_signal_fails_fast(span_exporter: InMemo
page = MagicMock()
page.url = "https://example.com/no-download"
+ download_listeners: dict[str, Callable[[object], None]] = {}
+ page.on.side_effect = lambda event, callback: download_listeners.__setitem__(event, callback)
page.context.browser = None
browser_state = MagicMock()
@@ -1818,7 +1821,11 @@ async def test_handle_action_download_no_signal_fails_fast(span_exporter: InMemo
assert results[-1].needs_followup is True
assert results[-1].followup_message == DOWNLOAD_NOT_TRIGGERED_FOLLOWUP_MESSAGE
assert wait_for_downloads.await_count == 0
- page.off.assert_called_once()
+ page.off.assert_any_call("download", download_listeners["download"])
+ # Managed (non-adopted) sessions must not gain popup-download-event wiring.
+ assert "popup" not in download_listeners
+ assert not any(c.args and c.args[0] == "popup" for c in page.on.call_args_list)
+ assert not any(c.args and c.args[0] == "popup" for c in page.off.call_args_list)
span_attrs = _download_wait_span_attrs(span_exporter)
assert span_attrs["download_signal_observed"] is False
assert span_attrs["download_wait_extended_for_in_flight_request"] is False
@@ -1905,6 +1912,8 @@ async def test_handle_action_download_fails_on_transient_user_defined_error_text
)
action.errors = [existing_error]
page.evaluate = AsyncMock()
+ download_listeners: dict[str, Callable[[object], None]] = {}
+ page.on.side_effect = lambda event, callback: download_listeners.__setitem__(event, callback)
async def expose_binding(_name: str, callback: Callable[[dict, dict], None]) -> None:
page._transient_text_callback = callback
@@ -1971,7 +1980,7 @@ async def test_handle_action_download_fails_on_transient_user_defined_error_text
assert [error.error_code for error in action.errors] == ["previous_error", "data_not_downloadable"]
assert action.terminal_user_errors is True
assert wait_for_downloads.await_count == 0
- page.off.assert_called_once()
+ page.off.assert_any_call("download", download_listeners["download"])
assert page.expose_binding.await_count == 1
observer_install_count = sum(
"new MutationObserver" in call.kwargs["expression"] for call in page.evaluate.await_args_list
@@ -2624,7 +2633,7 @@ async def test_handle_action_prefers_observed_file_over_download_event_copy(
assert wait_for_downloads.await_count == 1
assert settle_count == 1
download.save_as.assert_not_awaited()
- page.off.assert_called_once_with("download", download_callbacks["download"])
+ page.off.assert_any_call("download", download_callbacks["download"])
span_attrs = _download_wait_span_attrs(span_exporter)
assert span_attrs["download_signal_observed"] is True
assert span_attrs["download_signal_source"] == "browser_download_event"
@@ -2732,7 +2741,7 @@ async def test_handle_action_copies_download_event_when_no_observed_file_appears
persist.assert_awaited_once()
saved_path = download.save_as.await_args.args[0]
assert os.path.dirname(saved_path) == primary_dir
- page.off.assert_called_once_with("download", download_callbacks["download"])
+ page.off.assert_any_call("download", download_callbacks["download"])
span_attrs = _download_wait_span_attrs(span_exporter)
assert span_attrs["download_signal_observed"] is True
assert span_attrs["download_signal_source"] == "browser_download_event"
@@ -2835,7 +2844,7 @@ async def test_handle_action_ignores_empty_download_event_fallback_file(
assert remaining_files == []
assert wait_for_downloads.await_count == 1
download.save_as.assert_awaited_once()
- page.off.assert_called_once_with("download", download_callbacks["download"])
+ page.off.assert_any_call("download", download_callbacks["download"])
span_attrs = _download_wait_span_attrs(span_exporter)
assert span_attrs["download_signal_observed"] is True
assert span_attrs["download_signal_source"] == "browser_download_event"
@@ -2931,7 +2940,7 @@ async def test_handle_action_stops_after_download_event_fallback_failure(
assert action.download_triggered is False
assert wait_for_downloads.await_count == 0
download.save_as.assert_awaited_once()
- page.off.assert_called_once_with("download", download_callbacks["download"])
+ page.off.assert_any_call("download", download_callbacks["download"])
span_attrs = _download_wait_span_attrs(span_exporter)
assert span_attrs["download_signal_observed"] is True
assert span_attrs["download_signal_source"] == "browser_download_event"
@@ -2962,6 +2971,8 @@ async def test_handle_action_removes_late_zero_byte_duplicate_after_download_wai
page = MagicMock()
page.url = "https://example.com/download"
page.context.browser = None
+ download_listeners: dict[str, Callable[[object], None]] = {}
+ page.on.side_effect = lambda event, callback: download_listeners.__setitem__(event, callback)
browser_state = MagicMock()
browser_state.list_valid_pages = AsyncMock(return_value=[page])
@@ -3030,7 +3041,7 @@ async def test_handle_action_removes_late_zero_byte_duplicate_after_download_wai
assert results[-1].downloaded_files == ["report.pdf"]
assert action.downloaded_files == ["report.pdf"]
assert remaining_files == ["report.pdf"]
- page.off.assert_called_once()
+ page.off.assert_any_call("download", download_listeners["download"])
@pytest.mark.asyncio
@@ -3097,7 +3108,7 @@ async def test_handle_action_removes_download_listener_when_inner_action_raises(
action=action,
)
- page.off.assert_called_once_with("download", download_callbacks["download"])
+ page.off.assert_any_call("download", download_callbacks["download"])
@pytest.mark.asyncio
@@ -4733,3 +4744,283 @@ async def test_handle_download_file_action_navigates_to_validated_url(monkeypatc
validate.assert_called_once_with("https://example.test/file.pdf")
assert page.goto.call_args[0][0] == "https://example.test/validated.pdf"
assert isinstance(result[0], ActionSuccess)
+
+
+ADOPTED_BLOB_DOWNLOAD_URL = "blob:https://files.example.org/8c70-60a8e380e78a"
+
+
+async def test_handle_action_adopted_popup_blob_download_wired_end_to_end() -> None:
+ """Runtime proof of the eager blob path for adopted sessions (SKY-12621).
+
+ Drives the real wiring: page.on("popup", ...) -> popup "download" event -> eager
+ maybe_start -> result threaded into the save path -> listener cleanup. It fails if any of
+ those links is removed, because fix #1 was correct in isolation yet broken at runtime.
+ """
+ now = datetime.now(UTC)
+ organization = make_organization(now)
+ task = make_task(
+ now,
+ organization,
+ workflow_run_id="wr-1",
+ browser_session_id="pbs-session",
+ download_timeout=30.0,
+ )
+ step = make_step(now, task, step_id="step-1", status=StepStatus.created, order=0, output=None)
+
+ page = MagicMock()
+ page.url = "https://example.com/statements"
+ page.context.browser = None
+ page_listeners: dict[str, Callable[[object], None]] = {}
+ page.on.side_effect = lambda event, cb: page_listeners.__setitem__(event, cb)
+
+ browser_state = MagicMock()
+ browser_state.list_valid_pages = AsyncMock(return_value=[page])
+ scraped_page = ScrapedPage(
+ elements=[],
+ element_tree=[],
+ element_tree_trimmed=[],
+ _browser_state=browser_state,
+ _clean_up_func=AsyncMock(return_value=[]),
+ _scrape_exclude=None,
+ )
+ action = ClickAction(
+ element_id="view-document",
+ download=True,
+ organization_id=task.organization_id,
+ task_id=task.task_id,
+ step_id=step.step_id,
+ )
+
+ popup_page = MagicMock()
+ popup_page.url = "about:blank"
+ popup_listeners: dict[str, Callable[[object], None]] = {}
+ popup_page.on.side_effect = lambda event, cb: popup_listeners.__setitem__(event, cb)
+
+ download = MagicMock()
+ download.suggested_filename = "statement.pdf"
+ download.url = ADOPTED_BLOB_DOWNLOAD_URL
+ download.page = popup_page
+ download.save_as = AsyncMock()
+
+ with tempfile.TemporaryDirectory() as temp_root:
+ primary_dir = os.path.join(temp_root, "pbs-1")
+ os.makedirs(primary_dir)
+
+ async def mock_inner_handle_action(*args: object, **kwargs: object) -> list[ActionSuccess]:
+ # A "View Document" click opens the blob in a popup that mints and downloads it, then closes.
+ page_listeners["popup"](popup_page)
+ popup_listeners["download"](download)
+ return [ActionSuccess()]
+
+ mock_app = MagicMock()
+ mock_app.BROWSER_MANAGER.get_for_task.return_value = browser_state
+ mock_app.DATABASE.workflow_params.create_action = AsyncMock(return_value=action)
+ mock_app.STORAGE = MagicMock()
+ mock_app.STORAGE.list_downloading_files_in_browser_session = AsyncMock(return_value=[])
+ mock_app.STORAGE.list_downloaded_files_in_browser_session = AsyncMock(return_value=[])
+
+ with (
+ patch.object(ActionHandler, "_handle_action", side_effect=mock_inner_handle_action),
+ patch(
+ "skyvern.webeye.actions.handler._read_adopted_session_blob_bytes",
+ AsyncMock(return_value=b"%PDF-1.4 statement bytes"),
+ ) as eager_read,
+ patch("skyvern.webeye.actions.handler.get_download_dir", return_value=primary_dir),
+ patch(
+ "skyvern.webeye.actions.handler.skyvern_context.current",
+ return_value=MagicMock(run_id="pbs-1", download_suffix=None),
+ ),
+ patch(
+ "skyvern.webeye.actions.handler.check_downloading_files_and_wait_for_download_to_complete",
+ new=AsyncMock(),
+ ),
+ patch("skyvern.webeye.actions.handler.app", mock_app),
+ ):
+ results = await asyncio.wait_for(
+ ActionHandler.handle_action(
+ scraped_page=scraped_page,
+ task=task,
+ step=step,
+ page=page,
+ action=action,
+ ),
+ timeout=CI_TEST_RUNAWAY_TIMEOUT_SECONDS,
+ )
+
+ saved = sorted(os.listdir(primary_dir))
+
+ assert results[-1].download_triggered is True
+ assert results[-1].downloaded_files
+ assert len(saved) == 1 and saved[0].endswith("statement.pdf")
+ # Eager bytes came from the popup owner and short-circuit save_as.
+ eager_read.assert_awaited()
+ download.save_as.assert_not_awaited()
+ # Popup download wiring was registered and torn down.
+ assert "popup" in page_listeners
+ popup_page.off.assert_any_call("download", popup_listeners["download"])
+ page.off.assert_any_call("popup", page_listeners["popup"])
+
+
+async def test_handle_action_eager_read_timeout_does_not_starve_fallback() -> None:
+ """A stalled eager read must not consume the whole download-wait budget; the save_as fallback
+ must still run within its own bounded window (SKY-12621 fix 1)."""
+ now = datetime.now(UTC)
+ organization = make_organization(now)
+ task = make_task(
+ now,
+ organization,
+ workflow_run_id="wr-1",
+ browser_session_id="pbs-session",
+ download_timeout=30.0,
+ )
+ step = make_step(now, task, step_id="step-1", status=StepStatus.created, order=0, output=None)
+
+ page = MagicMock()
+ page.url = "https://example.com/statements"
+ page.context.browser = None
+ page_listeners: dict[str, Callable[[object], None]] = {}
+ page.on.side_effect = lambda event, cb: page_listeners.__setitem__(event, cb)
+
+ browser_state = MagicMock()
+ browser_state.list_valid_pages = AsyncMock(return_value=[page])
+ scraped_page = ScrapedPage(
+ elements=[],
+ element_tree=[],
+ element_tree_trimmed=[],
+ _browser_state=browser_state,
+ _clean_up_func=AsyncMock(return_value=[]),
+ _scrape_exclude=None,
+ )
+ action = ClickAction(
+ element_id="view-document",
+ download=True,
+ organization_id=task.organization_id,
+ task_id=task.task_id,
+ step_id=step.step_id,
+ )
+
+ download = MagicMock()
+ download.suggested_filename = "statement.pdf"
+ download.url = ADOPTED_BLOB_DOWNLOAD_URL
+ download.page = page
+
+ async def _save_as(target: object) -> None:
+ Path(str(target)).write_bytes(b"%PDF-1.4 fallback bytes")
+
+ download.save_as = AsyncMock(side_effect=_save_as)
+
+ async def _hang(*args: object, **kwargs: object) -> bytes:
+ await asyncio.Event().wait()
+ return b"never"
+
+ with tempfile.TemporaryDirectory() as temp_root:
+ primary_dir = os.path.join(temp_root, "pbs-1")
+ os.makedirs(primary_dir)
+
+ async def mock_inner_handle_action(*args: object, **kwargs: object) -> list[ActionSuccess]:
+ page_listeners["download"](download)
+ return [ActionSuccess()]
+
+ mock_app = MagicMock()
+ mock_app.BROWSER_MANAGER.get_for_task.return_value = browser_state
+ mock_app.DATABASE.workflow_params.create_action = AsyncMock(return_value=action)
+ mock_app.STORAGE = MagicMock()
+ mock_app.STORAGE.list_downloading_files_in_browser_session = AsyncMock(return_value=[])
+ mock_app.STORAGE.list_downloaded_files_in_browser_session = AsyncMock(return_value=[])
+
+ started_at = time.monotonic()
+ with (
+ patch.object(ActionHandler, "_handle_action", side_effect=mock_inner_handle_action),
+ patch("skyvern.webeye.actions.handler._read_adopted_session_blob_bytes", _hang),
+ patch("skyvern.webeye.actions.handler.EAGER_BLOB_READ_TIMEOUT_SECONDS", 0.1),
+ patch("skyvern.webeye.actions.handler.get_download_dir", return_value=primary_dir),
+ patch(
+ "skyvern.webeye.actions.handler.skyvern_context.current",
+ return_value=MagicMock(run_id="pbs-1", download_suffix=None),
+ ),
+ patch(
+ "skyvern.webeye.actions.handler.check_downloading_files_and_wait_for_download_to_complete",
+ new=AsyncMock(),
+ ),
+ patch("skyvern.webeye.actions.handler.app", mock_app),
+ ):
+ results = await asyncio.wait_for(
+ ActionHandler.handle_action(
+ scraped_page=scraped_page,
+ task=task,
+ step=step,
+ page=page,
+ action=action,
+ ),
+ timeout=CI_TEST_RUNAWAY_TIMEOUT_SECONDS,
+ )
+ elapsed = time.monotonic() - started_at
+ saved = sorted(os.listdir(primary_dir))
+
+ # The stalled eager read timed out fast and the save_as fallback produced the artifact.
+ assert elapsed < CI_TEST_RUNAWAY_TIMEOUT_SECONDS
+ assert results[-1].download_triggered is True
+ download.save_as.assert_awaited()
+ assert len(saved) == 1 and saved[0].endswith("statement.pdf")
+
+
+async def test_handle_action_managed_session_disables_eager_and_popup_wiring() -> None:
+ """The construction-site gate must disable eager capture and skip popup wiring for managed
+ (non-adopted) sessions (SKY-12621 fix 4)."""
+ now = datetime.now(UTC)
+ organization = make_organization(now)
+ task, step, page, browser_state, scraped_page, action = _make_download_click_context(
+ now=now,
+ organization=organization,
+ page_url="https://example.com/download",
+ ) # browser_session_id is None
+ page_listeners: dict[str, Callable[[object], None]] = {}
+ page.on.side_effect = lambda event, cb: page_listeners.__setitem__(event, cb)
+
+ captured_kwargs: dict[str, object] = {}
+ real_capture_cls = _EagerAdoptedBlobCapture
+
+ def _spy(**kwargs: object) -> _EagerAdoptedBlobCapture:
+ captured_kwargs.update(kwargs)
+ return real_capture_cls(**kwargs)
+
+ with tempfile.TemporaryDirectory() as temp_root:
+ primary_dir = os.path.join(temp_root, "pbs-1")
+ os.makedirs(primary_dir)
+
+ async def mock_inner_handle_action(*args: object, **kwargs: object) -> list[ActionSuccess]:
+ return [ActionSuccess()]
+
+ mock_app = MagicMock()
+ mock_app.BROWSER_MANAGER.get_for_task.return_value = browser_state
+ mock_app.DATABASE.workflow_params.create_action = AsyncMock(return_value=action)
+ mock_app.STORAGE = MagicMock()
+
+ with (
+ patch.object(ActionHandler, "_handle_action", side_effect=mock_inner_handle_action),
+ patch("skyvern.webeye.actions.handler._EagerAdoptedBlobCapture", side_effect=_spy),
+ patch("skyvern.webeye.actions.handler.BROWSER_DOWNLOAD_NO_SIGNAL_GRACE_TIME", 0.01),
+ patch("skyvern.webeye.actions.handler.DOWNLOAD_IN_FLIGHT_EXTENSION_MAX_SECONDS", 0.1),
+ patch("skyvern.webeye.actions.handler.DOWNLOAD_IN_FLIGHT_POLL_INTERVAL_SECONDS", 0.01),
+ patch("skyvern.webeye.actions.handler.list_files_in_directory", return_value=[]),
+ patch("skyvern.webeye.actions.handler.get_download_dir", return_value=primary_dir),
+ patch("skyvern.webeye.actions.handler.skyvern_context.current", return_value=None),
+ patch("skyvern.webeye.actions.handler.app", mock_app),
+ ):
+ await asyncio.wait_for(
+ ActionHandler.handle_action(
+ scraped_page=scraped_page,
+ task=task,
+ step=step,
+ page=page,
+ action=action,
+ ),
+ timeout=CI_TEST_RUNAWAY_TIMEOUT_SECONDS,
+ )
+
+ assert captured_kwargs.get("enabled") is False
+ assert "popup" not in page_listeners
+ assert not any(c.args and c.args[0] == "popup" for c in page.on.call_args_list)