Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
fix(SKY-10191): allow selecting credential when editing a parameter (#6155)
Trevor Cheung41681ddb4472
diff --git a/skyvern-frontend/src/routes/workflows/editor/panels/WorkflowParameterEditPanel.helpers.ts b/skyvern-frontend/src/routes/workflows/editor/panels/WorkflowParameterEditPanel.helpers.tsnew file mode 100644index 000000000..5e66fa672--- /dev/null+++ b/skyvern-frontend/src/routes/workflows/editor/panels/WorkflowParameterEditPanel.helpers.ts@@ -0,0 +1,73 @@+import {+ WorkflowEditorParameterType,+ WorkflowParameterValueType,+} from "../../types/workflowTypes";+import {+ ParametersState,+ parameterIsAzureVaultCredential,+ parameterIsBitwardenCredential,+ parameterIsSkyvernCredential,+} from "../types";++export type ParameterTypeSelection = WorkflowParameterValueType | "credential";++export type CredentialDataType = "password" | "secret" | "creditCard";++export type CredentialSource =+ | "bitwarden"+ | "skyvern"+ | "onepassword"+ | "azurevault"+ | "custom";++export function detectInitialParameterTypeSelection(+ initialValues: ParametersState[number] | undefined,+): ParameterTypeSelection | null {+ if (!initialValues) return null;+ if (initialValues.parameterType === "workflow") return initialValues.dataType;+ if (+ initialValues.parameterType === "credential" ||+ initialValues.parameterType === "secret" ||+ initialValues.parameterType === "creditCardData" ||+ initialValues.parameterType === "onepassword"+ ) {+ return "credential";+ }+ return null;+}++export function detectInitialCredentialDataType(+ initialValues: ParametersState[number] | undefined,+): CredentialDataType {+ if (!initialValues) return "password";+ if (initialValues.parameterType === "secret") return "secret";+ if (initialValues.parameterType === "creditCardData") return "creditCard";+ return "password";+}++export function detectInitialCredentialSource(+ initialValues: ParametersState[number] | undefined,+ isCloud: boolean,+): CredentialSource {+ if (!initialValues) return isCloud ? "skyvern" : "bitwarden";++ if (initialValues.parameterType === "secret") return "bitwarden";+ if (initialValues.parameterType === "creditCardData") return "bitwarden";+ if (initialValues.parameterType === "onepassword") return "onepassword";++ if (initialValues.parameterType === "credential") {+ if (parameterIsSkyvernCredential(initialValues)) return "skyvern";+ if (parameterIsBitwardenCredential(initialValues)) return "bitwarden";+ if (parameterIsAzureVaultCredential(initialValues)) return "azurevault";+ }++ return isCloud ? "skyvern" : "bitwarden";+}++export function header(type: WorkflowEditorParameterType, isEdit: boolean) {+ const prefix = isEdit ? "Edit" : "Add";+ if (type === "workflow") {+ return isEdit ? `${prefix} Input Parameter` : `${prefix} Parameter`;+ }+ return `${prefix} Context Parameter`;+}diff --git a/skyvern-frontend/src/routes/workflows/editor/panels/WorkflowParameterEditPanel.test.ts b/skyvern-frontend/src/routes/workflows/editor/panels/WorkflowParameterEditPanel.test.tsnew file mode 100644index 000000000..73ce0b865--- /dev/null+++ b/skyvern-frontend/src/routes/workflows/editor/panels/WorkflowParameterEditPanel.test.ts@@ -0,0 +1,186 @@+import { describe, expect, it } from "vitest";+import { ParametersState } from "../types";+import {+ detectInitialCredentialDataType,+ detectInitialCredentialSource,+ detectInitialParameterTypeSelection,+ header,+} from "./WorkflowParameterEditPanel.helpers";++type Parameter = ParametersState[number];++const workflowString: Parameter = {+ key: "name",+ parameterType: "workflow",+ dataType: "string",+ description: null,+ defaultValue: null,+};++const workflowInteger: Parameter = {+ ...workflowString,+ dataType: "integer",+};++const context: Parameter = {+ key: "ctx",+ parameterType: "context",+ sourceParameterKey: "name",+};++const bitwardenLogin: Parameter = {+ key: "login",+ parameterType: "credential",+ collectionId: "collection-id",+ itemId: "item-id",+ urlParameterKey: null,+};++const skyvernCredential: Parameter = {+ key: "skyvern_cred",+ parameterType: "credential",+ credentialId: "cred-123",+};++const azureCredential: Parameter = {+ key: "azure_cred",+ parameterType: "credential",+ vaultName: "vault",+ usernameKey: "u",+ passwordKey: "p",+ totpSecretKey: null,+};++const onepasswordCredential: Parameter = {+ key: "op",+ parameterType: "onepassword",+ vaultId: "v",+ itemId: "i",+};++const secretCredential: Parameter = {+ key: "secret",+ parameterType: "secret",+ identityKey: "id",+ identityFields: ["ssn"],+ collectionId: "collection-id",+};++const creditCardCredential: Parameter = {+ key: "cc",+ parameterType: "creditCardData",+ itemId: "item-id",+ collectionId: "collection-id",+};++describe("detectInitialParameterTypeSelection", () => {+ it("returns null when there are no initial values", () => {+ expect(detectInitialParameterTypeSelection(undefined)).toBeNull();+ });++ it("returns the dataType for workflow input parameters", () => {+ expect(detectInitialParameterTypeSelection(workflowString)).toBe("string");+ expect(detectInitialParameterTypeSelection(workflowInteger)).toBe(+ "integer",+ );+ });++ it("collapses every credential variant to 'credential'", () => {+ expect(detectInitialParameterTypeSelection(bitwardenLogin)).toBe(+ "credential",+ );+ expect(detectInitialParameterTypeSelection(skyvernCredential)).toBe(+ "credential",+ );+ expect(detectInitialParameterTypeSelection(azureCredential)).toBe(+ "credential",+ );+ expect(detectInitialParameterTypeSelection(onepasswordCredential)).toBe(+ "credential",+ );+ expect(detectInitialParameterTypeSelection(secretCredential)).toBe(+ "credential",+ );+ expect(detectInitialParameterTypeSelection(creditCardCredential)).toBe(+ "credential",+ );+ });++ it("returns null for context parameters", () => {+ expect(detectInitialParameterTypeSelection(context)).toBeNull();+ });+});++describe("header", () => {+ it("uses 'Add Parameter' as the unified add-mode title", () => {+ expect(header("workflow", false)).toBe("Add Parameter");+ });++ it("uses 'Edit Input Parameter' when editing any non-context parameter", () => {+ expect(header("workflow", true)).toBe("Edit Input Parameter");+ });++ it("preserves dedicated context titles for the context entry-point type", () => {+ expect(header("context", false)).toBe("Add Context Parameter");+ expect(header("context", true)).toBe("Edit Context Parameter");+ });+});++describe("detectInitialCredentialDataType", () => {+ it("defaults to 'password' when no initial values are provided", () => {+ expect(detectInitialCredentialDataType(undefined)).toBe("password");+ });++ it("maps secret parameters to 'secret'", () => {+ expect(detectInitialCredentialDataType(secretCredential)).toBe("secret");+ });++ it("maps creditCardData parameters to 'creditCard'", () => {+ expect(detectInitialCredentialDataType(creditCardCredential)).toBe(+ "creditCard",+ );+ });++ it("falls back to 'password' for other credential variants", () => {+ expect(detectInitialCredentialDataType(bitwardenLogin)).toBe("password");+ expect(detectInitialCredentialDataType(skyvernCredential)).toBe("password");+ expect(detectInitialCredentialDataType(onepasswordCredential)).toBe(+ "password",+ );+ expect(detectInitialCredentialDataType(azureCredential)).toBe("password");+ });+});++describe("detectInitialCredentialSource", () => {+ it("defaults to 'skyvern' on cloud and 'bitwarden' off-cloud when there are no initial values", () => {+ expect(detectInitialCredentialSource(undefined, true)).toBe("skyvern");+ expect(detectInitialCredentialSource(undefined, false)).toBe("bitwarden");+ });++ it("treats secret and creditCardData as Bitwarden", () => {+ expect(detectInitialCredentialSource(secretCredential, true)).toBe(+ "bitwarden",+ );+ expect(detectInitialCredentialSource(creditCardCredential, true)).toBe(+ "bitwarden",+ );+ });++ it("treats onepassword parameters as 1Password", () => {+ expect(detectInitialCredentialSource(onepasswordCredential, true)).toBe(+ "onepassword",+ );+ });++ it("disambiguates credential-typed parameters by their shape", () => {+ expect(detectInitialCredentialSource(bitwardenLogin, true)).toBe(+ "bitwarden",+ );+ expect(detectInitialCredentialSource(skyvernCredential, true)).toBe(+ "skyvern",+ );+ expect(detectInitialCredentialSource(azureCredential, true)).toBe(+ "azurevault",+ );+ });+});diff --git a/skyvern-frontend/src/routes/workflows/editor/panels/WorkflowParameterEditPanel.tsx b/skyvern-frontend/src/routes/workflows/editor/panels/WorkflowParameterEditPanel.tsxindex 5bfddc972..079858f35 100644--- a/skyvern-frontend/src/routes/workflows/editor/panels/WorkflowParameterEditPanel.tsx+++ b/skyvern-frontend/src/routes/workflows/editor/panels/WorkflowParameterEditPanel.tsx@@ -33,6 +33,15 @@ import { getDefaultValueForParameterType } from "../workflowEditorUtils";import { validateBitwardenLoginCredential } from "./util";import { HelpTooltip } from "@/components/HelpTooltip";import { useCustomCredentialServiceConfig } from "@/hooks/useCustomCredentialServiceConfig";+import {+ CredentialDataType,+ CredentialSource,+ detectInitialCredentialDataType,+ detectInitialCredentialSource,+ detectInitialParameterTypeSelection,+ header,+ ParameterTypeSelection,+} from "./WorkflowParameterEditPanel.helpers";type Props = {type: WorkflowEditorParameterType;@@ -51,19 +60,6 @@ const workflowParameterTypeOptions = [{ label: "JSON", value: WorkflowParameterValueType.JSON },];-type CredentialDataType = "password" | "secret" | "creditCard";-type CredentialSource =- | "bitwarden"- | "skyvern"- | "onepassword"- | "azurevault"- | "custom";--// When selecting from the Value Type dropdown, "credential" is a special value that triggers-// credential-specific UI. This is separate from WorkflowParameterValueType which only includes-// data types like string, integer, etc.-type ParameterTypeSelection = WorkflowParameterValueType | "credential";-// Determine available sources based on credential data typefunction getAvailableSourcesForDataType(dataType: CredentialDataType,@@ -104,25 +100,6 @@ function getAvailableSourcesForDataType(}}-function header(- type: WorkflowEditorParameterType,- isEdit: boolean,- isCredentialSelected: boolean,-) {- const prefix = isEdit ? "Edit" : "Add";- if (type === "workflow" && !isEdit) {- // Unified add mode- return `${prefix} Parameter`;- }- if (type === "workflow") {- return `${prefix} Input Parameter`;- }- if (type === "credential" || (!isEdit && isCredentialSelected)) {- return `${prefix} Credential Parameter`;- }- return `${prefix} Context Parameter`;-}-/*** Validates that a parameter key is a valid Python/Jinja2 identifier.* Parameter keys are used in Jinja2 templates, so they must be valid identifiers.@@ -159,36 +136,6 @@ function validateParameterKey(key: string): string | null {return null;}-// Helper to detect initial credential data type from existing parameter-function detectInitialCredentialDataType(- initialValues: ParametersState[number] | undefined,-): CredentialDataType {- if (!initialValues) return "password";- if (initialValues.parameterType === "secret") return "secret";- if (initialValues.parameterType === "creditCardData") return "creditCard";- return "password";-}--// Helper to detect initial credential source from existing parameter-function detectInitialCredentialSource(- initialValues: ParametersState[number] | undefined,- isCloud: boolean,-): CredentialSource {- if (!initialValues) return isCloud ? "skyvern" : "bitwarden";-- if (initialValues.parameterType === "secret") return "bitwarden";- if (initialValues.parameterType === "creditCardData") return "bitwarden";- if (initialValues.parameterType === "onepassword") return "onepassword";-- if (initialValues.parameterType === "credential") {- if (parameterIsSkyvernCredential(initialValues)) return "skyvern";- if (parameterIsBitwardenCredential(initialValues)) return "bitwarden";- if (parameterIsAzureVaultCredential(initialValues)) return "azurevault";- }-- return isCloud ? "skyvern" : "bitwarden";-}-function WorkflowParameterEditPanel({type,onClose,@@ -251,12 +198,10 @@ function WorkflowParameterEditPanel({? (initialValues?.collectionId ?? ""): "",);+ const initialParameterTypeSelection =+ detectInitialParameterTypeSelection(initialValues);const [parameterType, setParameterType] = useState<ParameterTypeSelection>(- type === "credential"- ? "credential"- : initialValues?.parameterType === "workflow"- ? initialValues.dataType- : "string",+ initialParameterTypeSelection ?? "string",);const [defaultValueState, setDefaultValueState] = useState<{@@ -343,11 +288,8 @@ function WorkflowParameterEditPanel({hasCustomCredentialService,);- // Check if we're in unified add mode and credential is selectedconst isCredentialSelected = parameterType === "credential";- const showCredentialFields =- type === "credential" ||- (type === "workflow" && !isEditMode && isCredentialSelected);+ const showCredentialFields = type === "workflow" && isCredentialSelected;// Determine what fields to show based on credential data type and sourceconst showBitwardenPasswordFields =@@ -378,7 +320,7 @@ function WorkflowParameterEditPanel({<ScrollAreaViewport className="max-h-[500px]"><div className="space-y-4 p-1 px-4"><header className="flex items-center justify-between">- <span>{header(type, isEditMode, isCredentialSelected)}</span>+ <span>{header(type, isEditMode)}</span><Cross2Icon className="h-6 w-6 cursor-pointer" onClick={onClose} /></header><div className="space-y-1">@@ -454,22 +396,22 @@ function WorkflowParameterEditPanel({</SelectTrigger><SelectContent><SelectGroup>- {workflowParameterTypeOptions- .filter((option) => {- // In edit mode, don't show credential option- if (isEditMode && option.value === "credential") {- return false;- }- return true;- })- .map((option) => (- <SelectItem key={option.value} value={option.value}>- {option.label}- </SelectItem>- ))}+ {workflowParameterTypeOptions.map((option) => (+ <SelectItem key={option.value} value={option.value}>+ {option.label}+ </SelectItem>+ ))}</SelectGroup></SelectContent></Select>+ {isEditMode &&+ initialParameterTypeSelection !== null &&+ initialParameterTypeSelection !== parameterType && (+ <p className="text-xs text-amber-400">+ Changing the type of an existing parameter may break+ blocks that reference it.+ </p>+ )}</div>{/* Default value section - only for non-credential types */}{!isCredentialSelected && (@@ -945,8 +887,8 @@ function WorkflowParameterEditPanel({return;}- // Handle credential parameters based on type + source combination- if (type === "credential" || isCredentialSelected) {+ // Handle credential parameters based on source + data-type combination+ if (isCredentialSelected) {// Skyvern managed credentials or Custom credential serviceif (credentialSource === "skyvern" ||diff --git a/skyvern-frontend/src/routes/workflows/editor/panels/WorkflowParametersPanel.tsx b/skyvern-frontend/src/routes/workflows/editor/panels/WorkflowParametersPanel.tsxindex 57c8e7b7d..8bdf6ba3c 100644--- a/skyvern-frontend/src/routes/workflows/editor/panels/WorkflowParametersPanel.tsx+++ b/skyvern-frontend/src/routes/workflows/editor/panels/WorkflowParametersPanel.tsx@@ -163,11 +163,9 @@ function WorkflowParametersPanel({ onMouseDownCapture }: Props) {operation: "edit",parameter: parameter,type:- parameter.parameterType === "onepassword" ||- parameter.parameterType === "secret" ||- parameter.parameterType === "creditCardData"- ? WorkflowEditorParameterTypes.Credential- : parameter.parameterType,+ parameter.parameterType === "context"+ ? WorkflowEditorParameterTypes.Context+ : WorkflowEditorParameterTypes.Workflow,});}}/>diff --git a/skyvern/config.py b/skyvern/config.pyindex 94de81ac4..be0e42425 100644--- a/skyvern/config.py+++ b/skyvern/config.py@@ -96,6 +96,7 @@ class Settings(BaseSettings):TEMP_PATH: str = "./temp"DOWNLOAD_PATH: str = f"{REPO_ROOT_DIR}/downloads"BROWSER_ACTION_TIMEOUT_MS: int = 5000+ POPUP_VIDEO_PATH_TIMEOUT_SECONDS: float = 3.0CACHED_ACTION_DELAY_SECONDS: float = 1.0# Page readiness settings for cached action execution# These help prevent cached actions from executing before the page is fully loadeddiff --git a/skyvern/webeye/browser_factory.py b/skyvern/webeye/browser_factory.pyindex d59bfc8c6..03781fa83 100644--- a/skyvern/webeye/browser_factory.py+++ b/skyvern/webeye/browser_factory.py@@ -19,7 +19,17 @@ from urllib.parse import parse_qsl, urlparseimport psutilimport structlog-from playwright.async_api import Browser, BrowserContext, ConsoleMessage, Download, Page, Playwright+from playwright.async_api import (+ Browser,+ BrowserContext,+ ConsoleMessage,+ Download,+)+from playwright.async_api import Error as PlaywrightError+from playwright.async_api import (+ Page,+ Playwright,+)from skyvern.config import settingsfrom skyvern.constants import (@@ -129,10 +139,11 @@ def set_popup_video_listener(browser_context: BrowserContext, browser_artifacts:async def _on_page(page: Page) -> None:try:- if not page.video:+ video = page.video+ if not video:return- async with asyncio.timeout(settings.BROWSER_ACTION_TIMEOUT_MS / 1000):- raw_path = await page.video.path()+ async with asyncio.timeout(settings.POPUP_VIDEO_PATH_TIMEOUT_SECONDS):+ raw_path = await video.path()if raw_path is None:returnvideo_path = str(raw_path)@@ -145,6 +156,14 @@ def set_popup_video_listener(browser_context: BrowserContext, browser_artifacts:returntracked_paths.add(video_path)browser_artifacts.video_artifacts.append(VideoArtifact(video_path=video_path))+ except PlaywrightError:+ LOG.debug("Failed to register popup page video", exc_info=True)+ except TimeoutError:+ try:+ page_origin = urlparse(page.url).hostname or "unknown"+ except Exception:+ page_origin = "unknown"+ LOG.warning("Popup video path resolution timed out", page_origin=page_origin)except Exception:LOG.warning("Failed to register popup page video", exc_info=True)diff --git a/skyvern/webeye/cdp_retry.py b/skyvern/webeye/cdp_retry.pynew file mode 100644index 000000000..5aeb3db01--- /dev/null+++ b/skyvern/webeye/cdp_retry.py@@ -0,0 +1,68 @@+from __future__ import annotations++import asyncio++import structlog+from playwright._impl._errors import Error as PWError+from playwright._impl._errors import TargetClosedError as PWTargetClosedError+from playwright._impl._errors import TimeoutError as PWTimeoutError+from playwright.async_api import Browser, Playwright++LOG = structlog.get_logger()++_CDP_CONNECTION_ERROR_SUBSTR_FALLBACK = (+ "econnrefused",+ "econnreset",+ "connect etimedout",+ "browser closed",+ "browser has been closed",+)+++def _is_cdp_connection_error(exc: Exception) -> bool:+ if isinstance(+ exc, (PWTimeoutError, PWTargetClosedError, ConnectionRefusedError, ConnectionResetError, TimeoutError)+ ):+ return True+ if isinstance(exc, PWError) and any(s in str(exc).lower() for s in _CDP_CONNECTION_ERROR_SUBSTR_FALLBACK):+ return True+ return False+++_CDP_RETRY_ATTEMPTS = 3+_CDP_RETRY_BACKOFF_SECONDS = (1, 3)+++async def connect_over_cdp_with_retry(+ playwright: Playwright,+ browser_address: str,+ headers: dict[str, str] | None = None,+) -> Browser:+ for attempt in range(1, _CDP_RETRY_ATTEMPTS + 1):+ try:+ browser = await playwright.chromium.connect_over_cdp(browser_address, headers=headers)+ if attempt > 1:+ LOG.info(+ "CDP connection recovered after retry",+ browser_address=browser_address,+ successful_attempt=attempt,+ )+ return browser+ except Exception as e:+ if not _is_cdp_connection_error(e) or attempt == _CDP_RETRY_ATTEMPTS:+ raise+ backoff = (+ _CDP_RETRY_BACKOFF_SECONDS[attempt - 1]+ if attempt - 1 < len(_CDP_RETRY_BACKOFF_SECONDS)+ else _CDP_RETRY_BACKOFF_SECONDS[-1]+ )+ LOG.warning(+ "CDP connection failed, retrying",+ browser_address=browser_address,+ attempt=attempt,+ max_attempts=_CDP_RETRY_ATTEMPTS,+ backoff_seconds=backoff,+ error_type=type(e).__name__,+ )+ await asyncio.sleep(backoff)+ raise RuntimeError("unreachable")diff --git a/skyvern/webeye/scraper/scraper.py b/skyvern/webeye/scraper/scraper.pyindex 09200f996..1921c187c 100644--- a/skyvern/webeye/scraper/scraper.py+++ b/skyvern/webeye/scraper/scraper.py@@ -296,6 +296,18 @@ def _should_use_page_ready_wait() -> bool:return bool(context and context.enable_page_ready_wait)+async def _wait_for_scrape_ready(skyvern_frame: SkyvernFrame) -> None:+ if _should_use_page_ready_wait():+ await skyvern_frame.wait_for_page_ready(+ network_idle_timeout_ms=settings.PAGE_READY_NETWORK_IDLE_TIMEOUT_MS,+ loading_indicator_timeout_ms=settings.PAGE_READY_LOADING_INDICATOR_TIMEOUT_MS,+ dom_stable_ms=settings.PAGE_READY_DOM_STABLE_MS,+ dom_stability_timeout_ms=settings.PAGE_READY_DOM_STABILITY_TIMEOUT_MS,+ )+ else:+ await skyvern_frame.safe_wait_for_animation_end()++@traced(name="skyvern.agent.scrape")async def scrape_web_unsafe(browser_state: BrowserState,@@ -344,15 +356,7 @@ async def scrape_web_unsafe()skyvern_frame = await SkyvernFrame.create_instance(page)- if _should_use_page_ready_wait():- await skyvern_frame.wait_for_page_ready(- network_idle_timeout_ms=settings.PAGE_READY_NETWORK_IDLE_TIMEOUT_MS,- loading_indicator_timeout_ms=settings.PAGE_READY_LOADING_INDICATOR_TIMEOUT_MS,- dom_stable_ms=settings.PAGE_READY_DOM_STABLE_MS,- dom_stability_timeout_ms=settings.PAGE_READY_DOM_STABILITY_TIMEOUT_MS,- )- else:- await skyvern_frame.safe_wait_for_animation_end()+ await _wait_for_scrape_ready(skyvern_frame)if wait_seconds > 0:LOG.info(f"Waiting for {wait_seconds} seconds before scraping the website.", wait_seconds=wait_seconds)@@ -523,15 +527,7 @@ async def add_frame_interactable_elements(try:skyvern_frame = await SkyvernFrame.create_instance(frame)- if _should_use_page_ready_wait():- await skyvern_frame.wait_for_page_ready(- network_idle_timeout_ms=settings.PAGE_READY_NETWORK_IDLE_TIMEOUT_MS,- loading_indicator_timeout_ms=settings.PAGE_READY_LOADING_INDICATOR_TIMEOUT_MS,- dom_stable_ms=settings.PAGE_READY_DOM_STABLE_MS,- dom_stability_timeout_ms=settings.PAGE_READY_DOM_STABILITY_TIMEOUT_MS,- )- else:- await skyvern_frame.safe_wait_for_animation_end()+ await _wait_for_scrape_ready(skyvern_frame)frame_elements, frame_element_tree = await skyvern_frame.build_tree_from_body(frame_name=skyvern_id, frame_index=frame_index, must_included_tags=must_included_tagsdiff --git a/tests/unit/test_cdp_connection_retry.py b/tests/unit/test_cdp_connection_retry.pynew file mode 100644index 000000000..3c0e2f74e--- /dev/null+++ b/tests/unit/test_cdp_connection_retry.py@@ -0,0 +1,83 @@+from __future__ import annotations++from unittest.mock import AsyncMock, MagicMock, patch++import pytest+from playwright._impl._errors import Error as PWError+from playwright._impl._errors import TimeoutError as PWTimeoutError++from skyvern.webeye.cdp_retry import connect_over_cdp_with_retry+++def _make_playwright(side_effect):+ pw = MagicMock()+ pw.chromium.connect_over_cdp = AsyncMock(side_effect=side_effect)+ return pw+++class TestRetryBehavior:+ @pytest.mark.asyncio+ async def test_succeeds_on_first_attempt(self):+ pw = _make_playwright(["browser"])+ result = await connect_over_cdp_with_retry(pw, "http://10.0.0.1:9224")+ assert result == "browser"+ assert pw.chromium.connect_over_cdp.call_count == 1++ @pytest.mark.asyncio+ async def test_succeeds_after_transient_failure(self):+ pw = _make_playwright(+ [+ PWError("BrowserType.connect_over_cdp: connect ECONNREFUSED 10.0.0.1:9224"),+ "browser",+ ]+ )+ with patch("skyvern.webeye.cdp_retry.asyncio.sleep", new_callable=AsyncMock) as mock_sleep:+ result = await connect_over_cdp_with_retry(pw, "http://10.0.0.1:9224")+ assert result == "browser"+ assert pw.chromium.connect_over_cdp.call_count == 2+ mock_sleep.assert_called_once_with(1)++ @pytest.mark.asyncio+ async def test_succeeds_after_two_transient_failures(self):+ pw = _make_playwright(+ [+ PWError("connect ECONNREFUSED"),+ PWTimeoutError("Timeout 30000ms exceeded."),+ "browser",+ ]+ )+ with patch("skyvern.webeye.cdp_retry.asyncio.sleep", new_callable=AsyncMock) as mock_sleep:+ result = await connect_over_cdp_with_retry(pw, "http://10.0.0.1:9224")+ assert result == "browser"+ assert pw.chromium.connect_over_cdp.call_count == 3+ assert mock_sleep.call_count == 2++ @pytest.mark.asyncio+ async def test_all_attempts_fail_raises(self):+ error = PWError("connect ECONNREFUSED 10.0.0.1:9224")+ pw = _make_playwright([error, error, error])+ with patch("skyvern.webeye.cdp_retry.asyncio.sleep", new_callable=AsyncMock):+ with pytest.raises(PWError):+ await connect_over_cdp_with_retry(pw, "http://10.0.0.1:9224")+ assert pw.chromium.connect_over_cdp.call_count == 3++ @pytest.mark.asyncio+ async def test_non_retryable_error_raises_immediately(self):+ pw = _make_playwright([PWError("net::ERR_NAME_NOT_RESOLVED")])+ with pytest.raises(PWError):+ await connect_over_cdp_with_retry(pw, "http://10.0.0.1:9224")+ assert pw.chromium.connect_over_cdp.call_count == 1++ @pytest.mark.asyncio+ async def test_backoff_is_bounded(self):+ error = PWError("connect ECONNRESET")+ pw = _make_playwright([error, error, error])+ sleep_values = []++ async def track_sleep(seconds):+ sleep_values.append(seconds)++ with patch("skyvern.webeye.cdp_retry.asyncio.sleep", side_effect=track_sleep):+ with pytest.raises(PWError):+ await connect_over_cdp_with_retry(pw, "http://10.0.0.1:9224")+ assert sleep_values == [1, 3]diff --git a/tests/unit/test_cdp_error_detection.py b/tests/unit/test_cdp_error_detection.pynew file mode 100644index 000000000..2979f7e81--- /dev/null+++ b/tests/unit/test_cdp_error_detection.py@@ -0,0 +1,40 @@+from __future__ import annotations++import pytest+from playwright._impl._errors import Error as PWError+from playwright._impl._errors import TargetClosedError as PWTargetClosedError+from playwright._impl._errors import TimeoutError as PWTimeoutError++from skyvern.webeye.cdp_retry import _is_cdp_connection_error+++class TestConnectionErrorDetection:+ @pytest.mark.parametrize(+ "exc",+ [+ PWTimeoutError("Timeout 30000ms exceeded."),+ PWTimeoutError("Timeout 120000ms exceeded."),+ PWTargetClosedError("Target page, context or browser has been closed"),+ ConnectionRefusedError("connect ECONNREFUSED 10.0.36.234:9224"),+ ConnectionResetError("connect ECONNRESET"),+ PWError("BrowserType.connect_over_cdp: connect ECONNREFUSED 10.0.36.234:9224"),+ PWError("Browser closed."),+ ],+ ids=lambda e: type(e).__name__ + ": " + str(e)[:50],+ )+ def test_connection_errors_detected(self, exc: Exception):+ assert _is_cdp_connection_error(exc), f"Expected connection error: {exc!r}"++ @pytest.mark.parametrize(+ "exc",+ [+ PWError("Navigation timeout exceeded"),+ ValueError("Element not found"),+ RuntimeError("LLM response parsing failed"),+ PWError("net::ERR_NAME_NOT_RESOLVED"),+ PWError("Page crashed"),+ ],+ ids=lambda e: type(e).__name__ + ": " + str(e)[:50],+ )+ def test_app_errors_not_detected(self, exc: Exception):+ assert not _is_cdp_connection_error(exc), f"Expected app error NOT to match: {exc!r}"diff --git a/tests/unit/test_real_browser_manager.py b/tests/unit/test_real_browser_manager.pyindex 2d15713bc..78dd309ec 100644--- a/tests/unit/test_real_browser_manager.py+++ b/tests/unit/test_real_browser_manager.py@@ -473,3 +473,71 @@ async def test_popup_video_listener_registers_pre_existing_pages() -> None:paths = [va.video_path for va in artifacts.video_artifacts]assert paths == ["/tmp/videos/initial.webm"]+++async def test_popup_video_listener_page_closed_no_warning() -> None:+ """PlaywrightError (e.g. Page closed) must not produce a WARNING log."""+ import structlog.testing+ from playwright.async_api import Error as PlaywrightError++ artifacts = BrowserArtifacts()+ browser_context = MagicMock()+ set_popup_video_listener(browser_context=browser_context, browser_artifacts=artifacts)++ handler = browser_context.on.call_args[0][1]+ page = MagicMock()+ page.video = MagicMock()+ page.video.path = AsyncMock(side_effect=PlaywrightError("Page closed"))++ with structlog.testing.capture_logs() as cap:+ await handler(page)++ assert len(artifacts.video_artifacts) == 0+ warning_events = [e for e in cap if e["log_level"] == "warning"]+ assert len(warning_events) == 0+++async def test_popup_video_listener_timeout_logs_sanitized_origin() -> None:+ """TimeoutError logs WARNING with only the domain, no query params or PII."""+ import structlog.testing++ artifacts = BrowserArtifacts()+ browser_context = MagicMock()+ set_popup_video_listener(browser_context=browser_context, browser_artifacts=artifacts)++ handler = browser_context.on.call_args[0][1]+ page = MagicMock()+ page.video = MagicMock()+ page.video.path = AsyncMock(side_effect=TimeoutError())+ page.url = "https://user:[email protected]/o/oauth2/auth?client_id=secret&redirect_uri=https://evil.com"++ with structlog.testing.capture_logs() as cap:+ await handler(page)++ assert len(artifacts.video_artifacts) == 0+ warning_events = [e for e in cap if e["log_level"] == "warning"]+ assert len(warning_events) == 1+ logged = str(warning_events[0])+ assert "example.com" in logged # nosemgrep: incomplete-url-substring-sanitization+ assert "user:pass" not in logged+ assert "client_id=secret" not in logged+ assert "redirect_uri" not in logged+++async def test_popup_video_listener_timeout_url_error_safe() -> None:+ """If page.url itself raises, the handler still completes without crashing."""+ artifacts = BrowserArtifacts()+ browser_context = MagicMock()+ set_popup_video_listener(browser_context=browser_context, browser_artifacts=artifacts)++ handler = browser_context.on.call_args[0][1]+ page = MagicMock()+ page.video = MagicMock()+ page.video.path = AsyncMock(side_effect=TimeoutError())+ type(page).url = property(lambda self: (_ for _ in ()).throw(RuntimeError("page destroyed")))++ await handler(page)+ assert len(artifacts.video_artifacts) == 0diff --git a/tests/unit/test_scraper_wait_for_scrape_ready.py b/tests/unit/test_scraper_wait_for_scrape_ready.pynew file mode 100644index 000000000..b8d8a3228--- /dev/null+++ b/tests/unit/test_scraper_wait_for_scrape_ready.py@@ -0,0 +1,33 @@+from unittest.mock import AsyncMock, patch++import pytest++from skyvern.config import settings+from skyvern.webeye.scraper import scraper+++async def test_wait_for_scrape_ready_uses_animation_wait_by_default() -> None:+ skyvern_frame = AsyncMock()++ with patch.object(scraper, "_should_use_page_ready_wait", return_value=False):+ await scraper._wait_for_scrape_ready(skyvern_frame)++ skyvern_frame.safe_wait_for_animation_end.assert_awaited_once()+ skyvern_frame.wait_for_page_ready.assert_not_awaited()+++async def test_wait_for_scrape_ready_uses_page_ready_when_enabled() -> None:+ skyvern_frame = AsyncMock()++ with patch.object(scraper, "_should_use_page_ready_wait", return_value=True):+ await scraper._wait_for_scrape_ready(skyvern_frame)++ skyvern_frame.wait_for_page_ready.assert_awaited_once_with(+ network_idle_timeout_ms=settings.PAGE_READY_NETWORK_IDLE_TIMEOUT_MS,+ loading_indicator_timeout_ms=settings.PAGE_READY_LOADING_INDICATOR_TIMEOUT_MS,+ dom_stable_ms=settings.PAGE_READY_DOM_STABLE_MS,+ dom_stability_timeout_ms=settings.PAGE_READY_DOM_STABILITY_TIMEOUT_MS,+ )+ skyvern_frame.safe_wait_for_animation_end.assert_not_awaited()