Skip to content

Automate browser based workflows with AI

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.py
index 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, Page
from skyvern.constants import BROWSER_DOWNLOADING_SUFFIX, BROWSER_INTERCEPTOR_DISABLE_TIMEOUT
from skyvern.forge.sdk.api import files as file_api
+from skyvern.forge.sdk.browser_network_egress_monitor import BrowserNetworkDenialReason
from skyvern.forge.sdk.core.hashing import diagnostic_fingerprint
from 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 = True
self._enabled = False
self._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})
+ return
request = event.get("request", {})
try:
monitor = self._network_egress_monitor
diff --git a/skyvern/webeye/skycdp/facade/locator.py b/skyvern/webeye/skycdp/facade/locator.py
index 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.py
index 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 Dialog
from skyvern.webeye.skycdp.facade.elements import ElementHandle, JSHandle, wait_for
from skyvern.webeye.skycdp.facade.evaluation import RemoteHandle, evaluate
from 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, Locator
from skyvern.webeye.skycdp.facade.network import dispatch
from skyvern.webeye.skycdp.facade.network_events import NetworkObserver
from 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.py
index a96e084f7..c8eadb4de 100644
--- a/tests/unit/test_cdp_download_interceptor.py
+++ b/tests/unit/test_cdp_download_interceptor.py
@@ -17,6 +17,7 @@ import pytest
from structlog.testing import capture_logs
import skyvern.webeye.cdp_download_interceptor as mod
+from skyvern.forge.sdk.browser_network_egress_monitor import BrowserNetworkEgressMonitor
from skyvern.forge.sdk.core.http_request_authorization import RunScopedRedirectHopAuthorizer
from 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 the
interception is resolved/cancelled or its target detaches before our async handler responds.