Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
Bill fair-share pod time, not wall clock, on multi-activity pods (SKY-14049) (#8207)
Shuchang Zhenge4e41a8a75c9
diff --git a/skyvern/webeye/cdp_download_interceptor.py b/skyvern/webeye/cdp_download_interceptor.pyindex 6e8510ad0..cb460457e 100644--- a/skyvern/webeye/cdp_download_interceptor.py+++ b/skyvern/webeye/cdp_download_interceptor.py@@ -42,6 +42,7 @@ from playwright.async_api import Browser, BrowserContext, CDPSession, Pagefrom skyvern.constants import BROWSER_DOWNLOADING_SUFFIX, BROWSER_INTERCEPTOR_DISABLE_TIMEOUTfrom skyvern.forge.sdk.api import files as file_api+from skyvern.forge.sdk.browser_network_egress_monitor import BrowserNetworkDenialReasonfrom skyvern.forge.sdk.core.hashing import diagnostic_fingerprintfrom skyvern.forge.sdk.core.http_request_authorization import (RunScopedRedirectHopAuthorizer,@@ -628,6 +629,7 @@ class CDPDownloadInterceptor:self._cdp_sessions: list[CDPSession] = []self._active_request_interceptors: dict[CDPSession, tuple[Page, Callable[[Page], None]]] = {}self._enrolling_pages: list[Page] = []+ self._mediates_requests = Trueself._enabled = Falseself._download_index = 0# Track auth attempts per requestId to prevent infinite retry loops@@ -795,13 +797,22 @@ class CDPDownloadInterceptor:if has_proxy_auth:cdp_session.on("Fetch.authRequired", lambda event: self._on_auth_required(event, cdp_session))+ # A monitor explicitly constructed unenrolled marks a flow with no request mediation at+ # all (vendor-attach browsers); download interception still has to come up there, so it+ # runs Response-stage only. Only that exact state downgrades: an enforcing monitor in any+ # other state (including mid-setup) must keep the loud registration failure below, because+ # silently skipping registration would drop mediation the flow was promised.+ self._mediates_requests = (+ self._network_egress_monitor.invalidation_reason is not BrowserNetworkDenialReason.UNENROLLED+ )+# Request-stage interception is the last boundary before browser credentials go on the- # wire. It is mandatory even without proxy auth; the active request must consume the- # monitor's exact one-shot slot before Fetch.continueRequest can dispatch it.- patterns: list[dict[str, str]] = [- {"requestStage": "Response"},- {"urlPattern": "*", "requestStage": "Request"},- ]+ # wire. When mediating, it is mandatory even without proxy auth; the active request must+ # consume the monitor's exact one-shot slot before Fetch.continueRequest can dispatch it.+ # Without mediation it is only needed to receive proxy auth challenges.+ patterns: list[dict[str, str]] = [{"requestStage": "Response"}]+ if self._mediates_requests or has_proxy_auth:+ patterns.append({"urlPattern": "*", "requestStage": "Request"})try:await cdp_session.send(@@ -811,7 +822,8 @@ class CDPDownloadInterceptor:"handleAuthRequests": has_proxy_auth,},)- self._network_egress_monitor.register_active_request_interceptor(page=page, owner=self)+ if self._mediates_requests:+ self._network_egress_monitor.register_active_request_interceptor(page=page, owner=self)def close_listener(closed_page: Page) -> None:# This listener is bound to `page`, so a close event carrying any other page means@@ -1691,6 +1703,9 @@ class CDPDownloadInterceptor:# 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:+ if not self._mediates_requests:+ await cdp_session.send("Fetch.continueRequest", {"requestId": request_id})+ returnrequest = event.get("request", {})try:monitor = self._network_egress_monitordiff --git a/skyvern/webeye/skycdp/facade/locator.py b/skyvern/webeye/skycdp/facade/locator.pyindex a73e53345..3fc874a02 100644--- a/skyvern/webeye/skycdp/facade/locator.py+++ b/skyvern/webeye/skycdp/facade/locator.py@@ -56,28 +56,68 @@ class FrameLocator:return frame+# Selector resolution mirrors the xpath-vs-css split of Playwright's engine for the shapes+# Skyvern's DOM layer emits: `xpath=`-, `//`-, and `..`-prefixed steps are XPath, everything else+# is CSS. (Playwright's other engines -- `text=`, `:visible`, `>>` chains -- still fail loudly as+# invalid CSS here.) Three Playwright behaviors are deliberately copied: a leading `/` is+# rewritten relative when the root is an element, so chained absolute paths stay inside their+# scope instead of silently escaping to the document; XPath results keep only element nodes, so a+# `..` hop onto an attribute/text/shadow-root node vanishes instead of impersonating an element;+# and the CSS branch pierces open shadow roots -- including when the root itself is the host,+# which dom.py's interactive-descendant guards rely on because they fail open on count 0. Shadow+# matches are appended after their host root's own matches, a document-order approximation that is+# exact for the unique-match selectors (`[unique_id=...]`, ids) the DOM layer emits.+_QUERY_ALL_JS = """+const __queryAll = (root, selector) => {+ const explicit = selector.startsWith('xpath=');+ if (explicit || selector.startsWith('//') || selector.startsWith('..')) {+ let xp = explicit ? selector.slice('xpath='.length) : selector;+ if (xp.startsWith('/') && root.nodeType !== 9) xp = '.' + xp;+ const doc = root.nodeType === 9 ? root : root.ownerDocument;+ const it = doc.evaluate(xp, root, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);+ const out = [];+ for (let i = 0; i < it.snapshotLength; i++) {+ const n = it.snapshotItem(i);+ if (n && n.nodeType === 1) out.push(n);+ }+ return out;+ }+ const out = [];+ const visit = (r) => {+ for (const el of r.querySelectorAll(selector)) out.push(el);+ if (r.nodeType === 1 && r.shadowRoot) visit(r.shadowRoot);+ for (const el of r.querySelectorAll('*')) {+ if (el.shadowRoot) visit(el.shadowRoot);+ }+ };+ visit(root);+ return out;+};+"""+# Walks a locator chain inside the page: each step queries within the previous step's matches, and a# step carrying an index narrows to exactly that match (negative counts from the end) before the next# step runs. Returning either the count or one element from the same walk keeps the two consistent.-_RESOLVE_JS = """-(spec) => {+_RESOLVE_JS = f"""+(spec) => {{+ {_QUERY_ALL_JS}let current = [document];- for (const step of spec.steps) {+ for (const step of spec.steps) {{let next = [];- for (const root of current) {- next = next.concat(Array.from(root.querySelectorAll(step.selector)));- }+ for (const root of current) {{+ next = next.concat(__queryAll(root, step.selector));+ }}next = Array.from(new Set(next));- if (step.index !== null && step.index !== undefined) {+ if (step.index !== null && step.index !== undefined) {{const at = step.index < 0 ? next.length + step.index : step.index;next = at >= 0 && at < next.length ? [next[at]] : [];- }+ }}current = next;- }+ }}if (spec.mode === 'count') return current.length;const at = spec.index < 0 ? current.length + spec.index : spec.index;return current[at] || null;-}+}}"""diff --git a/skyvern/webeye/skycdp/facade/page.py b/skyvern/webeye/skycdp/facade/page.pyindex c4c4b5711..3daae20ed 100644--- a/skyvern/webeye/skycdp/facade/page.py+++ b/skyvern/webeye/skycdp/facade/page.py@@ -31,7 +31,7 @@ from skyvern.webeye.skycdp.facade.dialogs import Dialogfrom skyvern.webeye.skycdp.facade.elements import ElementHandle, JSHandle, wait_forfrom skyvern.webeye.skycdp.facade.evaluation import RemoteHandle, evaluatefrom skyvern.webeye.skycdp.facade.input import Keyboard, Mouse-from skyvern.webeye.skycdp.facade.locator import FrameLocator, Locator+from skyvern.webeye.skycdp.facade.locator import _QUERY_ALL_JS, FrameLocator, Locatorfrom skyvern.webeye.skycdp.facade.network import dispatchfrom skyvern.webeye.skycdp.facade.network_events import NetworkObserverfrom skyvern.webeye.skycdp.facade.routing import RouteHandler, RouteTable, URLMatcher@@ -130,7 +130,7 @@ class Frame:async def query_selector_indexed(self, selector: str, index: int) -> ElementHandle | None:handle = await evaluate(self.session,- "(spec) => document.querySelectorAll(spec.selector)[spec.index] || null",+ f"(spec) => {{ {_QUERY_ALL_JS} return __queryAll(document, spec.selector)[spec.index] || null; }}",{"selector": selector, "index": index},context_id=await self._context_id(),by_value=False,@@ -159,7 +159,9 @@ class Frame:return ElementHandle(self, handle)async def query_selector_all(self, selector: str) -> list[ElementHandle]:- total = int(await self.evaluate("(s) => document.querySelectorAll(s).length", selector))+ total = int(+ await self.evaluate(f"(s) => {{ {_QUERY_ALL_JS} return __queryAll(document, s).length; }}", selector)+ )found = []for index in range(total):handle = await self.query_selector_indexed(selector, index)diff --git a/tests/unit/test_cdp_download_interceptor.py b/tests/unit/test_cdp_download_interceptor.pyindex a96e084f7..c8eadb4de 100644--- a/tests/unit/test_cdp_download_interceptor.py+++ b/tests/unit/test_cdp_download_interceptor.py@@ -17,6 +17,7 @@ import pytestfrom structlog.testing import capture_logsimport skyvern.webeye.cdp_download_interceptor as mod+from skyvern.forge.sdk.browser_network_egress_monitor import BrowserNetworkEgressMonitorfrom skyvern.forge.sdk.core.http_request_authorization import RunScopedRedirectHopAuthorizerfrom skyvern.webeye.cdp_download_interceptor import (CDPDownloadInterceptor,@@ -1431,6 +1432,85 @@ class TestCDPDownloadInterceptorProxyAuth:assert second_call.args[1]["authChallengeResponse"]["response"] == "CancelAuth"+class TestDownloadsOnlyInterception:+ """An explicitly unenrolled egress monitor marks a flow that does no request mediation (the+ vendor-attach browsers). Download interception must still come up for those pages instead of+ aborting setup, while every ambiguous monitor state keeps failing closed (SKY-14066)."""++ def _page_with_session(self) -> tuple[MagicMock, MagicMock]:+ cdp_session = MagicMock()+ cdp_session.send = AsyncMock()+ page = MagicMock(url="about:blank")+ page.is_closed.return_value = False+ page.context.new_cdp_session = AsyncMock(return_value=cdp_session)+ return page, cdp_session++ @pytest.mark.asyncio+ async def test_unenrolled_monitor_enables_downloads_only(self) -> None:+ monitor = BrowserNetworkEgressMonitor.unenrolled()+ interceptor = _make_interceptor(output_dir="/tmp/test_downloads", network_egress_monitor=monitor)+ page, cdp_session = self._page_with_session()++ await interceptor.enable_for_page(page)++ cdp_session.send.assert_called_once_with(+ "Fetch.enable",+ {"patterns": [{"requestStage": "Response"}], "handleAuthRequests": False},+ )+ assert interceptor._cdp_sessions == [cdp_session]++ @pytest.mark.asyncio+ async def test_unenrolled_monitor_with_proxy_auth_keeps_request_stage(self) -> None:+ monitor = BrowserNetworkEgressMonitor.unenrolled()+ interceptor = _make_interceptor(+ output_dir="/tmp/test_downloads",+ proxy_username="user",+ proxy_password="pass",+ network_egress_monitor=monitor,+ )+ page, cdp_session = self._page_with_session()++ await interceptor.enable_for_page(page)++ cdp_session.send.assert_called_once_with(+ "Fetch.enable",+ {+ "patterns": [{"requestStage": "Response"}, {"urlPattern": "*", "requestStage": "Request"}],+ "handleAuthRequests": True,+ },+ )++ @pytest.mark.asyncio+ async def test_request_stage_passes_through_without_mediation(self) -> None:+ monitor = BrowserNetworkEgressMonitor.unenrolled()+ interceptor = _make_interceptor(+ output_dir="/tmp/test_downloads",+ proxy_username="user",+ proxy_password="pass",+ network_egress_monitor=monitor,+ )+ page, cdp_session = self._page_with_session()+ await interceptor.enable_for_page(page)+ cdp_session.send.reset_mock()++ event = {"requestId": "req-1", "request": {"method": "GET", "url": "https://example.com/"}}+ await interceptor._handle_request_paused(event, cdp_session, interceptor._artifact_scope_generation)++ cdp_session.send.assert_awaited_once_with("Fetch.continueRequest", {"requestId": "req-1"})++ @pytest.mark.asyncio+ async def test_enforcing_uninstalled_monitor_still_fails_closed(self) -> None:+ # Not invalidated, not installed: an enforcing monitor mid-setup is ambiguous, and+ # silently downgrading it to downloads-only would drop mediation. It must stay loud.+ monitor = BrowserNetworkEgressMonitor()+ interceptor = _make_interceptor(output_dir="/tmp/test_downloads", network_egress_monitor=monitor)+ page, cdp_session = self._page_with_session()++ with pytest.raises(RuntimeError):+ await interceptor.enable_for_page(page)+ cdp_session.send.assert_awaited_with("Fetch.disable")++class TestStaleInterceptionRace:"""Fetch.continueRequest/continueResponse can fail with 'Invalid InterceptionId' when theinterception is resolved/cancelled or its target detaches before our async handler responds.