Skip to content

Automate browser based workflows with AI

Start Copilot build tests in the saved browser profile (SKY-16397) (#8681)

Andrew Neilsone1d68ebbf3fe
diff --git a/alembic/versions/2026_09_27_0541-9fec57bdb481_add_profile_read_only_to_persistent_browser_sessions.py b/alembic/versions/2026_09_27_0541-9fec57bdb481_add_profile_read_only_to_persistent_browser_sessions.py
new file mode 100644
index 000000000..8130bb8f9
--- /dev/null
+++ b/alembic/versions/2026_09_27_0541-9fec57bdb481_add_profile_read_only_to_persistent_browser_sessions.py
@@ -0,0 +1,30 @@
+"""add profile_read_only to persistent_browser_sessions
+
+Revision ID: 9fec57bdb481
+Revises: 9bde879d4fc0
+Create Date: 2026-09-27T05:41:09.702434+00:00
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "9fec57bdb481"
+down_revision: Union[str, None] = "9bde879d4fc0"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+ op.add_column(
+ "persistent_browser_sessions",
+ sa.Column("profile_read_only", sa.Boolean(), server_default=sa.false(), nullable=False),
+ )
+
+
+def downgrade() -> None:
+ op.drop_column("persistent_browser_sessions", "profile_read_only")
diff --git a/skyvern-frontend/src/components/BrowserStream.test.tsx b/skyvern-frontend/src/components/BrowserStream.test.tsx
index 915b59b1f..66a0bc27e 100644
--- a/skyvern-frontend/src/components/BrowserStream.test.tsx
+++ b/skyvern-frontend/src/components/BrowserStream.test.tsx
@@ -1,6 +1,7 @@
import { StrictMode, type ComponentProps } from "react";
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import {
+ act,
cleanup,
fireEvent,
render,
@@ -715,7 +716,9 @@ describe("BrowserStream", () => {
try {
const onStreamStateChange = vi.fn();
renderBrowserStream({ onStreamStateChange });
- await vi.advanceTimersByTimeAsync(1000);
+ await act(async () => {
+ await vi.advanceTimersByTimeAsync(1000);
+ });
expect(mocks.rfbInstances).toHaveLength(1);
expect(onStreamStateChange).toHaveBeenLastCalledWith("live", "pbs_test");
mocks.autoConnect.value = false;
diff --git a/skyvern/forge/sdk/api/files.py b/skyvern/forge/sdk/api/files.py
index dd774f6af..d459ed7ea 100644
--- a/skyvern/forge/sdk/api/files.py
+++ b/skyvern/forge/sdk/api/files.py
@@ -1413,6 +1413,11 @@ def is_temp_working_dir(path: str) -> bool:
return False
+def discard_temp_working_dir(path: str | None) -> None:
+ if path and is_temp_working_dir(path):
+ shutil.rmtree(path, ignore_errors=True)
+
+
def create_named_temporary_file(delete: bool = True, file_name: str | None = None) -> tempfile._TemporaryFileWrapper:
temp_dir = settings.TEMP_PATH
create_folder_if_not_exist(temp_dir)
diff --git a/skyvern/forge/sdk/artifact/storage/base.py b/skyvern/forge/sdk/artifact/storage/base.py
index 416b91332..e933188cb 100644
--- a/skyvern/forge/sdk/artifact/storage/base.py
+++ b/skyvern/forge/sdk/artifact/storage/base.py
@@ -472,6 +472,11 @@ class BaseStorage(ABC):
async def retrieve_browser_profile(self, organization_id: str, profile_id: str) -> str | None:
"""Retrieve a browser profile to a temporary directory."""
+ async def retrieve_browser_profile_copy(self, organization_id: str, profile_id: str) -> str | None:
+ """A working copy that a browser can change without touching the stored profile. Object stores already
+ extract to a temp directory; local storage, whose retrieve returns the stored directory, overrides this."""
+ return await self.retrieve_browser_profile(organization_id, profile_id)
+
async def browser_profile_exists(self, organization_id: str, profile_id: str) -> bool:
"""Whether a stored profile archive exists (has content). Non-destructive probe — some backends
(local) return the live directory, not a temp copy, so this must never delete what it finds.
diff --git a/skyvern/forge/sdk/artifact/storage/local.py b/skyvern/forge/sdk/artifact/storage/local.py
index 2365004de..6bc190cdf 100644
--- a/skyvern/forge/sdk/artifact/storage/local.py
+++ b/skyvern/forge/sdk/artifact/storage/local.py
@@ -16,6 +16,7 @@ from skyvern.forge.sdk.api.files import (
calculate_sha256_for_file,
get_download_dir,
get_skyvern_temp_dir,
+ make_run_temp_directory,
parse_uri_to_path,
register_local_download_root,
wait_for_pending_extension_rename,
@@ -377,6 +378,14 @@ class LocalStorage(BaseStorage):
return None
return str(stored_folder_path)
+ async def retrieve_browser_profile_copy(self, organization_id: str, profile_id: str) -> str | None:
+ stored_folder_path = await self.retrieve_browser_profile(organization_id, profile_id)
+ if stored_folder_path is None:
+ return None
+ working_copy = make_run_temp_directory(prefix="skyvern_browser_profile_")
+ self._copy_directory_best_effort(Path(stored_folder_path), Path(working_copy))
+ return working_copy
+
async def browser_profile_exists(self, organization_id: str, profile_id: str) -> bool:
"""Non-destructive existence check — stat the stored directory, never retrieve/delete it."""
stored_folder_path = self._resolve_browser_storage_path(organization_id, "profiles", profile_id)
diff --git a/skyvern/forge/sdk/copilot/build_test_connect_failure.py b/skyvern/forge/sdk/copilot/build_test_connect_failure.py
index e67f94866..f00ec9349 100644
--- a/skyvern/forge/sdk/copilot/build_test_connect_failure.py
+++ b/skyvern/forge/sdk/copilot/build_test_connect_failure.py
@@ -10,7 +10,10 @@ BuildTestConnectFailureState = Literal[
"cdp_connect_failed",
"occupied",
"billing_credit_admission_refusal",
+ "saved_profile_unresolved",
+ "saved_profile_not_applied",
]
+_SAVED_PROFILE_STATES = ("saved_profile_unresolved", "saved_profile_not_applied")
SUPERSEDED_BY_NEWER_TEST_REASON = "Stopped because a newer test in this chat took over the browser."
@@ -42,6 +45,9 @@ class BuildTestConnectFailure(BaseModel):
)
if self.retry_action is not None or any(value is not None for value in identities):
raise ValueError("billing credit admission refusal cannot carry a retry or browser/run identity")
+ elif self.state in _SAVED_PROFILE_STATES:
+ if self.retry_action is not None:
+ raise ValueError("a saved-profile start failure has no signed-out retry")
elif self.retry_action != "test_end_to_end":
raise ValueError("retryable browser acquisition failures require test_end_to_end")
return self
@@ -55,6 +61,16 @@ def build_test_connect_failure_sentence(failure: BuildTestConnectFailure) -> str
"Build test did not start because credits are exhausted. "
"No browser or run started. Upgrade your plan in Billing."
)
+ if failure.state == "saved_profile_unresolved":
+ return (
+ "Build test did not start: looking up the saved browser profile this workflow would load failed with "
+ "an error, so no signed-out run was attempted in its place."
+ )
+ if failure.state == "saved_profile_not_applied":
+ return (
+ "Build test did not start: the test browser could not be confirmed to have loaded the workflow's saved "
+ "browser profile, so no signed-out run was attempted in its place."
+ )
if failure.state == "occupied":
holder = f" ({failure.occupier_run_id})" if failure.occupier_run_id else ""
return (
diff --git a/skyvern/forge/sdk/copilot/build_test_outcome.py b/skyvern/forge/sdk/copilot/build_test_outcome.py
index 4a04a4890..1d070b9df 100644
--- a/skyvern/forge/sdk/copilot/build_test_outcome.py
+++ b/skyvern/forge/sdk/copilot/build_test_outcome.py
@@ -112,6 +112,8 @@ TerminalCause = Literal[
"cdp_connect_failed",
"occupied",
"billing_credit_admission_refusal",
+ "saved_profile_unresolved",
+ "saved_profile_not_applied",
]
BuildTestPacketLocatorUnobservedReason = Literal[
"worker_owned_run",
diff --git a/skyvern/forge/sdk/copilot/request_policy.py b/skyvern/forge/sdk/copilot/request_policy.py
index 0bb05ba59..21aa234a3 100644
--- a/skyvern/forge/sdk/copilot/request_policy.py
+++ b/skyvern/forge/sdk/copilot/request_policy.py
@@ -54,6 +54,7 @@ from skyvern.forge.sdk.copilot.secret_redaction import (
from skyvern.forge.sdk.copilot.tracing_setup import copilot_span
from skyvern.forge.sdk.copilot.workflow_credential_utils import (
URL_CANDIDATE_RE,
+ parse_workflow_yaml,
workflow_credential_ids,
workflow_credential_origins,
)
@@ -968,6 +969,7 @@ class RequestPolicy:
# Read from the saved workflow row, never from the submitted YAML. The submission is the live
# canvas, which carries a copilot proposal the user has not accepted, so it cannot grant a run.
persisted_workflow_credential_ids: list[str] = field(default_factory=list)
+ persisted_workflow_browser_profile_id: str | None = None
# Active Google OAuth connections admitted only for workflow execution. These never enter
# resolved_credentials, which remains the password-fill authority plane from ADR 0002.
run_approved_google_connection_ids: list[str] = field(default_factory=list)
@@ -4684,6 +4686,13 @@ async def _build_request_policy_bootstrap(
canonical_user_message=(redact_raw_secrets_for_prompt(user_message) if raw_secret_present else user_message),
)
policy.persisted_workflow_credential_ids = sorted(workflow_credential_ids(persisted_workflow_yaml or ""))
+ persisted_workflow = parse_workflow_yaml(persisted_workflow_yaml) if persisted_workflow_yaml else None
+ persisted_browser_profile_id = (
+ persisted_workflow.get("browser_profile_id") if isinstance(persisted_workflow, dict) else None
+ )
+ policy.persisted_workflow_browser_profile_id = (
+ persisted_browser_profile_id if isinstance(persisted_browser_profile_id, str) else None
+ )
policy.existing_workflow_credential_ids = sorted(workflow_credential_ids(workflow_yaml))
policy.existing_workflow_credential_origins = {
credential_id: sorted(origins) for credential_id, origins in workflow_credential_origins(workflow_yaml).items()
diff --git a/skyvern/forge/sdk/copilot/runtime.py b/skyvern/forge/sdk/copilot/runtime.py
index bf76504c4..116f0f446 100644
--- a/skyvern/forge/sdk/copilot/runtime.py
+++ b/skyvern/forge/sdk/copilot/runtime.py
@@ -65,7 +65,7 @@ from skyvern.forge.sdk.core import skyvern_context
from skyvern.forge.sdk.schemas.credentials import Credential
from skyvern.library.skyvern_browser import SkyvernBrowser
from skyvern.schemas.browser_session_close import BrowserSessionCloseReason
-from skyvern.schemas.proxy_location import ProxyLocationInput
+from skyvern.schemas.proxy_location import ProxyLocation, ProxyLocationInput
from skyvern.webeye.browser_engine import is_any_engine_error
from skyvern.webeye.browser_errors import (
BrowserCdpAcquisitionError,
@@ -1888,7 +1888,7 @@ async def _drop_browser_session_id_at_its_fixed_deadline(ctx: AgentContext) -> N
def _build_test_connect_failure_result(failure: BuildTestConnectFailure) -> dict[str, Any]:
sentence = build_test_connect_failure_sentence(failure)
- explicit_absence = failure.state == "billing_credit_admission_refusal"
+ explicit_absence = failure.retry_action is None
return {
"ok": False,
"error": sentence,
@@ -1920,7 +1920,41 @@ def _browser_session_acquisition_failure_result(failure: BuildTestConnectFailure
return {"ok": False, "error": "Failed to create browser session"}
-async def _provision_browser_session(ctx: AgentContext) -> BuildTestConnectFailure | None:
+@dataclass(frozen=True)
+class BuildTestBrowserSeed:
+ browser_profile_id: str
+ proxy_session_id: str | None
+
+
+class _SeededCreateSessionKwargs(TypedDict, total=False):
+ browser_profile_id: str
+ profile_read_only: bool
+ generate_browser_profile: bool
+ proxy_session_id: str
+ proxy_location: ProxyLocation
+ inherit_profile_proxy: bool
+
+
+def _seeded_create_session_kwargs(seed: BuildTestBrowserSeed | None) -> _SeededCreateSessionKwargs:
+ if seed is None:
+ return {}
+ # An exporter that cannot read or predates profile_read_only then saves under the session id, never the bp_.
+ kwargs: _SeededCreateSessionKwargs = {
+ "browser_profile_id": seed.browser_profile_id,
+ "profile_read_only": True,
+ "generate_browser_profile": True,
+ }
+ if seed.proxy_session_id:
+ kwargs["proxy_session_id"] = seed.proxy_session_id
+ kwargs["proxy_location"] = ProxyLocation.RESIDENTIAL_ISP
+ else:
+ kwargs["inherit_profile_proxy"] = True
+ return kwargs
+
+
+async def _provision_browser_session(
+ ctx: AgentContext, *, seed: BuildTestBrowserSeed | None = None
+) -> BuildTestConnectFailure | None:
"""Create a browser session if the context holds none.
Returns an immutable acquisition fact on failure and ``None`` on success. Generic callers
@@ -1973,6 +2007,7 @@ async def _provision_browser_session(ctx: AgentContext) -> BuildTestConnectFailu
organization_id=ctx.organization_id,
timeout_minutes=30,
created_by="copilot",
+ **_seeded_create_session_kwargs(seed),
)
if ctx.browser_session_id:
# A sibling call installed a session while this create was in flight. Adopt theirs and
@@ -2056,9 +2091,11 @@ async def ensure_browser_session(ctx: AgentContext) -> dict[str, Any] | None:
return None if failure is None else _browser_session_acquisition_failure_result(failure)
-async def ensure_build_test_browser_session(ctx: AgentContext) -> dict[str, Any] | None:
+async def ensure_build_test_browser_session(
+ ctx: AgentContext, *, seed: BuildTestBrowserSeed | None = None
+) -> dict[str, Any] | None:
async with browser_session_recovery(ctx):
- failure = await _provision_browser_session(ctx)
+ failure = await _provision_browser_session(ctx, seed=seed)
return None if failure is None else _build_test_connect_failure_result(failure)
diff --git a/skyvern/forge/sdk/copilot/tools/run_execution.py b/skyvern/forge/sdk/copilot/tools/run_execution.py
index 1a448d959..aeabea84f 100644
--- a/skyvern/forge/sdk/copilot/tools/run_execution.py
+++ b/skyvern/forge/sdk/copilot/tools/run_execution.py
@@ -9,6 +9,7 @@ import json
import os
import tempfile
import time
+import uuid
from collections import defaultdict
from collections.abc import Mapping, Sequence
from dataclasses import dataclass
@@ -155,13 +156,16 @@ from skyvern.forge.sdk.copilot.run_outcome import (
)
from skyvern.forge.sdk.copilot.runtime import (
AgentContext,
+ BuildTestBrowserSeed,
FrontierStartProvenance,
OriginRunRedactionRegistry,
PreRunPageReference,
RegisteredArtifactEntry,
RegisteredArtifactEvidence,
+ _build_test_connect_failure_result,
browser_page_custody_lock,
browser_session_recovery,
+ close_browser_session_quietly,
ensure_build_test_browser_session,
record_attached_browser_driver,
record_sensitive_origin_run_taint,
@@ -199,8 +203,10 @@ from skyvern.forge.sdk.copilot.turn_halt import (
stash_build_test_superseded_halt,
stash_turn_halt_from_blocker_signal,
)
+from skyvern.forge.sdk.copilot.turn_origin import TurnOrigin
from skyvern.forge.sdk.copilot.workflow_yaml import _process_workflow_yaml, runner_code_block_associations
from skyvern.forge.sdk.core import skyvern_context
+from skyvern.forge.sdk.db.enums import BrowserSeedSource
from skyvern.forge.sdk.executor.factory import AsyncExecutorFactory
from skyvern.forge.sdk.schemas.credentials import CredentialVaultType
from skyvern.forge.sdk.schemas.workflow_copilot import (
@@ -1367,7 +1373,8 @@ async def _workflow_from_prior_draft(ctx: CopilotContext, labels: list[str]) ->
def _run_starts_at_workflow_head(frontier_start_label: str | None, workflow_labels: Sequence[str]) -> bool:
- """A plan that starts at the first block is the workflow as production runs it: from a blank browser."""
+ """A plan that starts at the first block is the workflow as production runs it: from the browser state a
+ normal run would load."""
return bool(workflow_labels) and frontier_start_label == workflow_labels[0]
@@ -1688,6 +1695,7 @@ class _RunExecution:
outcome: RecordedRunOutcome | None = None
build_outcome: RecordedBuildTestOutcome | None = None
parameter_values: dict[str, Any] | None = dataclass_field(default=None, repr=False)
+ browser_seed_source: BrowserSeedSource | None = None
def source_is_current(self, ctx: AgentContext) -> bool:
return ctx.staged_workflow == self.source_at_start
@@ -1708,6 +1716,13 @@ class _ExecutionResult(dict[str, Any]):
"restored_saved_profile": False,
"inherited_browser_state": False,
}
+ elif execution.browser_seed_source is not None:
+ data["browser_start"] = {
+ "kind": "separate_saved_profile_context",
+ "restored_saved_profile": True,
+ "inherited_browser_state": False,
+ "seed_source": execution.browser_seed_source.value,
+ }
def _declared_execution_snapshot(workflow: Workflow) -> CopilotExecutionSnapshot:
@@ -2876,13 +2891,15 @@ def _credit_composition_verified_labels(
ctx.composition_verified_labels = workflow_labels[: max(end, len(credited))]
-async def acquire_build_test_browser_session(ctx: CopilotContext, *, fresh: bool) -> dict[str, Any] | None:
+async def acquire_build_test_browser_session(
+ ctx: CopilotContext, *, fresh: bool, seed: BuildTestBrowserSeed | None = None
+) -> dict[str, Any] | None:
"""The single initial-acquisition seam used by every build-test run."""
# Executed-source promotion holds this lock through persistence. Build-test acquisition can retire a
# fixed-deadline browser, so it must not replace that source's session while the write is in flight.
async with browser_session_recovery(ctx):
if fresh:
- return await ensure_build_test_browser_session(ctx)
+ return await ensure_build_test_browser_session(ctx, seed=seed)
return await verify_build_test_browser_session_by_attaching(
ctx,
copilot_chat_id=ctx.workflow_copilot_chat_id,
@@ -2890,6 +2907,46 @@ async def acquire_build_test_browser_session(ctx: CopilotContext, *, fresh: bool
)
+_UNSAVED_BROWSER_PROFILE_PICK_ERROR = (
+ "Saved browser profile approval blocked this Copilot run before dispatch. "
+ "Reason codes: unsaved_browser_profile_pick. The workflow draft selects a saved browser profile that the "
+ "saved workflow does not use, so it cannot seed a test until the workflow is saved with it."
+)
+
+
+def _build_test_seed_preview_run(workflow: Workflow, organization_id: str) -> WorkflowRun:
+ now = datetime.now(UTC)
+ return WorkflowRun(
+ workflow_run_id=f"copilot_seed_preview_{uuid.uuid4().hex}",
+ workflow_id=workflow.workflow_id,
+ workflow_permanent_id=workflow.workflow_permanent_id,
+ organization_id=organization_id,
+ status=WorkflowRunStatus.created,
+ extra_http_headers=workflow.extra_http_headers,
+ proxy_location=workflow.proxy_location,
+ created_at=now,
+ modified_at=now,
+ )
+
+
+async def _seed_profile_applied(organization_id: str, session_id: str, browser_profile_id: str) -> bool:
+ try:
+ session = await app.PERSISTENT_SESSIONS_MANAGER.get_session(session_id, organization_id)
+ except Exception:
+ LOG.warning("Could not confirm the build-test browser loaded its saved profile", exc_info=True)
+ return False
+ return session is not None and session.browser_profile_id == browser_profile_id and session.browser_profile_loaded
+
+
+def _saved_profile_start_failure(
+ state: BuildTestConnectFailureState, *, requested_block_labels: Sequence[str]
+) -> dict[str, Any]:
+ return _with_build_test_acquisition_context(
+ _build_test_connect_failure_result(BuildTestConnectFailure(state=state, retry_action=None)),
+ requested_block_labels=requested_block_labels,
+ )
+
+
def _with_build_test_acquisition_context(
result: dict[str, Any], *, requested_block_labels: Sequence[str]
) -> dict[str, Any]:
@@ -3414,6 +3471,77 @@ async def _run_blocks_and_collect_debug(
# The planner reads a head block that establishes no state as unanchored because it would
# meet whatever page authoring left open. A browser minted for this run is that proof.
start_provenance = "initial"
+ ephemeral_input_values = (
+ _ephemeral_input_values_by_parameter_key(execution.metadata, ctx.scout_trajectory)
+ if use_ephemeral_inputs
+ else {}
+ )
+ data, unbound_required_parameter_keys, reused_origin_input_keys = _resolve_run_data_and_unbound_keys(
+ list(snapshot.workflow_parameters),
+ user_params,
+ ephemeral_input_values=ephemeral_input_values,
+ origin_parameters=ctx.repair_origin_input_values,
+ origin_is_copilot_run=ctx.repair_origin_is_copilot_run,
+ )
+ browser_seed: BuildTestBrowserSeed | None = None
+ browser_seed_source: BrowserSeedSource | None = None
+ if (
+ use_fresh_session
+ and starts_at_workflow_head
+ and not explicit_blank
+ and ctx.turn_origin != TurnOrigin.code_block_ai_fallback
+ ):
+ # Previewed on the authored workflow, before the copy that turns off saving, so the profile is the
+ # one a normal run of this workflow would load.
+ try:
+ engine_enabled = await app.AGENT_FUNCTION.is_browser_memory_engine_enabled_for_org(ctx.organization_id)
+ preview_run = _build_test_seed_preview_run(snapshot.workflow, ctx.organization_id)
+ preview = await app.WORKFLOW_SERVICE.preview_run_seed(
+ workflow=snapshot.workflow,
+ workflow_run=preview_run,
+ parameter_values=data,
+ explicit_request_browser_profile_id=None,
+ engine_enabled=engine_enabled,
+ )
+ # A profile row with nothing stored boots blank in a normal run too.
+ if preview is not None and not await app.STORAGE.browser_profile_exists(ctx.organization_id, preview[0]):
+ preview = None
+ seed_owner_ids: list[str] = []
+ if preview is not None and preview[1] == BrowserSeedSource.credential:
+ seed_owner_ids = [
+ owner.credential_id
+ for owner in await app.DATABASE.credentials.get_credentials_by_browser_profile_id(
+ browser_profile_id=preview[0], organization_id=ctx.organization_id
+ )
+ ]
+ except Exception:
+ LOG.warning("Could not resolve the build test's saved browser profile", exc_info=True)
+ return _saved_profile_start_failure("saved_profile_unresolved", requested_block_labels=block_labels)
+ if preview is not None and preview[1] == BrowserSeedSource.credential:
+ # A credential's saved sign-in carries the credential's authority, so it needs the same run approval.
+ if not seed_owner_ids:
+ return _saved_profile_start_failure("saved_profile_unresolved", requested_block_labels=block_labels)
+ seed_approval_error = _credential_run_approval_error(seed_owner_ids, ctx.request_policy)
+ if seed_approval_error is not None:
+ return {"ok": False, "error": seed_approval_error}
+ if preview is not None and preview[1] == BrowserSeedSource.picked:
+ # A draft can name any profile in the org; only the saved workflow's pick at turn start is settled.
+ saved_pick = ctx.request_policy.persisted_workflow_browser_profile_id if ctx.request_policy else None
+ if preview[0] != saved_pick:
+ return {"ok": False, "error": _UNSAVED_BROWSER_PROFILE_PICK_ERROR}
+ if preview is not None:
+ seed_profile_id, browser_seed_source = preview
+ proxy_session_id = (
+ await app.WORKFLOW_SERVICE.preview_run_proxy_pin(
+ workflow=snapshot.workflow,
+ workflow_run=preview_run,
+ parameter_values=data,
+ seed_profile_id=seed_profile_id,
+ )
+ if engine_enabled
+ else None
+ )
+ browser_seed = BuildTestBrowserSeed(browser_profile_id=seed_profile_id, proxy_session_id=proxy_session_id)
resumes_a_build_test_browser = resume_session_id is not None and resume_session_id != ctx.browser_session_id
if explicit_blank or use_fresh_session or resumes_a_build_test_browser:
# Keep the authored profile configured, but never save a build test's browser over it: the
@@ -3437,10 +3565,18 @@ async def _run_blocks_and_collect_debug(
debug_session_id = ctx.browser_session_id
acquisition_ctx = replace(ctx)
acquisition_ctx.browser_session_id = None
- session_err = await acquire_build_test_browser_session(acquisition_ctx, fresh=True)
+ session_err = await acquire_build_test_browser_session(acquisition_ctx, fresh=True, seed=browser_seed)
if session_err is not None:
return _with_build_test_acquisition_context(session_err, requested_block_labels=block_labels)
run_session_id = acquisition_ctx.browser_session_id
+ if browser_seed is not None:
+ if not run_session_id or not await _seed_profile_applied(
+ ctx.organization_id, run_session_id, browser_seed.browser_profile_id
+ ):
+ if run_session_id:
+ await close_browser_session_quietly(ctx.organization_id, run_session_id)
+ return _saved_profile_start_failure("saved_profile_not_applied", requested_block_labels=block_labels)
+ execution.browser_seed_source = browser_seed_source
if explicit_blank and (
not isinstance(run_session_id, str) or not run_session_id or run_session_id == debug_session_id
):
@@ -3541,18 +3677,8 @@ async def _run_blocks_and_collect_debug(
all_workflow_params = list(snapshot.workflow_parameters)
all_output_params = list(snapshot.output_parameters)
- ephemeral_input_values = (
- _ephemeral_input_values_by_parameter_key(execution.metadata, ctx.scout_trajectory)
- if use_ephemeral_inputs
- else {}
- )
- data, ctx.unbound_required_parameter_keys, execution.reused_origin_input_keys = _resolve_run_data_and_unbound_keys(
- all_workflow_params,
- user_params,
- ephemeral_input_values=ephemeral_input_values,
- origin_parameters=ctx.repair_origin_input_values,
- origin_is_copilot_run=ctx.repair_origin_is_copilot_run,
- )
+ ctx.unbound_required_parameter_keys = unbound_required_parameter_keys
+ execution.reused_origin_input_keys = reused_origin_input_keys
execution.unbound_keys = list(ctx.unbound_required_parameter_keys)
# Only credential-typed values are ever read back; scout-typed form inputs stay out of the record.
execution.parameter_values = {
@@ -3609,6 +3735,35 @@ async def _run_blocks_and_collect_debug(
"ok": False,
"error": "The prepared run did not retain the requested blank browser; execution was not started.",
}
+ if browser_seed is not None:
+ # A session-bound run skips the engine's own seed stamp; its mid-run login handling reads this one.
+ try:
+ await app.DATABASE.workflow_runs.update_workflow_run(
+ workflow_run_id=workflow_run.workflow_run_id,
+ browser_profile_id=browser_seed.browser_profile_id,
+ browser_seed_source=browser_seed_source,
+ browser_sink_profile_id=None,
+ )
+ except Exception:
+ LOG.warning("Failed to record the build test's browser seed", exc_info=True)
+ await app.WORKFLOW_SERVICE.mark_workflow_run_as_failed_if_not_final(
+ workflow_run_id=workflow_run.workflow_run_id,
+ failure_reason="The test run's saved browser profile could not be recorded.",
+ )
+ if dispatch_draft_workflow_id is not None:
+ await _delete_dispatch_draft(dispatch_draft_workflow_id, ctx.organization_id)
+ dispatch_draft_workflow_id = None
+ if run_session_id:
+ await close_browser_session_quietly(ctx.organization_id, run_session_id)
+ return {
+ "ok": False,
+ "error": "The test run's saved browser profile could not be recorded; execution was not started.",
+ }
+ LOG.info(
+ "copilot_build_test_browser_seed_recorded",
+ workflow_run_id=workflow_run.workflow_run_id,
+ browser_seed_source=browser_seed_source,
+ )
if (
ctx.workflow_copilot_chat_id
diff --git a/skyvern/forge/sdk/db/models.py b/skyvern/forge/sdk/db/models.py
index 3ec1c8034..82534e30a 100644
--- a/skyvern/forge/sdk/db/models.py
+++ b/skyvern/forge/sdk/db/models.py
@@ -1633,6 +1633,7 @@ class PersistentBrowserSessionModel(Base):
bound_key = Column(String, nullable=True)
generate_browser_profile = Column(Boolean, default=False, nullable=False, server_default=sqlalchemy.false())
browser_profile_loaded = Column(Boolean, default=True, nullable=False, server_default=sqlalchemy.true())
+ profile_read_only = Column(Boolean, default=False, nullable=False, server_default=sqlalchemy.false())
instance_type = Column(String, nullable=True)
# Retained, unwritten columns: the pod-share estimator that filled them was replaced by the
# pool rate card, which prices whole run-hours and has no per-pod share to record.
diff --git a/skyvern/forge/sdk/db/repositories/browser_sessions.py b/skyvern/forge/sdk/db/repositories/browser_sessions.py
index 8fab72ecb..e01aac699 100644
--- a/skyvern/forge/sdk/db/repositories/browser_sessions.py
+++ b/skyvern/forge/sdk/db/repositories/browser_sessions.py
@@ -988,6 +988,7 @@ class BrowserSessionsRepository(BaseRepository):
bound_key: str | None = None,
download_run_id: str | None = None,
*,
+ profile_read_only: bool = False,
created_by: str | None = None,
workflow_run_id: str | None = None,
attempt_number: int | None = None,
@@ -1045,6 +1046,7 @@ class BrowserSessionsRepository(BaseRepository):
browser_type=browser_type.value if browser_type else None,
browser_profile_id=browser_profile_id,
generate_browser_profile=generate_browser_profile,
+ profile_read_only=profile_read_only,
provisioning_deadline_at=to_naive_utc(provisioning_deadline_at),
bound_workflow_permanent_id=bound_workflow_permanent_id,
bound_key=bound_key,
diff --git a/skyvern/forge/sdk/routes/browser_profiles.py b/skyvern/forge/sdk/routes/browser_profiles.py
index 86cbc4d20..4b9641877 100644
--- a/skyvern/forge/sdk/routes/browser_profiles.py
+++ b/skyvern/forge/sdk/routes/browser_profiles.py
@@ -15,7 +15,7 @@ from skyvern.exceptions import (
WorkflowRunNotFound,
)
from skyvern.forge import app
-from skyvern.forge.sdk.api.files import make_temp_directory
+from skyvern.forge.sdk.api.files import discard_temp_working_dir, make_temp_directory
from skyvern.forge.sdk.routes.code_samples import (
CREATE_BROWSER_PROFILE_CODE_SAMPLE_PYTHON,
CREATE_BROWSER_PROFILE_CODE_SAMPLE_TS,
@@ -788,36 +788,39 @@ async def _create_profile_from_session(
proxy_session_id = browser_session.proxy_session_id
try:
- profile = await app.DATABASE.browser_sessions.create_browser_profile(
- organization_id=organization_id,
- name=name,
- description=description,
- source_browser_type=source_browser_type,
- proxy_location=proxy_location,
- proxy_session_id=proxy_session_id,
- )
- except IntegrityError as exc:
- _handle_duplicate_profile_name(organization_id=organization_id, name=name, exc=exc)
+ try:
+ profile = await app.DATABASE.browser_sessions.create_browser_profile(
+ organization_id=organization_id,
+ name=name,
+ description=description,
+ source_browser_type=source_browser_type,
+ proxy_location=proxy_location,
+ proxy_session_id=proxy_session_id,
+ )
+ except IntegrityError as exc:
+ _handle_duplicate_profile_name(organization_id=organization_id, name=name, exc=exc)
- try:
- await app.STORAGE.store_browser_profile(
- organization_id=organization_id,
- profile_id=profile.browser_profile_id,
- directory=session_dir,
- )
- except Exception:
- rolled_back = await _hard_delete_created_profile_after_store_failure(
- organization_id=organization_id,
- browser_profile_id=profile.browser_profile_id,
- )
- LOG.error(
- "Failed to store browser profile artifacts",
- organization_id=organization_id,
- browser_profile_id=profile.browser_profile_id,
- rolled_back=rolled_back,
- exc_info=True,
- )
- raise
+ try:
+ await app.STORAGE.store_browser_profile(
+ organization_id=organization_id,
+ profile_id=profile.browser_profile_id,
+ directory=session_dir,
+ )
+ except Exception:
+ rolled_back = await _hard_delete_created_profile_after_store_failure(
+ organization_id=organization_id,
+ browser_profile_id=profile.browser_profile_id,
+ )
+ LOG.error(
+ "Failed to store browser profile artifacts",
+ organization_id=organization_id,
+ browser_profile_id=profile.browser_profile_id,
+ rolled_back=rolled_back,
+ exc_info=True,
+ )
+ raise
+ finally:
+ discard_temp_working_dir(session_dir)
# The promote copied the session's own export (profiles/{pbs_session}.zip) into the new bp_, so
# reap that source now that it's redundant. Keyed on the session id, never a reused bp_ profile.
@@ -922,41 +925,44 @@ async def _create_profile_from_workflow_run(
)
try:
- profile = await app.DATABASE.browser_sessions.create_browser_profile(
- organization_id=organization_id,
- name=name,
- description=description,
- proxy_location=proxy_location,
- proxy_session_id=proxy_session_id,
- )
- except IntegrityError as exc:
- _handle_duplicate_profile_name(organization_id=organization_id, name=name, exc=exc)
+ try:
+ profile = await app.DATABASE.browser_sessions.create_browser_profile(
+ organization_id=organization_id,
+ name=name,
+ description=description,
+ proxy_location=proxy_location,
+ proxy_session_id=proxy_session_id,
+ )
+ except IntegrityError as exc:
+ _handle_duplicate_profile_name(organization_id=organization_id, name=name, exc=exc)
- try:
- await app.STORAGE.store_browser_profile(
- organization_id=organization_id,
- profile_id=profile.browser_profile_id,
- directory=session_dir,
- )
- LOG.info(
- "Created browser profile from workflow run",
- organization_id=organization_id,
- browser_profile_id=profile.browser_profile_id,
- workflow_run_id=workflow_run_id,
- )
- except Exception:
- rolled_back = await _hard_delete_created_profile_after_store_failure(
- organization_id=organization_id,
- browser_profile_id=profile.browser_profile_id,
- )
- LOG.error(
- "Failed to store browser profile artifacts",
- organization_id=organization_id,
- browser_profile_id=profile.browser_profile_id,
- workflow_run_id=workflow_run_id,
- rolled_back=rolled_back,
- exc_info=True,
- )
- raise
+ try:
+ await app.STORAGE.store_browser_profile(
+ organization_id=organization_id,
+ profile_id=profile.browser_profile_id,
+ directory=session_dir,
+ )
+ LOG.info(
+ "Created browser profile from workflow run",
+ organization_id=organization_id,
+ browser_profile_id=profile.browser_profile_id,
+ workflow_run_id=workflow_run_id,
+ )
+ except Exception:
+ rolled_back = await _hard_delete_created_profile_after_store_failure(
+ organization_id=organization_id,
+ browser_profile_id=profile.browser_profile_id,
+ )
+ LOG.error(
+ "Failed to store browser profile artifacts",
+ organization_id=organization_id,
+ browser_profile_id=profile.browser_profile_id,
+ workflow_run_id=workflow_run_id,
+ rolled_back=rolled_back,
+ exc_info=True,
+ )
+ raise
+ finally:
+ discard_temp_working_dir(session_dir)
return profile
diff --git a/skyvern/forge/sdk/routes/credentials.py b/skyvern/forge/sdk/routes/credentials.py
index 1aa1c47fc..10bca62c2 100644
--- a/skyvern/forge/sdk/routes/credentials.py
+++ b/skyvern/forge/sdk/routes/credentials.py
@@ -49,6 +49,7 @@ from skyvern.exceptions import BrowserProfileNotFound
from skyvern.exceptions import HttpException as SkyvernHttpException
from skyvern.exceptions import SkyvernHTTPException
from skyvern.forge import app
+from skyvern.forge.sdk.api.files import discard_temp_working_dir
from skyvern.forge.sdk.core.aiohttp_helper import aiohttp_request
from skyvern.forge.sdk.db.datetime_utils import naive_utc_now, to_naive_utc
from skyvern.forge.sdk.db.enums import OrganizationAuthTokenType
@@ -1586,6 +1587,7 @@ async def _create_browser_profile_after_workflow(
``existing_browser_profile_id`` in place, otherwise a new profile is created and linked."""
max_polls = 120 # ~10 minutes at 5s intervals
poll_interval = 5
+ session_dir: str | None = None
try:
for _ in range(max_polls):
@@ -1643,7 +1645,6 @@ async def _create_browser_profile_after_workflow(
workflow_permanent_id=workflow_permanent_id,
)
return
- session_dir = None
max_retries = _SESSION_PERSIST_MAX_RETRIES
for attempt in range(max_retries):
session_dir = await retrieve_persisted_workflow_browser_state_dir(
@@ -1800,6 +1801,8 @@ async def _create_browser_profile_after_workflow(
credential_id=credential_id,
exc_info=True,
)
+ finally:
+ discard_temp_working_dir(session_dir)
async def _delete_replaced_credential_item(
diff --git a/skyvern/forge/sdk/schemas/persistent_browser_sessions.py b/skyvern/forge/sdk/schemas/persistent_browser_sessions.py
index 240937eb9..beab8d814 100644
--- a/skyvern/forge/sdk/schemas/persistent_browser_sessions.py
+++ b/skyvern/forge/sdk/schemas/persistent_browser_sessions.py
@@ -120,6 +120,8 @@ class PersistentBrowserSession(BaseModel):
# False once a requested browser_profile_id failed to load at launch (fell back to a fresh profile),
# so teardown exported under the session id rather than the bp_ id.
browser_profile_loaded: bool = True
+ # Loads browser_profile_id but saves nothing at teardown, under either the bp_ or the session id.
+ profile_read_only: bool = False
@property
def is_browser_ready(self) -> bool:
@@ -150,7 +152,7 @@ class PersistentBrowserSession(BaseModel):
A reuse session (browser_profile_id set) must always re-export so the updated session-cookie
sidecar survives; gating it off would silently log the profile out on the next reuse.
"""
- return bool(self.generate_browser_profile or self.browser_profile_id)
+ return not self.profile_read_only and bool(self.generate_browser_profile or self.browser_profile_id)
class AddressablePersistentBrowserSession(PersistentBrowserSession):
diff --git a/skyvern/forge/sdk/workflow/service.py b/skyvern/forge/sdk/workflow/service.py
index a1d29f4df..3afd151f5 100644
--- a/skyvern/forge/sdk/workflow/service.py
+++ b/skyvern/forge/sdk/workflow/service.py
@@ -4134,7 +4134,13 @@ class WorkflowService:
return []
async def _resolve_active_credential_pin_for_setup(
- self, *, workflow: Workflow, workflow_run_id: str, organization_id: str, parameter_values: dict[str, Any]
+ self,
+ *,
+ workflow: Workflow,
+ workflow_run_id: str,
+ organization_id: str,
+ parameter_values: dict[str, Any],
+ read_only: bool = False,
) -> tuple[str, str] | None:
"""The run's active single-login credential's dedicated-IP pin at setup — (credential_id,
proxy_session_id) if that credential pins its IP, else None. Same single-unambiguous-login guard
@@ -4145,6 +4151,7 @@ class WorkflowService:
workflow_run_id=workflow_run_id,
organization_id=organization_id,
parameter_values=parameter_values,
+ read_only=read_only,
)
for credential_id in credential_ids:
try:
@@ -4163,6 +4170,67 @@ class WorkflowService:
return db_cred.credential_id, db_cred.proxy_session_id
return None
+ async def _resolve_run_proxy_pin(
+ self,
+ *,
+ workflow: Workflow,
+ workflow_run: WorkflowRun,
+ parameter_values: dict[str, Any],
+ seed_profile_id: str | None,
+ organization_id: str,
+ read_only: bool = False,
+ ) -> tuple[str, str, str] | None:
+ """(proxy_session_id, credential_id, pin source) of the dedicated IP run setup pins, or None."""
+ if app.AGENT_FUNCTION.has_proxy_session_extra_http_headers(workflow_run.extra_http_headers):
+ return None
+ active = await self._resolve_active_credential_pin_for_setup(
+ workflow=workflow,
+ workflow_run_id=workflow_run.workflow_run_id,
+ organization_id=organization_id,
+ parameter_values=parameter_values,
+ read_only=read_only,
+ )
+ if active:
+ credential_id, proxy_session_id = active
+ return proxy_session_id, credential_id, "credential"
+ if not seed_profile_id:
+ return None
+ owners = await app.DATABASE.credentials.get_credentials_by_browser_profile_id(
+ browser_profile_id=seed_profile_id, organization_id=organization_id
+ )
+ owner = next((c for c in owners if c.pin_saved_session_ip and c.proxy_session_id), None)
+ if owner is None or owner.proxy_session_id is None:
+ return None
+ return owner.proxy_session_id, owner.credential_id, "seed_profile"
+
+ async def preview_run_proxy_pin(
+ self,
+ *,
+ workflow: Workflow,
+ workflow_run: WorkflowRun,
+ parameter_values: dict[str, Any],
+ seed_profile_id: str | None,
+ ) -> str | None:
+ """The proxy session run setup would pin for this seed, writing nothing; None when it pins nothing or
+ the lookup fails, since setup's own pin is best-effort."""
+ try:
+ pin = await self._resolve_run_proxy_pin(
+ workflow=workflow,
+ workflow_run=workflow_run,
+ parameter_values=parameter_values,
+ seed_profile_id=seed_profile_id,
+ organization_id=workflow_run.organization_id,
+ read_only=True,
+ )
+ except Exception:
+ LOG.warning(
+ "Failed to preview credential dedicated IP pin",
+ workflow_permanent_id=workflow.workflow_permanent_id,
+ exc_info=True,
+ )
+ return None
+ return pin[0] if pin else None
+
async def _maybe_pin_credential_profile_ip(
self,
*,
@@ -4177,32 +4245,16 @@ class WorkflowService:
credential isn't pinned, fall back to the seed profile's owning-credential pin. Best-effort — a
failure never blocks setup."""
try:
- if app.AGENT_FUNCTION.has_proxy_session_extra_http_headers(workflow_run.extra_http_headers):
- return workflow_run
- pin_source = "credential"
- proxy_session_id: str | None = None
- pinned_credential_id: str | None = None
- active = await self._resolve_active_credential_pin_for_setup(
+ pin = await self._resolve_run_proxy_pin(
workflow=workflow,
- workflow_run_id=workflow_run.workflow_run_id,
- organization_id=organization_id,
+ workflow_run=workflow_run,
parameter_values=parameter_values,
+ seed_profile_id=seed_profile_id,
+ organization_id=organization_id,
)
- if active:
- pinned_credential_id, proxy_session_id = active
- elif seed_profile_id:
- owners = await app.DATABASE.credentials.get_credentials_by_browser_profile_id(
- browser_profile_id=seed_profile_id, organization_id=organization_id
- )
- owner = next((c for c in owners if c.pin_saved_session_ip and c.proxy_session_id), None)
- if owner:
- proxy_session_id, pinned_credential_id, pin_source = (
- owner.proxy_session_id,
- owner.credential_id,
- "seed_profile",
- )
- if not proxy_session_id:
+ if pin is None:
return workflow_run
+ proxy_session_id, pinned_credential_id, pin_source = pin
headers = app.AGENT_FUNCTION.merge_proxy_session_extra_http_headers(
dict(workflow_run.extra_http_headers or {}), proxy_session_id
)
diff --git a/skyvern/webeye/browser_factory.py b/skyvern/webeye/browser_factory.py
index be038b465..4daa5da58 100644
--- a/skyvern/webeye/browser_factory.py
+++ b/skyvern/webeye/browser_factory.py
@@ -47,6 +47,7 @@ from skyvern.exceptions import (
)
from skyvern.forge import app
from skyvern.forge.sdk.api.files import (
+ discard_temp_working_dir,
get_current_run_dir,
get_download_dir,
make_run_temp_directory,
@@ -990,6 +991,17 @@ def _is_chrome_running() -> bool:
return False
+def _read_only_copy_cleanup(read_only_copy: str | None) -> BrowserCleanupFunc:
+ if read_only_copy is None:
+ return None
+ copy_dir = read_only_copy
+
+ async def _discard() -> None:
+ await asyncio.to_thread(discard_temp_working_dir, copy_dir)
+
+ return _discard
+
+
@_forbidden_in_attach_only_worker("a local headless Chromium launch")
async def _create_headless_chromium(
playwright: Playwright,
@@ -1016,7 +1028,12 @@ async def _create_headless_chromium(
loaded_from_saved_profile = False
if browser_profile_id and organization_id_for_profile:
- profile_dir = await app.STORAGE.retrieve_browser_profile(
+ retrieve_profile = (
+ app.STORAGE.retrieve_browser_profile_copy
+ if kwargs.get("profile_read_only")
+ else app.STORAGE.retrieve_browser_profile
+ )
+ profile_dir = await retrieve_profile(
organization_id=organization_id_for_profile,
profile_id=browser_profile_id,
)
@@ -1035,6 +1052,7 @@ async def _create_headless_chromium(
organization_id=organization_id_for_profile,
)
+ read_only_copy = user_data_dir if loaded_from_saved_profile and kwargs.get("profile_read_only") else None
if not user_data_dir:
user_data_dir = make_run_temp_directory(prefix="skyvern_browser_")
@@ -1060,30 +1078,36 @@ async def _create_headless_chromium(
if loaded_from_saved_profile:
browser_artifacts.applied_browser_profile_id = browser_profile_id
try:
- browser_context = await playwright.chromium.launch_persistent_context(**browser_args)
- except Exception as launch_error:
- if loaded_from_saved_profile and _is_browser_profile_corruption_error(launch_error):
- LOG.warning(
- "Browser launch failed with saved profile — profile may be corrupted, falling back to fresh profile",
- browser_profile_id=browser_profile_id,
- organization_id=organization_id_for_profile,
- error=str(launch_error),
- )
- fallback_dir = make_run_temp_directory(prefix="skyvern_browser_")
- BrowserContextFactory.update_chromium_browser_preferences(
- user_data_dir=fallback_dir,
- download_dir=download_dir,
- )
- browser_args["user_data_dir"] = fallback_dir
- browser_artifacts = BrowserContextFactory.build_browser_artifacts(
- har_path=browser_args["record_har_path"],
- browser_session_dir=fallback_dir,
- )
- browser_artifacts.mark_seed_load_failed()
+ try:
browser_context = await playwright.chromium.launch_persistent_context(**browser_args)
- else:
- raise
- return browser_context, browser_artifacts, None
+ except Exception as launch_error:
+ if loaded_from_saved_profile and _is_browser_profile_corruption_error(launch_error):
+ LOG.warning(
+ "Browser launch failed with saved profile — profile may be corrupted, falling back to fresh profile",
+ browser_profile_id=browser_profile_id,
+ organization_id=organization_id_for_profile,
+ error=str(launch_error),
+ )
+ discard_temp_working_dir(read_only_copy)
+ read_only_copy = None
+ fallback_dir = make_run_temp_directory(prefix="skyvern_browser_")
+ BrowserContextFactory.update_chromium_browser_preferences(
+ user_data_dir=fallback_dir,
+ download_dir=download_dir,
+ )
+ browser_args["user_data_dir"] = fallback_dir
+ browser_artifacts = BrowserContextFactory.build_browser_artifacts(
+ har_path=browser_args["record_har_path"],
+ browser_session_dir=fallback_dir,
+ )
+ browser_artifacts.mark_seed_load_failed()
+ browser_context = await playwright.chromium.launch_persistent_context(**browser_args)
+ else:
+ raise
+ except BaseException:
+ discard_temp_working_dir(read_only_copy)
+ raise
+ return browser_context, browser_artifacts, _read_only_copy_cleanup(read_only_copy)
@_forbidden_in_attach_only_worker("a local headful Chromium launch")
@@ -1112,7 +1136,12 @@ async def _create_headful_chromium(
loaded_from_saved_profile = False
if browser_profile_id and organization_id_for_profile:
- profile_dir = await app.STORAGE.retrieve_browser_profile(
+ retrieve_profile = (
+ app.STORAGE.retrieve_browser_profile_copy
+ if kwargs.get("profile_read_only")
+ else app.STORAGE.retrieve_browser_profile
+ )
+ profile_dir = await retrieve_profile(
organization_id=organization_id_for_profile,
profile_id=browser_profile_id,
)
@@ -1131,6 +1160,7 @@ async def _create_headful_chromium(
organization_id=organization_id_for_profile,
)
+ read_only_copy = user_data_dir if loaded_from_saved_profile and kwargs.get("profile_read_only") else None
if not user_data_dir:
user_data_dir = make_run_temp_directory(prefix="skyvern_browser_")
@@ -1180,6 +1210,8 @@ async def _create_headful_chromium(
organization_id=organization_id_for_profile,
error=str(launch_error),
)
+ discard_temp_working_dir(read_only_copy)
+ read_only_copy = None
fallback_dir = make_run_temp_directory(prefix="skyvern_browser_")
BrowserContextFactory.update_chromium_browser_preferences(
user_data_dir=fallback_dir,
@@ -1199,9 +1231,10 @@ async def _create_headful_chromium(
else:
raise
except BaseException:
+ discard_temp_working_dir(read_only_copy)
await release_started_display_recording(browser_artifacts)
raise
- return browser_context, browser_artifacts, None
+ return browser_context, browser_artifacts, _read_only_copy_cleanup(read_only_copy)
def default_user_data_dir() -> pathlib.Path:
diff --git a/skyvern/webeye/default_persistent_sessions_manager.py b/skyvern/webeye/default_persistent_sessions_manager.py
index 0201dd552..8f3eaeee4 100644
--- a/skyvern/webeye/default_persistent_sessions_manager.py
+++ b/skyvern/webeye/default_persistent_sessions_manager.py
@@ -665,6 +665,7 @@ class DefaultPersistentSessionsManager(PersistentSessionsManager):
queue_deadline_epoch_ms: int | None = None,
workflow_run_id: str | None = None,
*,
+ profile_read_only: bool = False,
created_by: str | None = None,
attempt_number: int | None = None,
dispatch_claim_started_at: datetime | None = None,
@@ -695,6 +696,7 @@ class DefaultPersistentSessionsManager(PersistentSessionsManager):
bound_workflow_permanent_id=bound_workflow_permanent_id,
bound_key=bound_key,
download_run_id=resolve_run_download_id(skyvern_context.current(), fallback_run_id=runnable_id),
+ profile_read_only=profile_read_only,
created_by=created_by,
)
except BaseException as error:
@@ -747,6 +749,7 @@ class DefaultPersistentSessionsManager(PersistentSessionsManager):
organization_id=organization_id,
extra_http_headers=extra_http_headers,
browser_profile_id=session.browser_profile_id,
+ profile_read_only=session.profile_read_only,
cdp_port=cdp_port,
runtime_event_context=BrowserRuntimeLogContext(
browser_session_id=session_id,
@@ -782,6 +785,17 @@ class DefaultPersistentSessionsManager(PersistentSessionsManager):
await _discard_browser_state(browser_state, discarded_cdp_port)
return
+ if session.browser_profile_id is not None:
+ # Written before the session is registered, so a caller that waits for the browser state
+ # reads the load outcome and never the column's default of True.
+ await self.database.browser_sessions.update_persistent_browser_session(
+ session_id,
+ organization_id=organization_id,
+ browser_profile_loaded=(
+ browser_state.browser_artifacts.applied_browser_profile_id == session.browser_profile_id
+ ),
+ )
+
launched_session = BrowserSession(
browser_state=browser_state,
organization_id=organization_id,
diff --git a/skyvern/webeye/persistent_sessions_manager.py b/skyvern/webeye/persistent_sessions_manager.py
index c3238aceb..867c0f1ff 100644
--- a/skyvern/webeye/persistent_sessions_manager.py
+++ b/skyvern/webeye/persistent_sessions_manager.py
@@ -203,6 +203,7 @@ class PersistentSessionsManager(Protocol):
queue_deadline_epoch_ms: int | None = None,
workflow_run_id: str | None = None,
*,
+ profile_read_only: bool = False,
created_by: str | None = None,
attempt_number: int | None = None,
dispatch_claim_started_at: datetime | None = None,
diff --git a/skyvern/webeye/real_browser_manager.py b/skyvern/webeye/real_browser_manager.py
index fb1c7c866..11b668ef4 100644
--- a/skyvern/webeye/real_browser_manager.py
+++ b/skyvern/webeye/real_browser_manager.py
@@ -713,6 +713,7 @@ class RealBrowserManager(BrowserManager):
engine_workflow_run_id: str | None = None,
user_browser_type: str | None = None,
runtime_event_context: BrowserRuntimeLogContext | None = None,
+ profile_read_only: bool = False,
) -> BrowserState:
requested_at_monotonic = time.monotonic()
acquisition_context = runtime_event_context or BrowserRuntimeLogContext.for_run(
@@ -801,6 +802,7 @@ class RealBrowserManager(BrowserManager):
cdp_port=cdp_port,
browser_address_is_server_assigned=bool(context and context.browser_address_is_server_assigned),
browser_profile_id=browser_profile_id,
+ profile_read_only=profile_read_only,
browser_session_id=browser_session_id,
user_browser_type=user_browser_type,
engine_selection=selection,
@@ -835,6 +837,7 @@ class RealBrowserManager(BrowserManager):
# The proxy this context was actually built with. A reader naming the hop that failed
# cannot recover it from anywhere else once the context exists.
state.built_with_proxy_location = proxy_location
+ state.profile_read_only = profile_read_only
# The pre-dispatch address heuristic is passed as-is; the canonical event resolves it
# to the mode a vendor branch recorded at dispatch time (a create that ignores a
# fallback browser_address), covering both this success and the failure path uniformly.
diff --git a/skyvern/webeye/real_browser_state.py b/skyvern/webeye/real_browser_state.py
index b7ff38ec6..28aeff0be 100644
--- a/skyvern/webeye/real_browser_state.py
+++ b/skyvern/webeye/real_browser_state.py
@@ -168,6 +168,22 @@ def expect_process_driver_teardown() -> None:
LOG.debug("Failed to record driver teardown intent", exc_info=True)
+def _chain_browser_cleanups(first: BrowserCleanupFunc, second: BrowserCleanupFunc) -> BrowserCleanupFunc:
+ if first is None or first is second:
+ return second
+ if second is None:
+ return first
+ earlier, later = first, second
+
+ async def _both() -> None:
+ try:
+ await earlier()
+ finally:
+ await later()
+
+ return _both
+
+
class RealBrowserState(BrowserState):
def __init__(
self,
@@ -251,6 +267,8 @@ class RealBrowserState(BrowserState):
# The proxy this browser was actually built with. Downstream layers see only a flattened
# sentence, which cannot say which hop it went through.
self.built_with_proxy_location: ProxyLocationInput = None
+ # A read-only state rebuilds its context from a copy of the saved profile, never the stored one.
+ self.profile_read_only = False
self._ever_connected = browser_context is not None
self._close_requested = False
self._runtime_events_deferred = defer_runtime_events
@@ -549,6 +567,7 @@ class RealBrowserState(BrowserState):
browser_address=browser_address,
browser_address_is_server_assigned=bool(context and context.browser_address_is_server_assigned),
browser_profile_id=browser_profile_id,
+ profile_read_only=self.profile_read_only,
browser_session_id=browser_session_id,
engine_selection=self.engine_selection,
download_binding=effective_download_binding,
@@ -563,6 +582,9 @@ class RealBrowserState(BrowserState):
self.browser_context = browser_context
self.browser_context_route_policy_url = effective_route_policy_url
self.browser_artifacts = browser_artifacts
+ if self.profile_read_only:
+ # A replaced context may still leave its profile copy behind; delete it with this one.
+ browser_cleanup = _chain_browser_cleanups(self.browser_cleanup, browser_cleanup)
self.browser_cleanup = browser_cleanup
self._browser_state_diagnostic = None
self._ever_connected = True
diff --git a/tests/unit/forge/sdk/artifact/storage/test_local_storage.py b/tests/unit/forge/sdk/artifact/storage/test_local_storage.py
index b2d9c274c..2c8b305ca 100644
--- a/tests/unit/forge/sdk/artifact/storage/test_local_storage.py
+++ b/tests/unit/forge/sdk/artifact/storage/test_local_storage.py
@@ -125,6 +125,25 @@ async def test_delete_browser_profile_hard_delete_raises_on_failure(
await local_storage.delete_browser_profile(TEST_ORGANIZATION_ID, "bp_1", hard_delete=False)
[email protected](("read_only", "stored_after"), [(False, "session=rotated"), (True, "session=original")])
+async def test_only_a_read_only_browser_leaves_the_stored_profile_unchanged(
+ local_storage: LocalStorage, tmp_path: Path, monkeypatch: pytest.MonkeyPatch, read_only: bool, stored_after: str
+) -> None:
+ monkeypatch.setattr(settings, "BROWSER_SESSION_BASE_PATH", str(tmp_path / "sessions"))
+ monkeypatch.setattr(settings, "TEMP_PATH", str(tmp_path / "temp"))
+ stored = tmp_path / "sessions" / TEST_ORGANIZATION_ID / "profiles" / "bp_1"
+ (stored / "Default").mkdir(parents=True)
+ (stored / "Default" / "Cookies").write_text("session=original")
+ retrieve = local_storage.retrieve_browser_profile_copy if read_only else local_storage.retrieve_browser_profile
+
+ browser_dir = await retrieve(TEST_ORGANIZATION_ID, "bp_1")
+ assert browser_dir is not None
+ (Path(browser_dir) / "Default" / "Cookies").write_text("session=rotated")
+
+ assert (stored / "Default" / "Cookies").read_text() == stored_after
+
+
@pytest.mark.asyncio
async def test_delete_legacy_file_deletes_managed_artifact(tmp_path: Path) -> None:
storage = LocalStorage(artifact_path=str(tmp_path))
diff --git a/tests/unit/forge/sdk/test_create_browser_profile_from_session_route.py b/tests/unit/forge/sdk/test_create_browser_profile_from_session_route.py
index 098dd33eb..fa0f8bcfa 100644
--- a/tests/unit/forge/sdk/test_create_browser_profile_from_session_route.py
+++ b/tests/unit/forge/sdk/test_create_browser_profile_from_session_route.py
@@ -516,6 +516,43 @@ async def test_create_profile_from_workflow_run_still_stores_workflow_archive(
)
[email protected]("store_fails", [False, True])
+async def test_create_profile_from_workflow_run_discards_the_retrieved_copy_only(
+ monkeypatch: pytest.MonkeyPatch, tmp_path: Path, store_fails: bool
+) -> None:
+ temp_root = tmp_path / "temp"
+ retrieved_copy = temp_root / "skyvern_browser_profile_x"
+ retrieved_copy.mkdir(parents=True)
+ (retrieved_copy / "Cookies").write_text("session_token=abc")
+ stored_dir = tmp_path / "browser_sessions" / "org_oss" / "wp_1"
+ stored_dir.mkdir(parents=True)
+ monkeypatch.setattr(browser_profiles_route.settings, "TEMP_PATH", str(temp_root))
+ _client, mocks = _build_client(monkeypatch)
+ mocks.get_workflow.return_value = SimpleNamespace(workflow_permanent_id="wp_1", persist_browser_session=True)
+ if store_fails:
+ mocks.store_profile.side_effect = RuntimeError("upload failed")
+
+ for source_dir in (retrieved_copy, stored_dir):
+ mocks.get_workflow_run.return_value = _workflow_run(
+ browser_profile_id="bp_managed" if source_dir == retrieved_copy else None
+ )
+ mocks.retrieve_profile.return_value = str(retrieved_copy)
+ mocks.retrieve_session.return_value = str(stored_dir)
+ if store_fails:
+ with pytest.raises(RuntimeError):
+ await browser_profiles_route._create_profile_from_workflow_run(
+ organization_id="org_oss", name="my profile", description=None, workflow_run_id="wr_1"
+ )
+ else:
+ await browser_profiles_route._create_profile_from_workflow_run(
+ organization_id="org_oss", name="my profile", description=None, workflow_run_id="wr_1"
+ )
+
+ assert not retrieved_copy.exists()
+ assert stored_dir.exists()
+
+
@pytest.mark.asyncio
async def test_create_profile_from_workflow_run_reads_managed_profile_blob(
monkeypatch: pytest.MonkeyPatch,
diff --git a/tests/unit/test_browser_context_factory_marker.py b/tests/unit/test_browser_context_factory_marker.py
index 1ea1dc758..34324f28e 100644
--- a/tests/unit/test_browser_context_factory_marker.py
+++ b/tests/unit/test_browser_context_factory_marker.py
@@ -10,6 +10,7 @@ auto-stamp.
from __future__ import annotations
import asyncio
+from pathlib import Path
from types import SimpleNamespace
from typing import Any
from unittest.mock import AsyncMock, MagicMock
@@ -17,6 +18,8 @@ from unittest.mock import AsyncMock, MagicMock
import pytest
from playwright.async_api import BrowserContext, Locator, Page
+from skyvern.config import settings
+from skyvern.forge.sdk.artifact.storage.local import LocalStorage
from skyvern.forge.sdk.workflow.models.code_block_recorder import RecordingPage
from skyvern.webeye import browser_factory as factory_module
from skyvern.webeye import display_recorder as dr
@@ -300,6 +303,48 @@ async def test_headless_chromium_stamps_applied_browser_profile_id(
assert artifacts_no_profile.applied_browser_profile_id is None
[email protected]("read_only", [False, True])
+async def test_headless_chromium_runs_only_a_read_only_profile_on_a_copy(
+ monkeypatch: pytest.MonkeyPatch, tmp_path: Path, read_only: bool
+) -> None:
+ from skyvern.forge import app
+
+ monkeypatch.setattr(settings, "BROWSER_SESSION_BASE_PATH", str(tmp_path / "sessions"))
+ monkeypatch.setattr(settings, "TEMP_PATH", str(tmp_path / "temp"))
+ stored = tmp_path / "sessions" / "o_test" / "profiles" / "bp_test"
+ (stored / "Default").mkdir(parents=True)
+ (stored / "Default" / "Cookies").write_text("session=saved")
+ storage = LocalStorage()
+ monkeypatch.setattr(app.STORAGE, "retrieve_browser_profile", storage.retrieve_browser_profile)
+ monkeypatch.setattr(app.STORAGE, "retrieve_browser_profile_copy", storage.retrieve_browser_profile_copy)
+ monkeypatch.setattr(BrowserContextFactory, "update_chromium_browser_preferences", MagicMock())
+ monkeypatch.setattr(
+ BrowserContextFactory,
+ "build_browser_args",
+ MagicMock(return_value={"record_har_path": str(tmp_path / "h.har")}),
+ )
+ monkeypatch.setattr(factory_module, "initialize_download_dir", lambda: str(tmp_path / "downloads"))
+ playwright = MagicMock()
+ playwright.chromium.launch_persistent_context = AsyncMock(return_value=MagicMock())
+
+ _, artifacts, cleanup = await factory_module._create_headless_chromium(
+ playwright,
+ browser_profile_id="bp_test",
+ organization_id="o_test",
+ profile_read_only=read_only,
+ )
+
+ assert artifacts.applied_browser_profile_id == "bp_test"
+ browser_dir = Path(str(artifacts.browser_session_dir))
+ assert (browser_dir.resolve() == stored.resolve()) is not read_only
+ assert (browser_dir / "Default" / "Cookies").read_text() == "session=saved"
+ if cleanup is not None:
+ await cleanup()
+ assert browser_dir.exists() is not read_only
+ assert (stored / "Default" / "Cookies").read_text() == "session=saved"
+
+
@pytest.mark.asyncio
async def test_bootstrap_error_propagates_unwrapped_but_other_errors_are_wrapped(
monkeypatch: pytest.MonkeyPatch,
diff --git a/tests/unit/test_copilot_request_policy_workflow_credentials.py b/tests/unit/test_copilot_request_policy_workflow_credentials.py
index 12721c14f..b5e49f9f1 100644
--- a/tests/unit/test_copilot_request_policy_workflow_credentials.py
+++ b/tests/unit/test_copilot_request_policy_workflow_credentials.py
@@ -1398,3 +1398,23 @@ def test_a_page_admitting_a_second_credential_proposes_the_new_one() -> None:
proposed = StructuredContext.from_json_str(recorded).proposed_credential
assert proposed is not None
assert proposed.credential_id == freshly_admitted.credential_id
+
+
+async def test_the_settled_profile_pick_comes_from_the_saved_row_not_the_submitted_draft() -> None:
+ def workflow_yaml(browser_profile_id: str) -> str:
+ return (
+ f"title: t\nbrowser_profile_id: {browser_profile_id}\n"
+ "workflow_definition:\n parameters: []\n blocks: []\n"
+ )
+
+ policy = await _build_request_policy_bootstrap(
+ user_message="test the first block",
+ workflow_yaml=workflow_yaml("bp_draft"),
+ chat_history=[],
+ global_llm_context="",
+ organization_id="org-1",
+ persisted_workflow_yaml=workflow_yaml("bp_saved"),
+ )
+
+ assert policy.persisted_workflow_browser_profile_id == "bp_saved"
diff --git a/tests/unit/test_copilot_runtime.py b/tests/unit/test_copilot_runtime.py
index 57b479b9b..1f0e06e4f 100644
--- a/tests/unit/test_copilot_runtime.py
+++ b/tests/unit/test_copilot_runtime.py
@@ -16,7 +16,7 @@ from contextlib import asynccontextmanager
from datetime import UTC, datetime
from pathlib import Path
from types import SimpleNamespace
-from typing import Any
+from typing import Any, get_args
from unittest.mock import AsyncMock, MagicMock
import pytest
@@ -31,7 +31,12 @@ from skyvern.cli.mcp_tools import tabs as mcp_tabs
from skyvern.config import settings
from skyvern.forge.sdk.cache.local import LocalCache
from skyvern.forge.sdk.copilot import mcp_adapter, runtime
-from skyvern.forge.sdk.copilot.build_test_connect_failure import SUPERSEDED_BY_NEWER_TEST_REASON
+from skyvern.forge.sdk.copilot.build_test_connect_failure import (
+ SUPERSEDED_BY_NEWER_TEST_REASON,
+ BuildTestConnectFailure,
+ BuildTestConnectFailureState,
+)
+from skyvern.forge.sdk.copilot.build_test_outcome import connect_failure_from_run_blocks_result
from skyvern.forge.sdk.copilot.config import CopilotConfig
from skyvern.forge.sdk.copilot.mcp_adapter import SchemaOverlay
from skyvern.forge.sdk.copilot.request_policy import RequestPolicy
@@ -40,16 +45,19 @@ from skyvern.forge.sdk.copilot.runtime import (
RAW_SECRET_BROWSER_ERROR,
AgentContext,
BrowserSessionReplacement,
+ BuildTestBrowserSeed,
ensure_browser_session,
+ ensure_build_test_browser_session,
mcp_browser_context,
mcp_to_copilot,
replace_browser_session,
)
from skyvern.forge.sdk.copilot.tools import mcp_hooks, run_execution
from skyvern.forge.sdk.copilot.unrecoverable_tool_error import _is_unrecoverable_browser_session_error
-from skyvern.forge.sdk.schemas.persistent_browser_sessions import PersistentBrowserSession
+from skyvern.forge.sdk.schemas.persistent_browser_sessions import PersistentBrowserSession, export_profile_storage_id
from skyvern.forge.sdk.workflow.models.workflow import WorkflowRunStatus
from skyvern.schemas.browser_session_close import BrowserSessionCloseReason
+from skyvern.schemas.proxy_location import ProxyLocation
from skyvern.webeye.browser_errors import (
BrowserCdpConnectionError,
BrowserRetryableCdpError,
@@ -383,6 +391,7 @@ async def test_ensure_browser_session_waits_for_browser_context(monkeypatch: pyt
assert ctx.browser_session_id == "bs_1"
assert mock_manager.get_browser_state.await_count == 3
assert ctx.attached_browser_drivers == {"bs_1": runtime.AttachedBrowserDriver("bs_1", ready_state)}
+ assert mock_manager.create_session.call_args.kwargs.keys() == {"organization_id", "timeout_minutes", "created_by"}
@pytest.mark.asyncio
@@ -905,6 +914,73 @@ async def test_create_closes_its_session_when_a_sibling_installed_one_first(
assert mock_manager.close_session.await_args.args[1] == "bs_loser"
+ ("proxy_session_id", "proxy_kwargs"),
+ [
+ (None, {"inherit_profile_proxy": True}),
+ ("ps_pinned", {"proxy_session_id": "ps_pinned", "proxy_location": ProxyLocation.RESIDENTIAL_ISP}),
+ ],
+)
+async def test_a_seeded_build_test_mint_loads_the_profile_without_exporting_over_it(
+ monkeypatch: pytest.MonkeyPatch, proxy_session_id: str | None, proxy_kwargs: dict[str, object]
+) -> None:
+ ready = MagicMock()
+ ready.browser_context = _FakeBrowserContext()
+ mock_manager = MagicMock()
+ mock_manager.create_session = AsyncMock(return_value=SimpleNamespace(persistent_browser_session_id="bs_seeded"))
+ mock_manager.get_browser_state = AsyncMock(return_value=ready)
+ mock_app = MagicMock()
+ mock_app.PERSISTENT_SESSIONS_MANAGER = mock_manager
+ monkeypatch.setattr(runtime, "app", mock_app)
+ ctx = _make_ctx()
+
+ result = await ensure_build_test_browser_session(
+ ctx, seed=BuildTestBrowserSeed(browser_profile_id="bp_saved", proxy_session_id=proxy_session_id)
+ )
+
+ assert result is None
+ assert ctx.browser_session_id == "bs_seeded"
+ create = mock_manager.create_session.call_args.kwargs
+ assert create == {
+ "organization_id": ctx.organization_id,
+ "timeout_minutes": 30,
+ "created_by": "copilot",
+ "browser_profile_id": "bp_saved",
+ "profile_read_only": True,
+ "generate_browser_profile": True,
+ **proxy_kwargs,
+ }
+ session_row = PersistentBrowserSession(
+ persistent_browser_session_id="bs_seeded",
+ organization_id=ctx.organization_id,
+ created_at=datetime.now(UTC),
+ modified_at=datetime.now(UTC),
+ browser_profile_id=create["browser_profile_id"],
+ profile_read_only=create["profile_read_only"],
+ )
+ assert not session_row.should_export_profile()
+ fallback_export_target = export_profile_storage_id(
+ session_id="bs_seeded",
+ browser_profile_id=create["browser_profile_id"],
+ generate_browser_profile=create["generate_browser_profile"],
+ )
+ assert fallback_export_target == "bs_seeded"
+
+
+def test_every_connect_failure_without_a_retry_reads_back_as_recorded() -> None:
+ no_retry_states = []
+ for state in get_args(BuildTestConnectFailureState):
+ try:
+ failure = BuildTestConnectFailure(state=state, retry_action=None)
+ except ValueError:
+ continue
+ no_retry_states.append(state)
+ assert connect_failure_from_run_blocks_result(runtime._build_test_connect_failure_result(failure)) == failure
+
+ assert {"saved_profile_unresolved", "saved_profile_not_applied"} <= set(no_retry_states)
+
+
@pytest.mark.asyncio
async def test_self_heal_browser_state_adoption_does_not_enter_persistent_resolve_ceiling(
monkeypatch: pytest.MonkeyPatch,
diff --git a/tests/unit/test_default_persistent_sessions_manager_close.py b/tests/unit/test_default_persistent_sessions_manager_close.py
index ca6d146bd..e91131b26 100644
--- a/tests/unit/test_default_persistent_sessions_manager_close.py
+++ b/tests/unit/test_default_persistent_sessions_manager_close.py
@@ -29,6 +29,7 @@ class _LaunchBrowserSessionsRepository:
proxy_location=None,
proxy_session_id=None,
browser_profile_id=None,
+ profile_read_only=False,
browser_address=None,
upstream_cdp_url=None,
started_at=None,
@@ -491,6 +492,36 @@ async def test_launch_standalone_browser_continues_when_cdp_probe_fails() -> Non
}
[email protected](("applied_browser_profile_id", "loaded"), [("bp_saved", True), (None, False)])
+async def test_launch_records_whether_the_requested_profile_loaded_before_the_session_is_usable(
+ applied_browser_profile_id: str | None, loaded: bool
+) -> None:
+ manager, repository = _launch_manager()
+ repository.session.browser_profile_id = "bp_saved"
+ browser_state = MagicMock()
+ browser_state.browser_artifacts = BrowserArtifacts(applied_browser_profile_id=applied_browser_profile_id)
+ browser_state.get_or_create_page = AsyncMock(return_value=MagicMock())
+ browser_state.close = AsyncMock()
+ browser_manager = MagicMock()
+ browser_manager._create_browser_state = AsyncMock(return_value=browser_state)
+ agent_function = MagicMock()
+ agent_function.build_proxy_session_extra_http_headers.return_value = {}
+
+ with (
+ patch.object(
+ manager_mod, "app", SimpleNamespace(BROWSER_MANAGER=browser_manager, AGENT_FUNCTION=agent_function)
+ ),
+ patch.object(manager_mod.settings, "BROWSER_TYPE", "chromium-headful"),
+ patch.object(manager_mod, "_allocate_cdp_port", return_value=9244),
+ patch.object(manager_mod, "_probe_local_cdp_address", AsyncMock(return_value=None)),
+ ):
+ await manager._launch_browser_for_session("pbs_local", "org_local")
+
+ assert repository.updates[0] == {"browser_profile_loaded": loaded}
+ assert repository.session.status == "running"
+
+
@pytest.mark.asyncio
async def test_probe_local_cdp_address_stops_after_connection_refusal() -> None:
open_connection = AsyncMock(side_effect=ConnectionRefusedError)
diff --git a/tests/unit/test_real_browser_manager.py b/tests/unit/test_real_browser_manager.py
index b6266376f..c14964da7 100644
--- a/tests/unit/test_real_browser_manager.py
+++ b/tests/unit/test_real_browser_manager.py
@@ -2643,6 +2643,30 @@ async def test_repair_forwards_pinned_engine_selection() -> None:
assert create_browser_context.await_args.kwargs["engine_selection"] is selection
+async def test_a_read_only_state_rebuilds_from_a_profile_copy_and_still_deletes_the_old_copy() -> None:
+ old_copy_cleanup = AsyncMock()
+ new_copy_cleanup = AsyncMock()
+ state = RealBrowserState(pw=MagicMock(), browser_context=None, browser_cleanup=old_copy_cleanup)
+ state.profile_read_only = True
+ context = MagicMock()
+ context.pages = []
+
+ with (
+ patch(
+ "skyvern.webeye.real_browser_state.BrowserContextFactory.create_browser_context",
+ AsyncMock(return_value=(context, BrowserArtifacts(), new_copy_cleanup)),
+ ) as create_browser_context,
+ patch.object(state, "get_working_page", AsyncMock(return_value=MagicMock())),
+ ):
+ await state.check_and_fix_state(browser_profile_id="bp_saved")
+
+ assert create_browser_context.await_args.kwargs["profile_read_only"] is True
+ await state._run_browser_cleanup_bounded()
+ old_copy_cleanup.assert_awaited_once()
+ new_copy_cleanup.assert_awaited_once()
+
+
class _EngE(Exception):
pass
diff --git a/tests/unit/test_seed_precedence_engine.py b/tests/unit/test_seed_precedence_engine.py
index f585aace1..d1945f80d 100644
--- a/tests/unit/test_seed_precedence_engine.py
+++ b/tests/unit/test_seed_precedence_engine.py
@@ -1539,6 +1539,46 @@ async def test_setup_pin_resolves_pool_credential(monkeypatch: pytest.MonkeyPatc
assert result == ("cred_pool", "ps_pool")
[email protected](("saved_selection", "expected_pin"), [(None, None), ("cred_pool", "ps_pool")])
+async def test_pin_preview_reads_a_pool_selection_but_never_makes_one(
+ monkeypatch: pytest.MonkeyPatch, saved_selection: str | None, expected_pin: str | None
+) -> None:
+ monkeypatch.setattr(app.WORKFLOW_CONTEXT_MANAGER, "workflow_run_contexts", {})
+ monkeypatch.setattr(
+ app.DATABASE.workflow_run_credential_selections, "get_selection", AsyncMock(return_value=saved_selection)
+ )
+ select = AsyncMock(return_value="cred_a")
+ monkeypatch.setattr(service_module, "select_credential_for_run", select)
+ monkeypatch.setattr(
+ app.DATABASE.credentials,
+ "get_credential",
+ AsyncMock(
+ return_value=SimpleNamespace(
+ credential_id="cred_pool", pin_saved_session_ip=True, proxy_session_id="ps_pool"
+ )
+ ),
+ )
+ monkeypatch.setattr(app.DATABASE.credentials, "get_credentials_by_browser_profile_id", AsyncMock(return_value=[]))
+ monkeypatch.setattr(app.AGENT_FUNCTION, "has_proxy_session_extra_http_headers", lambda headers: False)
+ workflow = _workflow_with_blocks(
+ _login_block("login", _credential_parameter("login", "cred_primary", credential_ids=["cred_a", "cred_pool"]))
+ )
+ run = SimpleNamespace(
+ workflow_run_id="copilot_build_test_seed_preview", organization_id="o_test", extra_http_headers=None
+ )
+
+ pin = await WorkflowService().preview_run_proxy_pin(
+ workflow=workflow, # type: ignore[arg-type]
+ workflow_run=run, # type: ignore[arg-type]
+ parameter_values={},
+ seed_profile_id=None,
+ )
+
+ assert pin == expected_pin
+ select.assert_not_awaited()
+
+
@pytest.mark.asyncio
async def test_setup_credential_prefers_request_value_over_default_for_workflow_parameter(
monkeypatch: pytest.MonkeyPatch,