Skip to content

Automate browser based workflows with AI

feat(SKY-11051): back Save & Reuse Session with auto-managed browser profiles (#7032)

Suchintan03e23fe9ba0b
diff --git a/alembic/versions/2026_07_02_2317-ecf365563e98_managed_browser_profiles_for_save_and_reuse_session.py b/alembic/versions/2026_07_02_2317-ecf365563e98_managed_browser_profiles_for_save_and_reuse_session.py
new file mode 100644
index 000000000..de4304f7d
--- /dev/null
+++ b/alembic/versions/2026_07_02_2317-ecf365563e98_managed_browser_profiles_for_save_and_reuse_session.py
@@ -0,0 +1,67 @@
+"""managed browser profiles for save and reuse session
+
+Revision ID: ecf365563e98
+Revises: a1cad008154a
+Create Date: 2026-07-02T23:17:33.611632+00:00
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "ecf365563e98"
+down_revision: Union[str, None] = "a1cad008154a"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+ op.add_column(
+ "browser_profiles",
+ sa.Column("is_managed", sa.Boolean(), server_default=sa.text("false"), nullable=False),
+ )
+ op.add_column("browser_profiles", sa.Column("workflow_permanent_id", sa.String(), nullable=True))
+ op.add_column("browser_profiles", sa.Column("browser_profile_key_digest", sa.String(), nullable=True))
+ op.create_index(
+ "uq_browser_profiles_org_name_user",
+ "browser_profiles",
+ ["organization_id", "name"],
+ unique=True,
+ postgresql_where=sa.text("is_managed = false"),
+ sqlite_where=sa.text("is_managed = false"),
+ )
+ op.create_index(
+ "uq_browser_profiles_managed_segment",
+ "browser_profiles",
+ ["organization_id", "workflow_permanent_id", "browser_profile_key_digest"],
+ unique=True,
+ # Exclude soft-deleted rows so deleting a managed profile doesn't tombstone the
+ # segment — the next run re-creates it instead of colliding on the unique key.
+ postgresql_where=sa.text("is_managed = true AND deleted_at IS NULL"),
+ sqlite_where=sa.text("is_managed = true AND deleted_at IS NULL"),
+ )
+ op.create_index("idx_browser_profiles_wpid", "browser_profiles", ["workflow_permanent_id"], unique=False)
+ op.drop_constraint("uc_org_browser_profile_name", "browser_profiles", type_="unique")
+
+
+def downgrade() -> None:
+ op.execute("DELETE FROM browser_profiles WHERE is_managed = true")
+ op.create_unique_constraint("uc_org_browser_profile_name", "browser_profiles", ["organization_id", "name"])
+ op.drop_index("idx_browser_profiles_wpid", table_name="browser_profiles")
+ op.drop_index(
+ "uq_browser_profiles_managed_segment",
+ table_name="browser_profiles",
+ postgresql_where=sa.text("is_managed = true AND deleted_at IS NULL"),
+ )
+ op.drop_index(
+ "uq_browser_profiles_org_name_user",
+ table_name="browser_profiles",
+ postgresql_where=sa.text("is_managed = false"),
+ )
+ op.drop_column("browser_profiles", "browser_profile_key_digest")
+ op.drop_column("browser_profiles", "workflow_permanent_id")
+ op.drop_column("browser_profiles", "is_managed")
diff --git a/skyvern-frontend/src/api/types.ts b/skyvern-frontend/src/api/types.ts
index 49755e853..bf6da1067 100644
--- a/skyvern-frontend/src/api/types.ts
+++ b/skyvern-frontend/src/api/types.ts
@@ -842,6 +842,8 @@ export type BrowserProfileApiResponse = {
source_browser_type: string | null;
proxy_location?: ProxyLocation | null;
proxy_session_id?: string | null;
+ is_managed?: boolean;
+ workflow_permanent_id?: string | null;
created_at: string;
modified_at: string;
deleted_at: string | null;
diff --git a/skyvern-frontend/src/routes/browserProfiles/BrowserProfileItem.tsx b/skyvern-frontend/src/routes/browserProfiles/BrowserProfileItem.tsx
index 4cb7306b7..05d7b1948 100644
--- a/skyvern-frontend/src/routes/browserProfiles/BrowserProfileItem.tsx
+++ b/skyvern-frontend/src/routes/browserProfiles/BrowserProfileItem.tsx
@@ -3,7 +3,9 @@ import { Pencil1Icon } from "@radix-ui/react-icons";
import { useNavigate } from "react-router-dom";
import { BrowserProfileApiResponse } from "@/api/types";
+import { CopyButton } from "@/components/CopyButton";
import { SelectionCheckboxCell } from "@/components/SelectionCheckbox";
+import { Badge } from "@/components/ui/badge";
import { Button } from "@/components/ui/button";
import { TableCell, TableRow } from "@/components/ui/table";
import {
@@ -67,7 +69,37 @@ function BrowserProfileItem({
/>
)}
<TableCell className="truncate">
- <span title={profile.name}>{profile.name}</span>
+ <div className="flex min-w-0 flex-col gap-0.5">
+ <div className="flex min-w-0 items-center gap-2">
+ <span className="truncate" title={profile.name}>
+ {profile.name}
+ </span>
+ {profile.is_managed ? (
+ <Badge
+ variant="secondary"
+ className="shrink-0"
+ title="Auto-saved from a Save & Reuse Session workflow. Recreated automatically on the next run."
+ >
+ Auto-managed
+ </Badge>
+ ) : null}
+ </div>
+ <div
+ className="flex min-w-0 items-center gap-1 text-xs text-muted-foreground"
+ onClick={stopRowClick}
+ >
+ <span
+ className="truncate font-mono"
+ title={profile.browser_profile_id}
+ >
+ {profile.browser_profile_id}
+ </span>
+ <CopyButton
+ value={profile.browser_profile_id}
+ className="size-5 shrink-0"
+ />
+ </div>
+ </div>
</TableCell>
<TableCell className="truncate text-muted-foreground">
{profile.description ? (
diff --git a/skyvern-frontend/src/routes/browserProfiles/BrowserProfilesList.tsx b/skyvern-frontend/src/routes/browserProfiles/BrowserProfilesList.tsx
index 392fb4089..c4a358a52 100644
--- a/skyvern-frontend/src/routes/browserProfiles/BrowserProfilesList.tsx
+++ b/skyvern-frontend/src/routes/browserProfiles/BrowserProfilesList.tsx
@@ -49,9 +49,10 @@ import { BrowserProfileItem } from "./BrowserProfileItem";
type Props = {
searchKey?: string;
+ managed?: boolean;
};
-function BrowserProfilesList({ searchKey }: Props = {}) {
+function BrowserProfilesList({ searchKey, managed }: Props = {}) {
const [searchParams, setSearchParams] = useSearchParams();
const page = searchParams.get("page") ? Number(searchParams.get("page")) : 1;
const itemsPerPage = searchParams.get("page_size")
@@ -84,12 +85,14 @@ function BrowserProfilesList({ searchKey }: Props = {}) {
page,
page_size: itemsPerPage,
searchKey,
+ managed,
});
const { data: nextPageProfiles } = useBrowserProfilesQuery({
page: page + 1,
page_size: itemsPerPage,
searchKey,
+ managed,
enabled: (profiles?.length ?? 0) === itemsPerPage,
});
@@ -124,7 +127,7 @@ function BrowserProfilesList({ searchKey }: Props = {}) {
} = useRowSelection({
items: pageItems,
getId: (profile) => profile.browser_profile_id,
- resetKey: JSON.stringify([page, itemsPerPage, searchKey ?? ""]),
+ resetKey: JSON.stringify([page, itemsPerPage, searchKey ?? "", managed]),
});
async function handleBulkDeleteConfirm() {
@@ -211,6 +214,19 @@ function BrowserProfilesList({ searchKey }: Props = {}) {
<div className="rounded-md border border-slate-700 bg-slate-elevation1 p-10 text-sm text-neutral-600 dark:text-slate-300">
{hasSearch ? (
<>No browser profiles match &ldquo;{searchKey}&rdquo;.</>
+ ) : managed === true ? (
+ <div className="flex flex-col items-center gap-3 text-center">
+ <BrowserIcon className="size-10 text-neutral-600 dark:text-slate-400" />
+ <div className="space-y-1">
+ <p className="text-base font-medium text-slate-100">
+ No auto-managed profiles yet
+ </p>
+ <p className="mx-auto max-w-md text-sm text-neutral-600 dark:text-slate-400">
+ Run a workflow with Save &amp; Reuse Session enabled and Skyvern
+ creates one automatically.
+ </p>
+ </div>
+ </div>
) : (
<div className="flex flex-col items-center gap-3 text-center">
<BrowserIcon className="size-10 text-neutral-600 dark:text-slate-400" />
diff --git a/skyvern-frontend/src/routes/browserProfiles/BrowserProfilesPage.tsx b/skyvern-frontend/src/routes/browserProfiles/BrowserProfilesPage.tsx
index 545e9fb3e..9b5db5747 100644
--- a/skyvern-frontend/src/routes/browserProfiles/BrowserProfilesPage.tsx
+++ b/skyvern-frontend/src/routes/browserProfiles/BrowserProfilesPage.tsx
@@ -16,6 +16,16 @@ function BrowserProfilesPage() {
const [searchParams, setSearchParams] = useSearchParams();
const [search, setSearch] = useState("");
const [debouncedSearch] = useDebounce(search, 250);
+ const [profileType, setProfileType] = useState<"all" | "user" | "managed">(
+ "all",
+ );
+ const managed = profileType === "all" ? undefined : profileType === "managed";
+
+ function resetToFirstPage() {
+ const params = new URLSearchParams(searchParams);
+ params.set("page", "1");
+ setSearchParams(params, { replace: true });
+ }
// Mounted for its side effects: rehydrates an in-progress create from
// sessionStorage so the toast still fires if the user navigates here from
@@ -34,20 +44,33 @@ function BrowserProfilesPage() {
</p>
</div>
<div className="flex items-center justify-between gap-4">
- <TableSearchInput
- value={search}
- onChange={(value) => {
- setSearch(value);
- const params = new URLSearchParams(searchParams);
- params.set("page", "1");
- setSearchParams(params, { replace: true });
- }}
- placeholder="Search browser profiles..."
- className="w-48 lg:w-72"
- />
+ <div className="flex items-center gap-2">
+ <TableSearchInput
+ value={search}
+ onChange={(value) => {
+ setSearch(value);
+ resetToFirstPage();
+ }}
+ placeholder="Search browser profiles..."
+ className="w-48 lg:w-72"
+ />
+ <select
+ aria-label="Filter browser profiles by type"
+ className="h-9 rounded-md border border-input bg-background px-2 text-sm"
+ value={profileType}
+ onChange={(e) => {
+ setProfileType(e.target.value as "all" | "user" | "managed");
+ resetToFirstPage();
+ }}
+ >
+ <option value="all">All</option>
+ <option value="user">User profiles</option>
+ <option value="managed">Auto-managed</option>
+ </select>
+ </div>
<CreateBrowserProfileButton />
</div>
- <BrowserProfilesList searchKey={debouncedSearch} />
+ <BrowserProfilesList searchKey={debouncedSearch} managed={managed} />
</div>
);
}
diff --git a/skyvern-frontend/src/routes/workflows/components/BrowserProfileSelector.tsx b/skyvern-frontend/src/routes/workflows/components/BrowserProfileSelector.tsx
index 77bbc3183..79efbdc79 100644
--- a/skyvern-frontend/src/routes/workflows/components/BrowserProfileSelector.tsx
+++ b/skyvern-frontend/src/routes/workflows/components/BrowserProfileSelector.tsx
@@ -57,6 +57,7 @@ function BrowserProfileSelector({
page_size: PAGE_SIZE,
searchKey: debouncedSearch,
enabled: open,
+ managed: false,
});
const profiles = useMemo(
diff --git a/skyvern-frontend/src/routes/workflows/hooks/useBrowserProfilesQuery.ts b/skyvern-frontend/src/routes/workflows/hooks/useBrowserProfilesQuery.ts
index 7159fbe21..8e8bf436d 100644
--- a/skyvern-frontend/src/routes/workflows/hooks/useBrowserProfilesQuery.ts
+++ b/skyvern-frontend/src/routes/workflows/hooks/useBrowserProfilesQuery.ts
@@ -14,6 +14,7 @@ type Props = UseQueryOptions & {
page?: number;
page_size?: number;
searchKey?: string;
+ managed?: boolean;
};
function useBrowserProfilesQuery(props: Props = {}) {
@@ -22,12 +23,20 @@ function useBrowserProfilesQuery(props: Props = {}) {
page,
page_size,
searchKey,
+ managed,
...queryOptions
} = props;
const credentialGetter = useCredentialGetter();
return useQuery<QueryReturnType>({
- queryKey: ["browserProfiles", includeDeleted, page, page_size, searchKey],
+ queryKey: [
+ "browserProfiles",
+ includeDeleted,
+ page,
+ page_size,
+ searchKey,
+ managed,
+ ],
queryFn: async () => {
const client = await getClient(credentialGetter, "sans-api-v1");
const params = new URLSearchParams();
@@ -43,6 +52,9 @@ function useBrowserProfilesQuery(props: Props = {}) {
if (searchKey) {
params.set("search_key", searchKey);
}
+ if (managed !== undefined) {
+ params.set("managed", String(managed));
+ }
return client
.get("/browser_profiles", { params })
.then((res) => res.data);
diff --git a/skyvern-frontend/src/routes/workflows/hooks/useInfiniteBrowserProfilesQuery.ts b/skyvern-frontend/src/routes/workflows/hooks/useInfiniteBrowserProfilesQuery.ts
index 471a3c613..1ee7cd665 100644
--- a/skyvern-frontend/src/routes/workflows/hooks/useInfiniteBrowserProfilesQuery.ts
+++ b/skyvern-frontend/src/routes/workflows/hooks/useInfiniteBrowserProfilesQuery.ts
@@ -7,6 +7,7 @@ interface UseInfiniteBrowserProfilesQueryParams {
page_size?: number;
searchKey?: string;
enabled?: boolean;
+ managed?: boolean;
}
// Dedupe by id so concurrent-insert page-boundary repeats don't duplicate rows;
@@ -35,9 +36,10 @@ function useInfiniteBrowserProfilesQuery(
const credentialGetter = useCredentialGetter();
const pageSize = params?.page_size ?? 20;
const searchKey = params?.searchKey ?? "";
+ const managed = params?.managed;
return useInfiniteQuery<Array<BrowserProfileApiResponse>>({
- queryKey: ["browserProfiles-infinite", searchKey, pageSize],
+ queryKey: ["browserProfiles-infinite", searchKey, pageSize, managed],
queryFn: async ({ pageParam = 1 }) => {
const client = await getClient(credentialGetter, "sans-api-v1");
const searchParams = new URLSearchParams();
@@ -46,6 +48,9 @@ function useInfiniteBrowserProfilesQuery(
if (searchKey) {
searchParams.append("search_key", searchKey);
}
+ if (managed !== undefined) {
+ searchParams.append("managed", String(managed));
+ }
return client
.get<Array<BrowserProfileApiResponse>>("/browser_profiles", {
params: searchParams,
diff --git a/skyvern/forge/sdk/db/models.py b/skyvern/forge/sdk/db/models.py
index 96dfa69d3..9988a8a86 100644
--- a/skyvern/forge/sdk/db/models.py
+++ b/skyvern/forge/sdk/db/models.py
@@ -1211,7 +1211,24 @@ class BrowserProfileModel(Base):
__table_args__ = (
Index("idx_browser_profiles_org", "organization_id"),
Index("idx_browser_profiles_org_name", "organization_id", "name"),
- UniqueConstraint("organization_id", "name", name="uc_org_browser_profile_name"),
+ Index(
+ "uq_browser_profiles_org_name_user",
+ "organization_id",
+ "name",
+ unique=True,
+ postgresql_where=text("is_managed = false"),
+ sqlite_where=text("is_managed = false"),
+ ),
+ Index(
+ "uq_browser_profiles_managed_segment",
+ "organization_id",
+ "workflow_permanent_id",
+ "browser_profile_key_digest",
+ unique=True,
+ postgresql_where=text("is_managed = true AND deleted_at IS NULL"),
+ sqlite_where=text("is_managed = true AND deleted_at IS NULL"),
+ ),
+ Index("idx_browser_profiles_wpid", "workflow_permanent_id"),
)
browser_profile_id = Column(String, primary_key=True, default=generate_browser_profile_id)
@@ -1221,6 +1238,9 @@ class BrowserProfileModel(Base):
source_browser_type = Column(String, nullable=True)
proxy_location = Column(String, nullable=True)
proxy_session_id = Column(String, nullable=True)
+ is_managed = Column(Boolean, nullable=False, server_default=sqlalchemy.false(), default=False)
+ workflow_permanent_id = Column(String, nullable=True)
+ browser_profile_key_digest = Column(String, nullable=True)
created_at = Column(DateTime, default=datetime.datetime.utcnow, nullable=False)
modified_at = Column(DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow, nullable=False)
deleted_at = Column(DateTime, nullable=True)
diff --git a/skyvern/forge/sdk/db/repositories/browser_sessions.py b/skyvern/forge/sdk/db/repositories/browser_sessions.py
index 9cbd729d1..a13c77fa2 100644
--- a/skyvern/forge/sdk/db/repositories/browser_sessions.py
+++ b/skyvern/forge/sdk/db/repositories/browser_sessions.py
@@ -5,6 +5,7 @@ from datetime import datetime, timedelta
import structlog
from sqlalchemy import case, desc, or_, select
+from sqlalchemy.exc import IntegrityError
from skyvern.config import settings
from skyvern.exceptions import BrowserProfileNotFound
@@ -67,6 +68,51 @@ class BrowserSessionsRepository(BaseRepository):
await session.refresh(browser_profile)
return BrowserProfile.model_validate(browser_profile)
+ @db_operation("get_or_create_managed_browser_profile")
+ async def get_or_create_managed_browser_profile(
+ self,
+ *,
+ organization_id: str,
+ workflow_permanent_id: str,
+ browser_profile_key_digest: str,
+ name: str,
+ ) -> tuple[BrowserProfile, bool]:
+ digest = browser_profile_key_digest or ""
+ async with self.Session() as session:
+ query = (
+ select(BrowserProfileModel)
+ .filter_by(
+ organization_id=organization_id,
+ workflow_permanent_id=workflow_permanent_id,
+ browser_profile_key_digest=digest,
+ is_managed=True,
+ )
+ .filter(BrowserProfileModel.deleted_at.is_(None))
+ )
+ browser_profile = (await session.scalars(query)).first()
+ if browser_profile:
+ return BrowserProfile.model_validate(browser_profile), False
+
+ browser_profile = BrowserProfileModel(
+ browser_profile_id=generate_browser_profile_id(),
+ organization_id=organization_id,
+ name=name,
+ is_managed=True,
+ workflow_permanent_id=workflow_permanent_id,
+ browser_profile_key_digest=digest,
+ )
+ session.add(browser_profile)
+ try:
+ await session.commit()
+ except IntegrityError:
+ await session.rollback()
+ browser_profile = (await session.scalars(query)).first()
+ if browser_profile:
+ return BrowserProfile.model_validate(browser_profile), False
+ raise
+ await session.refresh(browser_profile)
+ return BrowserProfile.model_validate(browser_profile), True
+
@db_operation("get_browser_profile")
async def get_browser_profile(
self,
@@ -88,6 +134,25 @@ class BrowserSessionsRepository(BaseRepository):
return None
return BrowserProfile.model_validate(browser_profile)
+ @db_operation("list_managed_browser_profiles_for_workflow")
+ async def list_managed_browser_profiles_for_workflow(
+ self,
+ *,
+ organization_id: str,
+ workflow_permanent_id: str,
+ include_deleted: bool = False,
+ ) -> list[BrowserProfile]:
+ async with self.Session() as session:
+ query = select(BrowserProfileModel).filter_by(
+ organization_id=organization_id,
+ workflow_permanent_id=workflow_permanent_id,
+ is_managed=True,
+ )
+ if not include_deleted:
+ query = query.filter(BrowserProfileModel.deleted_at.is_(None))
+ browser_profiles = await session.scalars(query)
+ return [BrowserProfile.model_validate(profile) for profile in browser_profiles.all()]
+
@db_operation("list_browser_profiles")
async def list_browser_profiles(
self,
@@ -96,6 +161,7 @@ class BrowserSessionsRepository(BaseRepository):
page: int = 1,
page_size: int = 10,
search_key: str | None = None,
+ managed: bool | None = None,
) -> list[BrowserProfile]:
if page < 1:
raise ValueError(f"Page must be greater than 0, got {page}")
@@ -104,6 +170,8 @@ class BrowserSessionsRepository(BaseRepository):
query = select(BrowserProfileModel).filter_by(organization_id=organization_id)
if not include_deleted:
query = query.filter(BrowserProfileModel.deleted_at.is_(None))
+ if managed is not None:
+ query = query.filter(BrowserProfileModel.is_managed.is_(managed))
if search_key:
search_like = f"%{search_key}%"
query = query.filter(
diff --git a/skyvern/forge/sdk/routes/agent_protocol.py b/skyvern/forge/sdk/routes/agent_protocol.py
index 265868c04..14fdb39eb 100644
--- a/skyvern/forge/sdk/routes/agent_protocol.py
+++ b/skyvern/forge/sdk/routes/agent_protocol.py
@@ -111,6 +111,7 @@ from skyvern.forge.sdk.schemas.tasks import (
from skyvern.forge.sdk.schemas.workflow_runs import WorkflowRunTimeline
from skyvern.forge.sdk.services import org_auth_service
from skyvern.forge.sdk.settings_manager import SettingsManager
+from skyvern.forge.sdk.workflow.browser_profile_key import build_workflow_browser_session_storage_key_from_digest
from skyvern.forge.sdk.workflow.exceptions import (
FailedToCreateWorkflow,
FailedToUpdateWorkflow,
@@ -4473,10 +4474,38 @@ async def reset_workflow_browser_profile(
workflow_permanent_id=workflow_permanent_id,
)
try:
+ # Include soft-deleted rows: their segment digests still address legacy archives
+ # that would otherwise survive the reset and reseed state on the next run.
+ managed_profiles = await app.DATABASE.browser_sessions.list_managed_browser_profiles_for_workflow(
+ organization_id=current_org.organization_id,
+ workflow_permanent_id=workflow_permanent_id,
+ include_deleted=True,
+ )
await app.STORAGE.delete_browser_session(
organization_id=current_org.organization_id,
workflow_permanent_id=workflow_permanent_id,
)
+ segment_digests = {
+ profile.browser_profile_key_digest for profile in managed_profiles if profile.browser_profile_key_digest
+ }
+ for digest in segment_digests:
+ await app.STORAGE.delete_browser_session(
+ organization_id=current_org.organization_id,
+ workflow_permanent_id=build_workflow_browser_session_storage_key_from_digest(
+ workflow_permanent_id, digest
+ ),
+ )
+ for profile in managed_profiles:
+ if profile.deleted_at is not None:
+ continue
+ await app.STORAGE.delete_browser_profile(
+ organization_id=current_org.organization_id,
+ profile_id=profile.browser_profile_id,
+ )
+ await app.DATABASE.browser_sessions.delete_browser_profile(
+ profile_id=profile.browser_profile_id,
+ organization_id=current_org.organization_id,
+ )
except SkyvernHTTPException:
raise
except Exception as exc:
diff --git a/skyvern/forge/sdk/routes/browser_profiles.py b/skyvern/forge/sdk/routes/browser_profiles.py
index 4dbea6500..e6d3b6936 100644
--- a/skyvern/forge/sdk/routes/browser_profiles.py
+++ b/skyvern/forge/sdk/routes/browser_profiles.py
@@ -37,6 +37,7 @@ from skyvern.forge.sdk.schemas.browser_profiles import (
from skyvern.forge.sdk.schemas.organizations import Organization
from skyvern.forge.sdk.schemas.persistent_browser_sessions import export_profile_storage_id
from skyvern.forge.sdk.services import org_auth_service
+from skyvern.forge.sdk.workflow.browser_session_persistence import retrieve_persisted_workflow_browser_state_dir
from skyvern.schemas.proxy_pinning import apply_proxy_pin_update as _apply_proxy_pin_update
from skyvern.schemas.proxy_pinning import should_generate_proxy_session_id
from skyvern.schemas.runs import ProxyLocation, ProxyLocationInput
@@ -210,6 +211,10 @@ async def list_browser_profiles(
),
examples=["my_profile", "production"],
),
+ managed: bool | None = Query(
+ None,
+ description="Omit to return all profiles; false returns only user-created profiles; true returns only auto-managed profiles.",
+ ),
current_org: Organization = Depends(org_auth_service.get_current_org),
) -> list[BrowserProfile]:
"""List all browser profiles for the current organization."""
@@ -221,6 +226,7 @@ async def list_browser_profiles(
page=page,
page_size=page_size,
search_key=search_key,
+ managed=managed,
)
profiles = await app.DATABASE.browser_sessions.list_browser_profiles(
@@ -229,6 +235,7 @@ async def list_browser_profiles(
page=page,
page_size=page_size,
search_key=search_key,
+ managed=managed,
)
LOG.info(
@@ -828,15 +835,12 @@ async def _create_profile_from_workflow_run(
# Poll for a short grace period so that immediate profile-creation requests
# succeed without forcing clients to implement retry loops.
poll_attempts = 30 # ~30 s max wait
- browser_session_storage_key = await app.WORKFLOW_SERVICE.get_workflow_browser_session_storage_key(
- workflow=workflow,
- workflow_run=workflow_run,
- )
session_dir: str | None = None
for attempt in range(poll_attempts):
- session_dir = await app.STORAGE.retrieve_browser_session(
+ session_dir = await retrieve_persisted_workflow_browser_state_dir(
organization_id=organization_id,
- workflow_permanent_id=browser_session_storage_key,
+ workflow=workflow,
+ workflow_run=workflow_run,
)
if session_dir:
break # session found
diff --git a/skyvern/forge/sdk/routes/credentials.py b/skyvern/forge/sdk/routes/credentials.py
index a9bddcc22..36ab6e0ff 100644
--- a/skyvern/forge/sdk/routes/credentials.py
+++ b/skyvern/forge/sdk/routes/credentials.py
@@ -118,6 +118,7 @@ from skyvern.forge.sdk.services.credentials import (
normalize_totp_config,
parse_totp_config,
)
+from skyvern.forge.sdk.workflow.browser_session_persistence import retrieve_persisted_workflow_browser_state_dir
from skyvern.forge.sdk.workflow.models.parameter import WorkflowParameterType
from skyvern.forge.sdk.workflow.models.workflow import WorkflowRequestBody, WorkflowRunStatus
from skyvern.schemas.credential_folders import (
@@ -1461,16 +1462,13 @@ async def _create_browser_profile_after_workflow(
workflow_permanent_id=workflow_permanent_id,
)
return
- browser_session_storage_key = await app.WORKFLOW_SERVICE.get_workflow_browser_session_storage_key(
- workflow=workflow,
- workflow_run=workflow_run,
- )
session_dir = None
max_retries = _SESSION_PERSIST_MAX_RETRIES
for attempt in range(max_retries):
- session_dir = await app.STORAGE.retrieve_browser_session(
+ session_dir = await retrieve_persisted_workflow_browser_state_dir(
organization_id=organization_id,
- workflow_permanent_id=browser_session_storage_key,
+ workflow=workflow,
+ workflow_run=workflow_run,
)
if session_dir:
break
diff --git a/skyvern/forge/sdk/schemas/browser_profiles.py b/skyvern/forge/sdk/schemas/browser_profiles.py
index cb99d3efd..fd42bcfe9 100644
--- a/skyvern/forge/sdk/schemas/browser_profiles.py
+++ b/skyvern/forge/sdk/schemas/browser_profiles.py
@@ -16,6 +16,9 @@ class BrowserProfile(BaseModel):
source_browser_type: str | None = None
proxy_location: ProxyLocationInput = None
proxy_session_id: str | None = None
+ is_managed: bool = False
+ workflow_permanent_id: str | None = None
+ browser_profile_key_digest: str | None = None
created_at: datetime
modified_at: datetime
deleted_at: datetime | None = None
diff --git a/skyvern/forge/sdk/workflow/browser_profile_key.py b/skyvern/forge/sdk/workflow/browser_profile_key.py
index 9fdde9a44..1f0fa7e7f 100644
--- a/skyvern/forge/sdk/workflow/browser_profile_key.py
+++ b/skyvern/forge/sdk/workflow/browser_profile_key.py
@@ -37,8 +37,21 @@ def build_workflow_browser_session_storage_key(
workflow_permanent_id: str,
rendered_browser_profile_key: str | None,
) -> str:
- rendered = rendered_browser_profile_key.strip() if rendered_browser_profile_key else ""
- if not rendered:
+ digest = build_browser_profile_key_digest(rendered_browser_profile_key)
+ return build_workflow_browser_session_storage_key_from_digest(workflow_permanent_id, digest)
+
+
+def build_workflow_browser_session_storage_key_from_digest(
+ workflow_permanent_id: str,
+ digest: str | None,
+) -> str:
+ if not digest:
return workflow_permanent_id
- digest = sha256(rendered.encode("utf-8")).hexdigest()[:_PROFILE_SEGMENT_DIGEST_LENGTH]
return f"{workflow_permanent_id}/{_PROFILE_SEGMENT_PATH}/{digest}"
+
+
+def build_browser_profile_key_digest(rendered_browser_profile_key: str | None) -> str:
+ rendered = rendered_browser_profile_key.strip() if rendered_browser_profile_key else ""
+ if not rendered:
+ return ""
+ return sha256(rendered.encode("utf-8")).hexdigest()[:_PROFILE_SEGMENT_DIGEST_LENGTH]
diff --git a/skyvern/forge/sdk/workflow/browser_session_persistence.py b/skyvern/forge/sdk/workflow/browser_session_persistence.py
new file mode 100644
index 000000000..2f64179c8
--- /dev/null
+++ b/skyvern/forge/sdk/workflow/browser_session_persistence.py
@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from skyvern.forge import app
+from skyvern.forge.sdk.workflow.models.workflow import Workflow, WorkflowRun
+
+
+async def retrieve_persisted_workflow_browser_state_dir(
+ *,
+ organization_id: str,
+ workflow: Workflow,
+ workflow_run: WorkflowRun,
+) -> str | None:
+ browser_profile_id = workflow_run.browser_profile_id
+ if browser_profile_id:
+ profile = await app.DATABASE.browser_sessions.get_browser_profile(
+ profile_id=browser_profile_id,
+ organization_id=organization_id,
+ )
+ # Only managed profiles owned by this workflow receive the run's end-of-run
+ # write-back; a user (or foreign managed) profile's blob is curated starting
+ # state, so reading it here would return stale data.
+ if profile and profile.is_managed and profile.workflow_permanent_id == workflow_run.workflow_permanent_id:
+ session_dir = await app.STORAGE.retrieve_browser_profile(
+ organization_id=organization_id,
+ profile_id=browser_profile_id,
+ )
+ if session_dir:
+ return session_dir
+
+ browser_session_storage_key = await app.WORKFLOW_SERVICE.get_workflow_browser_session_storage_key(
+ workflow=workflow,
+ workflow_run=workflow_run,
+ )
+ return await app.STORAGE.retrieve_browser_session(
+ organization_id=organization_id,
+ workflow_permanent_id=browser_session_storage_key,
+ )
diff --git a/skyvern/forge/sdk/workflow/service.py b/skyvern/forge/sdk/workflow/service.py
index da5865658..f7b0eb1d4 100644
--- a/skyvern/forge/sdk/workflow/service.py
+++ b/skyvern/forge/sdk/workflow/service.py
@@ -73,6 +73,7 @@ from skyvern.forge.sdk.schemas.tasks import Task, TaskStatus
from skyvern.forge.sdk.schemas.workflow_runs import WorkflowRunBlock, WorkflowRunTimeline, WorkflowRunTimelineType
from skyvern.forge.sdk.trace import traced
from skyvern.forge.sdk.workflow.browser_profile_key import (
+ build_browser_profile_key_digest,
build_workflow_browser_session_storage_key,
render_browser_profile_key,
)
@@ -174,6 +175,8 @@ LOG = structlog.get_logger()
DEFAULT_FIRST_BLOCK_LABEL = "block_1"
DEFAULT_WORKFLOW_TITLE = "New Workflow"
+MANAGED_BROWSER_PROFILE_NAME_MAX_LENGTH = 120
+MANAGED_BROWSER_PROFILE_KEY_MAX_LENGTH = 40
# Empirical S3 upload SLA; no start buffer (back-to-back leakage is worse than late uploads to the next run).
RECORDING_WINDOW_END_BUFFER = timedelta(minutes=15)
@@ -510,6 +513,27 @@ def _resolve_first_block_url(
return None
+def _truncate_managed_browser_profile_part(value: str, max_length: int) -> str:
+ if len(value) <= max_length:
+ return value
+ if max_length <= 3:
+ return value[:max_length]
+ return f"{value[: max_length - 3]}..."
+
+
+def _build_managed_browser_profile_name(workflow_title: str | None, rendered_key: str | None) -> str:
+ title = (workflow_title or DEFAULT_WORKFLOW_TITLE).strip() or DEFAULT_WORKFLOW_TITLE
+ if not rendered_key:
+ suffix = " (auto-saved session)"
+ title = _truncate_managed_browser_profile_part(title, MANAGED_BROWSER_PROFILE_NAME_MAX_LENGTH - len(suffix))
+ return f"{title}{suffix}"
+
+ key = _truncate_managed_browser_profile_part(rendered_key, MANAGED_BROWSER_PROFILE_KEY_MAX_LENGTH)
+ suffix = f" (auto-saved: {key})"
+ title = _truncate_managed_browser_profile_part(title, MANAGED_BROWSER_PROFILE_NAME_MAX_LENGTH - len(suffix))
+ return f"{title}{suffix}"
+
+
class WorkflowService:
# Prevent GC of fire-and-forget asyncio tasks (e.g. task_run sync).
_background_tasks: set[asyncio.Task] = set() # noqa: RUF012
@@ -1266,14 +1290,6 @@ class WorkflowService:
workflow_run_id=workflow_run.workflow_run_id,
)
- browser_profile_key = getattr(workflow, "browser_profile_key", None)
- if getattr(workflow, "persist_browser_session", False) and browser_profile_key:
- await self.get_workflow_browser_session_storage_key(
- workflow=workflow,
- workflow_run=workflow_run,
- parameter_values={param.key: value for param, value in workflow_parameter_values},
- )
-
await self._validate_credential_ids(
[
value
@@ -1283,6 +1299,12 @@ class WorkflowService:
organization,
)
+ workflow_run = await self._prepare_persisted_workflow_browser_profile(
+ workflow=workflow,
+ workflow_run=workflow_run,
+ parameter_values={param.key: value for param, value in workflow_parameter_values},
+ )
+
if workflow_parameter_values:
try:
await self.create_workflow_run_parameters(
@@ -1342,15 +1364,102 @@ class WorkflowService:
return "value cannot be null"
return "database error while saving parameter value"
- async def get_workflow_browser_session_storage_key(
+ async def _prepare_persisted_workflow_browser_profile(
self,
*,
workflow: Workflow,
workflow_run: WorkflowRun,
- parameter_values: dict[str, Any] | None = None,
- ) -> str:
+ parameter_values: dict[str, Any],
+ ) -> WorkflowRun:
+ if not workflow.persist_browser_session:
+ return workflow_run
+
+ if workflow_run.browser_profile_id:
+ return workflow_run
+
+ rendered_key = await self._render_workflow_browser_profile_key(
+ workflow=workflow,
+ workflow_run=workflow_run,
+ parameter_values=parameter_values,
+ )
+ digest = build_browser_profile_key_digest(rendered_key)
+ profile, created = await app.DATABASE.browser_sessions.get_or_create_managed_browser_profile(
+ organization_id=workflow_run.organization_id,
+ workflow_permanent_id=workflow.workflow_permanent_id,
+ browser_profile_key_digest=digest,
+ name=_build_managed_browser_profile_name(workflow.title, rendered_key),
+ )
+ if created:
+ try:
+ await self._seed_managed_browser_profile_from_legacy_session(
+ workflow=workflow,
+ workflow_run=workflow_run,
+ rendered_key=rendered_key,
+ browser_profile_id=profile.browser_profile_id,
+ )
+ except Exception:
+ # Roll back the empty row so the next run re-attempts creation + seed;
+ # this run degrades to the legacy session path instead of failing setup.
+ LOG.warning(
+ "Failed to seed managed browser profile from legacy session; rolling back and using legacy path",
+ workflow_run_id=workflow_run.workflow_run_id,
+ browser_profile_id=profile.browser_profile_id,
+ exc_info=True,
+ )
+ await app.DATABASE.browser_sessions.hard_delete_browser_profile(
+ profile_id=profile.browser_profile_id,
+ organization_id=workflow_run.organization_id,
+ )
+ return workflow_run
+ updated_workflow_run = await app.DATABASE.workflow_runs.update_workflow_run(
+ workflow_run_id=workflow_run.workflow_run_id,
+ browser_profile_id=profile.browser_profile_id,
+ )
+ LOG.info(
+ "Stamped workflow run with managed browser profile",
+ workflow_run_id=workflow_run.workflow_run_id,
+ workflow_permanent_id=workflow.workflow_permanent_id,
+ browser_profile_id=profile.browser_profile_id,
+ browser_profile_key_digest=digest,
+ )
+ return updated_workflow_run
+
+ async def _seed_managed_browser_profile_from_legacy_session(
+ self,
+ *,
+ workflow: Workflow,
+ workflow_run: WorkflowRun,
+ rendered_key: str | None,
+ browser_profile_id: str,
+ ) -> None:
+ # Lazy migration: carry a workflow's accumulated Save & Reuse login state onto its new
+ # managed profile the first time we create it, so the next run starts logged in. The OSS
+ # launch path has no legacy-archive fallback, so this copy must happen here, not at launch.
+ storage_key = build_workflow_browser_session_storage_key(workflow.workflow_permanent_id, rendered_key)
+ legacy_session_dir = await app.STORAGE.retrieve_browser_session(workflow_run.organization_id, storage_key)
+ if not legacy_session_dir:
+ return
+ await app.STORAGE.store_browser_profile(
+ workflow_run.organization_id,
+ profile_id=browser_profile_id,
+ directory=legacy_session_dir,
+ )
+ LOG.info(
+ "Seeded managed browser profile from legacy session archive",
+ workflow_run_id=workflow_run.workflow_run_id,
+ browser_profile_id=browser_profile_id,
+ browser_session_storage_key=storage_key,
+ )
+
+ async def _render_workflow_browser_profile_key(
+ self,
+ *,
+ workflow: Workflow,
+ workflow_run: WorkflowRun,
+ parameter_values: dict[str, Any] | None,
+ ) -> str | None:
if not workflow.browser_profile_key:
- return workflow.workflow_permanent_id
+ return None
if parameter_values is None:
try:
@@ -1377,6 +1486,23 @@ class WorkflowService:
workflow_run_id=workflow_run.workflow_run_id,
)
+ return rendered_key
+
+ async def get_workflow_browser_session_storage_key(
+ self,
+ *,
+ workflow: Workflow,
+ workflow_run: WorkflowRun,
+ parameter_values: dict[str, Any] | None = None,
+ ) -> str:
+ if not workflow.browser_profile_key:
+ return workflow.workflow_permanent_id
+
+ rendered_key = await self._render_workflow_browser_profile_key(
+ workflow=workflow,
+ workflow_run=workflow_run,
+ parameter_values=parameter_values,
+ )
storage_key = build_workflow_browser_session_storage_key(workflow.workflow_permanent_id, rendered_key)
LOG.info(
"Resolved workflow browser session storage key",
@@ -1453,6 +1579,7 @@ class WorkflowService:
workflow: Workflow,
*,
browser_session_id: str | None = None,
+ browser_profile_id: str | None = None,
proxy_location: ProxyLocationInput = None,
) -> PersistentBrowserSession | None:
if browser_session_id: # the user has supplied an id, so no need to create one
@@ -1469,6 +1596,7 @@ class WorkflowService:
browser_session = await app.PERSISTENT_SESSIONS_MANAGER.create_session(
organization_id=organization_id,
timeout_minutes=timeout_seconds // 60,
+ browser_profile_id=browser_profile_id,
proxy_location=proxy_location,
)
@@ -1476,6 +1604,15 @@ class WorkflowService:
return None
+ async def _browser_profile_is_managed(self, *, organization_id: str, browser_profile_id: str | None) -> bool:
+ if not browser_profile_id:
+ return False
+ profile = await app.DATABASE.browser_sessions.get_browser_profile(
+ profile_id=browser_profile_id,
+ organization_id=organization_id,
+ )
+ return bool(profile and profile.is_managed)
+
async def auto_create_browser_session_for_code_block_if_needed(
self,
organization_id: str,
@@ -1862,11 +1999,16 @@ class WorkflowService:
return workflow_run
browser_session = None
- if not browser_profile_id:
+ using_managed_browser_profile = await self._browser_profile_is_managed(
+ organization_id=organization.organization_id,
+ browser_profile_id=browser_profile_id,
+ )
+ if not browser_profile_id or using_managed_browser_profile:
browser_session = await self.auto_create_browser_session_if_needed(
organization.organization_id,
workflow,
browser_session_id=browser_session_id,
+ browser_profile_id=browser_profile_id if using_managed_browser_profile else None,
proxy_location=workflow_run.proxy_location,
)
@@ -6141,41 +6283,74 @@ class WorkflowService:
)
if tasks:
await self.persist_debug_artifacts(browser_state, tasks[-1], workflow, workflow_run)
- # Skip workflow-scoped session save when using browser_profile_id to avoid conflicts
- # (profile persistence is handled separately via the profile storage)
- if (
- workflow.persist_browser_session
- and browser_state.browser_artifacts.browser_session_dir
- and not workflow_run.browser_profile_id
- ):
- if workflow_run.status == WorkflowRunStatus.completed:
- browser_session_storage_key = await self.get_workflow_browser_session_storage_key(
- workflow=workflow,
- workflow_run=workflow_run,
- )
- if not close_browser_on_completion:
- # Browser stays alive here, so close()'s cookie snapshot never ran; capture
- # session cookies now or they're missing from the archived profile on reuse.
- await persist_session_cookies(
- browser_state.browser_context,
- browser_state.browser_artifacts.browser_session_dir,
- )
- await app.STORAGE.store_browser_session(
- workflow_run.organization_id,
- browser_session_storage_key,
- browser_state.browser_artifacts.browser_session_dir,
- )
- LOG.info(
- "Persisted browser session for workflow run",
- workflow_run_id=workflow_run.workflow_run_id,
- browser_session_storage_key=browser_session_storage_key,
- )
- else:
+ if workflow.persist_browser_session and browser_state.browser_artifacts.browser_session_dir:
+ if workflow_run.status != WorkflowRunStatus.completed:
LOG.info(
"Skipped persisting browser session for non-completed workflow run",
workflow_run_id=workflow_run.workflow_run_id,
workflow_run_status=workflow_run.status,
)
+ else:
+ browser_profile = None
+ if workflow_run.browser_profile_id:
+ browser_profile = await app.DATABASE.browser_sessions.get_browser_profile(
+ workflow_run.browser_profile_id,
+ organization_id=workflow_run.organization_id,
+ )
+
+ if (
+ browser_profile
+ and browser_profile.is_managed
+ # Only write back to a managed profile this workflow owns; a foreign
+ # managed id supplied explicitly is treated like a user profile.
+ and browser_profile.workflow_permanent_id == workflow_run.workflow_permanent_id
+ ):
+ if not close_browser_on_completion:
+ await persist_session_cookies(
+ browser_state.browser_context,
+ browser_state.browser_artifacts.browser_session_dir,
+ )
+ await app.STORAGE.store_browser_profile(
+ workflow_run.organization_id,
+ profile_id=browser_profile.browser_profile_id,
+ directory=browser_state.browser_artifacts.browser_session_dir,
+ )
+ LOG.info(
+ "Persisted managed browser profile for workflow run",
+ workflow_run_id=workflow_run.workflow_run_id,
+ browser_profile_id=browser_profile.browser_profile_id,
+ )
+ elif browser_profile is None:
+ # No managed profile to write back to: either none was stamped, or a
+ # stamped managed profile was deleted between setup and finalization.
+ # Persist to the legacy session archive so the run's state isn't lost —
+ # the next run reseeds a managed profile from it. Only the deleted-mid-run
+ # case is unexpected, so warn there.
+ if workflow_run.browser_profile_id:
+ LOG.warning(
+ "Managed browser profile missing at finalization; persisting to legacy session archive instead",
+ workflow_run_id=workflow_run.workflow_run_id,
+ browser_profile_id=workflow_run.browser_profile_id,
+ )
+ browser_session_storage_key = await self.get_workflow_browser_session_storage_key(
+ workflow=workflow,
+ workflow_run=workflow_run,
+ )
+ if not close_browser_on_completion:
+ await persist_session_cookies(
+ browser_state.browser_context,
+ browser_state.browser_artifacts.browser_session_dir,
+ )
+ await app.STORAGE.store_browser_session(
+ workflow_run.organization_id,
+ browser_session_storage_key,
+ browser_state.browser_artifacts.browser_session_dir,
+ )
+ LOG.info(
+ "Persisted browser session for workflow run",
+ workflow_run_id=workflow_run.workflow_run_id,
+ browser_session_storage_key=browser_session_storage_key,
+ )
await app.ARTIFACT_MANAGER.wait_for_upload_aiotasks(all_workflow_task_ids)
diff --git a/skyvern/webeye/default_persistent_sessions_manager.py b/skyvern/webeye/default_persistent_sessions_manager.py
index 9cb241be0..faf91a19e 100644
--- a/skyvern/webeye/default_persistent_sessions_manager.py
+++ b/skyvern/webeye/default_persistent_sessions_manager.py
@@ -408,6 +408,7 @@ class DefaultPersistentSessionsManager(PersistentSessionsManager):
url=url,
organization_id=organization_id,
extra_http_headers=extra_http_headers,
+ browser_profile_id=session.browser_profile_id,
)
await browser_state.get_or_create_page(
url=url or "about:blank",
diff --git a/tests/unit/forge/sdk/db/test_list_browser_profiles_ordering.py b/tests/unit/forge/sdk/db/test_list_browser_profiles_ordering.py
index b92ef430b..6e1d435ae 100644
--- a/tests/unit/forge/sdk/db/test_list_browser_profiles_ordering.py
+++ b/tests/unit/forge/sdk/db/test_list_browser_profiles_ordering.py
@@ -3,9 +3,11 @@ Selectors paginate this endpoint, so newest-first must come from the database.
"""
from datetime import datetime
+from typing import Any
import pytest
import pytest_asyncio
+from sqlalchemy.exc import IntegrityError
from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
from skyvern.forge.sdk.db.models import Base, BrowserProfileModel
@@ -31,14 +33,28 @@ async def repo_and_session() -> tuple:
await engine.dispose()
-async def _add_profile(session_factory, name: str, created_at: datetime) -> str:
+async def _add_profile(
+ session_factory,
+ name: str,
+ created_at: datetime,
+ *,
+ profile_id: str | None = None,
+ is_managed: bool = False,
+ workflow_permanent_id: str | None = None,
+ browser_profile_key_digest: str | None = None,
+ deleted_at: datetime | None = None,
+) -> str:
async with session_factory() as session:
profile = BrowserProfileModel(
- browser_profile_id=f"bp_{name}",
+ browser_profile_id=profile_id or f"bp_{name}",
organization_id=ORG,
name=name,
created_at=created_at,
modified_at=created_at,
+ is_managed=is_managed,
+ workflow_permanent_id=workflow_permanent_id,
+ browser_profile_key_digest=browser_profile_key_digest,
+ deleted_at=deleted_at,
)
session.add(profile)
await session.commit()
@@ -84,3 +100,186 @@ async def test_pagination_walks_from_newest_to_oldest(repo_and_session) -> None:
assert [p.name for p in page_1] == ["newest"]
assert [p.name for p in page_2] == ["middle"]
assert [p.name for p in page_3] == ["oldest"]
+
+
+async def test_list_filters_managed_profiles(repo_and_session) -> None:
+ repo, session_factory = repo_and_session
+ await _add_profile(session_factory, "user", datetime(2026, 1, 1))
+ await _add_profile(
+ session_factory,
+ "managed",
+ datetime(2026, 1, 2),
+ is_managed=True,
+ workflow_permanent_id="wpid_test",
+ browser_profile_key_digest="",
+ )
+
+ all_profiles = await repo.list_browser_profiles(organization_id=ORG)
+ user_profiles = await repo.list_browser_profiles(organization_id=ORG, managed=False)
+ managed_profiles = await repo.list_browser_profiles(organization_id=ORG, managed=True)
+
+ assert [p.name for p in all_profiles] == ["managed", "user"]
+ assert [p.name for p in user_profiles] == ["user"]
+ assert [p.name for p in managed_profiles] == ["managed"]
+
+
+async def test_sqlite_partial_index_allows_managed_profile_name_to_match_user_profile(repo_and_session) -> None:
+ _, session_factory = repo_and_session
+ await _add_profile(session_factory, "shared", datetime(2026, 1, 1), profile_id="bp_user")
+
+ await _add_profile(
+ session_factory,
+ "shared",
+ datetime(2026, 1, 2),
+ profile_id="bp_managed",
+ is_managed=True,
+ workflow_permanent_id="wpid_test",
+ browser_profile_key_digest="",
+ )
+
+
+async def test_sqlite_partial_index_allows_recreating_soft_deleted_managed_segment(repo_and_session) -> None:
+ _, session_factory = repo_and_session
+ await _add_profile(
+ session_factory,
+ "managed old",
+ datetime(2026, 1, 1),
+ profile_id="bp_managed_old",
+ is_managed=True,
+ workflow_permanent_id="wpid_test",
+ browser_profile_key_digest="digest",
+ deleted_at=datetime(2026, 1, 2),
+ )
+
+ await _add_profile(
+ session_factory,
+ "managed new",
+ datetime(2026, 1, 3),
+ profile_id="bp_managed_new",
+ is_managed=True,
+ workflow_permanent_id="wpid_test",
+ browser_profile_key_digest="digest",
+ )
+
+
+async def test_list_managed_browser_profiles_for_workflow_returns_active_managed_rows(repo_and_session) -> None:
+ repo, session_factory = repo_and_session
+ await _add_profile(session_factory, "user", datetime(2026, 1, 1), workflow_permanent_id="wpid_test")
+ await _add_profile(
+ session_factory,
+ "managed active",
+ datetime(2026, 1, 2),
+ is_managed=True,
+ workflow_permanent_id="wpid_test",
+ browser_profile_key_digest="",
+ )
+ await _add_profile(
+ session_factory,
+ "managed deleted",
+ datetime(2026, 1, 3),
+ is_managed=True,
+ workflow_permanent_id="wpid_test",
+ browser_profile_key_digest="deleted",
+ deleted_at=datetime(2026, 1, 4),
+ )
+ await _add_profile(
+ session_factory,
+ "managed other",
+ datetime(2026, 1, 5),
+ is_managed=True,
+ workflow_permanent_id="wpid_other",
+ browser_profile_key_digest="",
+ )
+
+ profiles = await repo.list_managed_browser_profiles_for_workflow(
+ organization_id=ORG,
+ workflow_permanent_id="wpid_test",
+ )
+
+ assert [profile.name for profile in profiles] == ["managed active"]
+
+
+async def test_get_or_create_managed_browser_profile_returns_existing(repo_and_session) -> None:
+ repo, _ = repo_and_session
+
+ first, first_created = await repo.get_or_create_managed_browser_profile(
+ organization_id=ORG,
+ workflow_permanent_id="wpid_test",
+ browser_profile_key_digest="",
+ name="Workflow (auto-saved session)",
+ )
+ second, second_created = await repo.get_or_create_managed_browser_profile(
+ organization_id=ORG,
+ workflow_permanent_id="wpid_test",
+ browser_profile_key_digest="",
+ name="Workflow (auto-saved session)",
+ )
+
+ assert first.browser_profile_id == second.browser_profile_id
+ assert first.is_managed is True
+ assert first.workflow_permanent_id == "wpid_test"
+ assert first_created is True
+ assert second_created is False
+
+
+class _CommitRaceSessionFactory:
+ def __init__(self, session_factory: async_sessionmaker) -> None:
+ self.session_factory = session_factory
+ self.raised = False
+
+ def __call__(self) -> Any:
+ context = self.session_factory()
+ factory = self
+
+ class _Context:
+ async def __aenter__(self) -> Any:
+ session = await context.__aenter__()
+ original_commit = session.commit
+
+ async def commit() -> None:
+ if not factory.raised:
+ factory.raised = True
+ async with factory.session_factory() as winner_session:
+ winner = BrowserProfileModel(
+ browser_profile_id="bp_race_winner",
+ organization_id=ORG,
+ name="Race winner",
+ is_managed=True,
+ workflow_permanent_id="wpid_race",
+ browser_profile_key_digest="digest_race",
+ created_at=datetime(2026, 1, 1),
+ modified_at=datetime(2026, 1, 1),
+ )
+ winner_session.add(winner)
+ await winner_session.commit()
+ raise IntegrityError("insert", {}, Exception("duplicate"))
+ await original_commit()
+
+ session.commit = commit
+ return session
+
+ async def __aexit__(self, *args: object) -> None:
+ await context.__aexit__(*args)
+
+ return _Context()
+
+
+async def test_get_or_create_managed_browser_profile_recovers_from_integrity_race(repo_and_session) -> None:
+ _, session_factory = repo_and_session
+ repo = BrowserSessionsRepository(_CommitRaceSessionFactory(session_factory))
+
+ profile, created = await repo.get_or_create_managed_browser_profile(
+ organization_id=ORG,
+ workflow_permanent_id="wpid_race",
+ browser_profile_key_digest="digest_race",
+ name="Race loser",
+ )
+
+ assert profile.browser_profile_id == "bp_race_winner"
+ assert created is False
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 c6ceb2b8a..c921aa1e2 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
@@ -72,6 +72,7 @@ def _build_client(
get_workflow_run=AsyncMock(),
get_workflow=AsyncMock(),
create_profile=AsyncMock(return_value=_profile()),
+ get_db_profile=AsyncMock(return_value=SimpleNamespace(is_managed=True, workflow_permanent_id="wp_1")),
delete_db_profile=AsyncMock(),
hard_delete_db_profile=AsyncMock(),
retrieve_profile=AsyncMock(),
@@ -92,6 +93,7 @@ def _build_client(
browser_sessions=SimpleNamespace(
get_persistent_browser_session=mocks.get_session,
create_browser_profile=mocks.create_profile,
+ get_browser_profile=mocks.get_db_profile,
delete_browser_profile=mocks.delete_db_profile,
hard_delete_browser_profile=mocks.hard_delete_db_profile,
),
@@ -420,6 +422,7 @@ async def test_create_profile_from_workflow_run_still_stores_workflow_archive(
mocks.get_workflow_run.return_value = SimpleNamespace(
workflow_id="wf_1",
workflow_permanent_id="wp_1",
+ browser_profile_id=None,
)
mocks.get_workflow.return_value = SimpleNamespace(
workflow_permanent_id="wp_1",
@@ -446,6 +449,107 @@ async def test_create_profile_from_workflow_run_still_stores_workflow_archive(
)
+async def test_create_profile_from_workflow_run_reads_managed_profile_blob(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ _client, mocks = _build_client(monkeypatch)
+ mocks.get_workflow_run.return_value = SimpleNamespace(
+ workflow_id="wf_1",
+ workflow_permanent_id="wp_1",
+ browser_profile_id="bp_managed",
+ )
+ mocks.get_workflow.return_value = SimpleNamespace(
+ workflow_permanent_id="wp_1",
+ persist_browser_session=True,
+ )
+ mocks.retrieve_profile.return_value = "/tmp/managed_profile_dir"
+
+ profile = await browser_profiles_route._create_profile_from_workflow_run(
+ organization_id="org_oss",
+ name="my profile",
+ description=None,
+ workflow_run_id="wr_1",
+ )
+
+ assert profile == _profile()
+ mocks.retrieve_profile.assert_awaited_once_with(organization_id="org_oss", profile_id="bp_managed")
+ mocks.retrieve_session.assert_not_awaited()
+ mocks.store_profile.assert_awaited_once_with(
+ organization_id="org_oss",
+ profile_id="bp_new",
+ directory="/tmp/managed_profile_dir",
+ )
+
+
+async def test_create_profile_from_workflow_run_falls_back_to_legacy_archive_for_managed_run(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ _client, mocks = _build_client(monkeypatch)
+ mocks.get_workflow_run.return_value = SimpleNamespace(
+ workflow_id="wf_1",
+ workflow_permanent_id="wp_1",
+ browser_profile_id="bp_managed",
+ )
+ mocks.get_workflow.return_value = SimpleNamespace(
+ workflow_permanent_id="wp_1",
+ persist_browser_session=True,
+ )
+ mocks.retrieve_profile.return_value = None
+ mocks.retrieve_session.return_value = "/tmp/workflow_session_dir"
+
+ await browser_profiles_route._create_profile_from_workflow_run(
+ organization_id="org_oss",
+ name="my profile",
+ description=None,
+ workflow_run_id="wr_1",
+ )
+
+ mocks.retrieve_profile.assert_awaited_once_with(organization_id="org_oss", profile_id="bp_managed")
+ mocks.retrieve_session.assert_awaited_once_with(
+ organization_id="org_oss",
+ workflow_permanent_id="wp_1",
+ )
+ mocks.store_profile.assert_awaited_once_with(
+ organization_id="org_oss",
+ profile_id="bp_new",
+ directory="/tmp/workflow_session_dir",
+ )
+
+
+async def test_create_profile_from_workflow_run_skips_user_profile_blob(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ _client, mocks = _build_client(monkeypatch)
+ mocks.get_workflow_run.return_value = SimpleNamespace(
+ workflow_id="wf_1",
+ workflow_permanent_id="wp_1",
+ browser_profile_id="bp_user",
+ )
+ mocks.get_workflow.return_value = SimpleNamespace(
+ workflow_permanent_id="wp_1",
+ persist_browser_session=True,
+ )
+ mocks.get_db_profile.return_value = SimpleNamespace(is_managed=False)
+ mocks.retrieve_session.return_value = "/tmp/workflow_session_dir"
+
+ await browser_profiles_route._create_profile_from_workflow_run(
+ organization_id="org_oss",
+ name="my profile",
+ description=None,
+ workflow_run_id="wr_1",
+ )
+
+ # A user profile's blob is its curated start state, not the run's end state.
+ mocks.retrieve_profile.assert_not_awaited()
+ mocks.retrieve_session.assert_awaited_once_with(
+ organization_id="org_oss",
+ workflow_permanent_id="wp_1",
+ )
+
+
@pytest.mark.asyncio
async def test_failed_workflow_run_profile_creation_hard_deletes_half_created_profile(
monkeypatch: pytest.MonkeyPatch,
@@ -454,6 +558,7 @@ async def test_failed_workflow_run_profile_creation_hard_deletes_half_created_pr
mocks.get_workflow_run.return_value = SimpleNamespace(
workflow_id="wf_1",
workflow_permanent_id="wp_1",
+ browser_profile_id=None,
)
mocks.get_workflow.return_value = SimpleNamespace(
workflow_permanent_id="wp_1",
diff --git a/tests/unit/forge/sdk/test_list_browser_profiles_route.py b/tests/unit/forge/sdk/test_list_browser_profiles_route.py
index a3e88b472..a44d7f28e 100644
--- a/tests/unit/forge/sdk/test_list_browser_profiles_route.py
+++ b/tests/unit/forge/sdk/test_list_browser_profiles_route.py
@@ -71,6 +71,7 @@ def test_list_browser_profiles_default_pagination(monkeypatch: pytest.MonkeyPatc
page=1,
page_size=10,
search_key=None,
+ managed=None,
)
@@ -87,6 +88,7 @@ def test_list_browser_profiles_explicit_pagination(monkeypatch: pytest.MonkeyPat
page=2,
page_size=10,
search_key=None,
+ managed=None,
)
@@ -121,6 +123,7 @@ def test_list_browser_profiles_alias_trailing_slash(monkeypatch: pytest.MonkeyPa
page=3,
page_size=5,
search_key=None,
+ managed=None,
)
@@ -139,6 +142,7 @@ def test_list_browser_profiles_search_key_hit_on_name(monkeypatch: pytest.Monkey
page=1,
page_size=10,
search_key="production",
+ managed=None,
)
@@ -157,6 +161,7 @@ def test_list_browser_profiles_search_key_hit_on_description(monkeypatch: pytest
page=1,
page_size=10,
search_key="staging_login",
+ managed=None,
)
@@ -174,6 +179,7 @@ def test_list_browser_profiles_search_key_miss(monkeypatch: pytest.MonkeyPatch)
page=1,
page_size=10,
search_key="no_such_profile",
+ managed=None,
)
@@ -190,6 +196,7 @@ def test_list_browser_profiles_search_key_with_pagination(monkeypatch: pytest.Mo
page=2,
page_size=5,
search_key="prod",
+ managed=None,
)
@@ -206,4 +213,5 @@ def test_list_browser_profiles_search_key_with_include_deleted(monkeypatch: pyte
page=1,
page_size=10,
search_key="archived",
+ managed=None,
)
diff --git a/tests/unit/forge/sdk/test_reset_browser_profile_route.py b/tests/unit/forge/sdk/test_reset_browser_profile_route.py
index 1875a93a9..caf57fd03 100644
--- a/tests/unit/forge/sdk/test_reset_browser_profile_route.py
+++ b/tests/unit/forge/sdk/test_reset_browser_profile_route.py
@@ -3,7 +3,7 @@
from __future__ import annotations
from types import SimpleNamespace
-from unittest.mock import AsyncMock
+from unittest.mock import AsyncMock, call
import pytest
from fastapi import FastAPI, Request
@@ -16,14 +16,26 @@ from skyvern.forge.sdk.routes import routers as routers_module
from skyvern.forge.sdk.services import org_auth_service
-def _build_client(monkeypatch: pytest.MonkeyPatch) -> tuple[TestClient, AsyncMock, AsyncMock]:
+def _build_client(monkeypatch: pytest.MonkeyPatch) -> tuple[TestClient, SimpleNamespace]:
async def _fake_org() -> SimpleNamespace:
return SimpleNamespace(organization_id="org_oss")
- get_workflow = AsyncMock()
- delete_browser_session = AsyncMock()
- monkeypatch.setattr(forge_app.WORKFLOW_SERVICE, "get_workflow_by_permanent_id", get_workflow)
- monkeypatch.setattr(forge_app.STORAGE, "delete_browser_session", delete_browser_session)
+ mocks = SimpleNamespace(
+ get_workflow=AsyncMock(),
+ delete_browser_session=AsyncMock(),
+ list_managed_profiles=AsyncMock(return_value=[]),
+ delete_profile_blob=AsyncMock(),
+ delete_db_profile=AsyncMock(),
+ )
+ monkeypatch.setattr(forge_app.WORKFLOW_SERVICE, "get_workflow_by_permanent_id", mocks.get_workflow)
+ monkeypatch.setattr(forge_app.STORAGE, "delete_browser_session", mocks.delete_browser_session)
+ monkeypatch.setattr(forge_app.STORAGE, "delete_browser_profile", mocks.delete_profile_blob)
+ monkeypatch.setattr(
+ forge_app.DATABASE.browser_sessions,
+ "list_managed_browser_profiles_for_workflow",
+ mocks.list_managed_profiles,
+ )
+ monkeypatch.setattr(forge_app.DATABASE.browser_sessions, "delete_browser_profile", mocks.delete_db_profile)
fastapi_app = FastAPI()
fastapi_app.dependency_overrides[org_auth_service.get_current_org] = _fake_org
@@ -33,37 +45,40 @@ def _build_client(monkeypatch: pytest.MonkeyPatch) -> tuple[TestClient, AsyncMoc
async def _handle_skyvern_http_exception(request: Request, exc: SkyvernHTTPException) -> JSONResponse:
return JSONResponse(status_code=exc.status_code, content={"detail": exc.message})
- return TestClient(fastapi_app), get_workflow, delete_browser_session
+ return TestClient(fastapi_app), mocks
def test_reset_browser_profile_clears_storage(monkeypatch: pytest.MonkeyPatch) -> None:
- client, get_workflow, delete_browser_session = _build_client(monkeypatch)
- get_workflow.return_value = SimpleNamespace(workflow_permanent_id="wpid_123")
+ client, mocks = _build_client(monkeypatch)
+ mocks.get_workflow.return_value = SimpleNamespace(workflow_permanent_id="wpid_123")
response = client.post("/v1/workflows/wpid_123/browser_session/reset_profile")
assert response.status_code == 204
- get_workflow.assert_awaited_once_with(workflow_permanent_id="wpid_123", organization_id="org_oss")
- delete_browser_session.assert_awaited_once_with(
+ mocks.get_workflow.assert_awaited_once_with(workflow_permanent_id="wpid_123", organization_id="org_oss")
+ mocks.delete_browser_session.assert_awaited_once_with(
organization_id="org_oss",
workflow_permanent_id="wpid_123",
)
+ mocks.delete_profile_blob.assert_not_awaited()
+ mocks.delete_db_profile.assert_not_awaited()
def test_reset_browser_profile_workflow_not_found(monkeypatch: pytest.MonkeyPatch) -> None:
- client, get_workflow, delete_browser_session = _build_client(monkeypatch)
- get_workflow.side_effect = WorkflowNotFound(workflow_permanent_id="wpid_missing")
+ client, mocks = _build_client(monkeypatch)
+ mocks.get_workflow.side_effect = WorkflowNotFound(workflow_permanent_id="wpid_missing")
response = client.post("/v1/workflows/wpid_missing/browser_session/reset_profile")
assert response.status_code == 404
- delete_browser_session.assert_not_awaited()
+ mocks.delete_browser_session.assert_not_awaited()
+ mocks.list_managed_profiles.assert_not_awaited()
def test_reset_browser_profile_storage_failure_returns_500(monkeypatch: pytest.MonkeyPatch) -> None:
- client, get_workflow, delete_browser_session = _build_client(monkeypatch)
- get_workflow.return_value = SimpleNamespace(workflow_permanent_id="wpid_123")
- delete_browser_session.side_effect = RuntimeError("s3 AccessDenied")
+ client, mocks = _build_client(monkeypatch)
+ mocks.get_workflow.return_value = SimpleNamespace(workflow_permanent_id="wpid_123")
+ mocks.delete_browser_session.side_effect = RuntimeError("s3 AccessDenied")
response = client.post("/v1/workflows/wpid_123/browser_session/reset_profile")
@@ -71,6 +86,56 @@ def test_reset_browser_profile_storage_failure_returns_500(monkeypatch: pytest.M
assert "retry" in response.json()["detail"].lower()
+def test_reset_browser_profile_clears_managed_profile_blobs_and_rows(monkeypatch: pytest.MonkeyPatch) -> None:
+ client, mocks = _build_client(monkeypatch)
+ mocks.get_workflow.return_value = SimpleNamespace(workflow_permanent_id="wpid_123")
+ mocks.list_managed_profiles.return_value = [
+ SimpleNamespace(browser_profile_id="bp_one", browser_profile_key_digest="", deleted_at=None),
+ SimpleNamespace(browser_profile_id="bp_two", browser_profile_key_digest="", deleted_at=None),
+ ]
+
+ response = client.post("/v1/workflows/wpid_123/browser_session/reset_profile")
+
+ assert response.status_code == 204
+ mocks.list_managed_profiles.assert_awaited_once_with(
+ organization_id="org_oss",
+ workflow_permanent_id="wpid_123",
+ include_deleted=True,
+ )
+ assert mocks.delete_profile_blob.await_args_list == [
+ call(organization_id="org_oss", profile_id="bp_one"),
+ call(organization_id="org_oss", profile_id="bp_two"),
+ ]
+ assert mocks.delete_db_profile.await_args_list == [
+ call(profile_id="bp_one", organization_id="org_oss"),
+ call(profile_id="bp_two", organization_id="org_oss"),
+ ]
+
+
+def test_reset_browser_profile_clears_segmented_legacy_archives(monkeypatch: pytest.MonkeyPatch) -> None:
+ client, mocks = _build_client(monkeypatch)
+ mocks.get_workflow.return_value = SimpleNamespace(workflow_permanent_id="wpid_123")
+ mocks.list_managed_profiles.return_value = [
+ SimpleNamespace(browser_profile_id="bp_seg", browser_profile_key_digest="abc123digest", deleted_at=None),
+ # Soft-deleted row: its blob/row are already gone, but its segment archive must still be cleared.
+ SimpleNamespace(
+ browser_profile_id="bp_gone", browser_profile_key_digest="def456digest", deleted_at="2026-01-01"
+ ),
+ ]
+
+ response = client.post("/v1/workflows/wpid_123/browser_session/reset_profile")
+
+ assert response.status_code == 204
+ session_deletes = {c.kwargs["workflow_permanent_id"] for c in mocks.delete_browser_session.await_args_list}
+ assert session_deletes == {
+ "wpid_123",
+ "wpid_123/profile_segments/abc123digest",
+ "wpid_123/profile_segments/def456digest",
+ }
+ mocks.delete_profile_blob.assert_awaited_once_with(organization_id="org_oss", profile_id="bp_seg")
+ mocks.delete_db_profile.assert_awaited_once_with(profile_id="bp_seg", organization_id="org_oss")
+
+
@pytest.mark.parametrize(
"path",
[
@@ -80,13 +145,13 @@ def test_reset_browser_profile_storage_failure_returns_500(monkeypatch: pytest.M
],
)
def test_alias_paths_still_work(monkeypatch: pytest.MonkeyPatch, path: str) -> None:
- client, get_workflow, delete_browser_session = _build_client(monkeypatch)
- get_workflow.return_value = SimpleNamespace(workflow_permanent_id="wpid_123")
+ client, mocks = _build_client(monkeypatch)
+ mocks.get_workflow.return_value = SimpleNamespace(workflow_permanent_id="wpid_123")
response = client.post(path)
assert response.status_code == 204
- delete_browser_session.assert_awaited_once_with(
+ mocks.delete_browser_session.assert_awaited_once_with(
organization_id="org_oss",
workflow_permanent_id="wpid_123",
)
diff --git a/tests/unit/test_browser_profile_key.py b/tests/unit/test_browser_profile_key.py
index fe988a2a2..1fcbef366 100644
--- a/tests/unit/test_browser_profile_key.py
+++ b/tests/unit/test_browser_profile_key.py
@@ -6,6 +6,7 @@ import pytest
from jinja2 import TemplateSyntaxError
from skyvern.forge.sdk.workflow.browser_profile_key import (
+ build_browser_profile_key_digest,
build_workflow_browser_session_storage_key,
render_browser_profile_key,
validate_browser_profile_key,
@@ -40,7 +41,9 @@ def test_validate_browser_profile_key_rejects_invalid_jinja() -> None:
def test_segmented_storage_key_uses_stable_hashed_suffix() -> None:
digest = sha256(b"cred_123").hexdigest()[:24]
assert build_workflow_browser_session_storage_key("wpid_test", "cred_123") == f"wpid_test/profile_segments/{digest}"
+ assert build_browser_profile_key_digest("cred_123") == digest
def test_empty_storage_key_keeps_legacy_workflow_key() -> None:
assert build_workflow_browser_session_storage_key("wpid_test", None) == "wpid_test"
+ assert build_browser_profile_key_digest(None) == ""
diff --git a/tests/unit/test_credential_test_trigger_type.py b/tests/unit/test_credential_test_trigger_type.py
index 3126082c3..12d2ffc89 100644
--- a/tests/unit/test_credential_test_trigger_type.py
+++ b/tests/unit/test_credential_test_trigger_type.py
@@ -46,9 +46,9 @@ def _patch_executor(monkeypatch: pytest.MonkeyPatch) -> None:
def _patch_cloud_proxy_session_headers(monkeypatch: pytest.MonkeyPatch) -> None:
agent_function = SimpleNamespace(
- build_proxy_session_extra_http_headers=lambda proxy_session_id: {"dedicated-ip": proxy_session_id}
- if proxy_session_id
- else None
+ build_proxy_session_extra_http_headers=lambda proxy_session_id: (
+ {"dedicated-ip": proxy_session_id} if proxy_session_id else None
+ )
)
monkeypatch.setattr(credentials.app, "AGENT_FUNCTION", agent_function)
diff --git a/tests/unit/test_credential_update_params.py b/tests/unit/test_credential_update_params.py
index 10894b439..9886648e6 100644
--- a/tests/unit/test_credential_update_params.py
+++ b/tests/unit/test_credential_update_params.py
@@ -431,7 +431,7 @@ async def test_browser_profile_resave_updates_proxy_pin_after_storage_write(monk
monkeypatch.setattr(
forge_app.DATABASE.workflow_runs,
"get_workflow_run",
- AsyncMock(return_value=SimpleNamespace(status=WorkflowRunStatus.completed)),
+ AsyncMock(return_value=SimpleNamespace(status=WorkflowRunStatus.completed, browser_profile_id=None)),
)
monkeypatch.setattr(forge_app.STORAGE, "retrieve_browser_session", AsyncMock(return_value="/tmp/session"))
monkeypatch.setattr(forge_app.STORAGE, "store_browser_profile", store_browser_profile)
@@ -491,7 +491,7 @@ async def test_browser_profile_resave_leaves_existing_profile_pin_when_credentia
monkeypatch.setattr(
forge_app.DATABASE.workflow_runs,
"get_workflow_run",
- AsyncMock(return_value=SimpleNamespace(status=WorkflowRunStatus.completed)),
+ AsyncMock(return_value=SimpleNamespace(status=WorkflowRunStatus.completed, browser_profile_id=None)),
)
monkeypatch.setattr(forge_app.STORAGE, "retrieve_browser_session", AsyncMock(return_value="/tmp/session"))
monkeypatch.setattr(forge_app.STORAGE, "store_browser_profile", store_browser_profile)
@@ -546,7 +546,7 @@ async def test_browser_profile_resave_preserves_different_existing_profile_pin(
monkeypatch.setattr(
forge_app.DATABASE.workflow_runs,
"get_workflow_run",
- AsyncMock(return_value=SimpleNamespace(status=WorkflowRunStatus.completed)),
+ AsyncMock(return_value=SimpleNamespace(status=WorkflowRunStatus.completed, browser_profile_id=None)),
)
monkeypatch.setattr(forge_app.STORAGE, "retrieve_browser_session", AsyncMock(return_value="/tmp/session"))
monkeypatch.setattr(forge_app.STORAGE, "store_browser_profile", store_browser_profile)
@@ -583,6 +583,131 @@ async def test_browser_profile_resave_preserves_different_existing_profile_pin(
assert events == ["store", "touch_profile", "update_credential"]
+async def test_credential_browser_profile_save_reads_managed_profile_blob(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ create_browser_profile = AsyncMock(return_value=SimpleNamespace(browser_profile_id="bp_created"))
+ update_credential = AsyncMock(return_value=SimpleNamespace())
+ store_browser_profile = AsyncMock()
+ retrieve_profile = AsyncMock(return_value="/tmp/managed_profile")
+ retrieve_session = AsyncMock()
+
+ monkeypatch.setattr(
+ forge_app.DATABASE.workflow_runs,
+ "get_workflow_run",
+ AsyncMock(
+ return_value=SimpleNamespace(
+ status=WorkflowRunStatus.completed,
+ browser_profile_id="bp_managed",
+ workflow_permanent_id="wpid_123",
+ )
+ ),
+ )
+ monkeypatch.setattr(
+ forge_app.DATABASE.workflows,
+ "get_workflow",
+ AsyncMock(return_value=SimpleNamespace(workflow_permanent_id="wpid_123")),
+ )
+ monkeypatch.setattr(
+ forge_app.DATABASE.browser_sessions,
+ "get_browser_profile",
+ AsyncMock(return_value=SimpleNamespace(is_managed=True, workflow_permanent_id="wpid_123")),
+ )
+ monkeypatch.setattr(forge_app.STORAGE, "retrieve_browser_profile", retrieve_profile)
+ monkeypatch.setattr(forge_app.STORAGE, "retrieve_browser_session", retrieve_session)
+ monkeypatch.setattr(forge_app.STORAGE, "store_browser_profile", store_browser_profile)
+ monkeypatch.setattr(
+ forge_app.DATABASE.credentials,
+ "get_credential",
+ AsyncMock(return_value=SimpleNamespace(proxy_location=None, proxy_session_id=None)),
+ )
+ monkeypatch.setattr(forge_app.DATABASE.credentials, "update_credential", update_credential)
+ monkeypatch.setattr(forge_app.DATABASE.browser_sessions, "create_browser_profile", create_browser_profile)
+
+ await credentials_routes._create_browser_profile_after_workflow(
+ credential_id="cred_123",
+ workflow_run_id="wr_123",
+ workflow_id="wf_123",
+ workflow_permanent_id="wpid_123",
+ organization_id="org_123",
+ credential_name="test",
+ test_url="https://example.com/login",
+ )
+
+ retrieve_profile.assert_awaited_once_with(organization_id="org_123", profile_id="bp_managed")
+ retrieve_session.assert_not_awaited()
+ store_browser_profile.assert_awaited_once_with(
+ organization_id="org_123",
+ profile_id="bp_created",
+ directory="/tmp/managed_profile",
+ )
+ update_credential.assert_awaited_once()
+
+
+async def test_credential_browser_profile_save_falls_back_to_legacy_archive_for_managed_run(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ create_browser_profile = AsyncMock(return_value=SimpleNamespace(browser_profile_id="bp_created"))
+ update_credential = AsyncMock(return_value=SimpleNamespace())
+ store_browser_profile = AsyncMock()
+ retrieve_profile = AsyncMock(return_value=None)
+ retrieve_session = AsyncMock(return_value="/tmp/legacy_session")
+ get_storage_key = AsyncMock(return_value="wpid_123")
+
+ monkeypatch.setattr(
+ forge_app.DATABASE.workflow_runs,
+ "get_workflow_run",
+ AsyncMock(
+ return_value=SimpleNamespace(
+ status=WorkflowRunStatus.completed,
+ browser_profile_id="bp_managed",
+ workflow_permanent_id="wpid_123",
+ )
+ ),
+ )
+ monkeypatch.setattr(
+ forge_app.DATABASE.workflows,
+ "get_workflow",
+ AsyncMock(return_value=SimpleNamespace(workflow_permanent_id="wpid_123")),
+ )
+ monkeypatch.setattr(
+ forge_app.DATABASE.browser_sessions,
+ "get_browser_profile",
+ AsyncMock(return_value=SimpleNamespace(is_managed=True, workflow_permanent_id="wpid_123")),
+ )
+ monkeypatch.setattr(forge_app.WORKFLOW_SERVICE, "get_workflow_browser_session_storage_key", get_storage_key)
+ monkeypatch.setattr(forge_app.STORAGE, "retrieve_browser_profile", retrieve_profile)
+ monkeypatch.setattr(forge_app.STORAGE, "retrieve_browser_session", retrieve_session)
+ monkeypatch.setattr(forge_app.STORAGE, "store_browser_profile", store_browser_profile)
+ monkeypatch.setattr(
+ forge_app.DATABASE.credentials,
+ "get_credential",
+ AsyncMock(return_value=SimpleNamespace(proxy_location=None, proxy_session_id=None)),
+ )
+ monkeypatch.setattr(forge_app.DATABASE.credentials, "update_credential", update_credential)
+ monkeypatch.setattr(forge_app.DATABASE.browser_sessions, "create_browser_profile", create_browser_profile)
+
+ await credentials_routes._create_browser_profile_after_workflow(
+ credential_id="cred_123",
+ workflow_run_id="wr_123",
+ workflow_id="wf_123",
+ workflow_permanent_id="wpid_123",
+ organization_id="org_123",
+ credential_name="test",
+ test_url="https://example.com/login",
+ )
+
+ retrieve_profile.assert_awaited_once_with(organization_id="org_123", profile_id="bp_managed")
+ retrieve_session.assert_awaited_once_with(organization_id="org_123", workflow_permanent_id="wpid_123")
+ store_browser_profile.assert_awaited_once_with(
+ organization_id="org_123",
+ profile_id="bp_created",
+ directory="/tmp/legacy_session",
+ )
+
+
def test_credential_route_treats_null_advanced_key_as_no_explicit_identity() -> None:
update_kwargs: dict[str, object] = {}
diff --git a/tests/unit/test_workflow_browser_profile_id.py b/tests/unit/test_workflow_browser_profile_id.py
index 1cbff4935..df2fdad8d 100644
--- a/tests/unit/test_workflow_browser_profile_id.py
+++ b/tests/unit/test_workflow_browser_profile_id.py
@@ -233,6 +233,7 @@ def _make_workflow_stub(
extra_http_headers=None,
cdp_connect_headers=None,
browser_profile_id=browser_profile_id,
+ persist_browser_session=False,
max_elapsed_time_minutes=max_elapsed_time_minutes,
run_with="agent",
code_version=None,
diff --git a/tests/unit/test_workflow_elapsed_timeout.py b/tests/unit/test_workflow_elapsed_timeout.py
index ab3018a95..775503f40 100644
--- a/tests/unit/test_workflow_elapsed_timeout.py
+++ b/tests/unit/test_workflow_elapsed_timeout.py
@@ -228,6 +228,7 @@ async def test_execute_workflow_returns_after_elapsed_timeout_without_finally(mo
monkeypatch.setattr(svc, "get_workflow_output_parameters", AsyncMock(return_value=[]))
monkeypatch.setattr(svc, "_collect_inherited_workflow_system_prompt", AsyncMock(return_value=None))
monkeypatch.setattr(svc, "auto_create_browser_session_if_needed", AsyncMock(return_value=None))
+ monkeypatch.setattr(svc, "_browser_profile_is_managed", AsyncMock(return_value=False))
monkeypatch.setattr(svc, "mark_workflow_run_as_timed_out", mark_workflow_run_as_timed_out)
monkeypatch.setattr(svc, "_execute_workflow_blocks", execute_workflow_blocks)
monkeypatch.setattr(svc, "generate_script_if_needed", generate_script_if_needed)
@@ -306,6 +307,7 @@ async def test_execute_workflow_times_out_slow_pre_block_script_lookup(monkeypat
monkeypatch.setattr(svc, "get_workflow_output_parameters", AsyncMock(return_value=[]))
monkeypatch.setattr(svc, "_collect_inherited_workflow_system_prompt", AsyncMock(return_value=None))
monkeypatch.setattr(svc, "auto_create_browser_session_if_needed", AsyncMock(return_value=None))
+ monkeypatch.setattr(svc, "_browser_profile_is_managed", AsyncMock(return_value=False))
monkeypatch.setattr(svc, "mark_workflow_run_as_timed_out", mark_workflow_run_as_timed_out)
monkeypatch.setattr(svc, "_execute_workflow_blocks", execute_workflow_blocks)
monkeypatch.setattr(svc, "clean_up_workflow", clean_up_workflow)
@@ -390,6 +392,7 @@ async def test_execute_workflow_preserves_completed_status_after_post_run_timeou
monkeypatch.setattr(svc, "get_workflow_output_parameters", AsyncMock(return_value=[]))
monkeypatch.setattr(svc, "_collect_inherited_workflow_system_prompt", AsyncMock(return_value=None))
monkeypatch.setattr(svc, "auto_create_browser_session_if_needed", AsyncMock(return_value=None))
+ monkeypatch.setattr(svc, "_browser_profile_is_managed", AsyncMock(return_value=False))
monkeypatch.setattr(svc, "mark_workflow_run_as_timed_out", mark_workflow_run_as_timed_out)
monkeypatch.setattr(svc, "_execute_workflow_blocks", AsyncMock(return_value=(completed_run, set())))
monkeypatch.setattr(svc, "generate_script_if_needed", AsyncMock(return_value=running_run))
@@ -479,6 +482,7 @@ async def test_execute_workflow_preserves_timed_out_status_after_non_terminal_po
monkeypatch.setattr(svc, "get_workflow_output_parameters", AsyncMock(return_value=[]))
monkeypatch.setattr(svc, "_collect_inherited_workflow_system_prompt", AsyncMock(return_value=None))
monkeypatch.setattr(svc, "auto_create_browser_session_if_needed", AsyncMock(return_value=None))
+ monkeypatch.setattr(svc, "_browser_profile_is_managed", AsyncMock(return_value=False))
monkeypatch.setattr(svc, "mark_workflow_run_as_timed_out", mark_workflow_run_as_timed_out)
monkeypatch.setattr(svc, "_execute_workflow_blocks", AsyncMock(return_value=(running_run, set())))
monkeypatch.setattr(svc, "generate_script_if_needed", AsyncMock(return_value=running_run))
@@ -572,6 +576,7 @@ async def test_execute_workflow_marks_timed_out_when_post_run_budget_is_exhauste
monkeypatch.setattr(svc, "get_workflow_output_parameters", AsyncMock(return_value=[]))
monkeypatch.setattr(svc, "_collect_inherited_workflow_system_prompt", AsyncMock(return_value=None))
monkeypatch.setattr(svc, "auto_create_browser_session_if_needed", AsyncMock(return_value=None))
+ monkeypatch.setattr(svc, "_browser_profile_is_managed", AsyncMock(return_value=False))
monkeypatch.setattr(svc, "mark_workflow_run_as_timed_out", mark_workflow_run_as_timed_out)
monkeypatch.setattr(svc, "_execute_workflow_blocks", AsyncMock(return_value=(running_run, set())))
monkeypatch.setattr(svc, "generate_script_if_needed", generate_script_if_needed)
@@ -747,6 +752,7 @@ async def test_execute_workflow_refreshes_terminal_status_after_immediate_post_r
monkeypatch.setattr(svc, "get_workflow_output_parameters", AsyncMock(return_value=[]))
monkeypatch.setattr(svc, "_collect_inherited_workflow_system_prompt", AsyncMock(return_value=None))
monkeypatch.setattr(svc, "auto_create_browser_session_if_needed", AsyncMock(return_value=None))
+ monkeypatch.setattr(svc, "_browser_profile_is_managed", AsyncMock(return_value=False))
monkeypatch.setattr(svc, "mark_workflow_run_as_timed_out", mark_workflow_run_as_timed_out)
monkeypatch.setattr(svc, "_execute_workflow_blocks", AsyncMock(return_value=(completed_run, set())))
monkeypatch.setattr(svc, "generate_script_if_needed", AsyncMock())
@@ -836,6 +842,7 @@ async def test_execute_workflow_returns_finalized_status_after_post_run_timeout(
monkeypatch.setattr(svc, "get_workflow_output_parameters", AsyncMock(return_value=[]))
monkeypatch.setattr(svc, "_collect_inherited_workflow_system_prompt", AsyncMock(return_value=None))
monkeypatch.setattr(svc, "auto_create_browser_session_if_needed", AsyncMock(return_value=None))
+ monkeypatch.setattr(svc, "_browser_profile_is_managed", AsyncMock(return_value=False))
monkeypatch.setattr(svc, "mark_workflow_run_as_timed_out", mark_workflow_run_as_timed_out)
monkeypatch.setattr(svc, "_execute_workflow_blocks", AsyncMock(return_value=(failed_run, set())))
monkeypatch.setattr(svc, "generate_script_if_needed", AsyncMock())
@@ -923,6 +930,7 @@ async def test_execute_workflow_runs_finally_for_existing_timed_out_status(
monkeypatch.setattr(svc, "get_workflow_output_parameters", AsyncMock(return_value=[]))
monkeypatch.setattr(svc, "_collect_inherited_workflow_system_prompt", AsyncMock(return_value=None))
monkeypatch.setattr(svc, "auto_create_browser_session_if_needed", AsyncMock(return_value=None))
+ monkeypatch.setattr(svc, "_browser_profile_is_managed", AsyncMock(return_value=False))
monkeypatch.setattr(svc, "mark_workflow_run_as_timed_out", mark_workflow_run_as_timed_out)
monkeypatch.setattr(svc, "_execute_workflow_blocks", AsyncMock(return_value=(timed_out_run, set())))
monkeypatch.setattr(svc, "generate_script_if_needed", AsyncMock())
diff --git a/tests/unit/test_workflow_run_parameter_batching.py b/tests/unit/test_workflow_run_parameter_batching.py
index b2ca3ca35..501963c60 100644
--- a/tests/unit/test_workflow_run_parameter_batching.py
+++ b/tests/unit/test_workflow_run_parameter_batching.py
@@ -47,6 +47,7 @@ def _make_service_with_mocks(
workflow_parameters: list[WorkflowParameter],
batch_side_effect: Exception | None = None,
single_side_effect: Exception | None = None,
+ persist_browser_session: bool = False,
) -> tuple[WorkflowService, SimpleNamespace, SimpleNamespace]:
"""Helper to build a WorkflowService with mocked internals for setup_workflow_run tests."""
service = WorkflowService()
@@ -59,6 +60,9 @@ def _make_service_with_mocks(
extra_http_headers=None,
cdp_connect_headers=None,
browser_profile_id=None,
+ persist_browser_session=persist_browser_session,
+ browser_profile_key=None,
+ title="Workflow",
max_elapsed_time_minutes=None,
run_with="agent",
code_version=None,
@@ -192,6 +196,41 @@ async def test_setup_workflow_run_raises_on_non_string_credential_id() -> None:
service.create_workflow_run_parameters.assert_not_awaited()
+async def test_setup_workflow_run_validates_credentials_before_preparing_managed_profile() -> None:
+ cred_param = _make_workflow_parameter(
+ "credential",
+ workflow_parameter_type=WorkflowParameterType.CREDENTIAL_ID,
+ )
+ service, organization, _ = _make_service_with_mocks(
+ workflow_parameters=[cred_param],
+ persist_browser_session=True,
+ )
+ service._validate_credential_ids = AsyncMock( # type: ignore[method-assign]
+ side_effect=InvalidCredentialId("Credential not found")
+ )
+ service._prepare_persisted_workflow_browser_profile = AsyncMock() # type: ignore[method-assign]
+
+ request = WorkflowRequestBody(data={"credential": "cred_missing"})
+
+ with patch("skyvern.forge.sdk.workflow.service.app") as mock_app:
+ mock_app.EXPERIMENTATION_PROVIDER.is_feature_enabled_cached = AsyncMock(return_value=False)
+ mock_app.AGENT_FUNCTION.should_use_flex_llm_routing = AsyncMock(return_value=False)
+
+ with pytest.raises(InvalidCredentialId):
+ await service.setup_workflow_run(
+ request_id="req_test",
+ workflow_request=request,
+ workflow_permanent_id="wpid_test",
+ organization=organization,
+ )
+
+ service._validate_credential_ids.assert_awaited_once_with(["cred_missing"], organization)
+ service._prepare_persisted_workflow_browser_profile.assert_not_awaited()
+ service.create_workflow_run_parameters.assert_not_awaited()
+ service.mark_workflow_run_as_failed.assert_awaited_once()
+
+
@pytest.mark.asyncio
async def test_setup_workflow_run_batches_credential_validation() -> None:
"""N credential parameters should issue a single get_credentials_by_ids call, not N get_credential calls."""
diff --git a/tests/unit/test_workflow_service_managed_browser_profile.py b/tests/unit/test_workflow_service_managed_browser_profile.py
new file mode 100644
index 000000000..a425c54b0
--- /dev/null
+++ b/tests/unit/test_workflow_service_managed_browser_profile.py
@@ -0,0 +1,253 @@
+from __future__ import annotations
+
+from types import SimpleNamespace
+from unittest.mock import AsyncMock
+
+import pytest
+
+from skyvern.forge import app
+from skyvern.forge.sdk.workflow.browser_profile_key import (
+ build_browser_profile_key_digest,
+ build_workflow_browser_session_storage_key,
+)
+from skyvern.forge.sdk.workflow.models.block import BlockType
+from skyvern.forge.sdk.workflow.service import WorkflowService
+
+
+def _workflow(browser_profile_key: str | None = None) -> SimpleNamespace:
+ return SimpleNamespace(
+ persist_browser_session=True,
+ browser_profile_key=browser_profile_key,
+ workflow_permanent_id="wpid_test",
+ title="Workflow",
+ )
+
+
+def _workflow_run(browser_profile_id: str | None = None) -> SimpleNamespace:
+ return SimpleNamespace(
+ workflow_run_id="wr_test",
+ organization_id="o_test",
+ browser_profile_id=browser_profile_id,
+ )
+
+
+def _mock_storage(monkeypatch: pytest.MonkeyPatch, *, legacy_dir: str | None) -> AsyncMock:
+ monkeypatch.setattr(app.STORAGE, "retrieve_browser_session", AsyncMock(return_value=legacy_dir))
+ store = AsyncMock()
+ monkeypatch.setattr(app.STORAGE, "store_browser_profile", store)
+ return store
+
+
+async def test_prepare_persisted_workflow_browser_profile_stamps_managed_profile(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ profile = SimpleNamespace(browser_profile_id="bp_managed")
+ updated_run = _workflow_run(browser_profile_id="bp_managed")
+ get_or_create = AsyncMock(return_value=(profile, True))
+ update_run = AsyncMock(return_value=updated_run)
+ monkeypatch.setattr(app.DATABASE.browser_sessions, "get_or_create_managed_browser_profile", get_or_create)
+ monkeypatch.setattr(app.DATABASE.workflow_runs, "update_workflow_run", update_run)
+ _mock_storage(monkeypatch, legacy_dir=None)
+
+ result = await WorkflowService()._prepare_persisted_workflow_browser_profile(
+ workflow=_workflow(browser_profile_key="{{ credential_id }}"),
+ workflow_run=_workflow_run(),
+ parameter_values={"credential_id": "cred_123"},
+ )
+
+ assert result is updated_run
+ get_or_create.assert_awaited_once_with(
+ organization_id="o_test",
+ workflow_permanent_id="wpid_test",
+ browser_profile_key_digest=build_browser_profile_key_digest("cred_123"),
+ name="Workflow (auto-saved: cred_123)",
+ )
+ update_run.assert_awaited_once_with(workflow_run_id="wr_test", browser_profile_id="bp_managed")
+
+
+async def test_prepare_persisted_workflow_browser_profile_uses_empty_digest_for_unkeyed_workflow(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ profile = SimpleNamespace(browser_profile_id="bp_managed")
+ updated_run = _workflow_run(browser_profile_id="bp_managed")
+ get_or_create = AsyncMock(return_value=(profile, True))
+ monkeypatch.setattr(app.DATABASE.browser_sessions, "get_or_create_managed_browser_profile", get_or_create)
+ monkeypatch.setattr(app.DATABASE.workflow_runs, "update_workflow_run", AsyncMock(return_value=updated_run))
+ _mock_storage(monkeypatch, legacy_dir=None)
+
+ await WorkflowService()._prepare_persisted_workflow_browser_profile(
+ workflow=_workflow(),
+ workflow_run=_workflow_run(),
+ parameter_values={},
+ )
+
+ get_or_create.assert_awaited_once_with(
+ organization_id="o_test",
+ workflow_permanent_id="wpid_test",
+ browser_profile_key_digest="",
+ name="Workflow (auto-saved session)",
+ )
+
+
+async def test_prepare_persisted_workflow_browser_profile_keeps_explicit_profile(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ get_or_create = AsyncMock()
+ update_run = AsyncMock()
+ monkeypatch.setattr(app.DATABASE.browser_sessions, "get_or_create_managed_browser_profile", get_or_create)
+ monkeypatch.setattr(app.DATABASE.workflow_runs, "update_workflow_run", update_run)
+ workflow_run = _workflow_run(browser_profile_id="bp_user")
+
+ result = await WorkflowService()._prepare_persisted_workflow_browser_profile(
+ workflow=_workflow(browser_profile_key="{{ credential_id }}"),
+ workflow_run=workflow_run,
+ parameter_values={"credential_id": "cred_123"},
+ )
+
+ assert result is workflow_run
+ get_or_create.assert_not_awaited()
+ update_run.assert_not_awaited()
+
+
+async def test_prepare_persisted_workflow_browser_profile_seeds_new_profile_from_legacy_archive(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ profile = SimpleNamespace(browser_profile_id="bp_managed")
+ get_or_create = AsyncMock(return_value=(profile, True))
+ monkeypatch.setattr(app.DATABASE.browser_sessions, "get_or_create_managed_browser_profile", get_or_create)
+ monkeypatch.setattr(
+ app.DATABASE.workflow_runs, "update_workflow_run", AsyncMock(return_value=_workflow_run("bp_managed"))
+ )
+ store = _mock_storage(monkeypatch, legacy_dir="/tmp/legacy_session")
+
+ await WorkflowService()._prepare_persisted_workflow_browser_profile(
+ workflow=_workflow(),
+ workflow_run=_workflow_run(),
+ parameter_values={},
+ )
+
+ store.assert_awaited_once_with(
+ "o_test",
+ profile_id="bp_managed",
+ directory="/tmp/legacy_session",
+ )
+
+
+async def test_prepare_persisted_workflow_browser_profile_rolls_back_on_seed_failure(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ profile = SimpleNamespace(browser_profile_id="bp_managed")
+ monkeypatch.setattr(
+ app.DATABASE.browser_sessions,
+ "get_or_create_managed_browser_profile",
+ AsyncMock(return_value=(profile, True)),
+ )
+ hard_delete = AsyncMock()
+ monkeypatch.setattr(app.DATABASE.browser_sessions, "hard_delete_browser_profile", hard_delete)
+ update_run = AsyncMock()
+ monkeypatch.setattr(app.DATABASE.workflow_runs, "update_workflow_run", update_run)
+ monkeypatch.setattr(app.STORAGE, "retrieve_browser_session", AsyncMock(return_value="/tmp/legacy_session"))
+ monkeypatch.setattr(app.STORAGE, "store_browser_profile", AsyncMock(side_effect=RuntimeError("upload failed")))
+ workflow_run = _workflow_run()
+
+ result = await WorkflowService()._prepare_persisted_workflow_browser_profile(
+ workflow=_workflow(),
+ workflow_run=workflow_run,
+ parameter_values={},
+ )
+
+ assert result is workflow_run
+ hard_delete.assert_awaited_once_with(profile_id="bp_managed", organization_id="o_test")
+ update_run.assert_not_awaited()
+
+
+async def test_prepare_persisted_workflow_browser_profile_does_not_seed_existing_profile(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ profile = SimpleNamespace(browser_profile_id="bp_managed")
+ get_or_create = AsyncMock(return_value=(profile, False))
+ monkeypatch.setattr(app.DATABASE.browser_sessions, "get_or_create_managed_browser_profile", get_or_create)
+ monkeypatch.setattr(
+ app.DATABASE.workflow_runs, "update_workflow_run", AsyncMock(return_value=_workflow_run("bp_managed"))
+ )
+ retrieve = AsyncMock(return_value="/tmp/legacy_session")
+ monkeypatch.setattr(app.STORAGE, "retrieve_browser_session", retrieve)
+ store = AsyncMock()
+ monkeypatch.setattr(app.STORAGE, "store_browser_profile", store)
+
+ await WorkflowService()._prepare_persisted_workflow_browser_profile(
+ workflow=_workflow(),
+ workflow_run=_workflow_run(),
+ parameter_values={},
+ )
+
+ retrieve.assert_not_awaited()
+ store.assert_not_awaited()
+
+
+def test_legacy_storage_key_matches_managed_digest_for_keyed_workflow() -> None:
+ # Read-compat invariant: the managed profile digest and the legacy archive segment must
+ # derive from the same rendered key, so seeding finds the right archive.
+ rendered = "cred_123"
+ storage_key = build_workflow_browser_session_storage_key("wpid_test", rendered)
+ assert storage_key.endswith(build_browser_profile_key_digest(rendered))
+
+
+async def test_auto_create_browser_session_for_human_interaction_loads_managed_profile(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ create_session = AsyncMock(return_value=SimpleNamespace(persistent_browser_session_id="pbs_test"))
+ monkeypatch.setattr(app.PERSISTENT_SESSIONS_MANAGER, "create_session", create_session)
+ workflow = SimpleNamespace(
+ workflow_definition=SimpleNamespace(
+ blocks=[SimpleNamespace(block_type=BlockType.HUMAN_INTERACTION, timeout_seconds=60)]
+ )
+ )
+
+ browser_session = await WorkflowService().auto_create_browser_session_if_needed(
+ "o_test",
+ workflow,
+ browser_profile_id="bp_managed",
+ )
+
+ assert browser_session.persistent_browser_session_id == "pbs_test"
+ create_session.assert_awaited_once_with(
+ organization_id="o_test",
+ timeout_minutes=61,
+ browser_profile_id="bp_managed",
+ proxy_location=None,
+ )
+
+
+async def test_browser_profile_is_managed_distinguishes_user_profiles(monkeypatch: pytest.MonkeyPatch) -> None:
+ get_browser_profile = AsyncMock(return_value=SimpleNamespace(is_managed=False))
+ monkeypatch.setattr(app.DATABASE.browser_sessions, "get_browser_profile", get_browser_profile)
+
+ is_managed = await WorkflowService()._browser_profile_is_managed(
+ organization_id="o_test",
+ browser_profile_id="bp_user",
+ )
+
+ assert is_managed is False
+ get_browser_profile.assert_awaited_once_with(profile_id="bp_user", organization_id="o_test")
+
+
+async def test_browser_profile_is_managed_detects_managed_profile(monkeypatch: pytest.MonkeyPatch) -> None:
+ get_browser_profile = AsyncMock(return_value=SimpleNamespace(is_managed=True))
+ monkeypatch.setattr(app.DATABASE.browser_sessions, "get_browser_profile", get_browser_profile)
+
+ is_managed = await WorkflowService()._browser_profile_is_managed(
+ organization_id="o_test",
+ browser_profile_id="bp_managed",
+ )
+
+ assert is_managed is True
diff --git a/tests/unit/test_workflow_service_profile_writeback.py b/tests/unit/test_workflow_service_profile_writeback.py
index b9e84937d..a5b7821b7 100644
--- a/tests/unit/test_workflow_service_profile_writeback.py
+++ b/tests/unit/test_workflow_service_profile_writeback.py
@@ -25,12 +25,12 @@ def _make_workflow(persist: bool = True) -> MagicMock:
return wf
-def _make_workflow_run(status: WorkflowRunStatus) -> MagicMock:
+def _make_workflow_run(status: WorkflowRunStatus, browser_profile_id: str | None = None) -> MagicMock:
wr = MagicMock()
wr.workflow_run_id = "wr_test"
wr.organization_id = "o_test"
wr.status = status
- wr.browser_profile_id = None
+ wr.browser_profile_id = browser_profile_id
wr.browser_address = None
wr.webhook_callback_url = None
wr.created_at = None
@@ -48,6 +48,7 @@ def _patch_clean_up_deps(monkeypatch: pytest.MonkeyPatch, browser_state: MagicMo
"""Patch all external dependencies of clean_up_workflow. Returns the store mock."""
store_mock = AsyncMock()
monkeypatch.setattr(app.STORAGE, "store_browser_session", store_mock)
+ monkeypatch.setattr(app.STORAGE, "store_browser_profile", AsyncMock())
monkeypatch.setattr(app.STORAGE, "save_downloaded_files", AsyncMock())
monkeypatch.setattr(app.BROWSER_MANAGER, "cleanup_for_workflow_run", AsyncMock(return_value=browser_state))
monkeypatch.setattr(app.ARTIFACT_MANAGER, "wait_for_upload_aiotasks", AsyncMock())
@@ -60,8 +61,9 @@ def _patch_clean_up_deps(monkeypatch: pytest.MonkeyPatch, browser_state: MagicMo
@pytest.mark.asyncio
-async def test_profile_persisted_on_completed_run(monkeypatch: pytest.MonkeyPatch) -> None:
- """Completed runs should write the browser profile back to S3."""
+async def test_legacy_session_persisted_on_completed_run_without_managed_profile(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
from skyvern.forge.sdk.workflow.service import WorkflowService
workflow = _make_workflow(persist=True)
@@ -76,6 +78,117 @@ async def test_profile_persisted_on_completed_run(monkeypatch: pytest.MonkeyPatc
await svc.clean_up_workflow(workflow=workflow, workflow_run=workflow_run, need_call_webhook=False)
store_mock.assert_awaited_once_with("o_test", "wpid_test", "/tmp/fake_profile")
+ app.STORAGE.store_browser_profile.assert_not_awaited()
+
+
+async def test_managed_profile_persisted_on_completed_run(monkeypatch: pytest.MonkeyPatch) -> None:
+ from skyvern.forge.sdk.workflow.service import WorkflowService
+
+ workflow = _make_workflow(persist=True)
+ workflow_run = _make_workflow_run(WorkflowRunStatus.completed, browser_profile_id="bp_managed")
+ browser_state = _make_browser_state()
+ store_session_mock = _patch_clean_up_deps(monkeypatch, browser_state)
+ monkeypatch.setattr(
+ app.DATABASE.browser_sessions,
+ "get_browser_profile",
+ AsyncMock(
+ return_value=SimpleNamespace(
+ is_managed=True, browser_profile_id="bp_managed", workflow_permanent_id="wpid_test"
+ )
+ ),
+ )
+
+ svc = WorkflowService()
+ monkeypatch.setattr(svc, "persist_video_data", AsyncMock())
+ monkeypatch.setattr(svc, "get_tasks_by_workflow_run_id", AsyncMock(return_value=[]))
+
+ await svc.clean_up_workflow(workflow=workflow, workflow_run=workflow_run, need_call_webhook=False)
+
+ app.STORAGE.store_browser_profile.assert_awaited_once_with(
+ "o_test",
+ profile_id="bp_managed",
+ directory="/tmp/fake_profile",
+ )
+ store_session_mock.assert_not_awaited()
+
+
+async def test_foreign_managed_profile_not_persisted_on_completed_run(monkeypatch: pytest.MonkeyPatch) -> None:
+ """A managed profile owned by another workflow must not receive this run's write-back."""
+ from skyvern.forge.sdk.workflow.service import WorkflowService
+
+ workflow = _make_workflow(persist=True)
+ workflow_run = _make_workflow_run(WorkflowRunStatus.completed, browser_profile_id="bp_foreign")
+ browser_state = _make_browser_state()
+ store_session_mock = _patch_clean_up_deps(monkeypatch, browser_state)
+ monkeypatch.setattr(
+ app.DATABASE.browser_sessions,
+ "get_browser_profile",
+ AsyncMock(
+ return_value=SimpleNamespace(
+ is_managed=True, browser_profile_id="bp_foreign", workflow_permanent_id="wpid_other"
+ )
+ ),
+ )
+
+ svc = WorkflowService()
+ monkeypatch.setattr(svc, "persist_video_data", AsyncMock())
+ monkeypatch.setattr(svc, "get_tasks_by_workflow_run_id", AsyncMock(return_value=[]))
+
+ await svc.clean_up_workflow(workflow=workflow, workflow_run=workflow_run, need_call_webhook=False)
+
+ app.STORAGE.store_browser_profile.assert_not_awaited()
+ store_session_mock.assert_not_awaited()
+
+
+async def test_missing_managed_profile_falls_back_to_legacy_session(monkeypatch: pytest.MonkeyPatch) -> None:
+ """A managed profile stamped at setup but deleted before finalization must recover, not drop state."""
+ from skyvern.forge.sdk.workflow.service import WorkflowService
+
+ workflow = _make_workflow(persist=True)
+ workflow_run = _make_workflow_run(WorkflowRunStatus.completed, browser_profile_id="bp_gone")
+ browser_state = _make_browser_state()
+ store_mock = _patch_clean_up_deps(monkeypatch, browser_state)
+ monkeypatch.setattr(
+ app.DATABASE.browser_sessions,
+ "get_browser_profile",
+ AsyncMock(return_value=None),
+ )
+
+ svc = WorkflowService()
+ monkeypatch.setattr(svc, "persist_video_data", AsyncMock())
+ monkeypatch.setattr(svc, "get_tasks_by_workflow_run_id", AsyncMock(return_value=[]))
+
+ await svc.clean_up_workflow(workflow=workflow, workflow_run=workflow_run, need_call_webhook=False)
+
+ store_mock.assert_awaited_once_with("o_test", "wpid_test", "/tmp/fake_profile")
+ app.STORAGE.store_browser_profile.assert_not_awaited()
+
+
+async def test_user_profile_not_persisted_on_completed_persist_run(monkeypatch: pytest.MonkeyPatch) -> None:
+ from skyvern.forge.sdk.workflow.service import WorkflowService
+
+ workflow = _make_workflow(persist=True)
+ workflow_run = _make_workflow_run(WorkflowRunStatus.completed, browser_profile_id="bp_user")
+ browser_state = _make_browser_state()
+ store_session_mock = _patch_clean_up_deps(monkeypatch, browser_state)
+ monkeypatch.setattr(
+ app.DATABASE.browser_sessions,
+ "get_browser_profile",
+ AsyncMock(return_value=SimpleNamespace(is_managed=False)),
+ )
+
+ svc = WorkflowService()
+ monkeypatch.setattr(svc, "persist_video_data", AsyncMock())
+ monkeypatch.setattr(svc, "get_tasks_by_workflow_run_id", AsyncMock(return_value=[]))
+
+ await svc.clean_up_workflow(workflow=workflow, workflow_run=workflow_run, need_call_webhook=False)
+
+ app.STORAGE.store_browser_profile.assert_not_awaited()
+ store_session_mock.assert_not_awaited()
@pytest.mark.asyncio