Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
SKY-11678 Add local credential vault persistence to OSS Docker (#7003)
Suchintan720d47d754c5
diff --git a/.dockerignore b/.dockerignoreindex 8fc469dd1..bc05d817a 100644--- a/.dockerignore+++ b/.dockerignore@@ -4,6 +4,9 @@**/traces**/inputs**/har+**/downloads+**/browser_sessions+**/credential_vault**/.git**/.github**/.mypy_cachediff --git a/.env.example b/.env.exampleindex ec2aa6a95..8de4fcc0b 100644--- a/.env.example+++ b/.env.example@@ -139,12 +139,29 @@ ANALYTICS_ID="anonymous"# OP_SERVICE_ACCOUNT_TOKEN: API token for 1Password integrationOP_SERVICE_ACCOUNT_TOKEN=""+# =============================================================================+# SKYVERN CREDENTIAL VAULT CONFIGURATION+# =============================================================================+# Built-in encrypted local vault used by default by the OSS Docker Compose setup.+# Docker also sets ENABLE_LOCAL_CREDENTIAL_VAULT=true and persists this under /data/credential_vault.+CREDENTIAL_VAULT_TYPE=skyvern+ENABLE_LOCAL_CREDENTIAL_VAULT=true+# LOCAL_CREDENTIAL_VAULT_PATH=/data/credential_vault+# Production self-hosters should set LOCAL_CREDENTIAL_VAULT_KEY from an external secret store.+# If unset, Skyvern generates .fernet_key inside LOCAL_CREDENTIAL_VAULT_PATH; backups or host-dir+# exposure of that directory include both encrypted items and the key needed to decrypt them.+# LOCAL_CREDENTIAL_VAULT_KEY=+# The OSS Docker volumes for browser_sessions/ and downloads/ can contain plaintext cookies,+# session tokens, and downloaded files. Treat them as sensitive and exclude them from casual backups.+# Enable recording skyvern logs as artifactsENABLE_LOG_ARTIFACTS=false# =============================================================================# SKYVERN BITWARDEN CONFIGURATION# =============================================================================+# Set CREDENTIAL_VAULT_TYPE=bitwarden to use Bitwarden or vaultwarden instead+# of the built-in Skyvern credential vault.# Your organization ID in official Bitwarden server or vaultwarden (if using organizations)SKYVERN_AUTH_BITWARDEN_ORGANIZATION_ID=your-org-id-herediff --git a/.gitignore b/.gitignoreindex b3f08ff9e..3592cdf38 100644--- a/.gitignore+++ b/.gitignore@@ -162,6 +162,7 @@ ig_*# Skyvern ignoresbrowser_sessions/+credential_vault/videos/skyvern/artifacts/artifacts/diff --git a/Dockerfile b/Dockerfileindex 351c3d5a5..d954a1565 100644--- a/Dockerfile+++ b/Dockerfile@@ -11,6 +11,7 @@ RUN uv pip compile pyproject.toml --extra server --python-version 3.11 -o requirFROM python:3.11-slim-bookwormWORKDIR /appCOPY --from=requirements-stage /tmp/requirements.txt /app/requirements.txt+COPY ./skyvern/forge/sdk/utils/tesseract_languages.py /tmp/tesseract_languages.pyRUN pip install --upgrade pip setuptools wheel# --no-deps: requirements.txt is fully resolved by uv, including the# pyproject overrides that loosen litellm's jsonschema==4.23.0 pin.@@ -18,7 +19,13 @@ RUN pip install --upgrade pip setuptools wheelRUN pip install --no-cache-dir --no-deps -r requirements.txtRUN playwright install-depsRUN playwright install-RUN apt-get install -y xauth x11-apps netpbm gpg ca-certificates x11vnc && apt-get clean+RUN apt-get update && \+ apt-get install -y xauth x11-apps netpbm gpg ca-certificates x11vnc tesseract-ocr $(python /tmp/tesseract_languages.py --apt-packages) && \+ tesseract --version && \+ rm /tmp/tesseract_languages.py && \+ apt-get clean && \+ rm -rf /var/lib/apt/lists/*+RUN pip install --no-cache-dir websockifyCOPY .nvmrc /app/.nvmrc@@ -47,6 +54,9 @@ ENV VIDEO_PATH=/data/videosENV HAR_PATH=/data/harENV LOG_PATH=/data/logENV ARTIFACT_STORAGE_PATH=/data/artifacts+ENV DOWNLOAD_PATH=/data/downloads+ENV BROWSER_SESSION_BASE_PATH=/data/browser_sessions+ENV LOCAL_CREDENTIAL_VAULT_PATH=/data/credential_vault# cache tiktokenRUN python /app/scripts/load_tiktoken.pydiff --git a/docker-compose.yml b/docker-compose.ymlindex 5614266da..fb8999bdb 100644--- a/docker-compose.yml+++ b/docker-compose.yml@@ -38,6 +38,9 @@ services:- ./videos:/data/videos- ./har:/data/har- ./log:/data/log+ - ./downloads:/data/downloads+ - ./browser_sessions:/data/browser_sessions+ - ./credential_vault:/data/credential_vault# Generated credentials allow the UI to pick up the local API key on first startup.- ./.skyvern:/app/.skyvern# Uncomment the following two lines if you want to connect to any local changes@@ -62,6 +65,11 @@ services:- BROWSER_REMOTE_DEBUGGING_URL=${BROWSER_REMOTE_DEBUGGING_URL:-http://127.0.0.1:9222}- BROWSER_REMOTE_DEBUGGING_HOST_HEADER=${BROWSER_REMOTE_DEBUGGING_HOST_HEADER:-}- BROWSER_CDP_CONNECT_TIMEOUT_MS=${BROWSER_CDP_CONNECT_TIMEOUT_MS:-120000}+ - DOWNLOAD_PATH=/data/downloads+ - BROWSER_SESSION_BASE_PATH=/data/browser_sessions+ - CREDENTIAL_VAULT_TYPE=${CREDENTIAL_VAULT_TYPE:-skyvern}+ - ENABLE_LOCAL_CREDENTIAL_VAULT=${ENABLE_LOCAL_CREDENTIAL_VAULT:-true}+ - LOCAL_CREDENTIAL_VAULT_PATH=/data/credential_vault- ENABLE_CODE_BLOCK=true# --- Control your own browser (Chrome/Chromium) ---# Prefer Chrome's chrome://inspect/#remote-debugging flow for an existing profile.diff --git a/docs/api-reference/openapi.json b/docs/api-reference/openapi.jsonindex 16a7b5f04..adc135536 100644--- a/docs/api-reference/openapi.json+++ b/docs/api-reference/openapi.json@@ -3645,10 +3645,10 @@"type": "null"}],- "description": "Filter credentials by vault type (e.g. 'custom', 'bitwarden', 'azure_vault')",+ "description": "Filter credentials by vault type (e.g. 'skyvern', 'custom', 'bitwarden', 'azure_vault')","title": "Vault Type"},- "description": "Filter credentials by vault type (e.g. 'custom', 'bitwarden', 'azure_vault')"+ "description": "Filter credentials by vault type (e.g. 'skyvern', 'custom', 'bitwarden', 'azure_vault')"},{"name": "credential_type",@@ -10550,7 +10550,7 @@"type": "null"}],- "description": "Which vault stores this credential (e.g., 'bitwarden', 'azure_vault', 'custom')"+ "description": "Which vault stores this credential (e.g., 'skyvern', 'bitwarden', 'azure_vault', 'custom')"},"browser_profile_id": {"anyOf": [@@ -10670,6 +10670,7 @@"CredentialVaultType": {"type": "string","enum": [+ "skyvern","bitwarden","azure_vault","gcp",diff --git a/docs/cloud/managing-credentials/external-providers.mdx b/docs/cloud/managing-credentials/external-providers.mdxindex d568ef68f..c9b60dfd7 100644--- a/docs/cloud/managing-credentials/external-providers.mdx+++ b/docs/cloud/managing-credentials/external-providers.mdx@@ -363,7 +363,7 @@ Restart Skyvern after setting these variables.| Status stays Inactive | Verify the API base URL is a valid URL and the API token is not empty. The configuration is validated on save but does not make a live request to your server. || Credentials not created | Review your API logs for auth errors. Ensure the response includes an `id` field. Skyvern expects HTTP 200 for all operations. || Credentials not retrieved | Ensure the GET response includes all required fields for the credential type (`username` and `password` for passwords, all card fields for credit cards, `secret_value` for secrets). |-| Env config not working | Restart Skyvern after setting variables. Verify `CREDENTIAL_VAULT_TYPE=custom` is set and both URL and token are provided. The default vault type is `bitwarden`, so this variable must be explicitly set. |+| Env config not working | Restart Skyvern after setting variables. Verify `CREDENTIAL_VAULT_TYPE=custom` is set and both URL and token are provided. Deployment defaults vary, so `custom` must be explicitly set for an external service. |---diff --git a/docs/sdk-reference/credentials/get-credentials.mdx b/docs/sdk-reference/credentials/get-credentials.mdxindex 6b1af0f8f..0121dfe01 100644--- a/docs/sdk-reference/credentials/get-credentials.mdx+++ b/docs/sdk-reference/credentials/get-credentials.mdx@@ -26,7 +26,7 @@ for (const c of creds) {|-----------|------|----------|---------|-------------|| `page` | `int` | No | `None` | Page number. || `page_size` | `int` | No | `None` | Results per page. |-| `vault_type` | `CredentialVaultType` | No | `None` | Filter credentials by vault type (e.g. `"custom"`, `"bitwarden"`, `"azure_vault"`). |+| `vault_type` | `CredentialVaultType` | No | `None` | Filter credentials by vault type (e.g. `"skyvern"`, `"custom"`, `"bitwarden"`, `"azure_vault"`). || `request_options` | `RequestOptions` | No | `None` | Per-request configuration (see below). |### Returns `list[CredentialResponse]`diff --git a/fern/openapi/skyvern_openapi.json b/fern/openapi/skyvern_openapi.jsonindex 39d44a0eb..ef4bbb20c 100644--- a/fern/openapi/skyvern_openapi.json+++ b/fern/openapi/skyvern_openapi.json@@ -3343,10 +3343,10 @@"type": "null"}],- "description": "Filter credentials by vault type (e.g. 'custom', 'bitwarden', 'azure_vault')",+ "description": "Filter credentials by vault type (e.g. 'skyvern', 'custom', 'bitwarden', 'azure_vault')","title": "Vault Type"},- "description": "Filter credentials by vault type (e.g. 'custom', 'bitwarden', 'azure_vault')"+ "description": "Filter credentials by vault type (e.g. 'skyvern', 'custom', 'bitwarden', 'azure_vault')"},{"name": "credential_type",@@ -9678,7 +9678,7 @@"type": "null"}],- "description": "Which vault stores this credential (e.g., 'bitwarden', 'azure_vault', 'custom')"+ "description": "Which vault stores this credential (e.g., 'skyvern', 'bitwarden', 'azure_vault', 'custom')"},"browser_profile_id": {"anyOf": [@@ -9767,6 +9767,7 @@"CredentialVaultType": {"type": "string","enum": [+ "skyvern","bitwarden","azure_vault","gcp",diff --git a/skyvern-ts/client/src/api/client/requests/GetCredentialsRequest.ts b/skyvern-ts/client/src/api/client/requests/GetCredentialsRequest.tsindex 284f0a78f..123c0050e 100644--- a/skyvern-ts/client/src/api/client/requests/GetCredentialsRequest.ts+++ b/skyvern-ts/client/src/api/client/requests/GetCredentialsRequest.ts@@ -15,6 +15,6 @@ export interface GetCredentialsRequest {page?: number;/** Number of items per page */page_size?: number;- /** Filter credentials by vault type (e.g. 'custom', 'bitwarden', 'azure_vault') */+ /** Filter credentials by vault type (e.g. 'skyvern', 'custom', 'bitwarden', 'azure_vault') */vault_type?: Skyvern.CredentialVaultType;}diff --git a/skyvern-ts/client/src/api/types/CredentialResponse.ts b/skyvern-ts/client/src/api/types/CredentialResponse.tsindex d5d7d9a34..d1b566b97 100644--- a/skyvern-ts/client/src/api/types/CredentialResponse.ts+++ b/skyvern-ts/client/src/api/types/CredentialResponse.ts@@ -14,7 +14,7 @@ export interface CredentialResponse {credential_type: Skyvern.CredentialTypeOutput;/** Name of the credential */name: string;- /** Which vault stores this credential (e.g., 'bitwarden', 'azure_vault', 'custom') */+ /** Which vault stores this credential (e.g., 'skyvern', 'bitwarden', 'azure_vault', 'custom') */vault_type?: Skyvern.CredentialVaultType;/** Browser profile ID linked to this credential */browser_profile_id?: string;diff --git a/skyvern-ts/client/src/api/types/CredentialVaultType.ts b/skyvern-ts/client/src/api/types/CredentialVaultType.tsindex d5e15f53f..3c87dd7b9 100644--- a/skyvern-ts/client/src/api/types/CredentialVaultType.ts+++ b/skyvern-ts/client/src/api/types/CredentialVaultType.ts@@ -1,8 +1,10 @@// This file was auto-generated by Fern from our API Definition.export const CredentialVaultType = {+ Skyvern: "skyvern",Bitwarden: "bitwarden",AzureVault: "azure_vault",+ Gcp: "gcp",Custom: "custom",} as const;export type CredentialVaultType = (typeof CredentialVaultType)[keyof typeof CredentialVaultType];diff --git a/skyvern/client/client.py b/skyvern/client/client.pyindex 0a6c887d8..814047c73 100644--- a/skyvern/client/client.py+++ b/skyvern/client/client.py@@ -2079,7 +2079,7 @@ class Skyvern:Number of items per pagevault_type : typing.Optional[CredentialVaultType]- Filter credentials by vault type (e.g. 'custom', 'bitwarden', 'azure_vault')+ Filter credentials by vault type (e.g. 'skyvern', 'custom', 'bitwarden', 'azure_vault')request_options : typing.Optional[RequestOptions]Request-specific configuration.@@ -5138,7 +5138,7 @@ class AsyncSkyvern:Number of items per pagevault_type : typing.Optional[CredentialVaultType]- Filter credentials by vault type (e.g. 'custom', 'bitwarden', 'azure_vault')+ Filter credentials by vault type (e.g. 'skyvern', 'custom', 'bitwarden', 'azure_vault')request_options : typing.Optional[RequestOptions]Request-specific configuration.diff --git a/skyvern/client/raw_client.py b/skyvern/client/raw_client.pyindex a60a95ed6..d3693789d 100644--- a/skyvern/client/raw_client.py+++ b/skyvern/client/raw_client.py@@ -2952,7 +2952,7 @@ class RawSkyvern:Number of items per pagevault_type : typing.Optional[CredentialVaultType]- Filter credentials by vault type (e.g. 'custom', 'bitwarden', 'azure_vault')+ Filter credentials by vault type (e.g. 'skyvern', 'custom', 'bitwarden', 'azure_vault')request_options : typing.Optional[RequestOptions]Request-specific configuration.@@ -6804,7 +6804,7 @@ class AsyncRawSkyvern:Number of items per pagevault_type : typing.Optional[CredentialVaultType]- Filter credentials by vault type (e.g. 'custom', 'bitwarden', 'azure_vault')+ Filter credentials by vault type (e.g. 'skyvern', 'custom', 'bitwarden', 'azure_vault')request_options : typing.Optional[RequestOptions]Request-specific configuration.diff --git a/skyvern/client/types/credential_response.py b/skyvern/client/types/credential_response.pyindex 16b357b46..1294c7663 100644--- a/skyvern/client/types/credential_response.py+++ b/skyvern/client/types/credential_response.py@@ -37,7 +37,7 @@ class CredentialResponse(UniversalBaseModel):vault_type: typing.Optional[CredentialVaultType] = pydantic.Field(default=None)"""- Which vault stores this credential (e.g., 'bitwarden', 'azure_vault', 'custom')+ Which vault stores this credential (e.g., 'skyvern', 'bitwarden', 'azure_vault', 'custom')"""browser_profile_id: typing.Optional[str] = pydantic.Field(default=None)diff --git a/skyvern/client/types/credential_vault_type.py b/skyvern/client/types/credential_vault_type.pyindex 5b578fc79..d310a1cac 100644--- a/skyvern/client/types/credential_vault_type.py+++ b/skyvern/client/types/credential_vault_type.py@@ -2,4 +2,4 @@import typing-CredentialVaultType = typing.Union[typing.Literal["bitwarden", "azure_vault", "custom"], typing.Any]+CredentialVaultType = typing.Union[typing.Literal["skyvern", "bitwarden", "azure_vault", "gcp", "custom"], typing.Any]diff --git a/skyvern/config.py b/skyvern/config.pyindex 7b6148697..4c00e72e5 100644--- a/skyvern/config.py+++ b/skyvern/config.py@@ -562,8 +562,11 @@ class Settings(BaseSettings):BITWARDEN_EMAIL: str | None = NoneOP_SERVICE_ACCOUNT_TOKEN: str | None = None- # Where credentials are stored: bitwarden, azure_vault, gcp, or custom+ # Where credentials are stored: skyvern, bitwarden, azure_vault, gcp, or customCREDENTIAL_VAULT_TYPE: str = "bitwarden"+ ENABLE_LOCAL_CREDENTIAL_VAULT: bool | None = None+ LOCAL_CREDENTIAL_VAULT_PATH: str = str(Path.home() / ".skyvern" / "credential_vault")+ LOCAL_CREDENTIAL_VAULT_KEY: str | None = None# GCP Secret Manager credential vault settingsGCP_CREDENTIAL_VAULT_PROJECT_ID: str | None = None # project hosting the Secret Manager secrets@@ -888,6 +891,11 @@ class Settings(BaseSettings):"""return self.ENV != "local"+ def is_local_credential_vault_enabled(self) -> bool:+ if self.ENABLE_LOCAL_CREDENTIAL_VAULT is not None:+ return self.ENABLE_LOCAL_CREDENTIAL_VAULT+ return not self.is_cloud_environment()+def execute_all_steps(self) -> bool:"""This provides the functionality to execute steps one by one through the local UI.diff --git a/skyvern/forge/forge_app.py b/skyvern/forge/forge_app.pyindex 4a999d95e..dd90bf02f 100644--- a/skyvern/forge/forge_app.py+++ b/skyvern/forge/forge_app.py@@ -41,6 +41,7 @@ from skyvern.forge.sdk.services.credential.bitwarden_credential_service import Bfrom skyvern.forge.sdk.services.credential.credential_vault_service import CredentialVaultServicefrom skyvern.forge.sdk.services.credential.custom_credential_vault_service import CustomCredentialVaultServicefrom skyvern.forge.sdk.services.credential.gcp_credential_vault_service import GcpCredentialVaultService+from skyvern.forge.sdk.services.credential.skyvern_credential_vault_service import SkyvernCredentialVaultServicefrom skyvern.forge.sdk.settings_manager import SettingsManagerfrom skyvern.forge.sdk.workflow.context_manager import WorkflowContextManagerfrom skyvern.forge.sdk.workflow.service import WorkflowService@@ -95,6 +96,7 @@ class ForgeApp:AGENT_FUNCTION: AgentFunctionPERSISTENT_SESSIONS_MANAGER: PersistentSessionsManagerBROWSER_SESSION_RECORDING_SERVICE: BrowserSessionRecordingService+ SKYVERN_CREDENTIAL_VAULT_SERVICE: SkyvernCredentialVaultService | NoneBITWARDEN_CREDENTIAL_VAULT_SERVICE: BitwardenCredentialVaultServiceAZURE_CREDENTIAL_VAULT_SERVICE: AzureCredentialVaultService | NoneGCP_CREDENTIAL_VAULT_SERVICE: GcpCredentialVaultService | None@@ -283,6 +285,9 @@ def create_forge_app() -> ForgeApp:app.AZURE_CLIENT_FACTORY = RealAzureClientFactory()app.GCP_CLIENT_FACTORY = RealGcpClientFactory()+ app.SKYVERN_CREDENTIAL_VAULT_SERVICE = (+ SkyvernCredentialVaultService() if settings.is_local_credential_vault_enabled() else None+ )app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = BitwardenCredentialVaultService()# Azure Credential Vault Service@@ -329,6 +334,7 @@ def create_forge_app() -> ForgeApp:else CustomCredentialVaultService() # Create service without client for organization-based configuration)app.CREDENTIAL_VAULT_SERVICES = {+ CredentialVaultType.SKYVERN: app.SKYVERN_CREDENTIAL_VAULT_SERVICE,CredentialVaultType.BITWARDEN: app.BITWARDEN_CREDENTIAL_VAULT_SERVICE,CredentialVaultType.AZURE_VAULT: app.AZURE_CREDENTIAL_VAULT_SERVICE,CredentialVaultType.GCP: app.GCP_CREDENTIAL_VAULT_SERVICE,diff --git a/skyvern/forge/sdk/routes/credentials.py b/skyvern/forge/sdk/routes/credentials.pyindex 5f4a35bea..a9bddcc22 100644--- a/skyvern/forge/sdk/routes/credentials.py+++ b/skyvern/forge/sdk/routes/credentials.py@@ -934,9 +934,10 @@ async def test_login(organization_id=organization_id,)try:- await app.DATABASE.credentials.delete_credential(+ await _delete_temporary_test_login_credential(credential_id=credential_id,organization_id=organization_id,+ reason="workflow setup error",)except Exception:LOG.warning(@@ -1374,20 +1375,11 @@ async def cancel_credential_test(# Only clean up temporary credentials after successful cancellation.# The background task may also try to delete — that's fine, it handles NotFound gracefully.try:- credential = await app.DATABASE.credentials.get_credential(+ await _delete_temporary_test_login_credential(credential_id=credential_id,organization_id=organization_id,+ reason="test cancellation",)- if credential and credential.name.startswith("_test_login_"):- await app.DATABASE.credentials.delete_credential(- credential_id=credential_id,- organization_id=organization_id,- )- LOG.info(- "Cleaned up temporary credential after test cancellation",- credential_id=credential_id,- organization_id=organization_id,- )except Exception:LOG.warning("Failed to clean up temporary credential after test cancellation",@@ -1441,14 +1433,10 @@ async def _create_browser_profile_after_workflow(# Clean up temporary credentials created by test-loginif credential_name.startswith("_test_login_"):try:- await app.DATABASE.credentials.delete_credential(- credential_id=credential_id,- organization_id=organization_id,- )- LOG.info(- "Deleted temporary credential after failed test",+ await _delete_temporary_test_login_credential(credential_id=credential_id,organization_id=organization_id,+ reason="failed test",)except Exception:LOG.warning(@@ -1601,9 +1589,10 @@ async def _create_browser_profile_after_workflow(# Clean up temporary credentials on poll timeoutif credential_name.startswith("_test_login_"):try:- await app.DATABASE.credentials.delete_credential(+ await _delete_temporary_test_login_credential(credential_id=credential_id,organization_id=organization_id,+ reason="poll timeout",)except Exception:LOG.warning(@@ -1620,9 +1609,10 @@ async def _create_browser_profile_after_workflow(# Clean up temporary credentials on unexpected errorif credential_name.startswith("_test_login_"):try:- await app.DATABASE.credentials.delete_credential(+ await _delete_temporary_test_login_credential(credential_id=credential_id,organization_id=organization_id,+ reason="profile persistence error",)except Exception:LOG.warning(@@ -1838,7 +1828,8 @@ async def get_credential_totp_code(if cached_response is not None:return cached_response- credential_service = await _get_credential_vault_service(vault_type_override=credential.vault_type)+ vault_type = credential.vault_type or CredentialVaultType.BITWARDEN+ credential_service = await _get_credential_vault_service(vault_type_override=vault_type)try:credential_item = await credential_service.get_credential_item(credential)except SkyvernHttpException as e:@@ -1981,7 +1972,7 @@ async def get_credentials(),vault_type: CredentialVaultType | None = Query(default=None,- description="Filter credentials by vault type (e.g. 'custom', 'bitwarden', 'azure_vault')",+ description="Filter credentials by vault type (e.g. 'skyvern', 'custom', 'bitwarden', 'azure_vault')",),credential_type: CredentialType | None = Query(default=None,@@ -2886,7 +2877,13 @@ async def _get_credential_vault_service(vault_type_override: CredentialVaultType | None = None,) -> CredentialVaultService:vault_type = vault_type_override or settings.CREDENTIAL_VAULT_TYPE- if vault_type == CredentialVaultType.BITWARDEN:+ 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")+ return app.SKYVERN_CREDENTIAL_VAULT_SERVICE+ elif vault_type == CredentialVaultType.BITWARDEN:return app.BITWARDEN_CREDENTIAL_VAULT_SERVICEelif vault_type == CredentialVaultType.AZURE_VAULT:if not app.AZURE_CREDENTIAL_VAULT_SERVICE:@@ -2904,6 +2901,30 @@ async def _get_credential_vault_service(raise HTTPException(status_code=400, detail="Credential storage not supported")+async def _delete_temporary_test_login_credential(+ *,+ credential_id: str,+ organization_id: str,+ reason: str,+) -> None:+ credential = await app.DATABASE.credentials.get_credential(+ credential_id=credential_id,+ organization_id=organization_id,+ )+ if not credential or not credential.name.startswith("_test_login_"):+ return++ vault_type = credential.vault_type or CredentialVaultType.BITWARDEN+ credential_service = await _get_credential_vault_service(vault_type_override=vault_type)+ await credential_service.delete_credential(credential)+ LOG.info(+ "Deleted temporary credential",+ credential_id=credential_id,+ organization_id=organization_id,+ reason=reason,+ )++def _convert_to_response(credential: Credential) -> CredentialResponse:"""Convert an internal ``Credential`` to a safe API response.diff --git a/skyvern/forge/sdk/schemas/credentials.py b/skyvern/forge/sdk/schemas/credentials.pyindex 4b0e87807..b629dd625 100644--- a/skyvern/forge/sdk/schemas/credentials.py+++ b/skyvern/forge/sdk/schemas/credentials.py@@ -12,6 +12,7 @@ from skyvern.utils.url_validators import validate_urlclass CredentialVaultType(StrEnum):+ SKYVERN = "skyvern"BITWARDEN = "bitwarden"AZURE_VAULT = "azure_vault"GCP = "gcp"@@ -220,7 +221,7 @@ class CreateCredentialRequest(BaseModel):default=None,description="Which vault to store this credential in. If omitted, uses the instance default. ""Use this to mix Skyvern-hosted and custom credentials within the same organization.",- examples=["custom", "azure_vault", "bitwarden"],+ examples=["skyvern", "custom", "azure_vault", "bitwarden"],)proxy_location: ProxyLocationInput = Field(default=None,@@ -257,7 +258,7 @@ class CredentialResponse(BaseModel):name: str = Field(..., description="Name of the credential", examples=["Amazon Login"])vault_type: CredentialVaultType | None = Field(default=None,- description="Which vault stores this credential (e.g., 'bitwarden', 'azure_vault', 'custom')",+ description="Which vault stores this credential (e.g., 'skyvern', 'bitwarden', 'azure_vault', 'custom')",)browser_profile_id: str | None = Field(default=None, description="Browser profile ID linked to this credential")tested_url: str | None = Field(default=None, description="Login page URL used during the credential test")@@ -337,7 +338,7 @@ class Credential(BaseModel):..., description="ID of the organization that owns the credential", examples=["o_1234567890"])name: str = Field(..., description="Name of the credential", examples=["Skyvern Login"])- vault_type: CredentialVaultType | None = Field(..., description="Where the secret is stored: Bitwarden vs Azure")+ vault_type: CredentialVaultType | None = Field(..., description="Where the secret is stored")item_id: str = Field(..., description="ID of the associated credential item", examples=["item_1234567890"])credential_type: CredentialType = Field(..., description="Type of the credential. Eg password, credit card, etc.")username: str | None = Field(..., description="For password credentials: the username")diff --git a/skyvern/forge/sdk/services/credential/skyvern_credential_vault_service.py b/skyvern/forge/sdk/services/credential/skyvern_credential_vault_service.pynew file mode 100644index 000000000..37c8961c9--- /dev/null+++ b/skyvern/forge/sdk/services/credential/skyvern_credential_vault_service.py@@ -0,0 +1,208 @@+import json+import os+import re+import secrets+from contextlib import suppress+from pathlib import Path++import structlog+from cryptography.fernet import Fernet, InvalidToken+from fastapi import HTTPException++from skyvern.config import settings+from skyvern.forge import app+from skyvern.forge.sdk.schemas.credentials import (+ CreateCredentialRequest,+ Credential,+ CredentialItem,+ CredentialType,+ CredentialVaultType,+ CreditCardCredential,+)+from skyvern.forge.sdk.services.credential.credential_vault_service import CredentialVaultService++LOG = structlog.get_logger()++_ITEM_ID_PATTERN = re.compile(r"^[A-Za-z0-9_-]+$")+++class SkyvernCredentialVaultService(CredentialVaultService):+ """Local encrypted credential vault for self-hosted Skyvern deployments."""++ def __init__(self) -> None:+ self._fernet: Fernet | None = None++ async def create_credential(self, organization_id: str, data: CreateCredentialRequest) -> Credential:+ item_id = self._generate_item_id()+ item = CredentialItem(+ item_id=item_id,+ name=data.name,+ credential_type=data.credential_type,+ credential=data.credential,+ )+ await self._store_item(item)++ try:+ return await self._create_db_credential(+ organization_id=organization_id,+ data=data,+ item_id=item_id,+ vault_type=CredentialVaultType.SKYVERN,+ )+ except Exception:+ self._delete_item_file(item_id)+ raise++ async def update_credential(self, credential: Credential, data: CreateCredentialRequest) -> Credential:+ credential_data = data.credential+ if data.credential_type == CredentialType.CREDIT_CARD and isinstance(credential_data, CreditCardCredential):+ credential_data = await self._preserve_omitted_credit_card_fields(+ credential=credential,+ updated_credential=credential_data,+ )++ new_item_id = self._generate_item_id()+ item = CredentialItem(+ item_id=new_item_id,+ name=data.name,+ credential_type=data.credential_type,+ credential=credential_data,+ )+ await self._store_item(item)++ try:+ return await self._update_db_credential(+ credential=credential,+ data=data,+ item_id=new_item_id,+ )+ except Exception:+ self._delete_item_file(new_item_id)+ raise++ async def delete_credential(self, credential: Credential) -> None:+ await app.DATABASE.credentials.delete_credential(credential.credential_id, credential.organization_id)+ self._delete_item_file(credential.item_id)++ async def post_delete_credential_item(self, item_id: str, organization_id: str | None = None) -> None:+ self._delete_item_file(item_id)++ async def get_credential_item(self, db_credential: Credential) -> CredentialItem:+ item_path = self._item_path(db_credential.item_id)+ if not item_path.exists():+ raise HTTPException(status_code=404, detail="Credential vault item not found")++ try:+ encrypted_payload = item_path.read_bytes()+ payload = self._get_fernet().decrypt(encrypted_payload).decode("utf-8")+ item = CredentialItem.model_validate(json.loads(payload))+ except InvalidToken as exc:+ raise HTTPException(status_code=500, detail="Credential vault item could not be decrypted") from exc+ except Exception as exc:+ LOG.warning(+ "Failed to read local credential vault item",+ credential_id=db_credential.credential_id,+ item_id=db_credential.item_id,+ error_type=type(exc).__name__,+ )+ raise HTTPException(status_code=500, detail="Credential vault item could not be read") from exc++ return item++ async def _store_item(self, item: CredentialItem) -> None:+ item_path = self._item_path(item.item_id)+ payload = json.dumps(item.model_dump(mode="json"), separators=(",", ":"))+ encrypted_payload = self._get_fernet().encrypt(payload.encode("utf-8"))++ temp_path = item_path.with_suffix(f".{secrets.token_urlsafe(8)}.tmp")+ try:+ self._write_file_durable(temp_path, encrypted_payload, mode=0o600)+ temp_path.replace(item_path)+ self._fsync_directory_best_effort(item_path.parent)+ finally:+ with suppress(FileNotFoundError):+ temp_path.unlink()++ def _get_fernet(self) -> Fernet:+ if self._fernet is not None:+ return self._fernet++ key = settings.LOCAL_CREDENTIAL_VAULT_KEY+ if key:+ self._fernet = Fernet(key.encode("utf-8"))+ return self._fernet++ vault_dir = self._vault_dir()+ key_path = vault_dir / ".fernet_key"+ if key_path.exists():+ key_bytes = key_path.read_bytes().strip()+ else:+ key_bytes = self._create_or_read_key_file(key_path)++ self._fernet = Fernet(key_bytes)+ return self._fernet++ def _create_or_read_key_file(self, key_path: Path) -> bytes:+ key_bytes = Fernet.generate_key()+ temp_path = key_path.with_name(f".fernet_key.{secrets.token_urlsafe(8)}.tmp")+ try:+ self._write_file_durable(temp_path, key_bytes + b"\n", mode=0o600)+ try:+ os.link(temp_path, key_path)+ self._fsync_directory_best_effort(key_path.parent)+ return key_bytes+ except FileExistsError:+ return key_path.read_bytes().strip()+ finally:+ with suppress(FileNotFoundError):+ temp_path.unlink()++ def _vault_dir(self) -> Path:+ vault_dir = Path(settings.LOCAL_CREDENTIAL_VAULT_PATH).expanduser().resolve()+ vault_dir.mkdir(parents=True, exist_ok=True)+ self._chmod_best_effort(vault_dir, 0o700)+ return vault_dir++ def _item_path(self, item_id: str) -> Path:+ if not item_id or not _ITEM_ID_PATTERN.fullmatch(item_id):+ raise HTTPException(status_code=400, detail="Invalid credential vault item ID")+ return self._vault_dir() / f"{item_id}.bin"++ def _delete_item_file(self, item_id: str) -> None:+ try:+ self._item_path(item_id).unlink(missing_ok=True)+ except HTTPException:+ raise+ except Exception:+ LOG.warning("Failed to delete local credential vault item", item_id=item_id, exc_info=True)++ @staticmethod+ def _generate_item_id() -> str:+ return f"creditem_{secrets.token_urlsafe(24)}"++ @staticmethod+ def _chmod_best_effort(path: Path, mode: int) -> None:+ with suppress(OSError):+ os.chmod(path, mode)++ @staticmethod+ def _write_file_durable(path: Path, payload: bytes, *, mode: int) -> None:+ fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, mode)+ try:+ with os.fdopen(fd, "wb") as file:+ fd = -1+ file.write(payload)+ file.flush()+ os.fsync(file.fileno())+ finally:+ if fd != -1:+ os.close(fd)++ @staticmethod+ def _fsync_directory_best_effort(path: Path) -> None:+ with suppress(OSError):+ fd = os.open(path, os.O_RDONLY)+ try:+ os.fsync(fd)+ finally:+ os.close(fd)diff --git a/tests/unit/test_credential_vault_type_override.py b/tests/unit/test_credential_vault_type_override.pyindex f0ce51d87..7bac4c57d 100644--- a/tests/unit/test_credential_vault_type_override.py+++ b/tests/unit/test_credential_vault_type_override.py@@ -1,11 +1,16 @@"""Tests for per-credential vault_type override in CreateCredentialRequest and vault service routing."""-from unittest.mock import MagicMock, patch+from types import SimpleNamespace+from unittest.mock import AsyncMock, MagicMock, patchimport pytestfrom fastapi import HTTPException-from skyvern.forge.sdk.routes.credentials import _get_credential_vault_service+from skyvern.config import Settings+from skyvern.forge.sdk.routes.credentials import (+ _delete_temporary_test_login_credential,+ _get_credential_vault_service,+)from skyvern.forge.sdk.schemas.credentials import (CreateCredentialRequest,CredentialResponse,@@ -19,6 +24,22 @@ from skyvern.forge.sdk.schemas.credentials import (from skyvern.forge.sdk.services.credential.credential_vault_service import CredentialVaultService+class TestLocalCredentialVaultSettings:+ """Verify the local filesystem vault is enabled only in local envs by default."""++ def test_local_credential_vault_defaults_enabled_for_local_env(self) -> None:+ settings = Settings(_env_file=None, ENV="local", ENABLE_LOCAL_CREDENTIAL_VAULT=None)+ assert settings.is_local_credential_vault_enabled()++ def test_local_credential_vault_defaults_disabled_for_non_local_env(self) -> None:+ settings = Settings(_env_file=None, ENV="prod", ENABLE_LOCAL_CREDENTIAL_VAULT=None)+ assert not settings.is_local_credential_vault_enabled()++ def test_local_credential_vault_can_be_explicitly_enabled_for_non_local_env(self) -> None:+ settings = Settings(_env_file=None, ENV="prod", ENABLE_LOCAL_CREDENTIAL_VAULT=True)+ assert settings.is_local_credential_vault_enabled()++class TestCreateCredentialRequestVaultType:"""Verify the optional vault_type field on CreateCredentialRequest."""@@ -57,6 +78,15 @@ class TestCreateCredentialRequestVaultType:)assert req.vault_type == CredentialVaultType.BITWARDEN+ def test_vault_type_can_be_set_to_skyvern(self) -> None:+ req = CreateCredentialRequest(+ name="Test",+ credential_type=CredentialType.PASSWORD,+ credential=NonEmptyPasswordCredential(username="u", password="p"),+ vault_type=CredentialVaultType.SKYVERN,+ )+ assert req.vault_type == CredentialVaultType.SKYVERN+def test_vault_type_serializes_in_json(self) -> None:req = CreateCredentialRequest(name="Test",@@ -145,6 +175,69 @@ class TestGetCredentialVaultServiceRouting:result = await _get_credential_vault_service()assert result is mock_bw+ @pytest.mark.asyncio+ async def test_no_override_uses_global_skyvern(self) -> None:+ mock_skyvern = MagicMock(spec=CredentialVaultService)+ with (+ patch("skyvern.forge.sdk.routes.credentials.settings") as mock_settings,+ patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,+ ):+ mock_settings.CREDENTIAL_VAULT_TYPE = CredentialVaultType.SKYVERN+ mock_settings.is_local_credential_vault_enabled.return_value = True+ mock_app.SKYVERN_CREDENTIAL_VAULT_SERVICE = mock_skyvern+ result = await _get_credential_vault_service()+ assert result is mock_skyvern++ @pytest.mark.asyncio+ async def test_no_override_skyvern_raises_when_local_vault_disabled(self) -> None:+ with (+ patch("skyvern.forge.sdk.routes.credentials.settings") as mock_settings,+ patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,+ ):+ mock_settings.CREDENTIAL_VAULT_TYPE = CredentialVaultType.SKYVERN+ mock_settings.is_local_credential_vault_enabled.return_value = False+ mock_app.SKYVERN_CREDENTIAL_VAULT_SERVICE = MagicMock(spec=CredentialVaultService)+ with pytest.raises(HTTPException) as exc_info:+ await _get_credential_vault_service()+ assert exc_info.value.status_code == 400+ assert "local credential vault is not enabled" in str(exc_info.value.detail)++ @pytest.mark.asyncio+ async def test_override_skyvern_ignores_global(self) -> None:+ mock_bw = MagicMock(spec=CredentialVaultService)+ mock_skyvern = MagicMock(spec=CredentialVaultService)+ with (+ patch("skyvern.forge.sdk.routes.credentials.settings") as mock_settings,+ patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,+ ):+ mock_settings.CREDENTIAL_VAULT_TYPE = CredentialVaultType.BITWARDEN+ mock_settings.is_local_credential_vault_enabled.return_value = True+ mock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_bw+ mock_app.SKYVERN_CREDENTIAL_VAULT_SERVICE = mock_skyvern+ result = await _get_credential_vault_service(+ vault_type_override=CredentialVaultType.SKYVERN,+ )+ assert result is mock_skyvern++ @pytest.mark.asyncio+ async def test_override_skyvern_raises_when_local_vault_disabled(self) -> None:+ mock_bw = MagicMock(spec=CredentialVaultService)+ mock_skyvern = MagicMock(spec=CredentialVaultService)+ with (+ patch("skyvern.forge.sdk.routes.credentials.settings") as mock_settings,+ patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,+ ):+ mock_settings.CREDENTIAL_VAULT_TYPE = CredentialVaultType.BITWARDEN+ mock_settings.is_local_credential_vault_enabled.return_value = False+ mock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_bw+ mock_app.SKYVERN_CREDENTIAL_VAULT_SERVICE = mock_skyvern+ with pytest.raises(HTTPException) as exc_info:+ await _get_credential_vault_service(+ vault_type_override=CredentialVaultType.SKYVERN,+ )+ assert exc_info.value.status_code == 400+ assert "local credential vault is not enabled" in str(exc_info.value.detail)+@pytest.mark.asyncioasync def test_override_custom_ignores_global(self) -> None:mock_bw = MagicMock(spec=CredentialVaultService)@@ -234,3 +327,88 @@ class TestGetCredentialVaultServiceRouting:mock_app.CUSTOM_CREDENTIAL_VAULT_SERVICE = mock_customresult = await _get_credential_vault_service(vault_type_override=None)assert result is mock_custom+++class TestTemporaryTestLoginCredentialCleanup:+ """Verify temporary login-test credentials are deleted through the owning vault service."""++ @pytest.mark.asyncio+ async def test_deletes_temporary_skyvern_credential_through_vault_service(self) -> None:+ credential = SimpleNamespace(+ credential_id="cred_temp",+ organization_id="org_test",+ name="_test_login_example",+ vault_type=CredentialVaultType.SKYVERN,+ )+ mock_repository = MagicMock()+ mock_repository.get_credential = AsyncMock(return_value=credential)+ mock_service = MagicMock(spec=CredentialVaultService)+ mock_service.delete_credential = AsyncMock()++ with (+ patch("skyvern.forge.sdk.routes.credentials.settings") as mock_settings,+ patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,+ ):+ mock_settings.is_local_credential_vault_enabled.return_value = True+ mock_app.DATABASE.credentials = mock_repository+ mock_app.SKYVERN_CREDENTIAL_VAULT_SERVICE = mock_service++ await _delete_temporary_test_login_credential(+ credential_id="cred_temp",+ organization_id="org_test",+ reason="test",+ )++ mock_service.delete_credential.assert_awaited_once_with(credential)++ @pytest.mark.asyncio+ async def test_defaults_missing_vault_type_to_bitwarden_for_legacy_credentials(self) -> None:+ credential = SimpleNamespace(+ credential_id="cred_temp",+ organization_id="org_test",+ name="_test_login_example",+ vault_type=None,+ )+ mock_repository = MagicMock()+ mock_repository.get_credential = AsyncMock(return_value=credential)+ mock_service = MagicMock(spec=CredentialVaultService)+ mock_service.delete_credential = AsyncMock()++ with (+ patch("skyvern.forge.sdk.routes.credentials.settings"),+ patch("skyvern.forge.sdk.routes.credentials.app") as mock_app,+ ):+ mock_app.DATABASE.credentials = mock_repository+ mock_app.BITWARDEN_CREDENTIAL_VAULT_SERVICE = mock_service++ await _delete_temporary_test_login_credential(+ credential_id="cred_temp",+ organization_id="org_test",+ reason="test",+ )++ mock_service.delete_credential.assert_awaited_once_with(credential)++ @pytest.mark.asyncio+ async def test_ignores_non_temporary_credentials(self) -> None:+ credential = SimpleNamespace(+ credential_id="cred_regular",+ organization_id="org_test",+ name="regular credential",+ vault_type=CredentialVaultType.SKYVERN,+ )+ mock_repository = MagicMock()+ mock_repository.get_credential = AsyncMock(return_value=credential)+ mock_service = MagicMock(spec=CredentialVaultService)+ mock_service.delete_credential = AsyncMock()++ with patch("skyvern.forge.sdk.routes.credentials.app") as mock_app:+ mock_app.DATABASE.credentials = mock_repository++ await _delete_temporary_test_login_credential(+ credential_id="cred_regular",+ organization_id="org_test",+ reason="test",+ )++ mock_service.delete_credential.assert_not_awaited()diff --git a/tests/unit/test_skyvern_credential_vault_service.py b/tests/unit/test_skyvern_credential_vault_service.pynew file mode 100644index 000000000..b65981c34--- /dev/null+++ b/tests/unit/test_skyvern_credential_vault_service.py@@ -0,0 +1,242 @@+from concurrent.futures import ThreadPoolExecutor+from datetime import datetime++import pytest+from cryptography.fernet import Fernet+from fastapi import HTTPException++from skyvern.config import settings+from skyvern.forge import app+from skyvern.forge.sdk.schemas.credentials import (+ CreateCredentialRequest,+ Credential,+ CredentialType,+ CredentialVaultType,+ NonEmptyPasswordCredential,+)+from skyvern.forge.sdk.services.credential.skyvern_credential_vault_service import (+ SkyvernCredentialVaultService,+)+++class _FakeCredentialRepository:+ def __init__(self) -> None:+ self.deleted: tuple[str, str] | None = None++ async def create_credential(self, **kwargs: object) -> Credential:+ return self._credential(+ credential_id="cred_test",+ organization_id=str(kwargs["organization_id"]),+ name=str(kwargs["name"]),+ vault_type=kwargs["vault_type"],+ item_id=str(kwargs["item_id"]),+ credential_type=kwargs["credential_type"],+ username=kwargs["username"],+ )++ async def update_credential_vault_data(self, **kwargs: object) -> Credential:+ return self._credential(+ credential_id=str(kwargs["credential_id"]),+ organization_id=str(kwargs["organization_id"]),+ name=str(kwargs["name"]),+ vault_type=CredentialVaultType.SKYVERN,+ item_id=str(kwargs["item_id"]),+ credential_type=kwargs["credential_type"],+ username=kwargs["username"],+ )++ async def delete_credential(self, credential_id: str, organization_id: str) -> None:+ self.deleted = (credential_id, organization_id)++ @staticmethod+ def _credential(+ *,+ credential_id: str,+ organization_id: str,+ name: str,+ vault_type: object,+ item_id: str,+ credential_type: object,+ username: object,+ ) -> Credential:+ return Credential(+ credential_id=credential_id,+ organization_id=organization_id,+ name=name,+ vault_type=vault_type,+ item_id=item_id,+ credential_type=credential_type,+ username=username,+ totp_type="none",+ totp_identifier=None,+ card_last4=None,+ card_brand=None,+ secret_label=None,+ browser_profile_id=None,+ tested_url=None,+ user_context=None,+ save_browser_session_intent=False,+ folder_id=None,+ created_at=datetime(2026, 1, 1),+ modified_at=datetime(2026, 1, 1),+ deleted_at=None,+ )+++class _FailingCreateCredentialRepository(_FakeCredentialRepository):+ async def create_credential(self, **kwargs: object) -> Credential:+ raise RuntimeError("database unavailable")+++class _FailingUpdateCredentialRepository(_FakeCredentialRepository):+ async def update_credential_vault_data(self, **kwargs: object) -> Credential:+ raise RuntimeError("database unavailable")+++def _password_request(name: str = "Login", password: str = "secret-password") -> CreateCredentialRequest:+ return CreateCredentialRequest(+ name=name,+ credential_type=CredentialType.PASSWORD,+ credential=NonEmptyPasswordCredential(username="[email protected]", password=password),+ )+++async def test_skyvern_credential_vault_round_trips_encrypted_password(tmp_path, monkeypatch) -> None:+ monkeypatch.setattr(settings, "LOCAL_CREDENTIAL_VAULT_PATH", str(tmp_path))+ monkeypatch.setattr(settings, "LOCAL_CREDENTIAL_VAULT_KEY", None)++ repository = _FakeCredentialRepository()+ monkeypatch.setattr(app.DATABASE, "credentials", repository)++ service = SkyvernCredentialVaultService()+ request = _password_request()++ credential = await service.create_credential("org_test", request)++ assert credential.vault_type == CredentialVaultType.SKYVERN+ item_path = tmp_path / f"{credential.item_id}.bin"+ assert item_path.exists()+ assert b"secret-password" not in item_path.read_bytes()++ item = await service.get_credential_item(credential)+ assert item.name == "Login"+ assert item.credential_type == CredentialType.PASSWORD+ assert item.credential.username == "[email protected]"+ assert item.credential.password == "secret-password"++ await service.delete_credential(credential)+ assert repository.deleted == ("cred_test", "org_test")+ assert not item_path.exists()+++async def test_skyvern_credential_vault_update_creates_new_item_and_cleans_old(tmp_path, monkeypatch) -> None:+ monkeypatch.setattr(settings, "LOCAL_CREDENTIAL_VAULT_PATH", str(tmp_path))+ monkeypatch.setattr(settings, "LOCAL_CREDENTIAL_VAULT_KEY", None)++ monkeypatch.setattr(app.DATABASE, "credentials", _FakeCredentialRepository())++ service = SkyvernCredentialVaultService()+ request = _password_request(password="old-password")+ credential = await service.create_credential("org_test", request)+ old_item_id = credential.item_id++ update_request = _password_request(name="Login Updated", password="new-password")+ updated = await service.update_credential(credential, update_request)++ assert updated.item_id != old_item_id+ assert (tmp_path / f"{old_item_id}.bin").exists()++ await service.post_delete_credential_item(old_item_id)+ assert not (tmp_path / f"{old_item_id}.bin").exists()++ item = await service.get_credential_item(updated)+ assert item.name == "Login Updated"+ assert item.credential.password == "new-password"+++async def test_skyvern_credential_vault_cleans_item_when_create_db_fails(tmp_path, monkeypatch) -> None:+ monkeypatch.setattr(settings, "LOCAL_CREDENTIAL_VAULT_PATH", str(tmp_path))+ monkeypatch.setattr(settings, "LOCAL_CREDENTIAL_VAULT_KEY", None)+ monkeypatch.setattr(app.DATABASE, "credentials", _FailingCreateCredentialRepository())++ service = SkyvernCredentialVaultService()++ with pytest.raises(RuntimeError, match="database unavailable"):+ await service.create_credential("org_test", _password_request())++ assert list(tmp_path.glob("*.bin")) == []+++async def test_skyvern_credential_vault_cleans_new_item_when_update_db_fails(tmp_path, monkeypatch) -> None:+ monkeypatch.setattr(settings, "LOCAL_CREDENTIAL_VAULT_PATH", str(tmp_path))+ monkeypatch.setattr(settings, "LOCAL_CREDENTIAL_VAULT_KEY", None)+ monkeypatch.setattr(app.DATABASE, "credentials", _FailingUpdateCredentialRepository())++ service = SkyvernCredentialVaultService()+ credential = await service.create_credential("org_test", _password_request(password="old-password"))+ old_item_path = tmp_path / f"{credential.item_id}.bin"++ with pytest.raises(RuntimeError, match="database unavailable"):+ await service.update_credential(+ credential,+ _password_request(name="Login Updated", password="new-password"),+ )++ assert old_item_path.exists()+ assert list(tmp_path.glob("*.bin")) == [old_item_path]+++async def test_skyvern_credential_vault_rejects_invalid_item_id(tmp_path, monkeypatch) -> None:+ monkeypatch.setattr(settings, "LOCAL_CREDENTIAL_VAULT_PATH", str(tmp_path))+ monkeypatch.setattr(settings, "LOCAL_CREDENTIAL_VAULT_KEY", None)+ credential = _FakeCredentialRepository._credential(+ credential_id="cred_test",+ organization_id="org_test",+ name="Login",+ vault_type=CredentialVaultType.SKYVERN,+ item_id="../outside",+ credential_type=CredentialType.PASSWORD,+ username="[email protected]",+ )++ with pytest.raises(HTTPException) as exc_info:+ await SkyvernCredentialVaultService().get_credential_item(credential)++ assert exc_info.value.status_code == 400+++async def test_skyvern_credential_vault_wrong_key_cannot_decrypt_item(tmp_path, monkeypatch) -> None:+ monkeypatch.setattr(settings, "LOCAL_CREDENTIAL_VAULT_PATH", str(tmp_path))+ monkeypatch.setattr(settings, "LOCAL_CREDENTIAL_VAULT_KEY", Fernet.generate_key().decode("utf-8"))+ monkeypatch.setattr(app.DATABASE, "credentials", _FakeCredentialRepository())++ credential = await SkyvernCredentialVaultService().create_credential("org_test", _password_request())+ monkeypatch.setattr(settings, "LOCAL_CREDENTIAL_VAULT_KEY", Fernet.generate_key().decode("utf-8"))++ with pytest.raises(HTTPException) as exc_info:+ await SkyvernCredentialVaultService().get_credential_item(credential)++ assert exc_info.value.status_code == 500+++def test_skyvern_credential_vault_key_file_creation_is_single_winner(tmp_path, monkeypatch) -> None:+ monkeypatch.setattr(settings, "LOCAL_CREDENTIAL_VAULT_PATH", str(tmp_path))+ monkeypatch.setattr(settings, "LOCAL_CREDENTIAL_VAULT_KEY", None)+ key_path = tmp_path / ".fernet_key"++ def create_key_file() -> bytes:+ return SkyvernCredentialVaultService()._create_or_read_key_file(key_path)++ with ThreadPoolExecutor(max_workers=8) as executor:+ returned_keys = list(executor.map(lambda _: create_key_file(), range(8)))++ stored_key = key_path.read_bytes().strip()+ assert len(set(returned_keys)) == 1+ assert returned_keys[0] == stored_key+ assert list(tmp_path.glob("*.tmp")) == []