Skip to content

Automate browser based workflows with AI

Restrict member temporary cleanup to test-login credentials (#9004)

Aaron Perez0f23931b8784
diff --git a/alembic/versions/2026_10_22_1208-bbc28e00784e_add_a_marker_for_incomplete_passkey_setup.py b/alembic/versions/2026_10_22_1208-bbc28e00784e_add_a_marker_for_incomplete_passkey_setup.py
new file mode 100644
index 000000000..394e6e168
--- /dev/null
+++ b/alembic/versions/2026_10_22_1208-bbc28e00784e_add_a_marker_for_incomplete_passkey_setup.py
@@ -0,0 +1,29 @@
+"""add a marker for incomplete passkey setup
+
+Revision ID: bbc28e00784e
+Revises: dcbaab676398
+Create Date: 2026-10-22T12:08:44.264921+00:00
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "bbc28e00784e"
+down_revision: Union[str, None] = "dcbaab676398"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+ op.execute("SET LOCAL lock_timeout = '5s'")
+ op.add_column("credentials", sa.Column("is_passkey_setup_pending", sa.Boolean(), nullable=True))
+
+
+def downgrade() -> None:
+ op.execute("SET LOCAL lock_timeout = '5s'")
+ op.drop_column("credentials", "is_passkey_setup_pending")
diff --git a/alembic/versions/2026_10_22_1208-dcbaab676398_add_a_marker_for_temporary_test_login_credentials.py b/alembic/versions/2026_10_22_1208-dcbaab676398_add_a_marker_for_temporary_test_login_credentials.py
new file mode 100644
index 000000000..fdec31039
--- /dev/null
+++ b/alembic/versions/2026_10_22_1208-dcbaab676398_add_a_marker_for_temporary_test_login_credentials.py
@@ -0,0 +1,29 @@
+"""add a marker for temporary test-login credentials
+
+Revision ID: dcbaab676398
+Revises: 5112f44a9e61
+Create Date: 2026-10-22T12:08:44.262351+00:00
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "dcbaab676398"
+down_revision: Union[str, None] = "5112f44a9e61"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+ op.execute("SET LOCAL lock_timeout = '5s'")
+ op.add_column("credentials", sa.Column("is_test_login_temporary", sa.Boolean(), nullable=True))
+
+
+def downgrade() -> None:
+ op.execute("SET LOCAL lock_timeout = '5s'")
+ op.drop_column("credentials", "is_test_login_temporary")
diff --git a/skyvern-frontend/src/routes/credentials/CredentialsModal.test.tsx b/skyvern-frontend/src/routes/credentials/CredentialsModal.test.tsx
index 8c9ac7df9..a2f569fb0 100644
--- a/skyvern-frontend/src/routes/credentials/CredentialsModal.test.tsx
+++ b/skyvern-frontend/src/routes/credentials/CredentialsModal.test.tsx
@@ -12,6 +12,7 @@ import { AxiosError, AxiosHeaders } from "axios";
import { MemoryRouter } from "react-router-dom";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { getClient } from "@/api/AxiosClient";
import type { CredentialApiResponse } from "@/api/types";
import { PageSlotsProvider, type PermissionsState } from "@/store/PageSlots";
@@ -490,6 +491,8 @@ describe("CredentialsModal additional two-factor methods", () => {
expect.objectContaining({ credentialId: "cred-passkey" }),
);
});
+ expect(postMock.mock.calls[0]?.[0]).toBe("/credentials/passkey/setup");
+ expect(getClient).toHaveBeenNthCalledWith(1, null, "sans-api-v1");
await waitFor(() => {
expect(deleteMock.mock.calls.map(([path]) => path)).toEqual(
retry
diff --git a/skyvern-frontend/src/routes/credentials/CredentialsModal.tsx b/skyvern-frontend/src/routes/credentials/CredentialsModal.tsx
index 54c59d00c..563a58ca2 100644
--- a/skyvern-frontend/src/routes/credentials/CredentialsModal.tsx
+++ b/skyvern-frontend/src/routes/credentials/CredentialsModal.tsx
@@ -1045,8 +1045,17 @@ function CredentialsModal({
const createCredentialMutation = useMutation({
mutationFn: async (request: CreateCredentialRequest) => {
- const client = await getClient(credentialGetter);
- const response = await client.post("/credentials", request);
+ const isPasskeySetup =
+ "totp_type" in request.credential &&
+ request.credential.totp_type === "passkey";
+ const client = await getClient(
+ credentialGetter,
+ isPasskeySetup ? "sans-api-v1" : "v1",
+ );
+ const response = await client.post(
+ isPasskeySetup ? "/credentials/passkey/setup" : "/credentials",
+ request,
+ );
return response.data;
},
onSuccess: async (data) => {
@@ -1531,6 +1540,9 @@ function CredentialsModal({
isEditMode &&
Boolean(editingCredential?.credential_id) &&
selectedAdditionalTwoFactorMethod?.saveBeforeCredentialUpdate === true;
+ const createPendingPasskey =
+ !isEditMode &&
+ selectedAdditionalTwoFactorMethod?.requestType === "passkey";
saveIntentRef.current = {
shouldTestAfterSave:
supportsInlineTest &&
@@ -1585,12 +1597,13 @@ function CredentialsModal({
username,
...(preservesStoredPassword ? {} : { password }),
totp: selectedAdditionalTwoFactorMethod || totp === "" ? null : totp,
- // Stage "none" for methods that attach after the base update. Methods
- // that opt into attach-first keep their server-written type here.
- totp_type:
- selectedAdditionalTwoFactorMethod &&
- selectedAdditionalTwoFactorMethod.value !==
- configuredAdditionalTwoFactorMethod?.value
+ // Create passkeys through the dedicated setup route; other methods
+ // that attach after an edit stage "none" until their material is saved.
+ totp_type: createPendingPasskey
+ ? selectedAdditionalTwoFactorMethod.requestType
+ : selectedAdditionalTwoFactorMethod &&
+ selectedAdditionalTwoFactorMethod.value !==
+ configuredAdditionalTwoFactorMethod?.value
? saveAdditionalTwoFactorBeforeUpdate
? selectedAdditionalTwoFactorMethod.requestType
: "none"
diff --git a/skyvern/forge/sdk/db/models.py b/skyvern/forge/sdk/db/models.py
index 5a179065c..71404d0c5 100644
--- a/skyvern/forge/sdk/db/models.py
+++ b/skyvern/forge/sdk/db/models.py
@@ -2010,6 +2010,8 @@ class CredentialModel(Base):
proxy_session_id = Column(String, nullable=True)
folder_id = Column(String, ForeignKey("credential_folders.folder_id", ondelete="SET NULL"), nullable=True)
created_by = Column(String, nullable=True)
+ is_test_login_temporary = Column(Boolean, nullable=True)
+ is_passkey_setup_pending = Column(Boolean, 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)
diff --git a/skyvern/forge/sdk/db/repositories/credentials.py b/skyvern/forge/sdk/db/repositories/credentials.py
index bac449cd0..78b4ffa8a 100644
--- a/skyvern/forge/sdk/db/repositories/credentials.py
+++ b/skyvern/forge/sdk/db/repositories/credentials.py
@@ -20,6 +20,7 @@ from skyvern.forge.sdk.schemas.credentials import (
Credential,
CredentialType,
CredentialVaultType,
+ TotpType,
)
from skyvern.forge.sdk.schemas.organization_bitwarden_collections import OrganizationBitwardenCollection
from skyvern.schemas.proxy_pinning import generate_proxy_session_id, should_generate_proxy_session_id
@@ -82,6 +83,7 @@ class CredentialRepository(BaseRepository):
proxy_session_id: str | None = None,
created_by: str | None = None,
vault_id: str | None = None,
+ is_passkey_setup_pending: bool | None = None,
) -> Credential:
proxy_location, proxy_session_id = normalize_proxy_pin_for_create(
proxy_location=proxy_location,
@@ -107,6 +109,7 @@ class CredentialRepository(BaseRepository):
proxy_location=serialized_proxy_location,
proxy_session_id=proxy_session_id,
created_by=created_by,
+ is_passkey_setup_pending=is_passkey_setup_pending,
)
session.add(credential)
await session.flush()
@@ -561,6 +564,8 @@ class CredentialRepository(BaseRepository):
proxy_location: ProxyLocationInput | object = _UNSET,
proxy_session_id: str | None | object = _UNSET,
rotate_proxy_session_id: bool = False,
+ is_test_login_temporary: bool | None = None,
+ is_passkey_setup_pending: bool | None = None,
) -> Credential:
async with self.Session() as session:
credential = (
@@ -591,6 +596,10 @@ class CredentialRepository(BaseRepository):
credential.auto_profile_disabled = auto_profile_disabled
if run_sequentially is not None:
credential.run_sequentially = run_sequentially
+ if is_test_login_temporary is not None:
+ credential.is_test_login_temporary = is_test_login_temporary
+ if is_passkey_setup_pending is not None:
+ credential.is_passkey_setup_pending = is_passkey_setup_pending
apply_proxy_pin_to_model(
credential,
entity_id=credential_id,
@@ -683,6 +692,12 @@ class CredentialRepository(BaseRepository):
credential.credential_type = credential_type
credential.username = username
credential.totp_type = totp_type
+ if credential.is_test_login_temporary is True:
+ credential.is_test_login_temporary = False
+ if credential.is_passkey_setup_pending is True and (
+ credential_type != CredentialType.PASSWORD or totp_type != TotpType.PASSKEY
+ ):
+ credential.is_passkey_setup_pending = False
credential.totp_identifier = totp_identifier
if has_totp_seed is not None:
credential.has_totp_seed = has_totp_seed
diff --git a/skyvern/forge/sdk/routes/credentials.py b/skyvern/forge/sdk/routes/credentials.py
index 04f4b3810..d0181a4d7 100644
--- a/skyvern/forge/sdk/routes/credentials.py
+++ b/skyvern/forge/sdk/routes/credentials.py
@@ -45,7 +45,6 @@ from fastapi import BackgroundTasks, Body, Depends, Header, HTTPException, Path,
from onepassword.client import Client as OnePasswordClient
from onepassword.errors import DesktopSessionExpiredException, RateLimitExceededException
from onepassword.types import Item
-from sqlalchemy.exc import IntegrityError
from sqlalchemy.ext.asyncio import AsyncSession
from skyvern.config import settings
@@ -96,7 +95,6 @@ from skyvern.forge.sdk.schemas.credentials import (
CredentialTotpCodeResponse,
CredentialType,
CredentialVaultType,
- CreditCardCredentialResponse,
ImportOnePasswordCredentialsRequest,
ImportOnePasswordCredentialsResponse,
NonEmptyPasswordCredential,
@@ -105,10 +103,8 @@ from skyvern.forge.sdk.schemas.credentials import (
OnePasswordItemOverview,
OnePasswordItemsResponse,
PasswordCredential,
- PasswordCredentialResponse,
RefreshOnePasswordCredentialsRequest,
RefreshOnePasswordCredentialsResponse,
- SecretCredentialResponse,
TestCredentialRequest,
TestCredentialResponse,
TestCredentialStatusResponse,
@@ -144,9 +140,24 @@ from skyvern.forge.sdk.schemas.organizations import (
from skyvern.forge.sdk.schemas.totp_codes import OTPType, RawTOTPCodeAccepted, TOTPCode, TOTPCodeCreate
from skyvern.forge.sdk.services import org_auth_service
from skyvern.forge.sdk.services.bitwarden import BitwardenService
+from skyvern.forge.sdk.services.credential import credential_creation_service
+from skyvern.forge.sdk.services.credential.credential_creation_service import (
+ convert_to_response as _convert_to_response,
+)
+from skyvern.forge.sdk.services.credential.credential_creation_service import (
+ fetch_credential_item_background,
+)
+from skyvern.forge.sdk.services.credential.credential_creation_service import (
+ get_credential_vault_service as _get_credential_vault_service,
+)
+from skyvern.forge.sdk.services.credential.credential_creation_service import (
+ update_credential_or_profile_conflict as _update_credential_or_profile_conflict,
+)
+from skyvern.forge.sdk.services.credential.credential_creation_service import (
+ validate_credential_browser_profile_id as _validate_credential_browser_profile_id,
+)
from skyvern.forge.sdk.services.credential.credential_vault_service import CredentialVaultService
from skyvern.forge.sdk.services.credential.custom_credential_vault_service import (
- CustomCredentialConfigurationError,
CustomCredentialNotConfiguredError,
)
from skyvern.forge.sdk.services.credentials import (
@@ -160,7 +171,6 @@ from skyvern.forge.sdk.services.credentials import (
from skyvern.forge.sdk.services.onepassword_token_service import resolve_onepassword_token, to_status
from skyvern.forge.sdk.services.request_principal import RequestPrincipal, get_request_principal, synthetic_user_id
from skyvern.forge.sdk.services.route_authorization import require_request_actions
-from skyvern.forge.sdk.settings_manager import SettingsManager
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
@@ -487,19 +497,6 @@ def _cache_totp_code_preview(
)
-async def fetch_credential_item_background(item_id: str) -> None:
- """
- Background task to fetch the recently added credential item from Bitwarden.
- This triggers Bitwarden to sync the vault earlier so the next request does not have to wait for the sync.
- """
- try:
- LOG.info("Pre-fetching credential item from Bitwarden in background", item_id=item_id)
- credential_item = await BitwardenService.get_credential_item(item_id)
- LOG.info("Successfully fetched credential item from Bitwarden", item_id=item_id, name=credential_item.name)
- except Exception as e:
- LOG.exception("Failed to fetch credential item from Bitwarden in background", item_id=item_id, error=str(e))
-
-
@legacy_base_router.post(
"/totp",
responses={402: {"description": "Insufficient credits to parse OTP content"}},
@@ -782,51 +779,6 @@ async def get_totp_codes(
return codes[:limit]
-async def _validate_credential_browser_profile_id(
- browser_profile_id: str,
- organization_id: str,
- current_credential_id: str | None = None,
-) -> None:
- """A credential may only link a PLAIN, unowned profile from its own org: not a workflow-managed
- profile and not one another credential already owns (living credential profiles are auto-created,
- never hand-linked). Raises HTTP 400 otherwise."""
- profile = await app.DATABASE.browser_sessions.get_browser_profile(
- profile_id=browser_profile_id, organization_id=organization_id
- )
- if profile is None:
- raise HTTPException(
- status_code=400, detail=f"Browser profile not found, browser_profile_id={browser_profile_id}"
- )
- if profile.is_managed or profile.workflow_permanent_id is not None:
- raise HTTPException(
- status_code=400,
- detail="A credential can only link a plain browser profile, not a workflow-managed one.",
- )
- links_by_profile = await app.DATABASE.credentials.get_browser_profile_credential_links(
- {browser_profile_id}, organization_id
- )
- if any(
- credential_id != current_credential_id
- for credential_id, _folder_id in links_by_profile.get(browser_profile_id, [])
- ):
- raise HTTPException(
- status_code=400,
- detail="This browser profile is already linked to another credential.",
- )
-
-
-async def _update_credential_or_profile_conflict(**kwargs: Any) -> Credential:
- """Apply a credential update, translating the one-credential-per-profile unique-constraint violation
- — the atomic backstop when a concurrent link slips past the read-before-write ownership check — into
- the same 400 the read-check raises."""
- try:
- return await app.DATABASE.credentials.update_credential(**kwargs)
- except IntegrityError as exc:
- if "uq_credentials_browser_profile_id" in str(getattr(exc, "orig", exc)):
- raise HTTPException(status_code=400, detail="This browser profile is already linked to another credential.")
- raise
-
-
@legacy_base_router.post("/credentials")
@legacy_base_router.post("/credentials/", include_in_schema=False)
@base_router.post(
@@ -877,90 +829,16 @@ async def create_credential(
current_org: Organization = Depends(org_auth_service.get_current_org_for_credential_routes),
current_user_id: str | None = Depends(org_auth_service.get_current_user_id_or_none),
) -> CredentialResponse:
- credential_service = await prepare_credential_create(current_org.organization_id, data)
- credential = await store_new_credential(
- current_org.organization_id, data, current_user_id, credential_service, background_tasks
- )
- return _convert_to_response(credential)
-
-
-async def prepare_credential_create(organization_id: str, data: CreateCredentialRequest) -> CredentialVaultService:
- """Every check a create runs before it touches a vault; raising here means nothing was stored."""
if isinstance(data.credential, NonEmptyPasswordCredential):
await _normalize_authenticator_totp_for_organization_or_raise(
data.credential,
- organization_id=organization_id,
- )
-
- await app.AGENT_FUNCTION.validate_credential_write(
- organization_id=organization_id,
- credential_type=data.credential_type,
- credential=data.credential,
- existing_credential=None,
- )
-
- # Validate the profile link BEFORE provisioning, so an invalid/managed/cross-org/owned profile
- # rejects with a 400 without leaving an orphan credential (and vault secret) behind.
- if data.browser_profile_id is not None:
- await _validate_credential_browser_profile_id(data.browser_profile_id, organization_id)
-
- return await _get_credential_vault_service(
- vault_type_override=data.vault_type,
- organization_id=organization_id,
- )
-
-
-async def store_new_credential(
- organization_id: str,
- data: CreateCredentialRequest,
- created_by: str | None,
- credential_service: CredentialVaultService,
- background_tasks: BackgroundTasks,
-) -> Credential:
- try:
- credential = await credential_service.create_credential(
- organization_id=organization_id,
- data=data,
- created_by=created_by,
- )
- except SkyvernHttpException as e:
- detail = (
- f"Custom credential service returned {e.error_message}"
- if e.error_message
- else f"Custom credential service returned HTTP {e.status_code}"
- )
- raise HTTPException(status_code=502, detail=detail) from e
-
- await record_request_audit_event(organization_id, "credential.create", "credential", credential.credential_id)
- if credential.vault_type == CredentialVaultType.BITWARDEN:
- # Early resyncing the Bitwarden vault
- background_tasks.add_task(fetch_credential_item_background, credential.item_id)
-
- pin_provided = "pin_saved_session_ip" in data.model_fields_set
- bpid_provided = "browser_profile_id" in data.model_fields_set
- auto_profile_disabled_provided = "auto_profile_disabled" in data.model_fields_set
- if bpid_provided or pin_provided or auto_profile_disabled_provided:
- # Only pass browser_profile_id when the caller sent it, so a pin-only request never passes the
- # omitted default (None) into the repo's unlink sentinel.
- profile_update: dict[str, Any] = {"browser_profile_id": data.browser_profile_id} if bpid_provided else {}
- credential = await _update_credential_or_profile_conflict(
- credential_id=credential.credential_id,
- organization_id=organization_id,
- **profile_update,
- # Only touch the pin when the caller sent it — supplying a profile alone must not reset it.
- pin_saved_session_ip=data.pin_saved_session_ip if pin_provided else None,
- auto_profile_disabled=data.auto_profile_disabled if auto_profile_disabled_provided else None,
+ organization_id=current_org.organization_id,
)
-
- background_tasks.add_task(
- app.AGENT_FUNCTION.on_credential_saved,
- organization_id=organization_id,
- credential_id=credential.credential_id,
- credential_type=data.credential_type,
- actor_user_id=created_by,
- vault=credential.vault_type.value if credential.vault_type is not None else None,
+ credential_service = await credential_creation_service.prepare_credential_create(current_org.organization_id, data)
+ credential = await credential_creation_service.store_new_credential(
+ current_org.organization_id, data, current_user_id, credential_service, background_tasks
)
- return credential
+ return _convert_to_response(credential)
LOGIN_TEST_PROMPT = (
@@ -1088,8 +966,11 @@ async def rename_credential(
"credential_id": credential_id,
"organization_id": current_org.organization_id,
}
- if "name" in data.model_fields_set:
+ if data.name is not None:
update_kwargs["name"] = data.name
+ if credential.is_test_login_temporary is True:
+ # The modal saves an inline test-login credential by renaming it.
+ update_kwargs["is_test_login_temporary"] = False
if "browser_profile_id" in data.model_fields_set:
# Explicit null unlinks (user picked Auto after attaching a profile); a non-null value still
# validates plain/unowned before linking. Omitted leaves the existing link untouched.
@@ -1207,11 +1088,12 @@ async def test_login(
background_tasks.add_task(fetch_credential_item_background, credential.item_id)
credential_id = credential.credential_id
+ update_kwargs: dict[str, Any] = {
+ "credential_id": credential_id,
+ "organization_id": organization_id,
+ "is_test_login_temporary": True,
+ }
if "proxy_location" in data.model_fields_set or "proxy_session_id" in data.model_fields_set:
- update_kwargs: dict[str, Any] = {
- "credential_id": credential_id,
- "organization_id": organization_id,
- }
_apply_proxy_pin_update(
update_kwargs,
proxy_location_was_set="proxy_location" in data.model_fields_set,
@@ -1219,7 +1101,6 @@ async def test_login(
proxy_session_id_was_set="proxy_session_id" in data.model_fields_set,
proxy_session_id=data.proxy_session_id,
)
- credential = await app.DATABASE.credentials.update_credential(**update_kwargs)
LOG.info(
"Testing login with inline credentials",
@@ -1268,6 +1149,8 @@ async def test_login(
)
try:
+ # Mark before workflow setup so any member cleanup can only target this test-login row.
+ credential = await app.DATABASE.credentials.update_credential(**update_kwargs)
workflow = await app.WORKFLOW_SERVICE.create_workflow_from_request(
organization=current_org,
request=workflow_create_request,
@@ -2337,8 +2220,8 @@ TEMP_CREDENTIAL_CLEANUP_WINDOW = timedelta(hours=24)
@legacy_base_router.delete(
"/credentials/{credential_id}/temporary",
status_code=204,
- summary="Delete a recently created credential",
- description="Deletes only a credential created by the current user in the last 24 hours.",
+ summary="Delete a temporary credential",
+ description="Deletes a temporary test-login or incomplete passkey credential created by the current user in the last 24 hours.",
tags=["Credentials"],
include_in_schema=False,
)
@@ -2371,7 +2254,9 @@ async def delete_temporary_credential(
)
-def _is_recent_credential_created_by(credential: Credential, user_id: str) -> bool:
+def _is_recent_temporary_credential_created_by(credential: Credential, user_id: str) -> bool:
+ if credential.is_test_login_temporary is not True and credential.is_passkey_setup_pending is not True:
+ return False
created_at = to_naive_utc(credential.created_at)
if credential.created_by != user_id or created_at is None:
return False
@@ -2392,10 +2277,12 @@ async def delete_organization_credential(
)
if not credential:
raise HTTPException(status_code=404, detail=f"Credential not found, credential_id={credential_id}")
- if expected_created_by is not None and not _is_recent_credential_created_by(credential, expected_created_by):
+ if expected_created_by is not None and not _is_recent_temporary_credential_created_by(
+ credential, expected_created_by
+ ):
raise HTTPException(status_code=404, detail=f"Credential not found, credential_id={credential_id}")
- requires_write_lock = await app.AGENT_FUNCTION.should_lock_credential_write(
+ requires_write_lock = expected_created_by is not None or await app.AGENT_FUNCTION.should_lock_credential_write(
credential=None,
existing_credential=credential,
)
@@ -2412,7 +2299,7 @@ async def delete_organization_credential(
)
if not latest_credential:
raise HTTPException(status_code=404, detail=f"Credential not found, credential_id={credential_id}")
- if expected_created_by is not None and not _is_recent_credential_created_by(
+ if expected_created_by is not None and not _is_recent_temporary_credential_created_by(
latest_credential, expected_created_by
):
raise HTTPException(status_code=404, detail=f"Credential not found, credential_id={credential_id}")
@@ -2449,69 +2336,69 @@ async def delete_organization_credential(
vault_type=vault_type,
)
- # Reap the credential's living browser profile so deleting a credential doesn't silently orphan
- # its cookie-bearing archive (unbounded S3 growth). Kept if a live owner still references it. The
- # reap hard-deletes the profile's S3 archive (irreversible, version-purging), so it rides the engine
- # kill-switch: flag-off orgs never lose a saved profile on credential delete (v1 has no unlink to
- # recover with), and a rollback disables it.
- profile_id = credential.browser_profile_id
- if profile_id and await app.AGENT_FUNCTION.is_browser_memory_engine_enabled_for_org(organization_id):
- try:
- # Narrow accepted race: a concurrent re-link between this check and the delete below.
- if await app.DATABASE.browser_sessions.has_live_browser_profile_references(
- profile_id=profile_id,
- organization_id=organization_id,
- exclude_credential_id=credential_id,
- ):
- LOG.info(
- "browser_memory.credential_profile_kept",
- organization_id=organization_id,
- credential_id=credential_id,
- browser_profile_id=profile_id,
- )
- else:
- # Erase the S3 archive first (idempotent, version-purging) so cookies are gone even if
- # the DB row was already soft-deleted; then soft-delete the row for bookkeeping.
- await app.STORAGE.delete_browser_profile(
- organization_id=organization_id,
+ # Reap the credential's living browser profile so deleting a credential doesn't silently orphan
+ # its cookie-bearing archive (unbounded S3 growth). Kept if a live owner still references it. The
+ # reap hard-deletes the profile's S3 archive (irreversible, version-purging), so it rides the engine
+ # kill-switch: flag-off orgs never lose a saved profile on credential delete (v1 has no unlink to
+ # recover with), and a rollback disables it.
+ profile_id = credential.browser_profile_id
+ if profile_id and await app.AGENT_FUNCTION.is_browser_memory_engine_enabled_for_org(organization_id):
+ try:
+ # Narrow accepted race: a concurrent re-link between this check and the delete below.
+ if await app.DATABASE.browser_sessions.has_live_browser_profile_references(
profile_id=profile_id,
- hard_delete=True,
- )
- try:
- await app.DATABASE.browser_sessions.delete_browser_profile(
- profile_id=profile_id,
+ organization_id=organization_id,
+ exclude_credential_id=credential_id,
+ ):
+ LOG.info(
+ "browser_memory.credential_profile_kept",
+ organization_id=organization_id,
+ credential_id=credential_id,
+ browser_profile_id=profile_id,
+ )
+ else:
+ # Erase the S3 archive first (idempotent, version-purging) so cookies are gone even if
+ # the DB row was already soft-deleted; then soft-delete the row for bookkeeping.
+ await app.STORAGE.delete_browser_profile(
organization_id=organization_id,
+ profile_id=profile_id,
+ hard_delete=True,
)
- except BrowserProfileNotFound:
- pass
- except Exception:
- # Erasure already succeeded; only the row soft-delete failed, leaving the row
- # alive with its blob gone. Log distinctly (not reap_failed) — the stale-memory
- # sweep reaps such rows.
- LOG.exception(
- "browser_memory.credential_profile_row_delete_failed",
+ try:
+ await app.DATABASE.browser_sessions.delete_browser_profile(
+ profile_id=profile_id,
+ organization_id=organization_id,
+ )
+ except BrowserProfileNotFound:
+ pass
+ except Exception:
+ # Erasure already succeeded; only the row soft-delete failed, leaving the row
+ # alive with its blob gone. Log distinctly (not reap_failed) — the stale-memory
+ # sweep reaps such rows.
+ LOG.exception(
+ "browser_memory.credential_profile_row_delete_failed",
+ organization_id=organization_id,
+ credential_id=credential_id,
+ browser_profile_id=profile_id,
+ )
+ LOG.info(
+ "browser_memory.credential_profile_reaped",
organization_id=organization_id,
credential_id=credential_id,
browser_profile_id=profile_id,
)
- LOG.info(
- "browser_memory.credential_profile_reaped",
+ except Exception as exc:
+ # The reap did not complete (typically the S3 hard-delete raised): the cookie-bearing archive
+ # is RETAINED and the row is left alive (the soft-delete runs only after a successful erase),
+ # so it stays discoverable for the stale-memory sweep. Never fail the user-facing delete for
+ # this (204 stands) — but log LOUD + alertable so the retained archive is not silently orphaned.
+ LOG.exception(
+ "browser_memory.credential_profile_reap_failed",
organization_id=organization_id,
credential_id=credential_id,
browser_profile_id=profile_id,
+ error=str(exc),
)
- except Exception as exc:
- # The reap did not complete (typically the S3 hard-delete raised): the cookie-bearing archive
- # is RETAINED and the row is left alive (the soft-delete runs only after a successful erase),
- # so it stays discoverable for the stale-memory sweep. Never fail the user-facing delete for
- # this (204 stands) — but log LOUD + alertable so the retained archive is not silently orphaned.
- LOG.exception(
- "browser_memory.credential_profile_reap_failed",
- organization_id=organization_id,
- credential_id=credential_id,
- browser_profile_id=profile_id,
- error=str(exc),
- )
_clear_cached_totp_code_preview(organization_id=organization_id, credential_id=credential_id)
await record_request_audit_event(
@@ -4448,53 +4335,6 @@ async def test_custom_credential_service_connection(
) from e
-async def _get_credential_vault_service(
- vault_type_override: CredentialVaultType | None = None,
- organization_id: str | None = None,
-) -> CredentialVaultService:
- """Resolve the vault service for a request.
-
- Callers about to write a secret pass ``organization_id`` so a vault configured per organization
- is preflighted here and an unusable configuration is refused before the write is attempted.
- """
- settings = SettingsManager.get_settings()
- vault_type = vault_type_override or settings.CREDENTIAL_VAULT_TYPE
- service: CredentialVaultService
- if vault_type == CredentialVaultType.SKYVERN:
- if not settings.is_local_credential_vault_enabled():
- raise HTTPException(status_code=400, detail="Skyvern local credential vault is not enabled")
- if not app.SKYVERN_CREDENTIAL_VAULT_SERVICE:
- raise HTTPException(status_code=400, detail="Skyvern local credential vault is not configured")
- service = app.SKYVERN_CREDENTIAL_VAULT_SERVICE
- elif vault_type == CredentialVaultType.BITWARDEN:
- service = app.BITWARDEN_CREDENTIAL_VAULT_SERVICE
- elif vault_type == CredentialVaultType.AZURE_VAULT:
- if not app.AZURE_CREDENTIAL_VAULT_SERVICE:
- raise HTTPException(status_code=400, detail="Azure Vault credential is not supported")
- service = app.AZURE_CREDENTIAL_VAULT_SERVICE
- elif vault_type == CredentialVaultType.GCP:
- if not app.GCP_CREDENTIAL_VAULT_SERVICE:
- raise HTTPException(status_code=400, detail="GCP credential vault is not supported")
- service = app.GCP_CREDENTIAL_VAULT_SERVICE
- elif vault_type == CredentialVaultType.CUSTOM:
- if not app.CUSTOM_CREDENTIAL_VAULT_SERVICE:
- raise HTTPException(status_code=400, detail="Custom credential vault is not supported")
- service = app.CUSTOM_CREDENTIAL_VAULT_SERVICE
- elif vault_type == CredentialVaultType.ONEPASSWORD:
- service = app.ONEPASSWORD_CREDENTIAL_VAULT_SERVICE
- else:
- raise HTTPException(status_code=400, detail="Credential storage not supported")
-
- if organization_id is not None:
- try:
- await service.validate_organization_configuration(organization_id)
- except CustomCredentialConfigurationError as e:
- # Already reported by the vault service; re-logging here would double-count.
- raise HTTPException(status_code=400, detail=str(e)) from e
-
- return service
-
-
async def _delete_temporary_test_login_credential(
*,
credential_id: str,
@@ -4517,94 +4357,3 @@ async def _delete_temporary_test_login_credential(
organization_id=organization_id,
reason=reason,
)
-
-
-def _convert_to_response(credential: Credential) -> CredentialResponse:
- """Convert an internal ``Credential`` to a safe API response.
-
- SECURITY: This function must ONLY copy non-sensitive metadata into the
- response. Never include passwords, TOTP secrets, full card numbers, CVVs,
- expiration dates, card holder names, credit card billing/contact fields,
- credit card metadata, or secret values. See the module
- docstring for the full security invariant.
- """
- is_onepassword = credential.vault_type == CredentialVaultType.ONEPASSWORD
- if credential.credential_type == CredentialType.PASSWORD:
- credential_response = PasswordCredentialResponse(
- username=credential.username or credential.credential_id,
- totp_type=credential.totp_type,
- totp_identifier=credential.totp_identifier,
- has_totp=bool(credential.has_totp_seed),
- )
- return CredentialResponse(
- credential=credential_response,
- credential_id=credential.credential_id,
- credential_type=credential.credential_type,
- name=credential.name,
- vault_type=credential.vault_type,
- vault_id=credential.vault_id if is_onepassword else None,
- item_id=credential.item_id if is_onepassword else None,
- upstream_missing_at=credential.upstream_missing_at if is_onepassword else None,
- browser_profile_id=credential.browser_profile_id,
- auto_profile_disabled=credential.auto_profile_disabled,
- pin_saved_session_ip=credential.pin_saved_session_ip,
- tested_url=credential.tested_url,
- user_context=credential.user_context,
- save_browser_session_intent=credential.save_browser_session_intent,
- run_sequentially=credential.run_sequentially,
- folder_id=credential.folder_id,
- proxy_location=credential.proxy_location,
- proxy_session_id=credential.proxy_session_id,
- created_by=credential.created_by,
- )
- elif credential.credential_type == CredentialType.CREDIT_CARD:
- credential_response = CreditCardCredentialResponse(
- last_four=credential.card_last4 or "****",
- brand=credential.card_brand or "Card Brand",
- )
- return CredentialResponse(
- credential=credential_response,
- credential_id=credential.credential_id,
- credential_type=credential.credential_type,
- name=credential.name,
- vault_type=credential.vault_type,
- vault_id=credential.vault_id if is_onepassword else None,
- item_id=credential.item_id if is_onepassword else None,
- upstream_missing_at=credential.upstream_missing_at if is_onepassword else None,
- browser_profile_id=credential.browser_profile_id,
- auto_profile_disabled=credential.auto_profile_disabled,
- pin_saved_session_ip=credential.pin_saved_session_ip,
- tested_url=credential.tested_url,
- user_context=credential.user_context,
- save_browser_session_intent=credential.save_browser_session_intent,
- run_sequentially=credential.run_sequentially,
- folder_id=credential.folder_id,
- proxy_location=credential.proxy_location,
- proxy_session_id=credential.proxy_session_id,
- created_by=credential.created_by,
- )
- elif credential.credential_type == CredentialType.SECRET:
- credential_response = SecretCredentialResponse(secret_label=credential.secret_label)
- return CredentialResponse(
- credential=credential_response,
- credential_id=credential.credential_id,
- credential_type=credential.credential_type,
- name=credential.name,
- vault_type=credential.vault_type,
- vault_id=credential.vault_id if is_onepassword else None,
- item_id=credential.item_id if is_onepassword else None,
- upstream_missing_at=credential.upstream_missing_at if is_onepassword else None,
- browser_profile_id=credential.browser_profile_id,
- auto_profile_disabled=credential.auto_profile_disabled,
- pin_saved_session_ip=credential.pin_saved_session_ip,
- tested_url=credential.tested_url,
- user_context=credential.user_context,
- save_browser_session_intent=credential.save_browser_session_intent,
- run_sequentially=credential.run_sequentially,
- folder_id=credential.folder_id,
- proxy_location=credential.proxy_location,
- proxy_session_id=credential.proxy_session_id,
- created_by=credential.created_by,
- )
- else:
- raise HTTPException(status_code=400, detail="Credential type not supported")
diff --git a/skyvern/forge/sdk/routes/workflow_copilot.py b/skyvern/forge/sdk/routes/workflow_copilot.py
index 07357b7fc..75c0414dc 100644
--- a/skyvern/forge/sdk/routes/workflow_copilot.py
+++ b/skyvern/forge/sdk/routes/workflow_copilot.py
@@ -169,11 +169,7 @@ from skyvern.forge.sdk.routes.browser_profiles import (
_hard_delete_created_profile_after_store_failure,
create_profile_from_running_session,
)
-from skyvern.forge.sdk.routes.credentials import (
- delete_organization_credential,
- prepare_credential_create,
- store_new_credential,
-)
+from skyvern.forge.sdk.routes.credentials import delete_organization_credential
from skyvern.forge.sdk.routes.routers import base_router
from skyvern.forge.sdk.schemas.copilot_turn_outcome import PersistedCopilotComposerMode, ResponseKind, TurnOutcome
from skyvern.forge.sdk.schemas.credentials import (
@@ -236,6 +232,10 @@ from skyvern.forge.sdk.schemas.workflow_copilot import (
copilot_proposal_metadata,
)
from skyvern.forge.sdk.services import org_auth_service
+from skyvern.forge.sdk.services.credential.credential_creation_service import (
+ prepare_credential_create,
+ store_new_credential,
+)
from skyvern.forge.sdk.services.credential.credential_vault_service import CredentialVaultService
from skyvern.forge.sdk.services.request_principal import get_request_principal
from skyvern.forge.sdk.services.route_authorization import require_request_actions
diff --git a/skyvern/forge/sdk/schemas/credentials.py b/skyvern/forge/sdk/schemas/credentials.py
index a1fb7af5e..7d28a12b1 100644
--- a/skyvern/forge/sdk/schemas/credentials.py
+++ b/skyvern/forge/sdk/schemas/credentials.py
@@ -497,6 +497,8 @@ class Credential(BaseModel):
default=None,
description="ID of the credential folder this credential belongs to, if any",
)
+ is_test_login_temporary: bool | None = Field(default=None, exclude=True)
+ is_passkey_setup_pending: bool | None = Field(default=None, exclude=True)
proxy_location: ProxyLocationInput = Field(
default=None,
description="Optional proxy location used for the credential's pinned proxy identity.",
diff --git a/skyvern/forge/sdk/services/credential/azure_credential_vault_service.py b/skyvern/forge/sdk/services/credential/azure_credential_vault_service.py
index 08af0a709..6ad01bb9d 100644
--- a/skyvern/forge/sdk/services/credential/azure_credential_vault_service.py
+++ b/skyvern/forge/sdk/services/credential/azure_credential_vault_service.py
@@ -63,6 +63,7 @@ class AzureCredentialVaultService(CredentialVaultService):
organization_id: str,
data: CreateCredentialRequest,
created_by: str | None = None,
+ is_passkey_setup_pending: bool = False,
) -> Credential:
item_id = await self._create_azure_secret_item(
organization_id=organization_id,
@@ -75,6 +76,7 @@ class AzureCredentialVaultService(CredentialVaultService):
item_id=item_id,
vault_type=CredentialVaultType.AZURE_VAULT,
created_by=created_by,
+ is_passkey_setup_pending=is_passkey_setup_pending,
)
return credential
diff --git a/skyvern/forge/sdk/services/credential/bitwarden_credential_service.py b/skyvern/forge/sdk/services/credential/bitwarden_credential_service.py
index 197163002..5465697a9 100644
--- a/skyvern/forge/sdk/services/credential/bitwarden_credential_service.py
+++ b/skyvern/forge/sdk/services/credential/bitwarden_credential_service.py
@@ -24,6 +24,7 @@ class BitwardenCredentialVaultService(CredentialVaultService):
organization_id: str,
data: CreateCredentialRequest,
created_by: str | None = None,
+ is_passkey_setup_pending: bool = False,
) -> Credential:
org_collection = await app.DATABASE.credentials.get_organization_bitwarden_collection(organization_id)
@@ -52,6 +53,7 @@ class BitwardenCredentialVaultService(CredentialVaultService):
item_id=item_id,
vault_type=CredentialVaultType.BITWARDEN,
created_by=created_by,
+ is_passkey_setup_pending=is_passkey_setup_pending,
)
return credential
diff --git a/skyvern/forge/sdk/services/credential/credential_creation_service.py b/skyvern/forge/sdk/services/credential/credential_creation_service.py
new file mode 100644
index 000000000..b4c22b2c3
--- /dev/null
+++ b/skyvern/forge/sdk/services/credential/credential_creation_service.py
@@ -0,0 +1,294 @@
+from __future__ import annotations
+
+from typing import Any
+
+import structlog
+from fastapi import BackgroundTasks, HTTPException
+from sqlalchemy.exc import IntegrityError
+
+from skyvern.exceptions import HttpException as SkyvernHttpException
+from skyvern.forge import app
+from skyvern.forge.agent_functions import record_request_audit_event
+from skyvern.forge.sdk.schemas.credentials import (
+ CreateCredentialRequest,
+ Credential,
+ CredentialResponse,
+ CredentialType,
+ CredentialVaultType,
+ CreditCardCredentialResponse,
+ NonEmptyPasswordCredential,
+ PasswordCredentialResponse,
+ SecretCredentialResponse,
+ TotpType,
+)
+from skyvern.forge.sdk.services.bitwarden import BitwardenService
+from skyvern.forge.sdk.services.credential.credential_vault_service import CredentialVaultService
+from skyvern.forge.sdk.services.credential.custom_credential_vault_service import CustomCredentialConfigurationError
+from skyvern.forge.sdk.settings_manager import SettingsManager
+
+LOG = structlog.get_logger()
+
+
+async def fetch_credential_item_background(item_id: str) -> None:
+ """Fetch a new Bitwarden item early so the next request does not wait for vault sync."""
+ try:
+ LOG.info("Pre-fetching credential item from Bitwarden in background", item_id=item_id)
+ credential_item = await BitwardenService.get_credential_item(item_id)
+ LOG.info("Successfully fetched credential item from Bitwarden", item_id=item_id, name=credential_item.name)
+ except Exception as e:
+ LOG.exception("Failed to fetch credential item from Bitwarden in background", item_id=item_id, error=str(e))
+
+
+async def validate_credential_browser_profile_id(
+ browser_profile_id: str,
+ organization_id: str,
+ current_credential_id: str | None = None,
+) -> None:
+ """Only allow linking an unowned, unmanaged profile from the same organization."""
+ profile = await app.DATABASE.browser_sessions.get_browser_profile(
+ profile_id=browser_profile_id, organization_id=organization_id
+ )
+ if profile is None:
+ raise HTTPException(
+ status_code=400, detail=f"Browser profile not found, browser_profile_id={browser_profile_id}"
+ )
+ if profile.is_managed or profile.workflow_permanent_id is not None:
+ raise HTTPException(
+ status_code=400,
+ detail="A credential can only link a plain browser profile, not a workflow-managed one.",
+ )
+ links_by_profile = await app.DATABASE.credentials.get_browser_profile_credential_links(
+ {browser_profile_id}, organization_id
+ )
+ if any(
+ credential_id != current_credential_id
+ for credential_id, _folder_id in links_by_profile.get(browser_profile_id, [])
+ ):
+ raise HTTPException(status_code=400, detail="This browser profile is already linked to another credential.")
+
+
+async def update_credential_or_profile_conflict(**kwargs: Any) -> Credential:
+ """Translate the profile-link unique constraint into the same 400 as the pre-write check."""
+ try:
+ return await app.DATABASE.credentials.update_credential(**kwargs)
+ except IntegrityError as exc:
+ if "uq_credentials_browser_profile_id" in str(getattr(exc, "orig", exc)):
+ raise HTTPException(status_code=400, detail="This browser profile is already linked to another credential.")
+ raise
+
+
+async def get_credential_vault_service(
+ vault_type_override: CredentialVaultType | None = None,
+ organization_id: str | None = None,
+) -> CredentialVaultService:
+ """Resolve and, when writing, preflight the configured vault service."""
+ settings = SettingsManager.get_settings()
+ vault_type = vault_type_override or settings.CREDENTIAL_VAULT_TYPE
+ service: CredentialVaultService
+ if vault_type == CredentialVaultType.SKYVERN:
+ if not settings.is_local_credential_vault_enabled():
+ raise HTTPException(status_code=400, detail="Skyvern local credential vault is not enabled")
+ if not app.SKYVERN_CREDENTIAL_VAULT_SERVICE:
+ raise HTTPException(status_code=400, detail="Skyvern local credential vault is not configured")
+ service = app.SKYVERN_CREDENTIAL_VAULT_SERVICE
+ elif vault_type == CredentialVaultType.BITWARDEN:
+ service = app.BITWARDEN_CREDENTIAL_VAULT_SERVICE
+ elif vault_type == CredentialVaultType.AZURE_VAULT:
+ if not app.AZURE_CREDENTIAL_VAULT_SERVICE:
+ raise HTTPException(status_code=400, detail="Azure Vault credential is not supported")
+ service = app.AZURE_CREDENTIAL_VAULT_SERVICE
+ elif vault_type == CredentialVaultType.GCP:
+ if not app.GCP_CREDENTIAL_VAULT_SERVICE:
+ raise HTTPException(status_code=400, detail="GCP credential vault is not supported")
+ service = app.GCP_CREDENTIAL_VAULT_SERVICE
+ elif vault_type == CredentialVaultType.CUSTOM:
+ if not app.CUSTOM_CREDENTIAL_VAULT_SERVICE:
+ raise HTTPException(status_code=400, detail="Custom credential vault is not configured")
+ service = app.CUSTOM_CREDENTIAL_VAULT_SERVICE
+ elif vault_type == CredentialVaultType.ONEPASSWORD:
+ service = app.ONEPASSWORD_CREDENTIAL_VAULT_SERVICE
+ else:
+ raise HTTPException(status_code=400, detail="Credential storage not supported")
+
+ if organization_id is not None:
+ try:
+ await service.validate_organization_configuration(organization_id)
+ except CustomCredentialConfigurationError as e:
+ # The vault service already reported this error; avoid double-counting it.
+ raise HTTPException(status_code=400, detail=str(e)) from e
+ return service
+
+
+async def prepare_credential_create(
+ organization_id: str,
+ data: CreateCredentialRequest,
+ *,
+ is_passkey_setup_pending: bool = False,
+) -> CredentialVaultService:
+ """Validate a create before it touches a vault and resolve its service."""
+ is_passkey_setup = (
+ data.credential_type == CredentialType.PASSWORD
+ and isinstance(data.credential, NonEmptyPasswordCredential)
+ and data.credential.totp_type == TotpType.PASSKEY
+ )
+ if is_passkey_setup != is_passkey_setup_pending:
+ raise HTTPException(status_code=400, detail="Passkey credentials must use the passkey setup route")
+
+ await app.AGENT_FUNCTION.validate_credential_write(
+ organization_id=organization_id,
+ credential_type=data.credential_type,
+ credential=data.credential,
+ existing_credential=None,
+ )
+ if data.browser_profile_id is not None:
+ await validate_credential_browser_profile_id(data.browser_profile_id, organization_id)
+ return await get_credential_vault_service(
+ vault_type_override=data.vault_type,
+ organization_id=organization_id,
+ )
+
+
+async def store_new_credential(
+ organization_id: str,
+ data: CreateCredentialRequest,
+ created_by: str | None,
+ credential_service: CredentialVaultService,
+ background_tasks: BackgroundTasks,
+ *,
+ is_passkey_setup_pending: bool = False,
+) -> Credential:
+ try:
+ if is_passkey_setup_pending:
+ credential = await credential_service.create_credential(
+ organization_id=organization_id,
+ data=data,
+ created_by=created_by,
+ is_passkey_setup_pending=True,
+ )
+ else:
+ credential = await credential_service.create_credential(
+ organization_id=organization_id,
+ data=data,
+ created_by=created_by,
+ )
+ except SkyvernHttpException as e:
+ detail = (
+ f"Custom credential service returned {e.error_message}"
+ if e.error_message
+ else f"Custom credential service returned HTTP {e.status_code}"
+ )
+ raise HTTPException(status_code=502, detail=detail) from e
+
+ await record_request_audit_event(organization_id, "credential.create", "credential", credential.credential_id)
+ if credential.vault_type == CredentialVaultType.BITWARDEN:
+ background_tasks.add_task(fetch_credential_item_background, credential.item_id)
+
+ pin_provided = "pin_saved_session_ip" in data.model_fields_set
+ bpid_provided = "browser_profile_id" in data.model_fields_set
+ auto_profile_disabled_provided = "auto_profile_disabled" in data.model_fields_set
+ if bpid_provided or pin_provided or auto_profile_disabled_provided:
+ profile_update: dict[str, Any] = {"browser_profile_id": data.browser_profile_id} if bpid_provided else {}
+ credential = await update_credential_or_profile_conflict(
+ credential_id=credential.credential_id,
+ organization_id=organization_id,
+ **profile_update,
+ pin_saved_session_ip=data.pin_saved_session_ip if pin_provided else None,
+ auto_profile_disabled=data.auto_profile_disabled if auto_profile_disabled_provided else None,
+ )
+
+ background_tasks.add_task(
+ app.AGENT_FUNCTION.on_credential_saved,
+ organization_id=organization_id,
+ credential_id=credential.credential_id,
+ credential_type=data.credential_type,
+ actor_user_id=created_by,
+ vault=credential.vault_type.value if credential.vault_type is not None else None,
+ )
+ return credential
+
+
+def convert_to_response(credential: Credential) -> CredentialResponse:
+ """Convert an internal ``Credential`` to a safe API response.
+
+ SECURITY: Copy only non-sensitive metadata. Never include passwords, TOTP secrets, full card numbers, CVVs,
+ expiration dates, card holder names, credit card billing/contact fields, credit card metadata, or secret values.
+ See the route module docstring for the full security invariant.
+ """
+ is_onepassword = credential.vault_type == CredentialVaultType.ONEPASSWORD
+ if credential.credential_type == CredentialType.PASSWORD:
+ credential_response = PasswordCredentialResponse(
+ username=credential.username or credential.credential_id,
+ totp_type=credential.totp_type,
+ totp_identifier=credential.totp_identifier,
+ has_totp=bool(credential.has_totp_seed),
+ )
+ return CredentialResponse(
+ credential=credential_response,
+ credential_id=credential.credential_id,
+ credential_type=credential.credential_type,
+ name=credential.name,
+ vault_type=credential.vault_type,
+ vault_id=credential.vault_id if is_onepassword else None,
+ item_id=credential.item_id if is_onepassword else None,
+ upstream_missing_at=credential.upstream_missing_at if is_onepassword else None,
+ browser_profile_id=credential.browser_profile_id,
+ auto_profile_disabled=credential.auto_profile_disabled,
+ pin_saved_session_ip=credential.pin_saved_session_ip,
+ tested_url=credential.tested_url,
+ user_context=credential.user_context,
+ save_browser_session_intent=credential.save_browser_session_intent,
+ run_sequentially=credential.run_sequentially,
+ folder_id=credential.folder_id,
+ proxy_location=credential.proxy_location,
+ proxy_session_id=credential.proxy_session_id,
+ created_by=credential.created_by,
+ )
+ if credential.credential_type == CredentialType.CREDIT_CARD:
+ credential_response = CreditCardCredentialResponse(
+ last_four=credential.card_last4 or "****",
+ brand=credential.card_brand or "Card Brand",
+ )
+ return CredentialResponse(
+ credential=credential_response,
+ credential_id=credential.credential_id,
+ credential_type=credential.credential_type,
+ name=credential.name,
+ vault_type=credential.vault_type,
+ vault_id=credential.vault_id if is_onepassword else None,
+ item_id=credential.item_id if is_onepassword else None,
+ upstream_missing_at=credential.upstream_missing_at if is_onepassword else None,
+ browser_profile_id=credential.browser_profile_id,
+ auto_profile_disabled=credential.auto_profile_disabled,
+ pin_saved_session_ip=credential.pin_saved_session_ip,
+ tested_url=credential.tested_url,
+ user_context=credential.user_context,
+ save_browser_session_intent=credential.save_browser_session_intent,
+ run_sequentially=credential.run_sequentially,
+ folder_id=credential.folder_id,
+ proxy_location=credential.proxy_location,
+ proxy_session_id=credential.proxy_session_id,
+ created_by=credential.created_by,
+ )
+ if credential.credential_type == CredentialType.SECRET:
+ return CredentialResponse(
+ credential=SecretCredentialResponse(secret_label=credential.secret_label),
+ credential_id=credential.credential_id,
+ credential_type=credential.credential_type,
+ name=credential.name,
+ vault_type=credential.vault_type,
+ vault_id=credential.vault_id if is_onepassword else None,
+ item_id=credential.item_id if is_onepassword else None,
+ upstream_missing_at=credential.upstream_missing_at if is_onepassword else None,
+ browser_profile_id=credential.browser_profile_id,
+ auto_profile_disabled=credential.auto_profile_disabled,
+ pin_saved_session_ip=credential.pin_saved_session_ip,
+ tested_url=credential.tested_url,
+ user_context=credential.user_context,
+ save_browser_session_intent=credential.save_browser_session_intent,
+ run_sequentially=credential.run_sequentially,
+ folder_id=credential.folder_id,
+ proxy_location=credential.proxy_location,
+ proxy_session_id=credential.proxy_session_id,
+ created_by=credential.created_by,
+ )
+ raise HTTPException(status_code=400, detail="Credential type not supported")
diff --git a/skyvern/forge/sdk/services/credential/credential_vault_service.py b/skyvern/forge/sdk/services/credential/credential_vault_service.py
index a1e7f45ee..75f438737 100644
--- a/skyvern/forge/sdk/services/credential/credential_vault_service.py
+++ b/skyvern/forge/sdk/services/credential/credential_vault_service.py
@@ -15,6 +15,7 @@ from skyvern.forge.sdk.schemas.credentials import (
CreditCardBillingAddress,
CreditCardCredential,
PasswordCredential,
+ TotpType,
)
LOG = structlog.get_logger()
@@ -44,6 +45,7 @@ class CredentialVaultService(ABC):
organization_id: str,
data: CreateCredentialRequest,
created_by: str | None = None,
+ is_passkey_setup_pending: bool = False,
) -> Credential:
"""Create a new credential in the vault and database."""
@@ -269,6 +271,7 @@ class CredentialVaultService(ABC):
item_id: str,
vault_type: CredentialVaultType,
created_by: str | None = None,
+ is_passkey_setup_pending: bool = False,
) -> Credential:
if data.credential_type == CredentialType.PASSWORD:
return await app.DATABASE.credentials.create_credential(
@@ -287,6 +290,9 @@ class CredentialVaultService(ABC):
proxy_location=data.proxy_location,
proxy_session_id=data.proxy_session_id,
created_by=created_by,
+ is_passkey_setup_pending=(
+ True if is_passkey_setup_pending and data.credential.totp_type == TotpType.PASSKEY else None
+ ),
)
elif data.credential_type == CredentialType.CREDIT_CARD:
return await app.DATABASE.credentials.create_credential(
diff --git a/skyvern/forge/sdk/services/credential/custom_credential_vault_service.py b/skyvern/forge/sdk/services/credential/custom_credential_vault_service.py
index 64e846b81..188db95e6 100644
--- a/skyvern/forge/sdk/services/credential/custom_credential_vault_service.py
+++ b/skyvern/forge/sdk/services/credential/custom_credential_vault_service.py
@@ -131,6 +131,7 @@ class CustomCredentialVaultService(CredentialVaultService):
organization_id: str,
data: CreateCredentialRequest,
created_by: str | None = None,
+ is_passkey_setup_pending: bool = False,
) -> Credential:
"""
Create a new credential in the custom vault and database.
@@ -167,6 +168,7 @@ class CustomCredentialVaultService(CredentialVaultService):
item_id=item_id,
vault_type=CredentialVaultType.CUSTOM,
created_by=created_by,
+ is_passkey_setup_pending=is_passkey_setup_pending,
)
except Exception:
# Attempt to clean up the external credential
diff --git a/skyvern/forge/sdk/services/credential/gcp_credential_vault_service.py b/skyvern/forge/sdk/services/credential/gcp_credential_vault_service.py
index 357d7eaf1..9978153d4 100644
--- a/skyvern/forge/sdk/services/credential/gcp_credential_vault_service.py
+++ b/skyvern/forge/sdk/services/credential/gcp_credential_vault_service.py
@@ -73,6 +73,7 @@ class GcpCredentialVaultService(CredentialVaultService):
organization_id: str,
data: CreateCredentialRequest,
created_by: str | None = None,
+ is_passkey_setup_pending: bool = False,
) -> Credential:
item_id = await self._create_gcp_secret_item(
organization_id=organization_id,
@@ -85,6 +86,7 @@ class GcpCredentialVaultService(CredentialVaultService):
item_id=item_id,
vault_type=CredentialVaultType.GCP,
created_by=created_by,
+ is_passkey_setup_pending=is_passkey_setup_pending,
)
return credential
diff --git a/skyvern/forge/sdk/services/credential/onepassword_credential_vault_service.py b/skyvern/forge/sdk/services/credential/onepassword_credential_vault_service.py
index dee93d1a5..657d1a071 100644
--- a/skyvern/forge/sdk/services/credential/onepassword_credential_vault_service.py
+++ b/skyvern/forge/sdk/services/credential/onepassword_credential_vault_service.py
@@ -114,6 +114,7 @@ class OnePasswordCredentialVaultService(CredentialVaultService):
organization_id: str,
data: CreateCredentialRequest,
created_by: str | None = None,
+ is_passkey_setup_pending: bool = False,
) -> Credential:
raise HTTPException(status_code=405, detail="Creating 1Password-backed credentials is not supported")
diff --git a/skyvern/forge/sdk/services/credential/skyvern_credential_vault_service.py b/skyvern/forge/sdk/services/credential/skyvern_credential_vault_service.py
index 663a36584..f668cd26f 100644
--- a/skyvern/forge/sdk/services/credential/skyvern_credential_vault_service.py
+++ b/skyvern/forge/sdk/services/credential/skyvern_credential_vault_service.py
@@ -39,6 +39,7 @@ class SkyvernCredentialVaultService(CredentialVaultService):
organization_id: str,
data: CreateCredentialRequest,
created_by: str | None = None,
+ is_passkey_setup_pending: bool = False,
) -> Credential:
item_id = self._generate_item_id()
item = CredentialItem(
@@ -56,6 +57,7 @@ class SkyvernCredentialVaultService(CredentialVaultService):
item_id=item_id,
vault_type=CredentialVaultType.SKYVERN,
created_by=created_by,
+ is_passkey_setup_pending=is_passkey_setup_pending,
)
except BaseException:
await self._reclaim_orphaned_vault_item(
diff --git a/tests/unit/forge/sdk/db/test_credentials_repository.py b/tests/unit/forge/sdk/db/test_credentials_repository.py
index 44f9c118f..360bdcf67 100644
--- a/tests/unit/forge/sdk/db/test_credentials_repository.py
+++ b/tests/unit/forge/sdk/db/test_credentials_repository.py
@@ -57,6 +57,102 @@ async def test_search_matches_an_exact_credential_id_within_the_org(repo_and_ses
assert await found(ORG_A, "portal") == [portal]
+async def test_test_login_temporary_marker_can_be_set_and_cleared(repo_and_session) -> None:
+ repo, _session_factory = repo_and_session
+ credential_id = await _add_credential(_session_factory, ORG_A, "Login")
+
+ marked = await repo.update_credential(
+ credential_id=credential_id,
+ organization_id=ORG_A,
+ is_test_login_temporary=True,
+ )
+ assert marked.is_test_login_temporary is True
+
+ saved = await repo.update_credential(
+ credential_id=credential_id,
+ organization_id=ORG_A,
+ is_test_login_temporary=False,
+ )
+ assert saved.is_test_login_temporary is False
+
+
+async def test_pending_passkey_setup_marker_can_be_set_and_cleared(repo_and_session) -> None:
+ repo, _session_factory = repo_and_session
+ credential = await repo.create_credential(
+ organization_id=ORG_A,
+ name="Passkey login",
+ vault_type=CredentialVaultType.CUSTOM,
+ item_id="passkey-item",
+ credential_type=CredentialType.PASSWORD,
+ username="[email protected]",
+ totp_type="passkey",
+ card_last4=None,
+ card_brand=None,
+ is_passkey_setup_pending=True,
+ )
+ assert credential.is_passkey_setup_pending is True
+
+ saved = await repo.update_credential(
+ credential_id=credential.credential_id,
+ organization_id=ORG_A,
+ is_passkey_setup_pending=False,
+ )
+ assert saved.is_passkey_setup_pending is False
+
+
+ ("credential_type", "totp_type", "is_pending"),
+ [
+ (CredentialType.PASSWORD, "none", False),
+ (CredentialType.PASSWORD, "authenticator", False),
+ (CredentialType.PASSWORD, "passkey", True),
+ (CredentialType.CREDIT_CARD, "none", False),
+ (CredentialType.SECRET, "none", False),
+ ],
+)
+async def test_generic_update_tracks_pending_passkey_marker(
+ repo_and_session, credential_type: CredentialType, totp_type: str, is_pending: bool
+) -> None:
+ repo, _session_factory = repo_and_session
+ credential = await repo.create_credential(
+ organization_id=ORG_A,
+ name="Passkey login",
+ vault_type=CredentialVaultType.CUSTOM,
+ item_id="passkey-item",
+ credential_type=CredentialType.PASSWORD,
+ username="[email protected]",
+ totp_type="passkey",
+ card_last4=None,
+ card_brand=None,
+ is_passkey_setup_pending=True,
+ )
+ await repo.update_credential(
+ credential_id=credential.credential_id,
+ organization_id=ORG_A,
+ is_test_login_temporary=True,
+ )
+
+ updated = await repo.update_credential_vault_data(
+ credential_id=credential.credential_id,
+ organization_id=ORG_A,
+ item_id="updated-item",
+ name="Saved login",
+ credential_type=credential_type,
+ username="[email protected]",
+ totp_type=totp_type,
+ totp_identifier=None,
+ card_last4=None,
+ card_brand=None,
+ )
+
+ assert updated.totp_type == totp_type
+ assert updated.is_passkey_setup_pending is is_pending
+ assert updated.is_test_login_temporary is False
+
+
@pytest.mark.asyncio
async def test_vault_item_link_is_unique_per_organization_and_round_trips(repo_and_session) -> None:
repo, _session_factory = repo_and_session
diff --git a/tests/unit/test_credential_delete_reaps_profile.py b/tests/unit/test_credential_delete_reaps_profile.py
index 6820b83e2..677cc714a 100644
--- a/tests/unit/test_credential_delete_reaps_profile.py
+++ b/tests/unit/test_credential_delete_reaps_profile.py
@@ -1,3 +1,4 @@
+from contextlib import asynccontextmanager
from types import SimpleNamespace
from unittest.mock import AsyncMock
@@ -5,6 +6,7 @@ import pytest
import structlog.testing
from fastapi import BackgroundTasks
+from skyvern.forge.sdk.db.datetime_utils import naive_utc_now
from skyvern.forge.sdk.routes import credentials
@@ -16,21 +18,44 @@ def _setup_app(
reap_raises: bool = False,
db_raises: bool = False,
engine_enabled: bool = True,
+ is_test_login_temporary: bool = False,
+ assert_lock_during_reap: bool = False,
) -> SimpleNamespace:
+ lock_state = {"held": False}
+ lock_calls: list[tuple[str, str]] = []
get_credential = AsyncMock(
return_value=SimpleNamespace(
vault_type=credentials.CredentialVaultType.BITWARDEN,
item_id="item_1",
organization_id="o_test",
browser_profile_id=browser_profile_id,
+ created_by="user_1",
+ created_at=naive_utc_now(),
+ is_test_login_temporary=is_test_login_temporary,
)
)
has_live = AsyncMock(return_value=has_refs)
db_delete_profile = AsyncMock(side_effect=RuntimeError("db down") if db_raises else None)
# reap_raises fails the S3 erasure (the security-critical path), which must be best-effort.
- storage_delete_profile = AsyncMock(side_effect=RuntimeError("boom") if reap_raises else None)
+
+ async def delete_profile(**kwargs: object) -> None:
+ if assert_lock_during_reap:
+ assert lock_state["held"]
+ if reap_raises:
+ raise RuntimeError("boom")
+
+ storage_delete_profile = AsyncMock(side_effect=delete_profile)
vault_service = SimpleNamespace(delete_credential=AsyncMock(), post_delete_credential_item=AsyncMock())
+ @asynccontextmanager
+ async def credential_write_lock(*, organization_id: str, credential_id: str):
+ lock_calls.append((organization_id, credential_id))
+ lock_state["held"] = True
+ try:
+ yield
+ finally:
+ lock_state["held"] = False
+
fake_app = SimpleNamespace(
DATABASE=SimpleNamespace(
credentials=SimpleNamespace(get_credential=get_credential),
@@ -44,15 +69,19 @@ def _setup_app(
AGENT_FUNCTION=SimpleNamespace(
is_browser_memory_engine_enabled_for_org=AsyncMock(return_value=engine_enabled),
should_lock_credential_write=AsyncMock(return_value=False),
+ credential_write_lock=credential_write_lock,
),
)
monkeypatch.setattr(credentials, "app", fake_app)
monkeypatch.setattr(credentials, "_clear_cached_totp_code_preview", lambda **kwargs: None)
+ monkeypatch.setattr(credentials, "record_request_audit_event", AsyncMock())
return SimpleNamespace(
has_live=has_live,
db_delete_profile=db_delete_profile,
storage_delete_profile=storage_delete_profile,
vault_service=vault_service,
+ lock_state=lock_state,
+ lock_calls=lock_calls,
)
@@ -64,6 +93,15 @@ async def _delete() -> None:
)
+async def _delete_temporary() -> None:
+ await credentials.delete_organization_credential(
+ organization_id="o_test",
+ credential_id="cred_1",
+ background_tasks=BackgroundTasks(),
+ expected_created_by="user_1",
+ )
+
+
@pytest.mark.asyncio
async def test_reaps_profile_when_no_live_owner(monkeypatch: pytest.MonkeyPatch) -> None:
mocks = _setup_app(monkeypatch, browser_profile_id="bp_1", has_refs=False)
@@ -76,6 +114,21 @@ async def test_reaps_profile_when_no_live_owner(monkeypatch: pytest.MonkeyPatch)
mocks.storage_delete_profile.assert_awaited_once_with(organization_id="o_test", profile_id="bp_1", hard_delete=True)
+async def test_temporary_delete_holds_credential_lock_through_profile_reap(monkeypatch: pytest.MonkeyPatch) -> None:
+ mocks = _setup_app(
+ monkeypatch,
+ browser_profile_id="bp_1",
+ is_test_login_temporary=True,
+ assert_lock_during_reap=True,
+ )
+
+ await _delete_temporary()
+
+ assert mocks.lock_calls == [("o_test", "cred_1")]
+ assert mocks.lock_state["held"] is False
+
+
@pytest.mark.asyncio
async def test_skips_reap_when_engine_off(monkeypatch: pytest.MonkeyPatch) -> None:
# Flag-off orgs must not hit the irreversible S3 archive delete on credential delete (v1 has no
diff --git a/tests/unit/test_credential_test_trigger_type.py b/tests/unit/test_credential_test_trigger_type.py
index 9153e236e..1b3933f90 100644
--- a/tests/unit/test_credential_test_trigger_type.py
+++ b/tests/unit/test_credential_test_trigger_type.py
@@ -137,8 +137,20 @@ async def test_test_login_trigger_type_from_user_agent(
return_value=SimpleNamespace(vault_type=None, credential_id="cred_test", totp_identifier=None)
)
)
+ update_credential = AsyncMock(
+ return_value=SimpleNamespace(
+ vault_type=None,
+ credential_id="cred_test",
+ totp_identifier=None,
+ proxy_location=None,
+ proxy_session_id=None,
+ )
+ )
monkeypatch.setattr(credentials, "_get_credential_vault_service", AsyncMock(return_value=vault_service))
monkeypatch.setattr(credentials, "_create_browser_profile_after_workflow", AsyncMock())
+ monkeypatch.setattr(
+ credentials.app, "DATABASE", SimpleNamespace(credentials=SimpleNamespace(update_credential=update_credential))
+ )
monkeypatch.setattr(credentials.app, "WORKFLOW_SERVICE", _workflow_service(setup_mock))
_patch_executor(monkeypatch)
@@ -150,6 +162,7 @@ async def test_test_login_trigger_type_from_user_agent(
)
setup_mock.assert_awaited_once()
+ assert update_credential.await_args.kwargs["is_test_login_temporary"] is True
assert setup_mock.call_args.kwargs["trigger_type"] == expected
assert response.workflow_run_id == "wr_test"
# test_login fires _create_browser_profile_after_workflow via create_task; drain the
@@ -196,6 +209,7 @@ async def test_test_login_seeds_proxy_pin_workflow_request(monkeypatch: pytest.M
)
workflow_request = setup_mock.call_args.kwargs["workflow_request"]
+ assert mock_credentials.update_credential.await_args.kwargs["is_test_login_temporary"] is True
assert workflow_request.proxy_location == ProxyLocation.RESIDENTIAL_ISP
assert workflow_request.extra_http_headers == {"dedicated-ip": "abc1234567"}
await asyncio.sleep(0)
@@ -274,8 +288,20 @@ def test_test_login_endpoint_wires_user_agent_header(
return_value=SimpleNamespace(vault_type=None, credential_id="cred_test", totp_identifier=None)
)
)
+ update_credential = AsyncMock(
+ return_value=SimpleNamespace(
+ vault_type=None,
+ credential_id="cred_test",
+ totp_identifier=None,
+ proxy_location=None,
+ proxy_session_id=None,
+ )
+ )
monkeypatch.setattr(credentials, "_get_credential_vault_service", AsyncMock(return_value=vault_service))
monkeypatch.setattr(credentials, "_create_browser_profile_after_workflow", AsyncMock())
+ monkeypatch.setattr(
+ credentials.app, "DATABASE", SimpleNamespace(credentials=SimpleNamespace(update_credential=update_credential))
+ )
monkeypatch.setattr(credentials.app, "WORKFLOW_SERVICE", _workflow_service(setup_mock))
_patch_executor(monkeypatch)
@@ -291,5 +317,6 @@ def test_test_login_endpoint_wires_user_agent_header(
)
assert resp.status_code == 200
+ assert update_credential.await_args.kwargs["is_test_login_temporary"] is True
setup_mock.assert_awaited_once()
assert setup_mock.call_args.kwargs["trigger_type"] == expected
diff --git a/tests/unit/test_credential_update_params.py b/tests/unit/test_credential_update_params.py
index 2f74609c5..7de3d8412 100644
--- a/tests/unit/test_credential_update_params.py
+++ b/tests/unit/test_credential_update_params.py
@@ -34,6 +34,7 @@ from skyvern.forge.sdk.schemas.credentials import (
TotpType,
UpdateCredentialRequest,
)
+from skyvern.forge.sdk.services.credential import credential_creation_service
from skyvern.forge.sdk.services.credential.credential_vault_service import CredentialVaultService
from skyvern.forge.sdk.services.credential.skyvern_credential_vault_service import SkyvernCredentialVaultService
from skyvern.forge.sdk.workflow.models.workflow import WorkflowRunStatus
@@ -127,7 +128,9 @@ async def test_create_credential_response_includes_generated_proxy_pin(monkeypat
totp_type=TotpType.AUTHENTICATOR,
)
vault_service = SimpleNamespace(create_credential=AsyncMock(return_value=stored_credential))
- monkeypatch.setattr(credentials_routes, "_get_credential_vault_service", AsyncMock(return_value=vault_service))
+ monkeypatch.setattr(
+ credential_creation_service, "get_credential_vault_service", AsyncMock(return_value=vault_service)
+ )
data = CreateCredentialRequest(
name="test",
@@ -198,7 +201,9 @@ async def test_credential_vault_service_update_db_credential_skips_tested_url_wh
async def test_create_credential_then_get_credential_returns_tested_url(monkeypatch: pytest.MonkeyPatch) -> None:
stored_credential = _make_password_credential(tested_url="https://example.com/login")
vault_service = SimpleNamespace(create_credential=AsyncMock(return_value=stored_credential))
- monkeypatch.setattr(credentials_routes, "_get_credential_vault_service", AsyncMock(return_value=vault_service))
+ monkeypatch.setattr(
+ credential_creation_service, "get_credential_vault_service", AsyncMock(return_value=vault_service)
+ )
monkeypatch.setattr(
forge_app.DATABASE.credentials,
"get_credential",
@@ -1155,7 +1160,9 @@ def _stored_credential(
@pytest.mark.asyncio
async def test_create_credential_links_validated_browser_profile_id(monkeypatch: pytest.MonkeyPatch) -> None:
vault_service = SimpleNamespace(create_credential=AsyncMock(return_value=_stored_credential()))
- monkeypatch.setattr(credentials_routes, "_get_credential_vault_service", AsyncMock(return_value=vault_service))
+ monkeypatch.setattr(
+ credential_creation_service, "get_credential_vault_service", AsyncMock(return_value=vault_service)
+ )
monkeypatch.setattr(
forge_app.DATABASE.browser_sessions,
"get_browser_profile",
@@ -1194,7 +1201,9 @@ async def test_create_credential_links_validated_browser_profile_id(monkeypatch:
@pytest.mark.asyncio
async def test_create_credential_persists_auto_profile_disabled(monkeypatch: pytest.MonkeyPatch) -> None:
vault_service = SimpleNamespace(create_credential=AsyncMock(return_value=_stored_credential()))
- monkeypatch.setattr(credentials_routes, "_get_credential_vault_service", AsyncMock(return_value=vault_service))
+ monkeypatch.setattr(
+ credential_creation_service, "get_credential_vault_service", AsyncMock(return_value=vault_service)
+ )
update_credential = AsyncMock(return_value=_stored_credential(auto_profile_disabled=True))
monkeypatch.setattr(forge_app.DATABASE.credentials, "update_credential", update_credential)
@@ -1217,7 +1226,9 @@ async def test_create_credential_persists_auto_profile_disabled(monkeypatch: pyt
async def test_create_credential_rejects_managed_browser_profile_id(monkeypatch: pytest.MonkeyPatch) -> None:
vault_create = AsyncMock(return_value=_stored_credential())
vault_service = SimpleNamespace(create_credential=vault_create)
- monkeypatch.setattr(credentials_routes, "_get_credential_vault_service", AsyncMock(return_value=vault_service))
+ monkeypatch.setattr(
+ credential_creation_service, "get_credential_vault_service", AsyncMock(return_value=vault_service)
+ )
monkeypatch.setattr(
forge_app.DATABASE.browser_sessions,
"get_browser_profile",
@@ -1553,7 +1564,9 @@ async def test_create_credential_profile_alone_does_not_reset_pin(monkeypatch: p
# K: supplying a browser_profile_id without a pin field must NOT reset the pin — pass None (leave
# unchanged), not the request model's default False.
vault_service = SimpleNamespace(create_credential=AsyncMock(return_value=_stored_credential()))
- monkeypatch.setattr(credentials_routes, "_get_credential_vault_service", AsyncMock(return_value=vault_service))
+ monkeypatch.setattr(
+ credential_creation_service, "get_credential_vault_service", AsyncMock(return_value=vault_service)
+ )
monkeypatch.setattr(
forge_app.DATABASE.browser_sessions,
"get_browser_profile",
@@ -1748,7 +1761,13 @@ class _PreservingVaultService(CredentialVaultService):
self.stored = stored
self.written: PasswordCredential | None = None
- async def create_credential(self, organization_id: str, data: CreateCredentialRequest) -> Credential:
+ async def create_credential(
+ self,
+ organization_id: str,
+ data: CreateCredentialRequest,
+ created_by: str | None = None,
+ is_passkey_setup_pending: bool = False,
+ ) -> Credential:
raise NotImplementedError
async def update_credential(self, credential: Credential, data: CreateCredentialRequest) -> Credential:
@@ -1847,8 +1866,8 @@ async def test_create_credential_records_the_caller_as_creator(
monkeypatch.setattr(settings, "LOCAL_CREDENTIAL_VAULT_KEY", None)
monkeypatch.setattr(forge_app.DATABASE, "credentials", db.credentials)
monkeypatch.setattr(
- credentials_routes,
- "_get_credential_vault_service",
+ credential_creation_service,
+ "get_credential_vault_service",
AsyncMock(return_value=SkyvernCredentialVaultService()),
)
diff --git a/tests/unit/test_credential_vault_type_override.py b/tests/unit/test_credential_vault_type_override.py
index f41532cf5..6dd8df8c3 100644
--- a/tests/unit/test_credential_vault_type_override.py
+++ b/tests/unit/test_credential_vault_type_override.py
@@ -9,10 +9,7 @@ from fastapi import BackgroundTasks, HTTPException
from skyvern.config import Settings
from skyvern.forge.sdk.routes import credentials as credentials_routes
-from skyvern.forge.sdk.routes.credentials import (
- _delete_temporary_test_login_credential,
- _get_credential_vault_service,
-)
+from skyvern.forge.sdk.routes.credentials import _delete_temporary_test_login_credential
from skyvern.forge.sdk.schemas.credentials import (
CreateCredentialRequest,
CredentialResponse,
@@ -24,6 +21,9 @@ from skyvern.forge.sdk.schemas.credentials import (
SecretCredentialResponse,
)
from skyvern.forge.sdk.services.credential import custom_credential_vault_service as custom_vault_module
+from skyvern.forge.sdk.services.credential.credential_creation_service import (
+ get_credential_vault_service as _get_credential_vault_service,
+)
from skyvern.forge.sdk.services.credential.credential_vault_service import CredentialVaultService
from skyvern.forge.sdk.services.credential.custom_credential_vault_service import (
CONFIGURATION_INVALID_MESSAGE,
@@ -178,8 +178,11 @@ class TestGetCredentialVaultServiceRouting:
mock_bw = MagicMock(spec=CredentialVaultService)
mock_settings = MagicMock(CREDENTIAL_VAULT_TYPE=CredentialVaultType.BITWARDEN)
with (
- patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,
- patch("skyvern.forge.sdk.routes.credentials.SettingsManager.get_settings", return_value=mock_settings),
+ patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app,
+ patch(
+ "skyvern.forge.sdk.services.credential.credential_creation_service.SettingsManager.get_settings",
+ return_value=mock_settings,
+ ),
):
mock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_bw
result = await _get_credential_vault_service()
@@ -191,8 +194,11 @@ class TestGetCredentialVaultServiceRouting:
mock_settings = MagicMock(CREDENTIAL_VAULT_TYPE=CredentialVaultType.SKYVERN)
mock_settings.is_local_credential_vault_enabled.return_value = True
with (
- patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,
- patch("skyvern.forge.sdk.routes.credentials.SettingsManager.get_settings", return_value=mock_settings),
+ patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app,
+ patch(
+ "skyvern.forge.sdk.services.credential.credential_creation_service.SettingsManager.get_settings",
+ return_value=mock_settings,
+ ),
):
mock_app.SKYVERN_CREDENTIAL_VAULT_SERVICE = mock_skyvern
result = await _get_credential_vault_service()
@@ -203,8 +209,11 @@ class TestGetCredentialVaultServiceRouting:
mock_settings = MagicMock(CREDENTIAL_VAULT_TYPE=CredentialVaultType.SKYVERN)
mock_settings.is_local_credential_vault_enabled.return_value = False
with (
- patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,
- patch("skyvern.forge.sdk.routes.credentials.SettingsManager.get_settings", return_value=mock_settings),
+ patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app,
+ patch(
+ "skyvern.forge.sdk.services.credential.credential_creation_service.SettingsManager.get_settings",
+ return_value=mock_settings,
+ ),
):
mock_app.SKYVERN_CREDENTIAL_VAULT_SERVICE = MagicMock(spec=CredentialVaultService)
with pytest.raises(HTTPException) as exc_info:
@@ -219,8 +228,11 @@ class TestGetCredentialVaultServiceRouting:
mock_settings = MagicMock(CREDENTIAL_VAULT_TYPE=CredentialVaultType.BITWARDEN)
mock_settings.is_local_credential_vault_enabled.return_value = True
with (
- patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,
- patch("skyvern.forge.sdk.routes.credentials.SettingsManager.get_settings", return_value=mock_settings),
+ patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app,
+ patch(
+ "skyvern.forge.sdk.services.credential.credential_creation_service.SettingsManager.get_settings",
+ return_value=mock_settings,
+ ),
):
mock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_bw
mock_app.SKYVERN_CREDENTIAL_VAULT_SERVICE = mock_skyvern
@@ -236,8 +248,11 @@ class TestGetCredentialVaultServiceRouting:
mock_settings = MagicMock(CREDENTIAL_VAULT_TYPE=CredentialVaultType.BITWARDEN)
mock_settings.is_local_credential_vault_enabled.return_value = False
with (
- patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,
- patch("skyvern.forge.sdk.routes.credentials.SettingsManager.get_settings", return_value=mock_settings),
+ patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app,
+ patch(
+ "skyvern.forge.sdk.services.credential.credential_creation_service.SettingsManager.get_settings",
+ return_value=mock_settings,
+ ),
):
mock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_bw
mock_app.SKYVERN_CREDENTIAL_VAULT_SERVICE = mock_skyvern
@@ -252,7 +267,7 @@ class TestGetCredentialVaultServiceRouting:
async def test_override_custom_ignores_global(self) -> None:
mock_bw = MagicMock(spec=CredentialVaultService)
mock_custom = MagicMock(spec=CredentialVaultService)
- with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:
+ with patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app:
mock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_bw
mock_app.CUSTOM_CREDENTIAL_VAULT_SERVICE = mock_custom
result = await _get_credential_vault_service(
@@ -264,7 +279,7 @@ class TestGetCredentialVaultServiceRouting:
async def test_override_azure_ignores_global(self) -> None:
mock_bw = MagicMock(spec=CredentialVaultService)
mock_azure = MagicMock(spec=CredentialVaultService)
- with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:
+ with patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app:
mock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_bw
mock_app.AZURE_CREDENTIAL_VAULT_SERVICE = mock_azure
result = await _get_credential_vault_service(
@@ -276,7 +291,7 @@ class TestGetCredentialVaultServiceRouting:
async def test_override_gcp_ignores_global(self) -> None:
mock_bw = MagicMock(spec=CredentialVaultService)
mock_gcp = MagicMock(spec=CredentialVaultService)
- with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:
+ with patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app:
mock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_bw
mock_app.GCP_CREDENTIAL_VAULT_SERVICE = mock_gcp
result = await _get_credential_vault_service(
@@ -287,7 +302,7 @@ class TestGetCredentialVaultServiceRouting:
@pytest.mark.asyncio
async def test_override_onepassword_uses_registered_service(self) -> None:
mock_onepassword = MagicMock(spec=CredentialVaultService)
- with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:
+ with patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app:
mock_app.ONEPASSWORD_CREDENTIAL_VAULT_SERVICE = mock_onepassword
result = await _get_credential_vault_service(
vault_type_override=CredentialVaultType.ONEPASSWORD,
@@ -296,7 +311,7 @@ class TestGetCredentialVaultServiceRouting:
@pytest.mark.asyncio
async def test_override_gcp_raises_when_not_configured(self) -> None:
- with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:
+ with patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app:
mock_app.GCP_CREDENTIAL_VAULT_SERVICE = None
with pytest.raises(HTTPException) as exc_info:
await _get_credential_vault_service(
@@ -307,7 +322,7 @@ class TestGetCredentialVaultServiceRouting:
@pytest.mark.asyncio
async def test_override_custom_raises_when_not_configured(self) -> None:
- with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:
+ with patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app:
mock_app.CUSTOM_CREDENTIAL_VAULT_SERVICE = None
with pytest.raises(HTTPException) as exc_info:
await _get_credential_vault_service(
@@ -321,8 +336,11 @@ class TestGetCredentialVaultServiceRouting:
mock_custom = MagicMock(spec=CredentialVaultService)
mock_settings = MagicMock(CREDENTIAL_VAULT_TYPE=CredentialVaultType.CUSTOM)
with (
- patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,
- patch("skyvern.forge.sdk.routes.credentials.SettingsManager.get_settings", return_value=mock_settings),
+ patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app,
+ patch(
+ "skyvern.forge.sdk.services.credential.credential_creation_service.SettingsManager.get_settings",
+ return_value=mock_settings,
+ ),
):
mock_app.CUSTOM_CREDENTIAL_VAULT_SERVICE = mock_custom
result = await _get_credential_vault_service(vault_type_override=None)
@@ -376,7 +394,7 @@ class TestCustomVaultOrganizationPreflight:
_install_stored_config(monkeypatch, stored_config)
monkeypatch.setattr(custom_vault_module, "CustomCredentialAPIClient", api_client)
- with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:
+ with patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app:
mock_app.CUSTOM_CREDENTIAL_VAULT_SERVICE = CustomCredentialVaultService()
with pytest.raises(HTTPException) as exc_info:
await _get_credential_vault_service(
@@ -395,7 +413,7 @@ class TestCustomVaultOrganizationPreflight:
) -> None:
_install_stored_config(monkeypatch, json.dumps({"api_token": "super-secret-token"}))
- with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:
+ with patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app:
mock_app.CUSTOM_CREDENTIAL_VAULT_SERVICE = CustomCredentialVaultService()
with pytest.raises(HTTPException) as exc_info:
await _get_credential_vault_service(
@@ -416,7 +434,7 @@ class TestCustomVaultOrganizationPreflight:
)
service = CustomCredentialVaultService()
- with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:
+ with patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app:
mock_app.CUSTOM_CREDENTIAL_VAULT_SERVICE = service
result = await _get_credential_vault_service(
vault_type_override=CredentialVaultType.CUSTOM,
@@ -430,8 +448,11 @@ class TestCustomVaultOrganizationPreflight:
mock_bw = MagicMock(spec=CredentialVaultService)
mock_settings = MagicMock(CREDENTIAL_VAULT_TYPE=CredentialVaultType.BITWARDEN)
with (
- patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,
- patch("skyvern.forge.sdk.routes.credentials.SettingsManager.get_settings", return_value=mock_settings),
+ patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app,
+ patch(
+ "skyvern.forge.sdk.services.credential.credential_creation_service.SettingsManager.get_settings",
+ return_value=mock_settings,
+ ),
):
mock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_bw
result = await _get_credential_vault_service(organization_id="org_test")
@@ -444,7 +465,7 @@ class TestCustomVaultOrganizationPreflight:
# The TOTP read path relies on this: it needs CustomCredentialNotConfiguredError to reach
# its own handler rather than being converted at the gate.
mock_custom = MagicMock(spec=CredentialVaultService)
- with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:
+ with patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app:
mock_app.CUSTOM_CREDENTIAL_VAULT_SERVICE = mock_custom
result = await _get_credential_vault_service(vault_type_override=CredentialVaultType.CUSTOM)
@@ -470,7 +491,7 @@ class TestCustomVaultOrganizationPreflight:
vault_type=CredentialVaultType.CUSTOM,
)
- with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:
+ with patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_app:
mock_app.CUSTOM_CREDENTIAL_VAULT_SERVICE = service
mock_app.AGENT_FUNCTION.validate_credential_write = AsyncMock()
with pytest.raises(HTTPException) as exc_info:
@@ -547,10 +568,14 @@ class TestTemporaryTestLoginCredentialCleanup:
with (
patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,
- patch("skyvern.forge.sdk.routes.credentials.SettingsManager.get_settings", return_value=mock_settings),
+ patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_creation_app,
+ patch(
+ "skyvern.forge.sdk.services.credential.credential_creation_service.SettingsManager.get_settings",
+ return_value=mock_settings,
+ ),
):
mock_app.DATABASE.credentials = mock_repository
- mock_app.SKYVERN_CREDENTIAL_VAULT_SERVICE = mock_service
+ mock_creation_app.SKYVERN_CREDENTIAL_VAULT_SERVICE = mock_service
await _delete_temporary_test_login_credential(
credential_id="cred_temp",
@@ -573,9 +598,12 @@ class TestTemporaryTestLoginCredentialCleanup:
mock_service = MagicMock(spec=CredentialVaultService)
mock_service.delete_credential = AsyncMock()
- with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:
+ with (
+ patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,
+ patch("skyvern.forge.sdk.services.credential.credential_creation_service.app") as mock_creation_app,
+ ):
mock_app.DATABASE.credentials = mock_repository
- mock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_service
+ mock_creation_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_service
await _delete_temporary_test_login_credential(
credential_id="cred_temp",