Skip to content

Automate browser based workflows with AI

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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.tsx
index 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 type
function 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 selected
const 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 source
const 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 service
if (
credentialSource === "skyvern" ||
diff --git a/skyvern-frontend/src/routes/workflows/editor/panels/WorkflowParametersPanel.tsx b/skyvern-frontend/src/routes/workflows/editor/panels/WorkflowParametersPanel.tsx
index 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.py
index 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.0
CACHED_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 loaded
diff --git a/skyvern/webeye/browser_factory.py b/skyvern/webeye/browser_factory.py
index 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, urlparse
import psutil
import 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 settings
from 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:
return
video_path = str(raw_path)
@@ -145,6 +156,14 @@ def set_popup_video_listener(browser_context: BrowserContext, browser_artifacts:
return
tracked_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.py
new file mode 100644
index 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.py
index 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_tags
diff --git a/tests/unit/test_cdp_connection_retry.py b/tests/unit/test_cdp_connection_retry.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
index 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) == 0
diff --git a/tests/unit/test_scraper_wait_for_scrape_ready.py b/tests/unit/test_scraper_wait_for_scrape_ready.py
new file mode 100644
index 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()