Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
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.pyindex 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 = 60DOWNLOAD_IN_FLIGHT_EXTENSION_MAX_SECONDS = 120DOWNLOAD_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.0DOWNLOAD_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 Nonedownload_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 resultsfinally:+ 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.pyindex 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 othe blob and returns the bytes that way."""+import asyncioimport base64from pathlib import Path-from unittest.mock import AsyncMock, MagicMock+from unittest.mock import AsyncMock, MagicMock, patchimport 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) -> Noneassert saved.read_bytes() == PDF_BODYpage.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 Nonediff --git a/tests/unit/test_download_file_action_handler.py b/tests/unit/test_download_file_action_handler.pyindex 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: InMemopage = 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 = Nonebrowser_state = MagicMock()@@ -1818,7 +1821,11 @@ async def test_handle_action_download_no_signal_fails_fast(span_exporter: InMemoassert results[-1].needs_followup is Trueassert results[-1].followup_message == DOWNLOAD_NOT_TRIGGERED_FOLLOWUP_MESSAGEassert 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 Falseassert 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_textassert [error.error_code for error in action.errors] == ["previous_error", "data_not_downloadable"]assert action.terminal_user_errors is Trueassert 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 == 1observer_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 == 1assert settle_count == 1download.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 Trueassert span_attrs["download_signal_source"] == "browser_download_event"@@ -2732,7 +2741,7 @@ async def test_handle_action_copies_download_event_when_no_observed_file_appearspersist.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 Trueassert 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 == 1download.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 Trueassert 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 Falseassert wait_for_downloads.await_count == 0download.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 Trueassert span_attrs["download_signal_source"] == "browser_download_event"@@ -2962,6 +2971,8 @@ async def test_handle_action_removes_late_zero_byte_duplicate_after_download_waipage = 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_waiassert 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(monkeypatcvalidate.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)