Skip to content

Automate browser based workflows with AI

Restrict access to credential folders (#8950)

Aaron Perez1ae950bb9d83
diff --git a/docs/api-reference/openapi.json b/docs/api-reference/openapi.json
index 6ba474d8d..40c5cad8f 100644
--- a/docs/api-reference/openapi.json
+++ b/docs/api-reference/openapi.json
@@ -11222,6 +11222,17 @@
],
"title": "Last Verified Login At"
},
+ "linked_credential_id": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ],
+ "title": "Linked Credential Id"
+ },
"linked_credential_name": {
"anyOf": [
{
diff --git a/fern/openapi/skyvern_openapi.json b/fern/openapi/skyvern_openapi.json
index 9c549fe7f..f1a65e388 100644
--- a/fern/openapi/skyvern_openapi.json
+++ b/fern/openapi/skyvern_openapi.json
@@ -11102,6 +11102,17 @@
],
"title": "Last Verified Login At"
},
+ "linked_credential_id": {
+ "anyOf": [
+ {
+ "type": "string"
+ },
+ {
+ "type": "null"
+ }
+ ],
+ "title": "Linked Credential Id"
+ },
"linked_credential_name": {
"anyOf": [
{
@@ -34515,4 +34526,4 @@
"x-fern-server-name": "Local"
}
]
-}
\ No newline at end of file
+}
diff --git a/skyvern/forge/agent_functions.py b/skyvern/forge/agent_functions.py
index 6c34a724f..505ef7a7a 100644
--- a/skyvern/forge/agent_functions.py
+++ b/skyvern/forge/agent_functions.py
@@ -989,6 +989,40 @@ class AgentFunction:
"""Return visible folder IDs for Cloud request lists; OSS keeps organization-wide visibility."""
return None
+ async def workflow_folders_restricted(self, organization_id: str) -> bool:
+ """Cloud reports folder restrictions; OSS has no workflow-folder ACLs."""
+ return False
+
+ async def accessible_workflow_reference_ids(
+ self, principal: RequestPrincipal | None, action: str, references: set[tuple[str, str]]
+ ) -> set[tuple[str, str]]:
+ """Return references visible to this principal; OSS has no workflow-folder ACLs."""
+ return references
+
+ async def accessible_credential_folder_ids(self, principal: RequestPrincipal | None) -> set[str] | None:
+ """Return visible credential-folder IDs for Cloud request lists; OSS keeps organization-wide visibility."""
+ return None
+
+ async def credential_folders_restricted(self, organization_id: str) -> bool:
+ """Cloud reports folder restrictions; OSS has no credential-folder ACLs."""
+ return False
+
+ async def credential_folder_admin_bypass(self, principal: RequestPrincipal | None) -> bool:
+ """Cloud reports the credential-folder Admin bypass; OSS has no credential-folder ACLs."""
+ return False
+
+ async def accessible_credential_ids(
+ self, principal: RequestPrincipal | None, action: str, credential_ids: set[str]
+ ) -> set[str]:
+ """Return credentials visible for an action; OSS has no credential-folder ACLs."""
+ return credential_ids
+
+ async def accessible_browser_session_ids(
+ self, principal: RequestPrincipal | None, organization_id: str, browser_session_ids: set[str]
+ ) -> set[str]:
+ """Return sessions whose associated workflow credentials are usable; OSS has no credential-folder ACLs."""
+ return browser_session_ids
+
async def enforce_folder_access(
self, principal: RequestPrincipal | None, action: str, resource: Mapping[str, object]
) -> None:
@@ -1017,6 +1051,48 @@ class AgentFunction:
"""Cloud raises 403 when a folder denies the action on any of the runs, checked in one pass; OSS allows."""
return None
+ async def enforce_credential_folder_access_for_ids(
+ self,
+ principal: RequestPrincipal | None,
+ action: str,
+ references: set[tuple[str, str]],
+ *,
+ session: AsyncSession | None = None,
+ ) -> None:
+ """Cloud raises 403 when a credential folder denies the action on any referenced credential or folder."""
+ return None
+
+ async def enforce_credential_use(
+ self,
+ organization_id: str,
+ credential_id: str,
+ *,
+ principal: RequestPrincipal | None = None,
+ workflow_run_id: str | None = None,
+ ) -> None:
+ """Cloud checks folder use before releasing a credential secret; OSS has no credential-folder ACLs."""
+
+ async def enforce_totp_identifier_credential_use(
+ self, organization_id: str, totp_identifier: str, *, workflow_run_id: str | None = None
+ ) -> None:
+ """Cloud checks credentials bound to a TOTP identifier; OSS has no credential-folder ACLs."""
+
+ async def enforce_browser_session_credential_use(
+ self, principal: RequestPrincipal | None, browser_session_id: str
+ ) -> None:
+ """Cloud checks the credential linked to a saved profile before session access; OSS has no folder ACLs."""
+
+ async def enforce_workflow_run_credential_use(
+ self,
+ principal: RequestPrincipal | None,
+ workflow_run_id: str,
+ *,
+ organization_id: str | None = None,
+ browser_profile_id: str | None = None,
+ browser_session_id: str | None = None,
+ ) -> None:
+ """Cloud checks credentials attached to run browser state; OSS has no credential-folder ACLs."""
+
async def hidden_workflow_permanent_ids(
self, principal: RequestPrincipal | None, organization_id: str
) -> frozenset[str] | None:
diff --git a/skyvern/forge/sdk/copilot/credential_pause.py b/skyvern/forge/sdk/copilot/credential_pause.py
index faca23cc4..c35931d4c 100644
--- a/skyvern/forge/sdk/copilot/credential_pause.py
+++ b/skyvern/forge/sdk/copilot/credential_pause.py
@@ -40,7 +40,12 @@ from skyvern.forge import app
from skyvern.forge.sdk.browser_action_policy import canonicalize_origin
from skyvern.forge.sdk.cache.base import BaseCache
from skyvern.forge.sdk.copilot.config import CopilotConfig
-from skyvern.forge.sdk.copilot.credential_resolution import loggable_origin, safe_admitted_url, url_parts
+from skyvern.forge.sdk.copilot.credential_resolution import (
+ load_credentials,
+ loggable_origin,
+ safe_admitted_url,
+ url_parts,
+)
from skyvern.forge.sdk.copilot.diagnosis_repair_contract import DiagnosisFailureType, RepairNextAction
from skyvern.forge.sdk.copilot.human_input_wait import pause_human_input
from skyvern.forge.sdk.copilot.request_policy import RequestPolicy
@@ -914,7 +919,7 @@ async def _try_resolve_credential_response(
return CredentialPauseResolution(action="signed_in", signed_in=signed_in) if signed_in else None
if not credential_id:
return None
- existing = await app.DATABASE.credentials.get_credentials_by_ids([credential_id], organization_id=organization_id)
+ existing = await load_credentials(organization_id, credential_ids=[credential_id])
if not existing:
return None
return CredentialPauseResolution(action="connected", credential=existing[0])
@@ -1063,7 +1068,10 @@ async def _run_credential_pause(
from skyvern.forge.sdk.copilot.tools.credential_fill import _read_vault_named_sites # circular import
# The vault entry's sites grant whole-site, so they are compared by site; an unreadable entry offers nothing.
- vault_sites = await _read_vault_named_sites(ctx, named_credential_id)
+ try:
+ vault_sites = await _read_vault_named_sites(ctx, named_credential_id)
+ except PermissionError:
+ vault_sites = None
if vault_sites is None or (vault_sites and not any(same_site(login_page_urls[0], uri) for uri in vault_sites)):
named_credential_id = None
timeout_seconds = copilot_config.credential_pause_timeout_seconds
diff --git a/skyvern/forge/sdk/copilot/credential_resolution.py b/skyvern/forge/sdk/copilot/credential_resolution.py
index 6b2b028ab..59ac3ab24 100644
--- a/skyvern/forge/sdk/copilot/credential_resolution.py
+++ b/skyvern/forge/sdk/copilot/credential_resolution.py
@@ -14,6 +14,7 @@ from urllib.parse import ParseResult, parse_qsl, urlencode, urlparse
from skyvern.forge import app
from skyvern.forge.sdk.schemas.credentials import Credential, CredentialType
+from skyvern.forge.sdk.services.request_principal import get_request_principal
CredentialUrlTier = Literal["url_exact", "url_path", "url_host"]
CredentialResolutionTier = Literal["url_exact", "url_path", "url_host", "urlless_sole"]
@@ -32,17 +33,56 @@ class CredentialResolution:
return any(candidate.credential_id == credential_id for candidate in self.candidates)
-async def load_credentials(organization_id: str) -> list[Credential]:
+async def credential_folder_ids_for_current_request() -> set[str] | None:
+ principal = get_request_principal()
+ return await app.AGENT_FUNCTION.accessible_credential_folder_ids(principal) if principal is not None else None
+
+
+async def load_credentials(
+ organization_id: str,
+ *,
+ credential_ids: Sequence[str] | None = None,
+ page: int | None = None,
+ page_size: int = 50,
+ include_deleted: bool = False,
+) -> list[Credential]:
+ allowed_folder_ids = await credential_folder_ids_for_current_request()
+ if credential_ids is not None:
+ return await app.DATABASE.credentials.get_credentials_by_ids(
+ list(credential_ids),
+ organization_id=organization_id,
+ allowed_folder_ids=allowed_folder_ids,
+ include_deleted=include_deleted,
+ )
+ if page is not None:
+ return await app.DATABASE.credentials.get_credentials(
+ organization_id=organization_id,
+ page=page,
+ page_size=page_size,
+ allowed_folder_ids=allowed_folder_ids,
+ )
+
page = 1
credentials: list[Credential] = []
while True:
- items = await app.DATABASE.credentials.get_credentials(organization_id=organization_id, page=page, page_size=50)
+ items = await app.DATABASE.credentials.get_credentials(
+ organization_id=organization_id,
+ page=page,
+ page_size=50,
+ allowed_folder_ids=allowed_folder_ids,
+ )
credentials.extend(items)
if len(items) < 50:
return sorted(credentials, key=lambda c: getattr(c, "created_at", None) or "", reverse=True)
page += 1
+async def count_visible_credentials(organization_id: str) -> int:
+ return await app.DATABASE.credentials.count_credentials(
+ organization_id, allowed_folder_ids=await credential_folder_ids_for_current_request()
+ )
+
+
def _parse_url(url: str) -> ParseResult | None:
"""`urlparse` that declines a malformed authority instead of raising.
diff --git a/skyvern/forge/sdk/copilot/demonstration_recorder.py b/skyvern/forge/sdk/copilot/demonstration_recorder.py
index a0c726bcb..8b729196c 100644
--- a/skyvern/forge/sdk/copilot/demonstration_recorder.py
+++ b/skyvern/forge/sdk/copilot/demonstration_recorder.py
@@ -19,12 +19,11 @@ from playwright.async_api import Page
from skyvern.cli.mcp_tools._localhost import is_localhost_url
from skyvern.config import settings
from skyvern.exceptions import BlockedHost, SkyvernHTTPException
-from skyvern.forge import app
from skyvern.forge.sdk.cache.base import BaseCache
from skyvern.forge.sdk.copilot.config import ALL_BLOCK_FAMILIES, AuthoringCapability
from skyvern.forge.sdk.copilot.context import CopilotContext
from skyvern.forge.sdk.copilot.credential_pause import apply_connected_credential_to_policy
-from skyvern.forge.sdk.copilot.credential_resolution import safe_admitted_url
+from skyvern.forge.sdk.copilot.credential_resolution import load_credentials, safe_admitted_url
from skyvern.forge.sdk.copilot.demonstration_tap import DEMONSTRATION_MAX_EVENTS, PageTap, TapEvent
from skyvern.forge.sdk.copilot.request_policy import RequestPolicy
from skyvern.forge.sdk.copilot.runtime import (
@@ -870,9 +869,7 @@ class DemonstrationRecorder:
or self.page is None
):
return
- credentials = await app.DATABASE.credentials.get_credentials_by_ids(
- [credential_id], organization_id=self.organization_id
- )
+ credentials = await load_credentials(self.organization_id, credential_ids=[credential_id])
if not credentials:
await self._notice("The saved credential is no longer available.", level="error")
return
diff --git a/skyvern/forge/sdk/copilot/demonstration_replay.py b/skyvern/forge/sdk/copilot/demonstration_replay.py
index f9cd7e5d2..03ea9f240 100644
--- a/skyvern/forge/sdk/copilot/demonstration_replay.py
+++ b/skyvern/forge/sdk/copilot/demonstration_replay.py
@@ -11,12 +11,11 @@ from typing import Any, cast
import structlog
from mcp.types import CallToolResult, TextContent
-from skyvern.forge import app
from skyvern.forge.sdk.api.llm.api_handler import LLMAPIHandler
from skyvern.forge.sdk.cache.base import BaseCache
from skyvern.forge.sdk.copilot.context import CopilotContext
from skyvern.forge.sdk.copilot.credential_pause import apply_connected_credential_to_policy
-from skyvern.forge.sdk.copilot.credential_resolution import safe_admitted_url
+from skyvern.forge.sdk.copilot.credential_resolution import load_credentials, safe_admitted_url
from skyvern.forge.sdk.copilot.demonstration_recorder import (
DEMONSTRATION_CANCELLED_TTL,
DEMONSTRATION_TTL,
@@ -213,9 +212,7 @@ async def _replay_events(
source_url = _safe_model_visible_url(_event_source_url(event))
credentials = []
if isinstance(credential_id, str):
- credentials = await app.DATABASE.credentials.get_credentials_by_ids(
- [credential_id], organization_id=ctx.organization_id
- )
+ credentials = await load_credentials(ctx.organization_id, credential_ids=[credential_id])
policy = ctx.request_policy
if credentials and isinstance(policy, RequestPolicy):
policy.credential_ask_login_page_urls = [source_url]
diff --git a/skyvern/forge/sdk/copilot/request_policy.py b/skyvern/forge/sdk/copilot/request_policy.py
index d573d4f5d..ea8bcc49b 100644
--- a/skyvern/forge/sdk/copilot/request_policy.py
+++ b/skyvern/forge/sdk/copilot/request_policy.py
@@ -14,7 +14,6 @@ import structlog
from pydantic import BaseModel, ConfigDict, ValidationError
from skyvern.config import settings
-from skyvern.forge import app
from skyvern.forge.log_redaction import redact_sensitive_fields
from skyvern.forge.prompts import prompt_engine
from skyvern.forge.sdk.api.llm.api_handler import LLMAPIHandler
@@ -214,10 +213,7 @@ async def _saved_credential_ids(citations: list[str], organization_id: str) -> s
connection_ids = {citation for citation in citations if citation.startswith("goac_")}
verified_ids: set[str] = set()
if credential_ids:
- credentials = await app.DATABASE.credentials.get_credentials_by_ids(
- credential_ids,
- organization_id=organization_id,
- )
+ credentials = await _load_credentials(organization_id, credential_ids=credential_ids)
verified_ids.update(credential.credential_id for credential in credentials)
if connection_ids:
connections = await google_oauth_service.get_visible_credentials_for_org(organization_id)
@@ -4363,10 +4359,7 @@ async def _seed_prior_approved_credentials(
missing_ids = sorted(approved_ids - {credential.credential_id for credential in policy.resolved_credentials})
if not missing_ids:
return
- credentials = await app.DATABASE.credentials.get_credentials_by_ids(
- missing_ids,
- organization_id=organization_id,
- )
+ credentials = await _load_credentials(organization_id, credential_ids=missing_ids)
policy.resolved_credentials = _deduplicate_credentials(
[
*policy.resolved_credentials,
@@ -4391,10 +4384,7 @@ async def _seed_proposed_credential(
seed = _proposed_credential_seed(global_llm_context)
if seed is None:
return
- credentials = await app.DATABASE.credentials.get_credentials_by_ids(
- [seed.credential_id],
- organization_id=organization_id,
- )
+ credentials = await _load_credentials(organization_id, credential_ids=[seed.credential_id])
credential = next((item for item in credentials if item.credential_id == seed.credential_id), None)
if credential is None:
return
diff --git a/skyvern/forge/sdk/copilot/tools/account_groups.py b/skyvern/forge/sdk/copilot/tools/account_groups.py
index 8460c767b..417783303 100644
--- a/skyvern/forge/sdk/copilot/tools/account_groups.py
+++ b/skyvern/forge/sdk/copilot/tools/account_groups.py
@@ -26,6 +26,7 @@ from skyvern.forge.sdk.copilot.ask_user import (
wait_for_interaction,
)
from skyvern.forge.sdk.copilot.context import CopilotContext
+from skyvern.forge.sdk.copilot.credential_resolution import load_credentials
from skyvern.forge.sdk.copilot.secret_redaction import redact_raw_secrets_for_prompt
from skyvern.forge.sdk.copilot.secret_scrub import scrub_secrets_from_structure, scrub_secrets_from_text
from skyvern.forge.sdk.copilot.tools.credentials import (
@@ -308,9 +309,7 @@ async def _latest_outcomes(
async def _resolve_credentials(ctx: CopilotContext, credential_ids: list[str]) -> dict[str, Credential]:
found = {
credential.credential_id: credential
- for credential in await app.DATABASE.credentials.get_credentials_by_ids(
- credential_ids, organization_id=ctx.organization_id
- )
+ for credential in await load_credentials(ctx.organization_id, credential_ids=credential_ids)
}
missing = [credential_id for credential_id in credential_ids if credential_id not in found]
if missing:
@@ -453,6 +452,7 @@ def _rows(group: WorkflowRunGroupResponse, labels: dict[str, str]) -> list[Accou
outcome=item.outcome,
)
for item in group.items
+ if item.key in labels
]
@@ -558,8 +558,8 @@ async def _group_for_this_workflow(ctx: CopilotContext, workflow_run_group_id: s
async def _labels(ctx: CopilotContext, group: WorkflowRunGroupResponse) -> dict[str, str]:
- credentials = await app.DATABASE.credentials.get_credentials_by_ids(
- [item.key for item in group.items], organization_id=ctx.organization_id
+ credentials = await load_credentials(
+ ctx.organization_id, credential_ids=[item.key for item in group.items], include_deleted=True
)
return {credential.credential_id: _label(credential) for credential in credentials}
diff --git a/skyvern/forge/sdk/copilot/tools/credential_deletion.py b/skyvern/forge/sdk/copilot/tools/credential_deletion.py
index e894b32bf..6a251a27d 100644
--- a/skyvern/forge/sdk/copilot/tools/credential_deletion.py
+++ b/skyvern/forge/sdk/copilot/tools/credential_deletion.py
@@ -4,6 +4,7 @@ from collections import Counter
from typing import Any, Literal
from uuid import uuid4
+from fastapi import HTTPException
from pydantic import BaseModel
from skyvern.config import settings
@@ -17,6 +18,8 @@ from skyvern.forge.sdk.copilot.ask_user import (
wait_for_interaction,
)
from skyvern.forge.sdk.copilot.context import CopilotContext
+from skyvern.forge.sdk.copilot.credential_resolution import count_visible_credentials, load_credentials
+from skyvern.forge.sdk.services.request_principal import get_request_principal
DELETE_TOOL_DESCRIPTION = (
"Delete saved credentials (passwords, cards, secrets) from this organization's Skyvern vault, after the "
@@ -47,6 +50,12 @@ def credential_delete_enabled() -> bool:
return settings.COPILOT_CREDENTIAL_DELETE_ENABLED
+async def enforce_credential_delete_access(credential_id: str) -> None:
+ await app.AGENT_FUNCTION.enforce_credential_folder_access_for_ids(
+ get_request_principal(), "credential.delete", {("credential_id", credential_id)}
+ )
+
+
async def build_delete_review(ctx: CopilotContext, credential_ids: list[str]) -> CredentialDeleteReview | str:
if not credential_ids:
return "Select at least one credential id."
@@ -60,23 +69,32 @@ async def build_delete_review(ctx: CopilotContext, credential_ids: list[str]) ->
return f"These credential ids are listed more than once: {duplicates}. Nothing was deleted."
found = {
credential.credential_id: credential
- for credential in await app.DATABASE.credentials.get_credentials_by_ids(
- credential_ids, organization_id=ctx.organization_id
- )
+ for credential in await load_credentials(ctx.organization_id, credential_ids=credential_ids)
}
missing = [credential_id for credential_id in credential_ids if credential_id not in found]
if missing:
return f"These ids are not saved credentials in this organization: {missing}. Nothing was deleted."
- return CredentialDeleteReview(
- rows=[
+ rows: list[CredentialDeleteRow] = []
+ for credential_id in credential_ids:
+ try:
+ await enforce_credential_delete_access(credential_id)
+ except HTTPException as exc:
+ if exc.status_code != 403:
+ raise
+ continue
+ credential = found[credential_id]
+ rows.append(
CredentialDeleteRow(
credential_id=credential_id,
- name=found[credential_id].name,
- credential_type=found[credential_id].credential_type,
+ name=credential.name,
+ credential_type=credential.credential_type,
)
- for credential_id in credential_ids
- ],
- total_credential_count=await app.DATABASE.credentials.count_credentials(ctx.organization_id),
+ )
+ if not rows:
+ return "None of the selected credentials can be deleted. Nothing was deleted."
+ return CredentialDeleteReview(
+ rows=rows,
+ total_credential_count=await count_visible_credentials(ctx.organization_id),
)
diff --git a/skyvern/forge/sdk/copilot/tools/credential_fill.py b/skyvern/forge/sdk/copilot/tools/credential_fill.py
index c88a09d1e..732f98ac8 100644
--- a/skyvern/forge/sdk/copilot/tools/credential_fill.py
+++ b/skyvern/forge/sdk/copilot/tools/credential_fill.py
@@ -83,6 +83,7 @@ from skyvern.forge.sdk.schemas.credentials import (
)
from skyvern.forge.sdk.schemas.workflow_copilot import CredentialRegistration, WorkflowCopilotCredentialRegistration
from skyvern.forge.sdk.services.credentials import generate_totp_code, normalize_totp_config
+from skyvern.forge.sdk.services.request_principal import get_request_principal
from skyvern.webeye.utils.dom import is_post_dispatch_click_timeout
from ._shared import _emit_tool_blocker_signal
@@ -285,7 +286,10 @@ async def _credential_evidence_admits_origin(
"""Whether the credential itself places it on the recovery origin, and nowhere else."""
if credential.credential_id == recovery.refused_credential_id:
return False
- vault_sites = await _read_vault_named_sites(copilot_ctx, credential.credential_id)
+ try:
+ vault_sites = await _read_vault_named_sites(copilot_ctx, credential.credential_id)
+ except PermissionError:
+ return False
if vault_sites is None:
return False
evidence = ([credential.tested_url] if credential.tested_url else []) + vault_sites
@@ -399,6 +403,11 @@ async def _vault_named_sites(copilot_ctx: AgentContext, credential_id: str) -> l
async def _read_vault_named_sites(copilot_ctx: AgentContext, credential_id: str) -> list[str] | None:
"""Sites the credential's own vault entry names (only Bitwarden items carry any), or None when the read failed."""
+ await app.AGENT_FUNCTION.enforce_credential_use(
+ copilot_ctx.organization_id,
+ credential_id,
+ principal=get_request_principal(),
+ )
cached = copilot_ctx.vault_login_uris_by_credential_id.get(credential_id)
if cached is not None:
return cached
@@ -1040,6 +1049,14 @@ async def _credential_fill_origin_grant(
async def _load_vault_credential_item(
copilot_ctx: AgentContext, credential_id: str
) -> tuple[CredentialItem | None, str]:
+ try:
+ await app.AGENT_FUNCTION.enforce_credential_use(
+ copilot_ctx.organization_id,
+ credential_id,
+ principal=get_request_principal(),
+ )
+ except PermissionError:
+ return None, "Credential not accessible."
try:
db_credential = await app.DATABASE.credentials.get_credential(
credential_id, organization_id=copilot_ctx.organization_id
@@ -1378,7 +1395,10 @@ async def _fill_credential_field_impl_serial(
"error": f"fill_credential_field `field` must be one of: {', '.join(CREDENTIAL_FILL_FIELD_NAMES)}.",
}
)
- origin_grant, policy_error = await _credential_fill_origin_grant(copilot_ctx, credential_id)
+ try:
+ origin_grant, policy_error = await _credential_fill_origin_grant(copilot_ctx, credential_id)
+ except PermissionError:
+ return finish({"ok": False, "error": "Credential not accessible."})
if policy_error or origin_grant is None:
LOG.info(
"copilot fill_credential_field rejected tool-side",
diff --git a/skyvern/forge/sdk/copilot/tools/credentials.py b/skyvern/forge/sdk/copilot/tools/credentials.py
index 2da423a90..6653918f1 100644
--- a/skyvern/forge/sdk/copilot/tools/credentials.py
+++ b/skyvern/forge/sdk/copilot/tools/credentials.py
@@ -880,10 +880,7 @@ async def _credential_ids_validation_error(credential_ids: list[str], ctx: Agent
]
try:
existing_credentials = (
- await app.DATABASE.credentials.get_credentials_by_ids(
- password_credential_ids,
- organization_id=ctx.organization_id,
- )
+ await load_credentials(ctx.organization_id, credential_ids=password_credential_ids)
if password_credential_ids
else []
)
@@ -1107,11 +1104,7 @@ async def _list_credentials(params: dict[str, Any], ctx: AgentContext) -> dict[s
page = max(1, params.get("page", 1))
page_size = min(max(1, params.get("page_size") or 10), LIST_CREDENTIALS_MAX_PAGE_SIZE)
- credentials = await app.DATABASE.credentials.get_credentials(
- organization_id=ctx.organization_id,
- page=page,
- page_size=page_size,
- )
+ credentials = await load_credentials(ctx.organization_id, page=page, page_size=page_size)
serialized = [_serialize_credential(credential) for credential in credentials]
_record_discovered_credentials_on_policy(ctx, credentials)
return {
diff --git a/skyvern/forge/sdk/copilot/tools/run_execution.py b/skyvern/forge/sdk/copilot/tools/run_execution.py
index 37f5245a3..a53ccdd52 100644
--- a/skyvern/forge/sdk/copilot/tools/run_execution.py
+++ b/skyvern/forge/sdk/copilot/tools/run_execution.py
@@ -3181,6 +3181,11 @@ async def _bind_origin_run_redaction_registry(
awaiting_runtime_secret_values = False
credential_parameters: dict[str, Any] = {}
for index, credential_id in enumerate(credential_ids):
+ await app.AGENT_FUNCTION.enforce_credential_use(
+ ctx.organization_id,
+ credential_id,
+ workflow_run_id=workflow_run_id,
+ )
try:
db_credential = await app.DATABASE.credentials.get_credential(
credential_id,
diff --git a/skyvern/forge/sdk/db/repositories/browser_sessions.py b/skyvern/forge/sdk/db/repositories/browser_sessions.py
index 6e51861d5..a775d8268 100644
--- a/skyvern/forge/sdk/db/repositories/browser_sessions.py
+++ b/skyvern/forge/sdk/db/repositories/browser_sessions.py
@@ -355,6 +355,7 @@ class BrowserSessionsRepository(BaseRepository):
page_size: int = 10,
search_key: str | None = None,
managed: bool | None = None,
+ exclude_search_profile_ids: set[str] | None = None,
) -> list[BrowserProfile]:
if page < 1:
raise ValueError(f"Page must be greater than 0, got {page}")
@@ -377,6 +378,8 @@ class BrowserSessionsRepository(BaseRepository):
BrowserProfileModel.description.ilike(search_like),
)
)
+ if exclude_search_profile_ids:
+ query = query.filter(BrowserProfileModel.browser_profile_id.notin_(exclude_search_profile_ids))
# The id tie-break only needs to be deterministic so pagination stays
# stable when created_at collides; it isn't meant to encode recency.
query = (
@@ -391,17 +394,23 @@ class BrowserSessionsRepository(BaseRepository):
# without a per-row usage fetch (which fanned out one 3-table join per row on every list load).
if profiles:
credential_rows = await session.execute(
- select(CredentialModel.browser_profile_id, CredentialModel.name).where(
+ select(
+ CredentialModel.browser_profile_id,
+ CredentialModel.credential_id,
+ CredentialModel.name,
+ ).where(
CredentialModel.browser_profile_id.in_([p.browser_profile_id for p in profiles]),
CredentialModel.organization_id == organization_id,
CredentialModel.deleted_at.is_(None),
)
)
- name_by_profile: dict[str, str] = {}
- for browser_profile_id, name in credential_rows.all():
- name_by_profile.setdefault(browser_profile_id, name)
+ credential_by_profile: dict[str, tuple[str, str]] = {}
+ for browser_profile_id, credential_id, name in credential_rows.all():
+ credential_by_profile.setdefault(browser_profile_id, (credential_id, name))
for profile in profiles:
- profile.linked_credential_name = name_by_profile.get(profile.browser_profile_id)
+ linked_credential = credential_by_profile.get(profile.browser_profile_id)
+ if linked_credential is not None:
+ profile.linked_credential_id, profile.linked_credential_name = linked_credential
return profiles
@@ -536,9 +545,7 @@ class BrowserSessionsRepository(BaseRepository):
linked_credentials = (
await session.scalars(
- select(CredentialModel)
- .filter_by(browser_profile_id=profile_id, organization_id=organization_id)
- .filter(CredentialModel.deleted_at.is_(None))
+ select(CredentialModel).filter_by(browser_profile_id=profile_id, organization_id=organization_id)
)
).all()
cleared_credential_ids = [credential.credential_id for credential in linked_credentials]
diff --git a/skyvern/forge/sdk/db/repositories/credential_folders.py b/skyvern/forge/sdk/db/repositories/credential_folders.py
index 3ef3f60a5..583632420 100644
--- a/skyvern/forge/sdk/db/repositories/credential_folders.py
+++ b/skyvern/forge/sdk/db/repositories/credential_folders.py
@@ -1,8 +1,10 @@
from __future__ import annotations
+from collections.abc import Awaitable, Callable
from datetime import datetime, timezone
from sqlalchemy import func, or_, select, update
+from sqlalchemy.ext.asyncio import AsyncSession
from skyvern.forge.sdk.db._error_handling import db_operation
from skyvern.forge.sdk.db.base_repository import BaseRepository
@@ -38,6 +40,7 @@ class CredentialFoldersRepository(BaseRepository):
page: int = 1,
page_size: int = 10,
search_query: str | None = None,
+ allowed_folder_ids: set[str] | None = None,
) -> list[CredentialFolderModel]:
async with self.Session() as session:
stmt = (
@@ -56,6 +59,9 @@ class CredentialFoldersRepository(BaseRepository):
)
)
+ if allowed_folder_ids is not None:
+ stmt = stmt.filter(CredentialFolderModel.folder_id.in_(allowed_folder_ids))
+
stmt = stmt.order_by(CredentialFolderModel.modified_at.desc())
stmt = stmt.offset((page - 1) * page_size).limit(page_size)
@@ -186,24 +192,34 @@ class CredentialFoldersRepository(BaseRepository):
credential_id: str,
organization_id: str,
folder_id: str | None,
+ authorize_move: Callable[[AsyncSession], Awaitable[None]] | None = None,
) -> Credential | None:
# Treat an empty folder_id as "remove from folder" (None) so it isn't
# written as a non-existent "" id and trip the folder foreign key.
folder_id = folder_id or None
async with self.Session() as session:
- credential = await session.get(CredentialModel, credential_id)
+ credential = await session.scalar(
+ select(CredentialModel).where(CredentialModel.credential_id == credential_id).with_for_update()
+ )
if credential is None or credential.organization_id != organization_id or credential.deleted_at is not None:
return None
# Validate the target folder in-org and bump its modified_at in a single fetch
if folder_id:
- folder_model = await session.get(CredentialFolderModel, folder_id)
+ folder_model = await session.scalar(
+ select(CredentialFolderModel).where(CredentialFolderModel.folder_id == folder_id).with_for_update()
+ )
if (
folder_model is None
or folder_model.organization_id != organization_id
or folder_model.deleted_at is not None
):
raise ValueError(f"Credential folder {folder_id} not found")
+
+ if authorize_move is not None:
+ await authorize_move(session)
+
+ if folder_id:
folder_model.modified_at = datetime.now(timezone.utc)
credential.folder_id = folder_id
diff --git a/skyvern/forge/sdk/db/repositories/credentials.py b/skyvern/forge/sdk/db/repositories/credentials.py
index c9aea4ace..e247d6833 100644
--- a/skyvern/forge/sdk/db/repositories/credentials.py
+++ b/skyvern/forge/sdk/db/repositories/credentials.py
@@ -3,12 +3,12 @@ from __future__ import annotations
from datetime import datetime, timezone
from typing import cast
-from sqlalchemy import func, or_, select, update
+from sqlalchemy import delete, func, or_, select, update
from skyvern.forge.sdk.db._error_handling import db_operation
from skyvern.forge.sdk.db.base_repository import BaseRepository
from skyvern.forge.sdk.db.exceptions import NotFoundError
-from skyvern.forge.sdk.db.models import CredentialModel, OrganizationBitwardenCollectionModel
+from skyvern.forge.sdk.db.models import CredentialModel, OrganizationBitwardenCollectionModel, TOTPCodeModel
from skyvern.forge.sdk.db.repositories.proxy_pin_update import apply_proxy_pin_to_model, normalize_proxy_pin_for_create
from skyvern.forge.sdk.db.utils import serialize_proxy_location
from skyvern.forge.sdk.schemas.credentials import (
@@ -19,10 +19,41 @@ from skyvern.forge.sdk.schemas.credentials import (
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
from skyvern.schemas.runs import ProxyLocation, ProxyLocationInput
+from skyvern.utils.email_validation import (
+ EMAIL_IDENTIFIER_TRIM_CHARS,
+ SAFE_EMAIL_ADDRESS_PATTERN,
+ normalize_identifier_if_email,
+)
+from skyvern.utils.phone_validation import (
+ looks_like_phone_identifier,
+ normalize_identifier,
+ phone_identifier_candidates,
+)
_UNSET = object()
+def _phone_identifier_aliases(identifier: str) -> set[str]:
+ aliases = set(phone_identifier_candidates(identifier))
+ normalized = normalize_identifier(identifier)
+ if normalized.startswith("+1") and len(normalized) == 12:
+ aliases.add(normalized[2:])
+ digits = "".join(character for character in identifier if character.isdigit())
+ if len(digits) == 10:
+ aliases.add(f"+1{digits}")
+ return aliases
+
+
+def _totp_identifiers_match(left: str, right: str) -> bool:
+ if normalize_identifier(left) == normalize_identifier(right):
+ return True
+ return (
+ looks_like_phone_identifier(left)
+ and looks_like_phone_identifier(right)
+ and bool(_phone_identifier_aliases(left) & _phone_identifier_aliases(right))
+ )
+
+
class CredentialRepository(BaseRepository):
"""Database operations for credential and Bitwarden collection management."""
@@ -95,6 +126,104 @@ class CredentialRepository(BaseRepository):
).all()
return [Credential.model_validate(c) for c in credentials]
+ @db_operation("get_credential_ids_by_browser_profile_ids")
+ async def get_credential_ids_by_browser_profile_ids(
+ self, browser_profile_ids: set[str] | None, organization_id: str
+ ) -> dict[str, set[str]]:
+ links_by_profile = await self.get_browser_profile_credential_links(browser_profile_ids, organization_id)
+ return {
+ profile_id: {credential_id for credential_id, _ in links} for profile_id, links in links_by_profile.items()
+ }
+
+ @db_operation("get_browser_profile_credential_links")
+ async def get_browser_profile_credential_links(
+ self, browser_profile_ids: set[str] | None, organization_id: str
+ ) -> dict[str, list[tuple[str, str | None]]]:
+ if browser_profile_ids == set():
+ return {}
+ async with self.Session() as session:
+ query = select(
+ CredentialModel.browser_profile_id,
+ CredentialModel.credential_id,
+ CredentialModel.folder_id,
+ ).where(
+ CredentialModel.browser_profile_id.is_not(None),
+ CredentialModel.organization_id == organization_id,
+ )
+ if browser_profile_ids is not None:
+ query = query.where(CredentialModel.browser_profile_id.in_(browser_profile_ids))
+ rows = (await session.execute(query)).all()
+ links_by_profile: dict[str, list[tuple[str, str | None]]] = {}
+ for browser_profile_id, credential_id, folder_id in rows:
+ if browser_profile_id is not None:
+ links_by_profile.setdefault(browser_profile_id, []).append((credential_id, folder_id))
+ return links_by_profile
+
+ @db_operation("get_credential_ids_by_totp_identifiers")
+ async def get_credential_ids_by_totp_identifiers(
+ self, totp_identifiers: set[str], organization_id: str
+ ) -> dict[str, set[str]]:
+ if not totp_identifiers:
+ return {}
+ normalized_identifiers = {normalize_identifier(value) for value in totp_identifiers}
+ phone_identifiers = {
+ normalize_identifier(value) for value in totp_identifiers if looks_like_phone_identifier(value)
+ }
+ phone_identifiers_by_candidate: dict[str, set[str]] = {}
+ for identifier in phone_identifiers:
+ candidates = phone_identifier_candidates(identifier)
+ # Keep the national alias authorization-only; OTP retrieval must not match ambiguous bare rows.
+ if identifier.startswith("+1") and len(identifier) == 12:
+ candidates.append(identifier[2:])
+ for candidate in candidates:
+ phone_identifiers_by_candidate.setdefault(candidate, set()).add(identifier)
+ email_identifiers = {
+ identifier
+ for value in totp_identifiers
+ if SAFE_EMAIL_ADDRESS_PATTERN.fullmatch(identifier := normalize_identifier_if_email(value))
+ }
+ async with self.Session() as session:
+ identifier_filters = [CredentialModel.totp_identifier.in_(totp_identifiers)]
+ if email_identifiers:
+ trim = func.btrim if session.bind.dialect.name == "postgresql" else func.trim
+ identifier_filters.append(
+ func.lower(trim(CredentialModel.totp_identifier, EMAIL_IDENTIFIER_TRIM_CHARS)).in_(
+ email_identifiers
+ )
+ )
+ rows = (
+ await session.execute(
+ select(CredentialModel.totp_identifier, CredentialModel.credential_id).where(
+ or_(*identifier_filters),
+ CredentialModel.organization_id == organization_id,
+ )
+ )
+ ).all()
+ if phone_identifiers:
+ # Legacy credentials may use punctuation that the OTP ingestion normalizer removes.
+ rows.extend(
+ (
+ await session.execute(
+ select(CredentialModel.totp_identifier, CredentialModel.credential_id).where(
+ CredentialModel.organization_id == organization_id,
+ CredentialModel.totp_identifier.is_not(None),
+ )
+ )
+ ).all()
+ )
+ credential_ids_by_identifier: dict[str, set[str]] = {}
+ for totp_identifier, credential_id in rows:
+ if totp_identifier is None:
+ continue
+ normalized = normalize_identifier(totp_identifier)
+ matches = {normalized} if normalized in normalized_identifiers else set()
+ if looks_like_phone_identifier(totp_identifier):
+ for candidate in phone_identifier_candidates(totp_identifier):
+ matches.update(phone_identifiers_by_candidate.get(candidate, set()))
+ for identifier in matches:
+ credential_ids_by_identifier.setdefault(identifier, set()).add(credential_id)
+ return credential_ids_by_identifier
+
@db_operation("link_browser_profile_if_unset")
async def link_browser_profile_if_unset(
self, credential_id: str, organization_id: str, browser_profile_id: str
@@ -141,22 +270,32 @@ class CredentialRepository(BaseRepository):
return None
@db_operation("get_credentials_by_ids")
- async def get_credentials_by_ids(self, credential_ids: list[str], organization_id: str) -> list[Credential]:
+ async def get_credentials_by_ids(
+ self,
+ credential_ids: list[str],
+ organization_id: str,
+ allowed_folder_ids: set[str] | None = None,
+ include_deleted: bool = False,
+ ) -> list[Credential]:
if not credential_ids:
return []
async with self.Session() as session:
- credentials = (
- await session.scalars(
- select(CredentialModel)
- .filter(CredentialModel.credential_id.in_(credential_ids))
- .filter_by(organization_id=organization_id)
- .filter(CredentialModel.deleted_at.is_(None))
+ query = (
+ select(CredentialModel)
+ .filter(CredentialModel.credential_id.in_(credential_ids))
+ .filter_by(organization_id=organization_id)
+ )
+ if not include_deleted:
+ query = query.filter(CredentialModel.deleted_at.is_(None))
+ if allowed_folder_ids is not None:
+ query = query.filter(
+ or_(CredentialModel.folder_id.is_(None), CredentialModel.folder_id.in_(allowed_folder_ids))
)
- ).all()
+ credentials = (await session.scalars(query)).all()
return [Credential.model_validate(credential) for credential in credentials]
@db_operation("count_credentials")
- async def count_credentials(self, organization_id: str) -> int:
+ async def count_credentials(self, organization_id: str, allowed_folder_ids: set[str] | None = None) -> int:
async with self.Session() as session:
query = (
select(func.count())
@@ -164,6 +303,10 @@ class CredentialRepository(BaseRepository):
.filter_by(organization_id=organization_id)
.filter(CredentialModel.deleted_at.is_(None))
)
+ if allowed_folder_ids is not None:
+ query = query.filter(
+ or_(CredentialModel.folder_id.is_(None), CredentialModel.folder_id.in_(allowed_folder_ids))
+ )
return int(await session.scalar(query) or 0)
@db_operation("get_credentials")
@@ -176,6 +319,7 @@ class CredentialRepository(BaseRepository):
credential_type: str | None = None,
search: str | None = None,
folder_id: str | None = None,
+ allowed_folder_ids: set[str] | None = None,
) -> list[Credential]:
async with self.Session() as session:
query = (
@@ -189,6 +333,10 @@ class CredentialRepository(BaseRepository):
query = query.filter(CredentialModel.credential_type == credential_type)
if folder_id is not None:
query = query.filter(CredentialModel.folder_id == folder_id)
+ if allowed_folder_ids is not None:
+ query = query.filter(
+ or_(CredentialModel.folder_id.is_(None), CredentialModel.folder_id.in_(allowed_folder_ids))
+ )
if search:
# Escape LIKE wildcards so a literal % or _ in the query narrows rather than broadens.
escaped = search.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")
@@ -306,6 +454,43 @@ class CredentialRepository(BaseRepository):
).first()
if not credential:
raise NotFoundError(f"Credential {credential_id} not found")
+ old_totp_identifier = credential.totp_identifier
+ if isinstance(old_totp_identifier, str) and (
+ totp_identifier is None or not _totp_identifiers_match(old_totp_identifier, totp_identifier)
+ ):
+ other_identifiers = (
+ await session.scalars(
+ select(CredentialModel.totp_identifier).where(
+ CredentialModel.organization_id == organization_id,
+ CredentialModel.credential_id != credential_id,
+ CredentialModel.totp_identifier.is_not(None),
+ )
+ )
+ ).all()
+ if not any(_totp_identifiers_match(old_totp_identifier, other) for other in other_identifiers):
+ if SAFE_EMAIL_ADDRESS_PATTERN.fullmatch(old_totp_identifier.strip()):
+ trim = func.btrim if session.bind.dialect.name == "postgresql" else func.trim
+ identifier_filter = func.lower(
+ trim(TOTPCodeModel.totp_identifier, EMAIL_IDENTIFIER_TRIM_CHARS)
+ ) == normalize_identifier(old_totp_identifier)
+ elif looks_like_phone_identifier(old_totp_identifier):
+ identifier_filter = TOTPCodeModel.totp_identifier.in_(
+ {old_totp_identifier, *_phone_identifier_aliases(old_totp_identifier)}
+ )
+ else:
+ identifier_filter = TOTPCodeModel.totp_identifier == old_totp_identifier
+ # Remove cached codes before their workflow context can make them appear unlinked.
+ await session.execute(
+ delete(TOTPCodeModel).where(
+ TOTPCodeModel.organization_id == organization_id,
+ identifier_filter,
+ or_(
+ TOTPCodeModel.task_id.is_not(None),
+ TOTPCodeModel.workflow_id.is_not(None),
+ TOTPCodeModel.workflow_run_id.is_not(None),
+ ),
+ )
+ )
credential.item_id = item_id
credential.name = name
credential.credential_type = credential_type
diff --git a/skyvern/forge/sdk/db/repositories/otp.py b/skyvern/forge/sdk/db/repositories/otp.py
index 8ad60a215..b0b085852 100644
--- a/skyvern/forge/sdk/db/repositories/otp.py
+++ b/skyvern/forge/sdk/db/repositories/otp.py
@@ -132,6 +132,7 @@ class OTPRepository(BaseRepository):
self,
organization_id: str,
limit: int = 50,
+ offset: int = 0,
valid_lifespan_minutes: int | None = None,
otp_type: OTPType | None = None,
workflow_run_id: str | None = None,
@@ -155,7 +156,8 @@ class OTPRepository(BaseRepository):
query = query.filter(TOTPCodeModel.workflow_run_id == workflow_run_id)
if totp_identifier:
query = query.filter(_identifier_filter(totp_identifier))
- query = query.order_by(TOTPCodeModel.created_at.desc()).limit(limit)
+ query = query.order_by(TOTPCodeModel.created_at.desc(), TOTPCodeModel.totp_code_id.desc())
+ query = query.offset(offset).limit(limit)
totp_codes = (await session.scalars(query)).all()
return [TOTPCode.model_validate(totp_code) for totp_code in totp_codes]
diff --git a/skyvern/forge/sdk/db/repositories/workflow_runs.py b/skyvern/forge/sdk/db/repositories/workflow_runs.py
index 21d1b375b..ff2f2dc78 100644
--- a/skyvern/forge/sdk/db/repositories/workflow_runs.py
+++ b/skyvern/forge/sdk/db/repositories/workflow_runs.py
@@ -3377,6 +3377,51 @@ class WorkflowRunsRepository(BaseRepository):
for run, title in workflow_runs_and_titles_tuples
]
+ @db_operation("get_workflow_run_ids_by_browser_session_ids")
+ async def get_workflow_run_ids_by_browser_session_ids(
+ self, browser_session_ids: Collection[str], organization_id: str
+ ) -> dict[str, set[str]]:
+ """Return every run associated with each session, without applying caller visibility filters."""
+ if not browser_session_ids:
+ return {}
+
+ associations = union_all(
+ select(WorkflowRunModel.browser_session_id, WorkflowRunModel.workflow_run_id).where(
+ WorkflowRunModel.organization_id == organization_id,
+ WorkflowRunModel.browser_session_id.in_(browser_session_ids),
+ ),
+ select(TaskModel.browser_session_id, TaskModel.workflow_run_id).where(
+ TaskModel.organization_id == organization_id,
+ TaskModel.browser_session_id.in_(browser_session_ids),
+ TaskModel.workflow_run_id.is_not(None),
+ ),
+ select(TaskV2Model.browser_session_id, TaskV2Model.workflow_run_id).where(
+ TaskV2Model.organization_id == organization_id,
+ TaskV2Model.browser_session_id.in_(browser_session_ids),
+ TaskV2Model.workflow_run_id.is_not(None),
+ ),
+ select(WorkflowRunAttemptModel.pinned_browser_session_id, WorkflowRunAttemptModel.workflow_run_id).where(
+ WorkflowRunAttemptModel.organization_id == organization_id,
+ WorkflowRunAttemptModel.pinned_browser_session_id.in_(browser_session_ids),
+ ),
+ select(
+ PersistentBrowserSessionModel.persistent_browser_session_id,
+ PersistentBrowserSessionModel.created_for_workflow_run_id,
+ ).where(
+ PersistentBrowserSessionModel.organization_id == organization_id,
+ PersistentBrowserSessionModel.persistent_browser_session_id.in_(browser_session_ids),
+ PersistentBrowserSessionModel.created_for_workflow_run_id.is_not(None),
+ ),
+ )
+ async with self.Session() as session:
+ rows = (await session.execute(associations)).all()
+
+ runs_by_session: dict[str, set[str]] = {}
+ for browser_session_id, workflow_run_id in rows:
+ if browser_session_id and workflow_run_id:
+ runs_by_session.setdefault(browser_session_id, set()).add(workflow_run_id)
+ return runs_by_session
+
@db_operation("get_workflow_metadata_for_browser_session")
async def get_workflow_metadata_for_browser_session(
self, browser_session_id: str, organization_id: str
diff --git a/skyvern/forge/sdk/routes/agent_protocol.py b/skyvern/forge/sdk/routes/agent_protocol.py
index 9b3d025cb..25880c021 100644
--- a/skyvern/forge/sdk/routes/agent_protocol.py
+++ b/skyvern/forge/sdk/routes/agent_protocol.py
@@ -168,6 +168,7 @@ from skyvern.forge.sdk.workflow.exceptions import (
InvalidTemplateWorkflowPermanentId,
WorkflowDefinitionValidationException,
)
+from skyvern.forge.sdk.workflow.models.parameter import CredentialParameter, WorkflowParameter, WorkflowParameterType
from skyvern.forge.sdk.workflow.models.tags import CallerType, TagSource, TagWriteContext
from skyvern.forge.sdk.workflow.models.validators import is_reserved_tag_key
from skyvern.forge.sdk.workflow.models.workflow import (
@@ -1573,6 +1574,7 @@ async def update_workflow_legacy(
changed_fields=changed_fields,
),
)
+ await _redact_inaccessible_workflow_credential_ids([workflow])
return workflow
@@ -1673,6 +1675,7 @@ async def update_workflow(
changed_fields=changed_fields,
),
)
+ await _redact_inaccessible_workflow_credential_ids([workflow])
return workflow
@@ -2064,6 +2067,7 @@ async def update_workflow_folder(
changed_fields=("folder_id",),
related_resource_ids=(workflow.folder_id,) if workflow.folder_id else (),
)
+ await _redact_inaccessible_workflow_credential_ids([workflow])
return workflow
except ValueError as e:
raise HTTPException(status_code=http_status.HTTP_400_BAD_REQUEST, detail=str(e)) from e
@@ -5810,12 +5814,15 @@ async def get_workflow_and_run_from_workflow_run_id(
x_user_agent: Annotated[str | None, Header(include_in_schema=False)] = None,
) -> WorkflowRunWithWorkflowResponse:
analytics.capture("skyvern-oss-agent-workflow-run-get")
- return await run_service.coalesce_in_flight(
+ response = await run_service.coalesce_in_flight(
_build_workflow_and_run_from_workflow_run_id,
current_org.organization_id,
workflow_run_id,
caps_run_response_values(x_user_agent),
)
+ response = response.model_copy(update={"workflow": response.workflow.model_copy(deep=True)})
+ await _redact_inaccessible_workflow_credential_ids([response.workflow])
+ return response
async def _build_workflow_and_run_from_workflow_run_id(
@@ -6024,6 +6031,7 @@ async def get_workflows(
search_key=effective_search or "",
statuses=effective_statuses,
)
+ await _redact_inaccessible_workflow_credential_ids(workflows)
return workflows
if only_saved_tasks and only_workflows:
@@ -6032,7 +6040,7 @@ async def get_workflows(
detail="only_saved_tasks and only_workflows cannot be used together",
)
- return await app.WORKFLOW_SERVICE.get_workflows_by_organization_id(
+ workflows = await app.WORKFLOW_SERVICE.get_workflows_by_organization_id(
organization_id=current_org.organization_id,
page=page,
page_size=page_size,
@@ -6044,6 +6052,81 @@ async def get_workflows(
statuses=effective_statuses,
workflow_tags=workflow_tags or None,
)
+ await _redact_inaccessible_workflow_credential_ids(workflows)
+ return workflows
+
+
+async def _redact_inaccessible_workflow_credential_ids(workflows: Sequence[Workflow]) -> None:
+ workflow_parameters = [
+ (
+ workflow.workflow_definition.parameters,
+ {
+ parameter.key
+ for parameter in workflow.workflow_definition.parameters
+ if isinstance(parameter, WorkflowParameter)
+ and parameter.workflow_parameter_type == WorkflowParameterType.CREDENTIAL_ID
+ },
+ )
+ for workflow in workflows
+ ]
+ credential_ids: set[str] = set()
+ for parameters, parameter_keys in workflow_parameters:
+ for parameter in parameters:
+ if isinstance(parameter, CredentialParameter):
+ credential_ids.update(
+ credential_id
+ for credential_id in (
+ parameter.credential_id if parameter.credential_id not in parameter_keys else None,
+ *(parameter.credential_ids or []),
+ *(parameter.fallback_credential_ids or []),
+ )
+ if credential_id
+ )
+ elif (
+ isinstance(parameter, WorkflowParameter)
+ and parameter.workflow_parameter_type == WorkflowParameterType.CREDENTIAL_ID
+ and isinstance(parameter.default_value, str)
+ and parameter.default_value
+ ):
+ credential_ids.add(parameter.default_value)
+ if not credential_ids:
+ return
+
+ principal = get_request_principal()
+ try:
+ accessible_ids = await app.AGENT_FUNCTION.accessible_credential_ids(
+ principal, "credential.read", credential_ids
+ )
+ except Exception:
+ LOG.warning(
+ "Workflow credential visibility check failed; redacting credential references",
+ organization_id=principal.organization_id if principal else None,
+ exc_info=True,
+ )
+ accessible_ids = set()
+
+ for parameters, parameter_keys in workflow_parameters:
+ for parameter in parameters:
+ if isinstance(parameter, CredentialParameter):
+ if parameter.credential_id not in accessible_ids and parameter.credential_id not in parameter_keys:
+ parameter.credential_id = ""
+ if parameter.credential_ids is not None:
+ parameter.credential_ids = [
+ credential_id for credential_id in parameter.credential_ids if credential_id in accessible_ids
+ ]
+ if parameter.fallback_credential_ids is not None:
+ parameter.fallback_credential_ids = [
+ credential_id
+ for credential_id in parameter.fallback_credential_ids
+ if credential_id in accessible_ids
+ ]
+ elif (
+ isinstance(parameter, WorkflowParameter)
+ and parameter.workflow_parameter_type == WorkflowParameterType.CREDENTIAL_ID
+ and isinstance(parameter.default_value, str)
+ and parameter.default_value not in accessible_ids
+ ):
+ parameter.default_value = None
@base_router.put(
@@ -6101,6 +6184,7 @@ async def get_workflow_templates() -> list[Workflow]:
statuses=[WorkflowStatus.published, WorkflowStatus.draft],
)
+ await _redact_inaccessible_workflow_credential_ids(workflows)
return workflows
@@ -6151,6 +6235,7 @@ async def get_workflow(
workflow.set_effective_default_engine(
await effective_default_engine(workflow_permanent_id, current_org.organization_id)
)
+ await _redact_inaccessible_workflow_credential_ids([workflow])
return workflow
@@ -6185,10 +6270,12 @@ async def get_workflow_versions(
if workflow_permanent_id not in await app.STORAGE.retrieve_global_workflows():
raise InvalidTemplateWorkflowPermanentId(workflow_permanent_id=workflow_permanent_id)
- return await app.WORKFLOW_SERVICE.get_workflow_versions_by_permanent_id(
+ workflows = await app.WORKFLOW_SERVICE.get_workflow_versions_by_permanent_id(
workflow_permanent_id=workflow_permanent_id,
organization_id=None if template else current_org.organization_id,
)
+ await _redact_inaccessible_workflow_credential_ids(workflows)
+ return workflows
@base_router.post(
diff --git a/skyvern/forge/sdk/routes/browser_profiles.py b/skyvern/forge/sdk/routes/browser_profiles.py
index 09e322515..7df5b31d0 100644
--- a/skyvern/forge/sdk/routes/browser_profiles.py
+++ b/skyvern/forge/sdk/routes/browser_profiles.py
@@ -49,6 +49,7 @@ from skyvern.forge.sdk.schemas.persistent_browser_sessions import (
is_external_cdp_session,
)
from skyvern.forge.sdk.services import org_auth_service
+from skyvern.forge.sdk.services.request_principal import get_request_principal
from skyvern.forge.sdk.workflow.browser_session_persistence import retrieve_persisted_workflow_browser_state_dir
from skyvern.schemas.proxy_pinning import apply_proxy_pin_update as _apply_proxy_pin_update
from skyvern.schemas.proxy_pinning import should_generate_proxy_session_id
@@ -80,6 +81,11 @@ _SESSION_PROFILE_SAVE_LOCK_WAIT_SECONDS = 30
_SESSION_PROFILE_SAVED_MARKER_TTL = timedelta(days=1)
+def _redact_credential_profile_labels(profile: BrowserProfile) -> None:
+ profile.name = "Browser profile"
+ profile.description = None
+
+
def _normalize_proxy_pin_fields(
*,
proxy_location: ProxyLocationInput,
@@ -252,6 +258,29 @@ async def list_browser_profiles(
managed=managed,
)
+ principal = get_request_principal()
+ hidden_profile_ids: set[str] = set()
+ credential_links_by_profile: dict[str, list[tuple[str, str | None]]] | None = None
+ if (
+ search_key
+ and await app.AGENT_FUNCTION.credential_folders_restricted(organization_id)
+ and not await app.AGENT_FUNCTION.credential_folder_admin_bypass(principal)
+ ):
+ credential_links_by_profile = await app.DATABASE.credentials.get_browser_profile_credential_links(
+ None, organization_id
+ )
+ all_credential_ids = {
+ credential_id for links in credential_links_by_profile.values() for credential_id, _folder_id in links
+ }
+ allowed_credential_ids = await app.AGENT_FUNCTION.accessible_credential_ids(
+ principal, "credential.read", all_credential_ids
+ )
+ hidden_profile_ids = {
+ profile_id
+ for profile_id, links in credential_links_by_profile.items()
+ if not {credential_id for credential_id, _folder_id in links} <= allowed_credential_ids
+ }
+
profiles = await app.DATABASE.browser_sessions.list_browser_profiles(
organization_id=organization_id,
include_deleted=include_deleted,
@@ -259,8 +288,34 @@ async def list_browser_profiles(
page_size=page_size,
search_key=search_key,
managed=managed,
+ exclude_search_profile_ids=hidden_profile_ids,
)
+ if (
+ profiles
+ and await app.AGENT_FUNCTION.credential_folders_restricted(organization_id)
+ and not await app.AGENT_FUNCTION.credential_folder_admin_bypass(principal)
+ ):
+ if credential_links_by_profile is None:
+ credential_links_by_profile = await app.DATABASE.credentials.get_browser_profile_credential_links(
+ {profile.browser_profile_id for profile in profiles}, organization_id
+ )
+ credential_ids = {
+ credential_id for links in credential_links_by_profile.values() for credential_id, _folder_id in links
+ }
+ allowed_credential_ids = await app.AGENT_FUNCTION.accessible_credential_ids(
+ principal, "credential.read", credential_ids
+ )
+ for profile in profiles:
+ linked_ids = {
+ credential_id
+ for credential_id, _folder_id in credential_links_by_profile.get(profile.browser_profile_id, [])
+ }
+ if linked_ids and not linked_ids <= allowed_credential_ids:
+ profile.linked_credential_id = None
+ profile.linked_credential_name = None
+ _redact_credential_profile_labels(profile)
+
LOG.info(
"Listed browser profiles",
organization_id=organization_id,
@@ -325,6 +380,34 @@ async def get_browser_profile(
)
raise BrowserProfileNotFound(profile_id=profile_id, organization_id=organization_id)
+ linked_credentials = await app.DATABASE.credentials.get_credentials_by_browser_profile_id(
+ profile_id, organization_id
+ )
+ principal = get_request_principal()
+ redact_labels = False
+ if await app.AGENT_FUNCTION.credential_folders_restricted(
+ organization_id
+ ) and not await app.AGENT_FUNCTION.credential_folder_admin_bypass(principal):
+ linked_credential_links_by_profile = await app.DATABASE.credentials.get_browser_profile_credential_links(
+ {profile_id}, organization_id
+ )
+ linked_credential_ids = {
+ credential_id for credential_id, _folder_id in linked_credential_links_by_profile.get(profile_id, [])
+ }
+ allowed_credential_ids = await app.AGENT_FUNCTION.accessible_credential_ids(
+ principal, "credential.read", linked_credential_ids
+ )
+ if linked_credential_ids and not linked_credential_ids <= allowed_credential_ids:
+ linked_credentials = []
+ profile.linked_credential_id = None
+ profile.linked_credential_name = None
+ redact_labels = True
+ if linked_credentials:
+ profile.linked_credential_id = linked_credentials[0].credential_id
+ profile.linked_credential_name = linked_credentials[0].name
+ if redact_labels:
+ _redact_credential_profile_labels(profile)
+
LOG.info(
"Retrieved browser profile",
organization_id=organization_id,
@@ -373,6 +456,18 @@ async def get_browser_profile_usage(
profile_id=profile_id,
organization_id=organization_id,
)
+ principal = get_request_principal()
+ if (
+ usage.credentials
+ and await app.AGENT_FUNCTION.credential_folders_restricted(organization_id)
+ and not await app.AGENT_FUNCTION.credential_folder_admin_bypass(principal)
+ ):
+ allowed_credential_ids = await app.AGENT_FUNCTION.accessible_credential_ids(
+ principal, "credential.read", {credential.credential_id for credential in usage.credentials}
+ )
+ usage.credentials = [
+ credential for credential in usage.credentials if credential.credential_id in allowed_credential_ids
+ ]
LOG.info(
"Retrieved browser profile usage",
organization_id=organization_id,
diff --git a/skyvern/forge/sdk/routes/browser_sessions.py b/skyvern/forge/sdk/routes/browser_sessions.py
index 9756086e1..65cc098a7 100644
--- a/skyvern/forge/sdk/routes/browser_sessions.py
+++ b/skyvern/forge/sdk/routes/browser_sessions.py
@@ -37,11 +37,13 @@ from skyvern.forge.sdk.routes.routers import base_router
from skyvern.forge.sdk.schemas.organizations import Organization
from skyvern.forge.sdk.schemas.persistent_browser_sessions import (
API_BROWSER_SESSION_CREATED_BY,
+ PersistentBrowserSession,
PersistentBrowserSessionStatus,
is_external_cdp_session,
is_final_status,
)
from skyvern.forge.sdk.services import org_auth_service
+from skyvern.forge.sdk.services.request_principal import get_request_principal
from skyvern.forge.sdk.workflow.models.workflow import WorkflowRun
from skyvern.schemas.action_log import (
ACTION_LOG_DEFAULT_PAGE_SIZE,
@@ -96,6 +98,54 @@ def _browser_session_not_found() -> HTTPException:
return HTTPException(status_code=404, detail={"code": "browser_session_not_found"})
+async def _filter_credential_inaccessible_sessions(
+ sessions: list[PersistentBrowserSession], organization_id: str
+) -> list[PersistentBrowserSession]:
+ if not sessions:
+ return []
+ principal = get_request_principal()
+ profile_ids = {session.browser_profile_id for session in sessions if session.browser_profile_id}
+ try:
+ profile_accessible_ids = {session.persistent_browser_session_id for session in sessions}
+ if principal is None:
+ profile_accessible_ids = {
+ session.persistent_browser_session_id for session in sessions if not session.browser_profile_id
+ }
+ elif profile_ids and await app.AGENT_FUNCTION.credential_folders_restricted(organization_id):
+ links_by_profile = await app.DATABASE.credentials.get_browser_profile_credential_links(
+ profile_ids, organization_id
+ )
+ credential_ids = {credential_id for links in links_by_profile.values() for credential_id, _ in links}
+ accessible_credential_ids = await app.AGENT_FUNCTION.accessible_credential_ids(
+ principal, "credential.use", credential_ids
+ )
+ profile_accessible_ids = {
+ session.persistent_browser_session_id
+ for session in sessions
+ if not session.browser_profile_id
+ or {credential_id for credential_id, _ in links_by_profile.get(session.browser_profile_id, [])}
+ <= accessible_credential_ids
+ }
+ run_credential_accessible_ids = await app.AGENT_FUNCTION.accessible_browser_session_ids(
+ principal,
+ organization_id,
+ {session.persistent_browser_session_id for session in sessions},
+ )
+ except Exception:
+ LOG.warning(
+ "Browser session credential authorization failed; denying",
+ organization_id=organization_id,
+ exc_info=True,
+ )
+ return []
+ return [
+ session
+ for session in sessions
+ if session.persistent_browser_session_id in profile_accessible_ids
+ and session.persistent_browser_session_id in run_credential_accessible_ids
+ ]
+
+
async def _read_action_log_body(request: Request) -> bytes:
content_length = request.headers.get("content-length")
if content_length is not None:
@@ -166,6 +216,7 @@ async def get_browser_sessions_all(
page=page,
page_size=page_size,
)
+ browser_sessions = await _filter_credential_inaccessible_sessions(browser_sessions, current_org.organization_id)
responses = await asyncio.gather(
*[
@@ -731,6 +782,7 @@ async def get_browser_sessions(
for browser_session in browser_sessions
if browser_session.persistent_browser_session_id in visible_ids
]
+ visible_sessions = await _filter_credential_inaccessible_sessions(visible_sessions, current_org.organization_id)
return await asyncio.gather(
*[
BrowserSessionResponse.from_browser_session(browser_session, app.STORAGE)
diff --git a/skyvern/forge/sdk/routes/credentials.py b/skyvern/forge/sdk/routes/credentials.py
index cee6f0949..b050f8fdb 100644
--- a/skyvern/forge/sdk/routes/credentials.py
+++ b/skyvern/forge/sdk/routes/credentials.py
@@ -44,6 +44,7 @@ from fastapi import BackgroundTasks, Body, Depends, Header, HTTPException, Path,
from onepassword.client import Client as OnePasswordClient
from onepassword.errors import DesktopSessionExpiredException, RateLimitExceededException
from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
from skyvern.config import settings
from skyvern.exceptions import (
@@ -178,6 +179,7 @@ from skyvern.services.otp_service import (
)
from skyvern.services.run_service import cancel_workflow_run
from skyvern.utils.email_validation import normalize_identifier_if_email
+from skyvern.utils.phone_validation import normalize_identifier
from skyvern.utils.url_validators import validate_url
LOG = structlog.get_logger()
@@ -540,6 +542,34 @@ async def send_totp_code(
workflow_run = await app.DATABASE.workflow_runs.get_workflow_run(data.workflow_run_id, curr_org.organization_id)
if not workflow_run:
raise HTTPException(status_code=400, detail=f"Invalid workflow run id: {data.workflow_run_id}")
+ workflow_references = {
+ (kind, value)
+ for kind, value in (
+ ("task_id", data.task_id),
+ ("workflow_id", data.workflow_id),
+ ("workflow_run_id", data.workflow_run_id),
+ )
+ if value is not None
+ }
+ if await app.AGENT_FUNCTION.workflow_folders_restricted(curr_org.organization_id) and workflow_references:
+ accessible_references = await app.AGENT_FUNCTION.accessible_workflow_reference_ids(
+ get_request_principal(), "workflow_run.update", workflow_references
+ )
+ if workflow_references - accessible_references:
+ raise HTTPException(status_code=403, detail="Workflow folder access denied.")
+ if await app.AGENT_FUNCTION.credential_folders_restricted(curr_org.organization_id):
+ credential_ids_by_identifier = await app.DATABASE.credentials.get_credential_ids_by_totp_identifiers(
+ {totp_identifier}, curr_org.organization_id
+ )
+ await app.AGENT_FUNCTION.enforce_credential_folder_access_for_ids(
+ get_request_principal(),
+ "credential.use",
+ {
+ ("credential_id", credential_id)
+ for credential_ids in credential_ids_by_identifier.values()
+ for credential_id in credential_ids
+ },
+ )
content = data.content.strip()
otp_value: OTPValue | None = OTPValue(value=content)
otp_parse_skipped_for_insufficient_credits = False
@@ -660,16 +690,81 @@ async def get_totp_codes(
description="Maximum number of codes to return.",
),
) -> list[TOTPCode]:
- codes = await app.DATABASE.otp.get_recent_otp_codes(
- organization_id=curr_org.organization_id,
- limit=limit,
- valid_lifespan_minutes=None,
- otp_type=otp_type,
- workflow_run_id=workflow_run_id,
- totp_identifier=totp_identifier,
- )
+ principal = get_request_principal()
+ workflow_restricted = await app.AGENT_FUNCTION.workflow_folders_restricted(curr_org.organization_id)
+ credential_restricted = await app.AGENT_FUNCTION.credential_folders_restricted(curr_org.organization_id)
+ if (workflow_restricted or credential_restricted) and principal is None:
+ return []
+
+ restricted = workflow_restricted or credential_restricted
+ page_size = max(limit, 50) if restricted else limit
+ # shortcut: scan at most 1,000 OTPs; return 503 for incomplete results, use SQL ACL filtering to search older codes.
+ scan_limit = min(page_size * 10, 1_000) if restricted else limit
+ codes: list[TOTPCode] = []
+ offset = 0
+ while len(codes) < limit and offset < scan_limit:
+ page_limit = min(page_size, scan_limit - offset)
+ page = await app.DATABASE.otp.get_recent_otp_codes(
+ organization_id=curr_org.organization_id,
+ limit=page_limit,
+ offset=offset,
+ valid_lifespan_minutes=None,
+ otp_type=otp_type,
+ workflow_run_id=workflow_run_id,
+ totp_identifier=totp_identifier,
+ )
+ if not page:
+ break
+ page_length = len(page)
+ offset += page_length
+
+ if workflow_restricted:
+ references_by_code = {
+ code.totp_code_id: {
+ (kind, value)
+ for kind, value in (
+ ("workflow_id", code.workflow_id),
+ ("workflow_run_id", code.workflow_run_id),
+ ("task_id", code.task_id),
+ )
+ if value is not None
+ }
+ for code in page
+ }
+ accessible_references = await app.AGENT_FUNCTION.accessible_workflow_reference_ids(
+ principal, "workflow_run.read", set().union(*references_by_code.values())
+ )
+ page = [code for code in page if references_by_code[code.totp_code_id] <= accessible_references]
+
+ if credential_restricted and page and not await app.AGENT_FUNCTION.credential_folder_admin_bypass(principal):
+ credential_ids_by_identifier = await app.DATABASE.credentials.get_credential_ids_by_totp_identifiers(
+ {normalize_identifier(code.totp_identifier) for code in page}, curr_org.organization_id
+ )
+ credential_ids = set().union(*credential_ids_by_identifier.values())
+ allowed_credential_ids = await app.AGENT_FUNCTION.accessible_credential_ids(
+ principal, "credential.use", credential_ids
+ )
+ page = [
+ code
+ for code in page
+ if (
+ (linked_ids := credential_ids_by_identifier.get(normalize_identifier(code.totp_identifier))) is None
+ and (code.workflow_id or code.workflow_run_id or code.task_id)
+ )
+ or (linked_ids is not None and linked_ids <= allowed_credential_ids)
+ ]
+
+ codes.extend(page)
+ if page_length < page_limit:
+ break
+
+ if offset >= scan_limit and len(codes) < limit:
+ raise HTTPException(
+ status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+ detail="OTP search reached its access scan limit; add a filter and retry.",
+ )
- return codes
+ return codes[:limit]
async def _validate_credential_browser_profile_id(
@@ -692,10 +787,13 @@ async def _validate_credential_browser_profile_id(
status_code=400,
detail="A credential can only link a plain browser profile, not a workflow-managed one.",
)
- owners = await app.DATABASE.credentials.get_credentials_by_browser_profile_id(
- browser_profile_id=browser_profile_id, organization_id=organization_id
+ links_by_profile = await app.DATABASE.credentials.get_browser_profile_credential_links(
+ {browser_profile_id}, organization_id
)
- if any(owner.credential_id != current_credential_id for owner in owners):
+ 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.",
@@ -1481,6 +1579,22 @@ def _humanize_test_failure(raw_reason: str | None) -> str:
return "The login test was unsuccessful. Please verify your credentials and the login URL, then try again."
+async def _get_credential_test_run(credential_id: str, workflow_run_id: str, organization_id: str) -> Any:
+ workflow_run = await app.DATABASE.workflow_runs.get_workflow_run(
+ workflow_run_id=workflow_run_id, organization_id=organization_id
+ )
+ if workflow_run is None:
+ raise HTTPException(status_code=404, detail=f"Workflow run {workflow_run_id} not found")
+ parameters = await app.DATABASE.workflow_runs.get_workflow_run_parameters(workflow_run_id)
+ if not any(
+ workflow_parameter.workflow_parameter_type == WorkflowParameterType.CREDENTIAL_ID
+ and run_parameter.value == credential_id
+ for workflow_parameter, run_parameter in parameters
+ ):
+ raise HTTPException(status_code=404, detail=f"Workflow run {workflow_run_id} not found")
+ return workflow_run
+
+
@base_router.get(
"/credentials/{credential_id}/test/{workflow_run_id}",
response_model=TestCredentialStatusResponse,
@@ -1512,12 +1626,7 @@ async def get_test_credential_status(
current_org: Organization = Depends(org_auth_service.get_current_org_for_credential_routes),
) -> TestCredentialStatusResponse:
organization_id = current_org.organization_id
-
- workflow_run = await app.DATABASE.workflow_runs.get_workflow_run(
- workflow_run_id=workflow_run_id, organization_id=organization_id
- )
- if not workflow_run:
- raise HTTPException(status_code=404, detail=f"Workflow run {workflow_run_id} not found")
+ workflow_run = await _get_credential_test_run(credential_id, workflow_run_id, organization_id)
credential = await app.DATABASE.credentials.get_credential(
credential_id=credential_id, organization_id=organization_id
@@ -1623,6 +1732,7 @@ async def cancel_credential_test(
current_org: Organization = Depends(org_auth_service.get_current_org_for_credential_routes),
) -> CancelTestResponse:
organization_id = current_org.organization_id
+ await _get_credential_test_run(credential_id, workflow_run_id, organization_id)
LOG.info(
"Canceling credential test",
@@ -2615,6 +2725,10 @@ async def get_credentials(
SECURITY: Like ``get_credential``, this endpoint never returns raw secret
material. See the module docstring for the full security invariant.
"""
+ principal = get_request_principal()
+ allowed_folder_ids = (
+ await app.AGENT_FUNCTION.accessible_credential_folder_ids(principal) if principal is not None else None
+ )
credentials = await app.DATABASE.credentials.get_credentials(
current_org.organization_id,
page=page,
@@ -2623,6 +2737,7 @@ async def get_credentials(
credential_type=credential_type.value if isinstance(credential_type, CredentialType) else None,
search=search if isinstance(search, str) else None,
folder_id=folder_id if isinstance(folder_id, str) else None,
+ allowed_folder_ids=allowed_folder_ids,
)
return [_convert_to_response(credential) for credential in credentials]
@@ -2719,11 +2834,16 @@ async def get_credential_folders(
search: str | None = Query(None, description="Search folders by title or description"),
current_org: Organization = Depends(org_auth_service.get_current_org_for_credential_routes),
) -> list[CredentialFolder]:
+ principal = get_request_principal()
+ allowed_folder_ids = (
+ await app.AGENT_FUNCTION.accessible_credential_folder_ids(principal) if principal is not None else None
+ )
folders = await app.DATABASE.credential_folders.get_credential_folders(
organization_id=current_org.organization_id,
page=page,
page_size=page_size,
search_query=search,
+ allowed_folder_ids=allowed_folder_ids,
)
if folders:
@@ -2800,10 +2920,13 @@ async def delete_credential_folder(
folder_id: str = Path(..., description="Credential folder ID", examples=["cfld_123"]),
current_org: Organization = Depends(org_auth_service.get_current_org_for_credential_routes),
) -> dict:
- success = await app.DATABASE.credential_folders.soft_delete_credential_folder(
- folder_id=folder_id,
- organization_id=current_org.organization_id,
- )
+ try:
+ success = await app.DATABASE.credential_folders.soft_delete_credential_folder(
+ folder_id=folder_id,
+ organization_id=current_org.organization_id,
+ )
+ except ValueError as exc:
+ raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail=str(exc)) from exc
if not success:
raise HTTPException(status_code=404, detail=f"Credential folder {folder_id} not found")
@@ -2833,11 +2956,24 @@ async def update_credential_folder_assignment(
data: UpdateCredentialFolderRequest = Body(...),
current_org: Organization = Depends(org_auth_service.get_current_org_for_credential_routes),
) -> CredentialResponse:
+ principal = get_request_principal()
+
+ async def reauthorize_move(session: AsyncSession) -> None:
+ if principal is None:
+ return
+ references = {("credential_id", credential_id)}
+ if data.folder_id:
+ references.add(("folder_id", data.folder_id))
+ await app.AGENT_FUNCTION.enforce_credential_folder_access_for_ids(
+ principal, "credential.move", references, session=session
+ )
+
try:
credential = await app.DATABASE.credential_folders.set_credential_folder(
credential_id=credential_id,
organization_id=current_org.organization_id,
folder_id=data.folder_id,
+ authorize_move=reauthorize_move,
)
except ValueError as e:
raise HTTPException(status_code=400, detail=str(e)) from e
diff --git a/skyvern/forge/sdk/routes/streaming/auth.py b/skyvern/forge/sdk/routes/streaming/auth.py
index 295355dd1..302876d68 100644
--- a/skyvern/forge/sdk/routes/streaming/auth.py
+++ b/skyvern/forge/sdk/routes/streaming/auth.py
@@ -56,12 +56,43 @@ async def _close_unauthenticated(websocket: WebSocket, **log_kwargs: t.Any) -> N
async def folder_access_denied(websocket: WebSocket, action: str, resource: t.Mapping[str, str | None]) -> bool:
"""Close the stream when the caller's workflow folders do not cover the run behind it."""
+ principal = get_request_principal()
try:
# The evaluator judges one identifier per call, so each id behind the stream is checked on its own.
for key, value in resource.items():
if value:
- await app.AGENT_FUNCTION.enforce_folder_access(get_request_principal(), action, {key: value})
- except HTTPException:
+ await app.AGENT_FUNCTION.enforce_folder_access(principal, action, {key: value})
+ if key == "browser_session_id":
+ await app.AGENT_FUNCTION.enforce_browser_session_credential_use(principal, value)
+ elif key == "workflow_run_id":
+ await app.AGENT_FUNCTION.enforce_workflow_run_credential_use(principal, value)
+ elif key == "task_id":
+ try:
+ organization_id = principal.organization_id if principal else None
+ task = await app.DATABASE.tasks.get_task(value, organization_id=organization_id)
+ if task is None:
+ continue
+ if task.workflow_run_id:
+ await app.AGENT_FUNCTION.enforce_workflow_run_credential_use(
+ principal, task.workflow_run_id
+ )
+ session = await app.DATABASE.browser_sessions.get_persistent_browser_session_by_runnable_id(
+ value, organization_id=task.organization_id
+ )
+ if session:
+ await app.AGENT_FUNCTION.enforce_browser_session_credential_use(
+ principal, session.persistent_browser_session_id
+ )
+ except (HTTPException, PermissionError):
+ raise
+ except Exception as exc:
+ LOG.warning(
+ "Task stream credential authorization failed; denying",
+ task_id=value,
+ exc_info=True,
+ )
+ raise PermissionError("credential not accessible") from exc
+ except (HTTPException, PermissionError):
LOG.info("Rejecting streaming connection outside the caller's workflow folders.", action=action)
try:
await websocket.close(code=4403)
diff --git a/skyvern/forge/sdk/routes/twilio_integration.py b/skyvern/forge/sdk/routes/twilio_integration.py
index c53b3cfd1..9104d1163 100644
--- a/skyvern/forge/sdk/routes/twilio_integration.py
+++ b/skyvern/forge/sdk/routes/twilio_integration.py
@@ -34,6 +34,7 @@ from skyvern.forge.sdk.schemas.sms import (
TwilioPhoneNumberInfo,
)
from skyvern.forge.sdk.services import org_auth_service
+from skyvern.forge.sdk.services.request_principal import get_request_principal
from skyvern.forge.sdk.services.route_authorization import require_request_actions
from skyvern.forge.sdk.services.twilio_service import (
TwilioApiError,
@@ -423,6 +424,9 @@ async def _enable_twilio_phone_number_locked(
organization_id: str,
) -> OrganizationPhoneNumber:
if request.credential_id is not None:
+ await app.AGENT_FUNCTION.enforce_credential_folder_access_for_ids(
+ get_request_principal(), "credential.use", {("credential_id", request.credential_id)}
+ )
bound_credential = await app.DATABASE.credentials.get_credential(
request.credential_id, organization_id=organization_id
)
@@ -446,6 +450,14 @@ async def _enable_twilio_phone_number_locked(
raise HTTPException(status_code=409, detail="Phone number changed during lifecycle operation")
registered = await _get_registered_phone_number(phone_number, organization_id)
_require_twilio_provider(registered)
+ if (
+ registered is not None
+ and registered.credential_id is not None
+ and registered.credential_id != request.credential_id
+ ):
+ await app.AGENT_FUNCTION.enforce_credential_folder_access_for_ids(
+ get_request_principal(), "credential.use", {("credential_id", registered.credential_id)}
+ )
connected_config = await app.DATABASE.sms.get_connected_sms_config(organization_id)
if connected_config is None:
connected_config = await app.DATABASE.sms.create_sms_config(
@@ -704,7 +716,16 @@ async def list_registered_phone_numbers(
current_org: Annotated[Organization, Depends(org_auth_service.get_current_org_for_credential_routes)],
) -> list[OrganizationPhoneNumber]:
_require_twilio_sms_enabled()
- return await app.DATABASE.sms.list_phone_numbers(current_org.organization_id)
+ phone_numbers = await app.DATABASE.sms.list_phone_numbers(current_org.organization_id)
+ credential_ids = {phone.credential_id for phone in phone_numbers if phone.credential_id is not None}
+ if credential_ids and await app.AGENT_FUNCTION.credential_folders_restricted(current_org.organization_id):
+ accessible_credential_ids = await app.AGENT_FUNCTION.accessible_credential_ids(
+ get_request_principal(), "credential.read", credential_ids
+ )
+ for phone in phone_numbers:
+ if phone.credential_id not in accessible_credential_ids:
+ phone.credential_id = None
+ return phone_numbers
@twilio_integration_router.get(
@@ -793,6 +814,10 @@ async def _disable_twilio_phone_number_locked(
if registered is None:
raise HTTPException(status_code=404, detail="Phone number not found")
_require_twilio_provider(registered)
+ if registered.credential_id is not None:
+ await app.AGENT_FUNCTION.enforce_credential_folder_access_for_ids(
+ get_request_principal(), "credential.use", {("credential_id", registered.credential_id)}
+ )
was_quarantined = registered.status == "quarantined"
client: Any | None = None
if registered.provider_number_sid:
@@ -883,6 +908,15 @@ async def _disable_twilio_phone_number_locked(
phone_number.phone_number_id,
changed_fields=("status",),
)
+ if (
+ phone_number.credential_id is not None
+ and await app.AGENT_FUNCTION.credential_folders_restricted(organization_id)
+ and phone_number.credential_id
+ not in await app.AGENT_FUNCTION.accessible_credential_ids(
+ get_request_principal(), "credential.read", {phone_number.credential_id}
+ )
+ ):
+ phone_number.credential_id = None
return phone_number
diff --git a/skyvern/forge/sdk/routes/workflow_copilot.py b/skyvern/forge/sdk/routes/workflow_copilot.py
index babd0efff..74daaa786 100644
--- a/skyvern/forge/sdk/routes/workflow_copilot.py
+++ b/skyvern/forge/sdk/routes/workflow_copilot.py
@@ -75,7 +75,7 @@ from skyvern.forge.sdk.copilot.credential_pause import (
sign_in_site,
start_manual_sign_in,
)
-from skyvern.forge.sdk.copilot.credential_resolution import safe_admitted_url
+from skyvern.forge.sdk.copilot.credential_resolution import load_credentials, safe_admitted_url
from skyvern.forge.sdk.copilot.demonstration_recorder import (
DemonstrationRecorder,
DemonstrationRejection,
@@ -111,7 +111,10 @@ from skyvern.forge.sdk.copilot.review_gate import parse_execution_receipts, seri
from skyvern.forge.sdk.copilot.runtime import close_browser_session_quietly
from skyvern.forge.sdk.copilot.steer import STEER_DOORBELL_TTL, copilot_steer_key
from skyvern.forge.sdk.copilot.tools.account_groups import recover_account_group_links
-from skyvern.forge.sdk.copilot.tools.credential_deletion import credential_delete_enabled
+from skyvern.forge.sdk.copilot.tools.credential_deletion import (
+ credential_delete_enabled,
+ enforce_credential_delete_access,
+)
from skyvern.forge.sdk.copilot.tools.workflow_update import (
_validated_pending_workflow_proposal,
private_workflow_settings_from_proposal,
@@ -2188,6 +2191,7 @@ async def _commit_staged_workflow(
build_source=WorkflowBuildSource.copilot,
preserve_completion_contract=not clear_persisted_completion_contract,
validate_code_block_templates=False,
+ preserve_redacted_credential_references_from=canonical,
)
@@ -2272,6 +2276,7 @@ async def _restore_workflow_definition(original_workflow: Workflow | None, organ
build_source=original_workflow.build_source,
preserve_completion_contract=False,
validate_code_block_templates=False,
+ preserve_redacted_credential_references_from=original_workflow,
)
# A shielded finalizer runs in a child task with a copied context, so the marker has to be a
# mutable object shared by reference rather than a value set through the ContextVar.
@@ -4362,7 +4367,12 @@ async def _delete_one_credential(organization_id: str, credential_id: str) -> Cr
# A timeout stops the wait but never cancels the delete, so a late vault delete still gets its audit, profile
# reap, TOTP clear and item cleanup.
hooks = BackgroundTasks()
- deletion = _detach_credential_delete_task(delete_organization_credential(organization_id, credential_id, hooks))
+
+ async def delete() -> None:
+ await enforce_credential_delete_access(credential_id)
+ await delete_organization_credential(organization_id, credential_id, hooks)
+
+ deletion = _detach_credential_delete_task(delete())
deletion.add_done_callback(lambda _: _detach_credential_delete_task(_run_post_delete_hooks(hooks)))
try:
await asyncio.wait_for(asyncio.shield(deletion), CREDENTIAL_DELETE_TIMEOUT.total_seconds())
@@ -4717,8 +4727,9 @@ async def workflow_copilot_credential_response(
status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
detail="credential_id is required when action is 'connected'",
)
- existing = await app.DATABASE.credentials.get_credentials_by_ids(
- [credential_id], organization_id=organization.organization_id
+ existing = await load_credentials(
+ organization_id=organization.organization_id,
+ credential_ids=[credential_id],
)
if not existing:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Credential {credential_id} not found")
diff --git a/skyvern/forge/sdk/schemas/browser_profiles.py b/skyvern/forge/sdk/schemas/browser_profiles.py
index 3ae09b707..cc0f59176 100644
--- a/skyvern/forge/sdk/schemas/browser_profiles.py
+++ b/skyvern/forge/sdk/schemas/browser_profiles.py
@@ -23,8 +23,8 @@ class BrowserProfile(BaseModel):
modified_at: datetime
deleted_at: datetime | None = None
last_verified_login_at: datetime | None = None
- # Populated by the list endpoint (batched) so the UI can show the credential-login role + freshness on
- # rows without a per-row usage fetch. None on single-get and for profiles no credential links.
+ # Populated on list and single-get responses so the UI can show the linked credential when visible.
+ linked_credential_id: str | None = None
linked_credential_name: str | None = None
@field_validator("proxy_location", mode="before")
diff --git a/skyvern/forge/sdk/services/route_authorization.py b/skyvern/forge/sdk/services/route_authorization.py
index 8af502323..cf62336fc 100644
--- a/skyvern/forge/sdk/services/route_authorization.py
+++ b/skyvern/forge/sdk/services/route_authorization.py
@@ -137,7 +137,7 @@ ROUTE_ACTIONS: Mapping[str, str] = {
"skyvern.forge.sdk.routes.credentials.get_credential": "credential.read",
"skyvern.forge.sdk.routes.credentials.get_credential_folder": "credential_folder.read",
"skyvern.forge.sdk.routes.credentials.get_credential_folders": "credential_folder.list",
- "skyvern.forge.sdk.routes.credentials.get_credential_totp_code": "credential.read",
+ "skyvern.forge.sdk.routes.credentials.get_credential_totp_code": "credential.use",
"skyvern.forge.sdk.routes.credentials.get_credentials": "credential.list",
"skyvern.forge.sdk.routes.credentials.get_custom_credential_service_config": "vault_provider.read",
"skyvern.forge.sdk.routes.credentials.get_custom_credential_service_status": "vault_provider.status",
@@ -156,7 +156,7 @@ ROUTE_ACTIONS: Mapping[str, str] = {
"skyvern.forge.sdk.routes.credentials.update_bitwarden_credential": "vault_provider.update",
"skyvern.forge.sdk.routes.credentials.update_credential": "credential.update",
"skyvern.forge.sdk.routes.credentials.update_credential_folder": "credential_folder.update",
- "skyvern.forge.sdk.routes.credentials.update_credential_folder_assignment": "credential_folder.update",
+ "skyvern.forge.sdk.routes.credentials.update_credential_folder_assignment": "credential.move",
"skyvern.forge.sdk.routes.credentials.update_custom_credential_service_config": "vault_provider.update",
"skyvern.forge.sdk.routes.credentials.update_onepassword_token": "vault_provider.update",
"skyvern.forge.sdk.routes.custom_llms.create_custom_llm": "custom_model.create",
diff --git a/skyvern/forge/sdk/workflow/context_manager.py b/skyvern/forge/sdk/workflow/context_manager.py
index e194536fe..0e6b21169 100644
--- a/skyvern/forge/sdk/workflow/context_manager.py
+++ b/skyvern/forge/sdk/workflow/context_manager.py
@@ -1291,6 +1291,11 @@ class WorkflowRunContext:
organization: Organization,
fetch: CredentialFetch,
) -> None:
+ await app.AGENT_FUNCTION.enforce_credential_use(
+ organization.organization_id,
+ credential_id,
+ workflow_run_id=self.workflow_run_id,
+ )
db_credential = await app.DATABASE.credentials.get_credential(
credential_id, organization_id=organization.organization_id
)
diff --git a/skyvern/forge/sdk/workflow/service.py b/skyvern/forge/sdk/workflow/service.py
index 1b11a3d6e..1b8c03600 100644
--- a/skyvern/forge/sdk/workflow/service.py
+++ b/skyvern/forge/sdk/workflow/service.py
@@ -168,6 +168,7 @@ from skyvern.forge.sdk.schemas.persistent_browser_sessions import (
from skyvern.forge.sdk.schemas.tasks import Task, TaskStatus
from skyvern.forge.sdk.schemas.workflow_runs import WorkflowRunBlock, WorkflowRunTimeline, WorkflowRunTimelineType
from skyvern.forge.sdk.schemas.workflow_schedules import OneTimeDispatchStatus
+from skyvern.forge.sdk.services.request_principal import RequestPrincipal, get_request_principal
from skyvern.forge.sdk.streaming.registries import mark_stream_closing
from skyvern.forge.sdk.submission import shadow as submission_shadow
from skyvern.forge.sdk.trace import traced
@@ -356,8 +357,10 @@ from skyvern.schemas.workflows import (
BlockResult,
BlockStatus,
BlockType,
+ CredentialParameterYAML,
WorkflowCreateYAMLRequest,
WorkflowDefinitionYAML,
+ WorkflowParameterYAML,
WorkflowStatus,
)
from skyvern.services import script_service, uploaded_file_service, workflow_script_service
@@ -2821,10 +2824,33 @@ class WorkflowService:
)
return value
- async def _validate_credential_ids(self, credential_ids: list[str], organization: Organization) -> list[Credential]:
+ async def _validate_credential_ids(
+ self,
+ credential_ids: list[str],
+ organization: Organization,
+ *,
+ principal: RequestPrincipal | None = None,
+ workflow_run_id: str | None = None,
+ skip_credential_use_ids: set[str] | None = None,
+ ) -> list[Credential]:
if not credential_ids:
return []
unique_ids = list(dict.fromkeys(credential_ids))
+ principal = principal or get_request_principal()
+ for credential_id in unique_ids:
+ if skip_credential_use_ids and credential_id in skip_credential_use_ids:
+ continue
+ try:
+ await app.AGENT_FUNCTION.enforce_credential_use(
+ organization.organization_id,
+ credential_id,
+ principal=principal,
+ workflow_run_id=workflow_run_id,
+ )
+ except PermissionError as exc:
+ raise SkyvernHTTPException(
+ message="Credential not accessible", status_code=HTTPStatus.FORBIDDEN
+ ) from exc
existing = await app.DATABASE.credentials.get_credentials_by_ids(
unique_ids, organization_id=organization.organization_id
)
@@ -2899,7 +2925,9 @@ class WorkflowService:
continue
if isinstance(credential_id, str) and credential_id:
bound_credential_ids.append(credential_id)
- validated_bound_credentials = await self._validate_credential_ids(bound_credential_ids, organization)
+ validated_bound_credentials = await self._validate_credential_ids(
+ bound_credential_ids, organization, workflow_run_id=workflow_run.workflow_run_id
+ )
sequential_ids = sorted(
{credential.credential_id for credential in validated_bound_credentials if credential.run_sequentially}
)
@@ -2918,8 +2946,12 @@ class WorkflowService:
self,
parameters: list[Any],
organization: Organization,
+ *,
+ preserved_credential_references: set[tuple[str, str, str]] | None = None,
) -> None:
credential_ids_to_validate: list[str] = []
+ credential_ids_requiring_use: set[str] = set()
+ preserved_credential_references = preserved_credential_references or set()
for parameter in parameters:
key = getattr(parameter, "key", None) or "<unknown>"
credential_ids = getattr(parameter, "credential_ids", None)
@@ -2942,6 +2974,11 @@ class WorkflowService:
)
parameter.credential_id = credential_ids[0]
credential_ids_to_validate.extend(credential_ids)
+ credential_ids_requiring_use.update(
+ credential_id
+ for credential_id in credential_ids
+ if (key, "credential_ids", credential_id) not in preserved_credential_references
+ )
fallback_credential_ids = getattr(parameter, "fallback_credential_ids", None)
if fallback_credential_ids is not None:
@@ -2955,6 +2992,11 @@ class WorkflowService:
]
parameter.fallback_credential_ids = fallback_credential_ids or None
credential_ids_to_validate.extend(fallback_credential_ids)
+ credential_ids_requiring_use.update(
+ credential_id
+ for credential_id in fallback_credential_ids
+ if (key, "fallback_credential_ids", credential_id) not in preserved_credential_references
+ )
if (
getattr(parameter, "credential_ids", None) is not None
@@ -2983,7 +3025,17 @@ class WorkflowService:
status_code=400,
)
- await self._validate_credential_ids(credential_ids_to_validate, organization)
+ if credential_id := getattr(parameter, "credential_id", None):
+ credential_ids_to_validate.append(credential_id)
+ if (key, "credential_id", credential_id) not in preserved_credential_references:
+ credential_ids_requiring_use.add(credential_id)
+
+ # A hidden id reused in a different field is a new reference and still needs use access.
+ await self._validate_credential_ids(
+ credential_ids_to_validate,
+ organization,
+ skip_credential_use_ids=set(credential_ids_to_validate) - credential_ids_requiring_use,
+ )
@staticmethod
def _get_rotating_credential_parameters(workflow: Workflow) -> list[CredentialParameter]:
@@ -3132,7 +3184,9 @@ class WorkflowService:
return overrides
- async def _rotation_candidates_may_require_serialization(self, workflow: Workflow, organization_id: str) -> bool:
+ async def _rotation_candidates_may_require_serialization(
+ self, workflow: Workflow, organization_id: str, *, workflow_run_id: str | None = None
+ ) -> bool:
"""Conservatively decide whether a failed rotating-credential selection could still have
resolved to a credential opted into sequential execution. Any candidate flagged
run_sequentially — or any candidate we cannot verify — fails closed so a serialized lane is
@@ -3148,7 +3202,9 @@ class WorkflowService:
if organization is None:
return True
try:
- credentials = await self._validate_credential_ids(sorted(candidate_ids), organization)
+ credentials = await self._validate_credential_ids(
+ sorted(candidate_ids), organization, workflow_run_id=workflow_run_id
+ )
except Exception:
# Cannot verify the candidate pool (missing/invalid id or lookup error) — fail closed.
return True
@@ -3223,7 +3279,7 @@ class WorkflowService:
# candidate. A keyless workflow whose pool is provably non-sequential keeps the legacy
# best-effort partial selection — the pre-feature behavior for runs outside serialization.
if workflow.browser_profile_key or await self._rotation_candidates_may_require_serialization(
- workflow, organization_id
+ workflow, organization_id, workflow_run_id=workflow_run.workflow_run_id
):
raise
return selections
@@ -3233,6 +3289,7 @@ class WorkflowService:
workflow: Workflow,
organization: Organization,
request_data: dict[str, Any] | None,
+ credential_use_principal: RequestPrincipal | None = None,
) -> None:
all_workflow_parameters = await self.get_workflow_parameters(workflow_id=workflow.workflow_id)
schedule_parameters = [
@@ -3290,7 +3347,9 @@ class WorkflowService:
)
)
- await self._validate_credential_ids(credential_ids_to_validate, organization)
+ await self._validate_credential_ids(
+ credential_ids_to_validate, organization, principal=credential_use_principal
+ )
async def resolve_workflow_for_run(
self,
@@ -3676,7 +3735,9 @@ class WorkflowService:
parameter_values = {param.key: value for param, value in workflow_parameter_values}
if prevalidated_workflow_parameters is None:
await self._validate_credential_ids(
- self._credential_id_values(workflow_parameter_values), organization
+ self._credential_id_values(workflow_parameter_values),
+ organization,
+ workflow_run_id=workflow_run.workflow_run_id,
)
await self._validate_bitwarden_item_ids(workflow=workflow, parameter_values=parameter_values)
run_credential_parameter_overrides = await self._apply_run_credential_parameter_overrides(
@@ -11422,6 +11483,102 @@ class WorkflowService:
exc_info=True,
)
+ async def _preserve_redacted_credential_references(
+ self,
+ workflow_definition: WorkflowDefinition | WorkflowDefinitionYAML,
+ previous_workflow: Workflow | None,
+ ) -> set[tuple[str, str, str]]:
+ if previous_workflow is None:
+ return set()
+
+ previous_parameters = {
+ parameter.key: parameter
+ for parameter in previous_workflow.workflow_definition.parameters
+ if isinstance(parameter, CredentialParameter)
+ }
+ previous_workflow_parameters = {
+ parameter.key: parameter
+ for parameter in previous_workflow.workflow_definition.parameters
+ if isinstance(parameter, WorkflowParameter)
+ and parameter.workflow_parameter_type == WorkflowParameterType.CREDENTIAL_ID
+ }
+ credential_parameter_keys = set(previous_workflow_parameters)
+ credential_ids = {
+ credential_id
+ for parameter in previous_parameters.values()
+ for credential_id in (
+ parameter.credential_id if parameter.credential_id not in credential_parameter_keys else None,
+ *(parameter.credential_ids or []),
+ *(parameter.fallback_credential_ids or []),
+ )
+ if credential_id
+ }
+ credential_ids.update(
+ parameter.default_value
+ for parameter in previous_workflow_parameters.values()
+ if isinstance(parameter.default_value, str) and parameter.default_value
+ )
+ if not credential_ids:
+ return set()
+
+ visible_ids = await app.AGENT_FUNCTION.accessible_credential_ids(
+ get_request_principal(), "credential.read", credential_ids
+ )
+ preserved_references: set[tuple[str, str, str]] = set()
+ for parameter in workflow_definition.parameters:
+ if isinstance(parameter, (WorkflowParameter, WorkflowParameterYAML)):
+ previous_workflow_parameter = previous_workflow_parameters.get(parameter.key)
+ if (
+ previous_workflow_parameter is not None
+ and isinstance(previous_workflow_parameter.default_value, str)
+ and previous_workflow_parameter.default_value not in visible_ids
+ ):
+ if not parameter.default_value:
+ parameter.default_value = previous_workflow_parameter.default_value
+ if parameter.default_value == previous_workflow_parameter.default_value:
+ preserved_references.add(
+ (parameter.key, "default_value", previous_workflow_parameter.default_value)
+ )
+ continue
+ if not isinstance(parameter, (CredentialParameter, CredentialParameterYAML)):
+ continue
+ previous = previous_parameters.get(parameter.key)
+ if previous is None:
+ continue
+
+ if (
+ previous.credential_id
+ and previous.credential_id not in credential_parameter_keys
+ and previous.credential_id not in visible_ids
+ ):
+ if not parameter.credential_id:
+ parameter.credential_id = previous.credential_id
+ if parameter.credential_id == previous.credential_id:
+ preserved_references.add((parameter.key, "credential_id", previous.credential_id))
+
+ for field_name in ("credential_ids", "fallback_credential_ids"):
+ previous_values = getattr(previous, field_name) or []
+ hidden_values = [value for value in previous_values if value not in visible_ids]
+ if not hidden_values:
+ continue
+
+ # The workflow read serializer filters hidden ids; restore them in their prior positions.
+ values = list(getattr(parameter, field_name) or [])
+ hidden_after: dict[str | None, list[str]] = {}
+ preceding_visible: str | None = None
+ for value in previous_values:
+ if value in visible_ids and value in values:
+ preceding_visible = value
+ elif value in hidden_values and value not in values:
+ hidden_after.setdefault(preceding_visible, []).append(value)
+ for visible_value, hidden in hidden_after.items():
+ insert_at = values.index(visible_value) + 1 if visible_value in values else 0
+ values[insert_at:insert_at] = hidden
+ setattr(parameter, field_name, list(dict.fromkeys(values)))
+ preserved_references.update((parameter.key, field_name, value) for value in hidden_values)
+
+ return preserved_references
+
async def update_workflow_definition(
self,
workflow_id: str,
@@ -11460,17 +11617,24 @@ class WorkflowService:
preserve_completion_contract: bool = True,
created_via: str | None = None,
validate_code_block_templates: bool = True,
+ preserve_redacted_credential_references_from: Workflow | None = None,
+ preserved_credential_references: set[tuple[str, str, str]] | None = None,
) -> Workflow:
if workflow_definition is not None:
if validate_code_block_templates:
self._validate_code_block_templates(workflow_definition)
self._validate_block_engines(workflow_definition)
+ if preserved_credential_references is None:
+ preserved_credential_references = await self._preserve_redacted_credential_references(
+ workflow_definition, preserve_redacted_credential_references_from
+ )
if organization_id is not None:
organization = await app.DATABASE.organizations.get_organization(organization_id=organization_id)
if organization is not None:
await self._validate_and_normalize_credential_rotation_parameters(
workflow_definition.parameters,
organization,
+ preserved_credential_references=preserved_credential_references,
)
await encrypt_workflow_definition_secrets(workflow_definition, organization_id)
updated_workflow = await app.DATABASE.workflows.update_workflow_and_reconcile_definition_params(
@@ -17219,10 +17383,6 @@ class WorkflowService:
return (workflow, ()) if return_write_result else workflow
recording_id_to_attach = None
- await self._validate_and_normalize_credential_rotation_parameters(
- request.workflow_definition.parameters,
- organization,
- )
new_workflow_id: str | None = None
attached_recording_to_new_version = False
refresh_schedule_runtime_limits = False
@@ -17246,6 +17406,14 @@ class WorkflowService:
else:
existing_latest_workflow = None
+ preserved_credential_references = await self._preserve_redacted_credential_references(
+ request.workflow_definition, existing_latest_workflow
+ )
+ await self._validate_and_normalize_credential_rotation_parameters(
+ request.workflow_definition.parameters,
+ organization,
+ preserved_credential_references=preserved_credential_references,
+ )
if request.webhook_callback_url and (
existing_latest_workflow is None
or request.webhook_callback_url != existing_latest_workflow.webhook_callback_url
@@ -17294,6 +17462,7 @@ class WorkflowService:
created_via=created_via,
notify_workflow_saved=False,
validate_code_block_templates=validate_code_block_templates,
+ preserved_credential_references=preserved_credential_references,
)
self._schedule_workflow_saved_hook_best_effort(
diff --git a/skyvern/services/otp_service.py b/skyvern/services/otp_service.py
index 0208085e9..04bcd2fa2 100644
--- a/skyvern/services/otp_service.py
+++ b/skyvern/services/otp_service.py
@@ -1004,6 +1004,11 @@ async def poll_otp_value(
cancels this early (``asyncio.wait_for``) can pass its own contexts and then read
``observed_otp_types`` off them to report which kind of OTP did arrive.
"""
+ if totp_identifier:
+ await app.AGENT_FUNCTION.enforce_totp_identifier_credential_use(
+ organization_id, totp_identifier, workflow_run_id=workflow_run_id
+ )
+
timeout = timedelta(minutes=settings.VERIFICATION_CODE_POLLING_TIMEOUT_MINS)
if max_wait_seconds is not None:
timeout = min(timeout, timedelta(seconds=max_wait_seconds))
diff --git a/skyvern/utils/email_validation.py b/skyvern/utils/email_validation.py
index 1536f3d04..be3d834cf 100644
--- a/skyvern/utils/email_validation.py
+++ b/skyvern/utils/email_validation.py
@@ -1,14 +1,20 @@
import re
SAFE_EMAIL_ADDRESS_PATTERN = re.compile(r"^[A-Za-z0-9.!#$%&'*+/=?^_`{|}~-]+@[A-Za-z0-9.-]+$")
+# Keep SQL identifier matching aligned with Python's str.strip().
+EMAIL_IDENTIFIER_TRIM_CHARS = (
+ " \t\n\r\v\f\x1c\x1d\x1e\x1f\x85\xa0\u1680"
+ "\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a"
+ "\u2028\u2029\u202f\u205f\u3000"
+)
def normalize_email_address(value: str) -> str:
- return value.strip().casefold()
+ return value.strip(EMAIL_IDENTIFIER_TRIM_CHARS).casefold()
def normalize_identifier_if_email(value: str) -> str:
- stripped_identifier = value.strip()
+ stripped_identifier = value.strip(EMAIL_IDENTIFIER_TRIM_CHARS)
if SAFE_EMAIL_ADDRESS_PATTERN.fullmatch(stripped_identifier):
return normalize_email_address(value)
return value
diff --git a/skyvern/webeye/real_browser_manager.py b/skyvern/webeye/real_browser_manager.py
index 2079ff9b9..7973fb520 100644
--- a/skyvern/webeye/real_browser_manager.py
+++ b/skyvern/webeye/real_browser_manager.py
@@ -1037,6 +1037,14 @@ class RealBrowserManager(BrowserManager):
task: Task,
browser_session_id: str | None = None,
) -> BrowserState:
+ if task.workflow_run_id:
+ await app.AGENT_FUNCTION.enforce_workflow_run_credential_use(
+ None,
+ task.workflow_run_id,
+ organization_id=task.organization_id,
+ browser_session_id=browser_session_id,
+ )
+
browser_state = self.get_for_task(task_id=task.task_id, workflow_run_id=task.workflow_run_id)
lost_external_browser = False
if browser_state is not None:
@@ -1260,6 +1268,15 @@ class RealBrowserManager(BrowserManager):
if browser_profile_id is None:
browser_profile_id = workflow_run.browser_profile_id
+ # Shared run/task/SDK attachment boundary; route guards remain early 403s.
+ await app.AGENT_FUNCTION.enforce_workflow_run_credential_use(
+ None,
+ workflow_run_id,
+ organization_id=workflow_run.organization_id,
+ browser_profile_id=browser_profile_id,
+ browser_session_id=browser_session_id,
+ )
+
context = skyvern_context.current()
# A synthetic run never begins the session; only an explicit runnable can acquire it.
owner_fallback_id = None if context is not None and context.workflow_run_is_synthetic else workflow_run_id
diff --git a/tests/unit/forge/sdk/routes/streaming/test_screenshot_stream_disconnect.py b/tests/unit/forge/sdk/routes/streaming/test_screenshot_stream_disconnect.py
index 77719f1e9..49a2353f4 100644
--- a/tests/unit/forge/sdk/routes/streaming/test_screenshot_stream_disconnect.py
+++ b/tests/unit/forge/sdk/routes/streaming/test_screenshot_stream_disconnect.py
@@ -43,6 +43,9 @@ class _DisconnectedWebSocket:
async def send_json(self, data: dict) -> None:
self.sent.append(data)
+ async def close(self, *, code: int = 1000) -> None:
+ return None
+
async def receive(self) -> dict:
if not self._disconnect_delivered:
self._disconnect_delivered = True
@@ -74,7 +77,12 @@ async def test_workflow_run_streaming_stops_sending_once_the_client_is_gone(
monkeypatch.setattr(
app,
"AGENT_FUNCTION",
- SimpleNamespace(mark_streaming_viewer_active=AsyncMock(), enforce_folder_access=AsyncMock()),
+ SimpleNamespace(
+ mark_streaming_viewer_active=AsyncMock(),
+ enforce_folder_access=AsyncMock(),
+ enforce_browser_session_credential_use=AsyncMock(),
+ enforce_workflow_run_credential_use=AsyncMock(),
+ ),
)
with capture_logs() as logs:
@@ -108,6 +116,9 @@ class _WatchingWebSocket:
raise self._send_error
self.sent.append(data)
+ async def close(self, *, code: int = 1000) -> None:
+ return None
+
async def receive(self) -> dict:
await asyncio.Event().wait()
raise AssertionError("unreachable")
@@ -169,7 +180,12 @@ def run_stream(monkeypatch: pytest.MonkeyPatch) -> Callable[..., Awaitable[_Watc
monkeypatch.setattr(
app,
"AGENT_FUNCTION",
- SimpleNamespace(mark_streaming_viewer_active=AsyncMock(), enforce_folder_access=AsyncMock()),
+ SimpleNamespace(
+ mark_streaming_viewer_active=AsyncMock(),
+ enforce_folder_access=AsyncMock(),
+ enforce_browser_session_credential_use=AsyncMock(),
+ enforce_workflow_run_credential_use=AsyncMock(),
+ ),
)
async def _connect(
@@ -181,7 +197,17 @@ def run_stream(monkeypatch: pytest.MonkeyPatch) -> Callable[..., Awaitable[_Watc
task_id: str = "",
send_error: Exception | None = None,
) -> _WatchingWebSocket:
- monkeypatch.setattr(app, "DATABASE", SimpleNamespace(workflow_runs=runs, tasks=runs))
+ monkeypatch.setattr(
+ app,
+ "DATABASE",
+ SimpleNamespace(
+ workflow_runs=runs,
+ tasks=runs,
+ browser_sessions=SimpleNamespace(
+ get_persistent_browser_session_by_runnable_id=AsyncMock(return_value=None)
+ ),
+ ),
+ )
monkeypatch.setattr(app, "STORAGE", SimpleNamespace(get_streaming_file=AsyncMock(return_value=frame)))
monkeypatch.setattr(screenshot, "STREAMING_TIMEOUT", timeout_seconds)
websocket = _WatchingWebSocket(send_error)
@@ -204,7 +230,13 @@ async def test_run_stream_tile_counts_a_run_once_and_only_while_its_failure_is_u
pool_timeout = TimeoutError("QueuePool limit reached")
runs = _ScriptedRuns(
{
- "wr_blank": [WorkflowRunStatus.running, pool_timeout, WorkflowRunStatus.running, WorkflowRunStatus.running],
+ "wr_blank": [
+ WorkflowRunStatus.running,
+ pool_timeout,
+ WorkflowRunStatus.running,
+ WorkflowRunStatus.running,
+ WorkflowRunStatus.running,
+ ],
"wr_recovered": [
WorkflowRunStatus.running,
pool_timeout,
@@ -286,7 +318,9 @@ async def test_task_page_stream_error_counts_as_unrecovered_because_the_task_pag
run_stream: Callable[..., Awaitable[_WatchingWebSocket]],
) -> None:
pool_timeout = TimeoutError("QueuePool limit reached")
- runs = _ScriptedRuns({"wr_task": [WorkflowRunStatus.running, pool_timeout], "wr_run": [pool_timeout]})
+ runs = _ScriptedRuns(
+ {"wr_task": [WorkflowRunStatus.running, WorkflowRunStatus.running, pool_timeout], "wr_run": [pool_timeout]}
+ )
with capture_logs() as logs:
await run_stream(runs, frame=b"png", timeout_seconds=10_000, task_id="tsk_task")
await run_stream(runs, frame=b"png", timeout_seconds=10_000, workflow_run_id="wr_run")
diff --git a/tests/unit/forge/sdk/routes/test_browser_sessions.py b/tests/unit/forge/sdk/routes/test_browser_sessions.py
index e85114959..aaef03271 100644
--- a/tests/unit/forge/sdk/routes/test_browser_sessions.py
+++ b/tests/unit/forge/sdk/routes/test_browser_sessions.py
@@ -356,8 +356,12 @@ async def test_get_browser_session_enables_strict_download_lookup() -> None:
async def test_fan_out_listings_keep_each_sessions_storage_listings_sequential(endpoint: str) -> None:
"""These endpoints already gather across sessions, so overlapping a session's two listings would
only raise the request's peak pool checkouts from N to 2N."""
- sessions = [MagicMock(), MagicMock()]
+ sessions = [MagicMock(browser_profile_id=None, persistent_browser_session_id=f"pbs_{index}") for index in range(2)]
app_mock = MagicMock()
+ app_mock.AGENT_FUNCTION.enforce_browser_session_credential_use = AsyncMock()
+ app_mock.AGENT_FUNCTION.accessible_browser_session_ids = AsyncMock(
+ return_value={session.persistent_browser_session_id for session in sessions}
+ )
app_mock.DATABASE.browser_sessions.get_persistent_browser_sessions_history = AsyncMock(return_value=sessions)
app_mock.PERSISTENT_SESSIONS_MANAGER.get_active_sessions = AsyncMock(return_value=sessions)
app_mock.DATABASE.browser_sessions.get_folder_visible_browser_session_ids = AsyncMock(
diff --git a/tests/unit/forge/sdk/test_list_browser_profiles_route.py b/tests/unit/forge/sdk/test_list_browser_profiles_route.py
index a44d7f28e..e56b9c8e7 100644
--- a/tests/unit/forge/sdk/test_list_browser_profiles_route.py
+++ b/tests/unit/forge/sdk/test_list_browser_profiles_route.py
@@ -38,6 +38,7 @@ def _build_client(monkeypatch: pytest.MonkeyPatch) -> tuple[TestClient, AsyncMoc
async def _fake_org() -> SimpleNamespace:
return SimpleNamespace(organization_id=ORG_ID)
+ monkeypatch.setattr(forge_app.AGENT_FUNCTION, "credential_folders_restricted", AsyncMock(return_value=False))
list_browser_profiles = AsyncMock()
monkeypatch.setattr(
forge_app.DATABASE.browser_sessions,
@@ -72,6 +73,7 @@ def test_list_browser_profiles_default_pagination(monkeypatch: pytest.MonkeyPatc
page_size=10,
search_key=None,
managed=None,
+ exclude_search_profile_ids=set(),
)
@@ -89,6 +91,7 @@ def test_list_browser_profiles_explicit_pagination(monkeypatch: pytest.MonkeyPat
page_size=10,
search_key=None,
managed=None,
+ exclude_search_profile_ids=set(),
)
@@ -124,6 +127,7 @@ def test_list_browser_profiles_alias_trailing_slash(monkeypatch: pytest.MonkeyPa
page_size=5,
search_key=None,
managed=None,
+ exclude_search_profile_ids=set(),
)
@@ -143,6 +147,7 @@ def test_list_browser_profiles_search_key_hit_on_name(monkeypatch: pytest.Monkey
page_size=10,
search_key="production",
managed=None,
+ exclude_search_profile_ids=set(),
)
@@ -162,6 +167,7 @@ def test_list_browser_profiles_search_key_hit_on_description(monkeypatch: pytest
page_size=10,
search_key="staging_login",
managed=None,
+ exclude_search_profile_ids=set(),
)
@@ -180,6 +186,7 @@ def test_list_browser_profiles_search_key_miss(monkeypatch: pytest.MonkeyPatch)
page_size=10,
search_key="no_such_profile",
managed=None,
+ exclude_search_profile_ids=set(),
)
@@ -197,6 +204,7 @@ def test_list_browser_profiles_search_key_with_pagination(monkeypatch: pytest.Mo
page_size=5,
search_key="prod",
managed=None,
+ exclude_search_profile_ids=set(),
)
@@ -214,4 +222,5 @@ def test_list_browser_profiles_search_key_with_include_deleted(monkeypatch: pyte
page_size=10,
search_key="archived",
managed=None,
+ exclude_search_profile_ids=set(),
)
diff --git a/tests/unit/test_context_manager.py b/tests/unit/test_context_manager.py
index 33a5cf0fe..e71b3446d 100644
--- a/tests/unit/test_context_manager.py
+++ b/tests/unit/test_context_manager.py
@@ -341,6 +341,7 @@ def _install_credential_app(
),
CREDENTIAL_VAULT_SERVICES={CredentialVaultType.AZURE_VAULT: vault_service},
AGENT_FUNCTION=SimpleNamespace(
+ enforce_credential_use=AsyncMock(),
process_registered_credential_item=AsyncMock(side_effect=lambda **kwargs: kwargs["credential_item"]),
parse_enterprise_totp_secret=AsyncMock(return_value=None),
),
diff --git a/tests/unit/test_copilot_agent_helpers.py b/tests/unit/test_copilot_agent_helpers.py
index 8a667a0a3..374ccb082 100644
--- a/tests/unit/test_copilot_agent_helpers.py
+++ b/tests/unit/test_copilot_agent_helpers.py
@@ -5767,7 +5767,12 @@ workflow_definition:
assert "cred_missing" in error
assert "not found in this organization" in error
assert "Stop before creating, updating, or running the workflow" in error
- get_credentials_by_ids.assert_awaited_once_with(["cred_valid", "cred_missing"], organization_id="org-1")
+ get_credentials_by_ids.assert_awaited_once_with(
+ ["cred_valid", "cred_missing"],
+ organization_id="org-1",
+ allowed_folder_ids=None,
+ include_deleted=False,
+ )
@pytest.mark.asyncio
async def test_valid_tool_credential_reference_allows_tool_path(self, monkeypatch) -> None:
@@ -5783,7 +5788,9 @@ workflow_definition:
error = await _credential_reference_validation_error({"credential_id": "cred_valid"}, _ctx())
assert error is None
- get_credentials_by_ids.assert_awaited_once_with(["cred_valid"], organization_id="org-1")
+ get_credentials_by_ids.assert_awaited_once_with(
+ ["cred_valid"], organization_id="org-1", allowed_folder_ids=None, include_deleted=False
+ )
@pytest.mark.asyncio
async def test_update_workflow_allows_missing_credentials_for_explicit_untested_draft(self, monkeypatch) -> None:
@@ -6432,7 +6439,9 @@ class TestRunBlocksCredentialApproval:
assert result["ok"] is False
assert result["error"] == "Organization not found"
- database.credentials.get_credentials_by_ids.assert_awaited_once_with(["cred_resolved"], organization_id="org-1")
+ database.credentials.get_credentials_by_ids.assert_awaited_once_with(
+ ["cred_resolved"], organization_id="org-1", allowed_folder_ids=None, include_deleted=False
+ )
database.organizations.get_organization.assert_awaited_once_with(organization_id="org-1")
@pytest.mark.asyncio
@@ -7025,7 +7034,7 @@ class TestRunBlocksCredentialApprovalFrontierScope:
assert "unapproved_credential_reference" not in (result.get("error") or "")
assert result["error"] == "Organization not found"
database.credentials.get_credentials_by_ids.assert_awaited_once_with(
- [self.CREDENTIAL_ID], organization_id="org-1"
+ [self.CREDENTIAL_ID], organization_id="org-1", allowed_folder_ids=None, include_deleted=False
)
@pytest.mark.asyncio
@@ -7167,7 +7176,7 @@ class TestRunBlocksCredentialApprovalFrontierScope:
assert "not found in this organization" in result["error"]
assert self.CREDENTIAL_ID in result["error"]
database.credentials.get_credentials_by_ids.assert_awaited_once_with(
- [self.CREDENTIAL_ID], organization_id="org-1"
+ [self.CREDENTIAL_ID], organization_id="org-1", allowed_folder_ids=None, include_deleted=False
)
diff --git a/tests/unit/test_copilot_credential_deletion.py b/tests/unit/test_copilot_credential_deletion.py
index f61c673e6..49084f8f9 100644
--- a/tests/unit/test_copilot_credential_deletion.py
+++ b/tests/unit/test_copilot_credential_deletion.py
@@ -9,7 +9,7 @@ from unittest.mock import AsyncMock
import pytest
import pytest_asyncio
-from fastapi import FastAPI
+from fastapi import FastAPI, HTTPException
from httpx import ASGITransport, AsyncClient, Response
from pydantic_core import to_json
from sqlalchemy import event, select, update
@@ -29,7 +29,7 @@ from skyvern.forge.sdk.copilot.ask_user import (
)
from skyvern.forge.sdk.copilot.browser_ablation import resolve_copilot_tool_surface
from skyvern.forge.sdk.copilot.context import CopilotContext
-from skyvern.forge.sdk.copilot.tools import copilot_native_tools
+from skyvern.forge.sdk.copilot.tools import copilot_native_tools, credential_deletion
from skyvern.forge.sdk.copilot.tools.credential_deletion import delete_saved_credentials
from skyvern.forge.sdk.db.models import CredentialModel, WorkflowCopilotChatMessageModel, WorkflowCopilotChatModel
from skyvern.forge.sdk.routes import credentials as credential_routes
@@ -37,6 +37,7 @@ from skyvern.forge.sdk.routes import workflow_copilot as routes
from skyvern.forge.sdk.schemas.credentials import Credential, CredentialVaultType
from skyvern.forge.sdk.schemas.workflow_copilot import CopilotPendingTurn
from skyvern.forge.sdk.schemas.workflow_copilot import WorkflowCopilotChatSender as Sender
+from skyvern.forge.sdk.services.request_principal import AuthKind, RequestPrincipal
from tests.unit.conftest import RUN_GROUP_ORG, RUN_GROUP_WPID, GroupEnv
SECRET = "vault-secret-fixture-55190"
@@ -222,6 +223,31 @@ async def test_confirm_deletes_only_the_checked_entries_and_reports_each_outcome
assert SECRET not in to_json(surface).decode()
+async def test_confirmation_rechecks_delete_access_before_deleting_a_card_entry(
+ chat: Chat, monkeypatch: pytest.MonkeyPatch
+) -> None:
+ task = _start(chat, ["cred_1"])
+ card = await _card(chat)
+ viewer = RequestPrincipal(RUN_GROUP_ORG, AuthKind.bearer, "viewer", "org:member")
+ monkeypatch.setattr(credential_deletion, "get_request_principal", lambda: viewer)
+
+ async def deny_viewer(principal: RequestPrincipal | None, action: str, references: set[tuple[str, str]]) -> None:
+ assert principal == viewer
+ assert action == "credential.delete"
+ assert references == {("credential_id", "cred_1")}
+ raise HTTPException(status_code=403, detail="credential_folder_access_denied")
+
+ monkeypatch.setattr(app.AGENT_FUNCTION, "enforce_credential_folder_access_for_ids", deny_viewer)
+ confirmed = await _confirm(chat, card, ["cred_1"])
+ result = await asyncio.wait_for(task, 5)
+
+ assert confirmed.status_code == 200
+ assert [(item["credential_id"], item["outcome"]) for item in result["outcomes"]] == [("cred_1", "failed")]
+ assert chat.vault.deleted == []
+ assert not chat.vault.entered.is_set()
+
+
@pytest.mark.asyncio
@pytest.mark.parametrize("answer", ["skip", "approve_via_reply", "stop", "client_gone"])
async def test_an_unconfirmed_card_deletes_nothing(chat: Chat, answer: str) -> None:
diff --git a/tests/unit/test_copilot_credential_pause.py b/tests/unit/test_copilot_credential_pause.py
index 5d95f251b..cb959cd0d 100644
--- a/tests/unit/test_copilot_credential_pause.py
+++ b/tests/unit/test_copilot_credential_pause.py
@@ -44,6 +44,7 @@ from skyvern.exceptions import HttpException as VaultHttpException
from skyvern.forge import app
from skyvern.forge.sdk.cache.base import NoopLock
from skyvern.forge.sdk.copilot import credential_pause as credential_pause_module
+from skyvern.forge.sdk.copilot import credential_resolution
from skyvern.forge.sdk.copilot import tools as tools_module
from skyvern.forge.sdk.copilot.agent import _finalize_result_with_blocker_override, _turn_credential_prompt_reason
from skyvern.forge.sdk.copilot.blocker_signal import (
@@ -1212,6 +1213,36 @@ async def test_route_404_when_credential_unknown_or_foreign_org(monkeypatch: pyt
assert cache.set_calls == []
+async def test_route_404_when_connected_credential_is_in_a_hidden_folder(monkeypatch: pytest.MonkeyPatch) -> None:
+ cache = _FakeCache()
+ _seed_active_pause(cache, "org-1", "chat-1", "turn-1", "tok-1")
+ monkeypatch.setattr(app, "CACHE", cache, raising=False)
+ credential_lookup = AsyncMock(return_value=[])
+ monkeypatch.setattr(
+ app, "DATABASE", SimpleNamespace(credentials=SimpleNamespace(get_credentials_by_ids=credential_lookup))
+ )
+ monkeypatch.setattr(
+ credential_resolution, "credential_folder_ids_for_current_request", AsyncMock(return_value={"folder_visible"})
+ )
+ organization = SimpleNamespace(organization_id="org-1")
+
+ with pytest.raises(HTTPException) as excinfo:
+ await workflow_copilot_credential_response(
+ _response_request(action="connected", credential_id="cred_hidden"),
+ organization=organization,
+ )
+
+ assert excinfo.value.status_code == status.HTTP_404_NOT_FOUND
+ credential_lookup.assert_awaited_once_with(
+ ["cred_hidden"],
+ organization_id="org-1",
+ allowed_folder_ids={"folder_visible"},
+ include_deleted=False,
+ )
+ assert cache.set_calls == []
+
+
@pytest.mark.asyncio
async def test_route_writes_flag_for_connected_with_valid_credential(monkeypatch: pytest.MonkeyPatch) -> None:
cache = _FakeCache()
@@ -2508,6 +2539,21 @@ async def test_a_named_login_known_for_another_site_is_left_to_the_picker(
assert [card.named_credential_id for card in _sent_cards(ctx)] == [offered]
+async def test_denied_vault_site_read_leaves_a_named_login_to_the_picker(monkeypatch: pytest.MonkeyPatch) -> None:
+ ctx = _tool_ctx(monkeypatch, _answered_cache("skip"))
+ ctx.request_policy.current_turn_named_credential_ids = {"cred_1"}
+ monkeypatch.setattr(
+ credential_fill_module,
+ "_read_vault_named_sites",
+ AsyncMock(side_effect=PermissionError("credential not accessible")),
+ )
+
+ await _ask(ctx, "https://portal.example.com/login")
+
+ assert [card.named_credential_id for card in _sent_cards(ctx)] == [None]
+
+
@pytest.mark.asyncio
@pytest.mark.parametrize("carried_as", ["approval", "proposal"])
async def test_a_login_carried_in_for_another_site_is_left_to_the_picker_when_named_again(
@@ -2763,6 +2809,28 @@ async def test_origin_recovery_admits_no_credential_it_cannot_place_on_the_provi
_assert_declined(ctx, result, "connected_other_site")
+async def test_denied_vault_site_read_does_not_abort_origin_recovery(monkeypatch: pytest.MonkeyPatch) -> None:
+ ctx = _recovery_ctx(monkeypatch, _answered_cache("connected", "cred_idp"))
+ monkeypatch.setattr(
+ credential_fill_module,
+ "_read_vault_named_sites",
+ AsyncMock(side_effect=PermissionError("credential not accessible")),
+ )
+ _stub_credential_lookup(monkeypatch, _idp_credential())
+ monkeypatch.setattr(
+ credential_pause_module.app.DATABASE,
+ "workflow_params",
+ SimpleNamespace(record_pending_copilot_turn_credential_resume=AsyncMock()),
+ raising=False,
+ )
+
+ result = await _ask(ctx, f"{_IDP_ORIGIN}/login")
+
+ assert ctx.credential_pause_outcome == "not_admitted"
+ _assert_declined(ctx, result, "connected_other_site")
+
+
@pytest.mark.asyncio
async def test_a_recovery_connect_keeps_the_named_service_login_approved_beside_the_provider_login(
monkeypatch: pytest.MonkeyPatch,
diff --git a/tests/unit/test_copilot_fill_credential_field.py b/tests/unit/test_copilot_fill_credential_field.py
index b3aaa9820..b85c539d7 100644
--- a/tests/unit/test_copilot_fill_credential_field.py
+++ b/tests/unit/test_copilot_fill_credential_field.py
@@ -206,7 +206,10 @@ class TestResolveCredentialFillValue:
monkeypatch.setattr(
object.__getattribute__(app, "_inst"),
"AGENT_FUNCTION",
- SimpleNamespace(parse_enterprise_totp_secret=AsyncMock(return_value=None)),
+ SimpleNamespace(
+ enforce_credential_use=AsyncMock(),
+ parse_enterprise_totp_secret=AsyncMock(return_value=None),
+ ),
raising=False,
)
@@ -2727,7 +2730,7 @@ workflow_definition:
policy.current_turn_named_credential_ids = {"cred_123"}
if origin_arm == "saved_other_approved":
with patch(
- "skyvern.forge.sdk.copilot.request_policy.app.DATABASE.credentials.get_credentials_by_ids",
+ "skyvern.forge.sdk.copilot.credential_resolution.app.DATABASE.credentials.get_credentials_by_ids",
AsyncMock(return_value=[credential]),
):
await _seed_prior_approved_credentials(
diff --git a/tests/unit/test_copilot_positive_evidence_carriers.py b/tests/unit/test_copilot_positive_evidence_carriers.py
index 9d746c625..7e29d2e9c 100644
--- a/tests/unit/test_copilot_positive_evidence_carriers.py
+++ b/tests/unit/test_copilot_positive_evidence_carriers.py
@@ -673,7 +673,7 @@ async def test_track_a_registry_refuses_credential_run_even_when_scout_values_ar
run_execution_module,
"app",
SimpleNamespace(
- AGENT_FUNCTION=SimpleNamespace(serialize_codeblock_parameters=dict),
+ AGENT_FUNCTION=SimpleNamespace(enforce_credential_use=AsyncMock(), serialize_codeblock_parameters=dict),
DATABASE=SimpleNamespace(credentials=SimpleNamespace(get_credential=AsyncMock(return_value=None))),
),
)
@@ -722,6 +722,7 @@ async def test_track_a_registry_admits_complete_run_bound_static_credential_valu
"app",
SimpleNamespace(
AGENT_FUNCTION=SimpleNamespace(
+ enforce_credential_use=AsyncMock(),
serialize_codeblock_parameters=lambda values: values,
process_registered_credential_item=process,
),
@@ -768,6 +769,7 @@ async def test_track_a_registry_keeps_static_credential_values_when_totp_is_dyna
"app",
SimpleNamespace(
AGENT_FUNCTION=SimpleNamespace(
+ enforce_credential_use=AsyncMock(),
serialize_codeblock_parameters=lambda values: values,
process_registered_credential_item=AsyncMock(return_value=credential_item),
),
diff --git a/tests/unit/test_copilot_request_policy_workflow_credentials.py b/tests/unit/test_copilot_request_policy_workflow_credentials.py
index 11d70dc59..92f81fbb8 100644
--- a/tests/unit/test_copilot_request_policy_workflow_credentials.py
+++ b/tests/unit/test_copilot_request_policy_workflow_credentials.py
@@ -422,6 +422,7 @@ async def test_list_credentials_normalizes_pagination(
organization_id="org-1",
page=expected_page,
page_size=expected_page_size,
+ allowed_folder_ids=None,
)
assert result["data"]["page"] == expected_page
assert result["data"]["page_size"] == expected_page_size
diff --git a/tests/unit/test_credential_fallback.py b/tests/unit/test_credential_fallback.py
index 2b16f4d29..bc43ff03f 100644
--- a/tests/unit/test_credential_fallback.py
+++ b/tests/unit/test_credential_fallback.py
@@ -109,6 +109,7 @@ async def _validate_parameter(parameter: CredentialParameter, existing_ids: list
organization = SimpleNamespace(organization_id="org_test")
existing = [SimpleNamespace(credential_id=credential_id) for credential_id in existing_ids or []]
with patch("skyvern.forge.sdk.workflow.service.app") as mock_app:
+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()
mock_app.DATABASE.credentials.get_credentials_by_ids = AsyncMock(return_value=existing)
await service._validate_and_normalize_credential_rotation_parameters([parameter], organization)
@@ -119,7 +120,7 @@ async def test_workflow_save_validation_dedupes_fallback_credentials_preserving_
fallback_credential_ids=["cred_b", "cred_c", "cred_b", "cred_d", "cred_c"],
)
- await _validate_parameter(parameter, ["cred_b", "cred_c", "cred_d"])
+ await _validate_parameter(parameter, ["cred_primary", "cred_b", "cred_c", "cred_d"])
assert parameter.fallback_credential_ids == ["cred_b", "cred_c", "cred_d"]
assert parameter.credential_id == "cred_primary"
@@ -130,7 +131,7 @@ async def test_workflow_save_validation_rejects_unknown_fallback_credential_id()
parameter = _credential_parameter(fallback_credential_ids=["cred_missing"])
with pytest.raises(InvalidCredentialId):
- await _validate_parameter(parameter, [])
+ await _validate_parameter(parameter, ["cred_primary"])
@pytest.mark.asyncio
@@ -138,7 +139,7 @@ async def test_workflow_save_validation_rejects_bad_fallback_trigger() -> None:
parameter = _credential_parameter(fallback_credential_ids=["cred_b"], fallback_trigger="later")
with pytest.raises(SkyvernHTTPException, match="fallback_trigger"):
- await _validate_parameter(parameter, ["cred_b"])
+ await _validate_parameter(parameter, ["cred_primary", "cred_b"])
@pytest.mark.asyncio
@@ -153,7 +154,7 @@ async def test_workflow_save_validation_rejects_trigger_without_fallback_list()
async def test_workflow_save_validation_normalizes_empty_fallback_list_to_none() -> None:
parameter = _credential_parameter(fallback_credential_ids=[])
- await _validate_parameter(parameter)
+ await _validate_parameter(parameter, ["cred_primary"])
assert parameter.fallback_credential_ids is None
@@ -162,7 +163,7 @@ async def test_workflow_save_validation_normalizes_empty_fallback_list_to_none()
async def test_workflow_save_validation_drops_primary_credential_from_fallbacks() -> None:
parameter = _credential_parameter(fallback_credential_ids=["cred_primary", "cred_b"])
- await _validate_parameter(parameter, ["cred_b"])
+ await _validate_parameter(parameter, ["cred_primary", "cred_b"])
assert parameter.fallback_credential_ids == ["cred_b"]
@@ -206,7 +207,7 @@ async def test_workflow_save_validation_allows_rotation_without_fallback_credent
async def test_workflow_save_validation_allows_fallback_credentials_without_rotation() -> None:
parameter = _credential_parameter(fallback_credential_ids=["cred_b", "cred_c"])
- await _validate_parameter(parameter, ["cred_b", "cred_c"])
+ await _validate_parameter(parameter, ["cred_primary", "cred_b", "cred_c"])
assert parameter.credential_ids is None
assert parameter.fallback_credential_ids == ["cred_b", "cred_c"]
diff --git a/tests/unit/test_credential_rotation.py b/tests/unit/test_credential_rotation.py
index edd48ae02..38b1bef88 100644
--- a/tests/unit/test_credential_rotation.py
+++ b/tests/unit/test_credential_rotation.py
@@ -571,6 +571,7 @@ async def test_workflow_save_validation_rejects_unknown_credential_id() -> None:
with patch("skyvern.forge.sdk.workflow.service.app") as mock_app:
mock_app.DATABASE.workflows.get_browser_action_policy = AsyncMock(return_value=None)
mock_app.DATABASE.credentials.get_credentials_by_ids = AsyncMock(return_value=[])
+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()
with pytest.raises(InvalidCredentialId):
await service._validate_and_normalize_credential_rotation_parameters([parameter], org)
@@ -595,6 +596,7 @@ async def test_workflow_save_validation_normalizes_credential_id_to_first_rotati
with patch("skyvern.forge.sdk.workflow.service.app") as mock_app:
mock_app.DATABASE.workflows.get_browser_action_policy = AsyncMock(return_value=None)
mock_app.DATABASE.credentials.get_credentials_by_ids = AsyncMock(return_value=existing)
+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()
await service._validate_and_normalize_credential_rotation_parameters([parameter], org)
assert parameter.credential_id == "cred_a"
@@ -617,6 +619,7 @@ async def test_workflow_save_validation_dedupes_credential_ids_preserving_order(
with patch("skyvern.forge.sdk.workflow.service.app") as mock_app:
mock_app.DATABASE.workflows.get_browser_action_policy = AsyncMock(return_value=None)
mock_get_credentials = AsyncMock(return_value=existing)
+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()
mock_app.DATABASE.credentials.get_credentials_by_ids = mock_get_credentials
await service._validate_and_normalize_credential_rotation_parameters([parameter], org)
@@ -790,6 +793,7 @@ async def _attempt_setup_rotation_profile_run(
):
mock_app.DATABASE.workflows.get_browser_action_policy = AsyncMock(return_value=None)
mock_app.EXPERIMENTATION_PROVIDER.is_feature_enabled_cached = AsyncMock(return_value=False)
+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()
mock_app.AGENT_FUNCTION.should_use_flex_llm_routing = AsyncMock(return_value=False)
mock_app.AGENT_FUNCTION.is_browser_memory_engine_enabled = AsyncMock(return_value=False)
mock_app.DATABASE.browser_sessions.get_or_create_managed_browser_profile = AsyncMock(
@@ -873,6 +877,7 @@ async def _setup_bound_credentials(
patch("skyvern.forge.sdk.workflow.credential_selection.app") as selection_app,
):
mock_app.EXPERIMENTATION_PROVIDER.is_feature_enabled_cached = AsyncMock(return_value=False)
+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()
mock_app.AGENT_FUNCTION.should_use_flex_llm_routing = AsyncMock(return_value=False)
mock_app.DATABASE.workflows.get_browser_action_policy = AsyncMock(return_value=None)
mock_app.DATABASE.workflow_runs.update_workflow_run = AsyncMock(side_effect=update_workflow_run)
@@ -911,6 +916,7 @@ async def test_direct_bindings_snapshot_only_opted_in_credentials_and_runtime_re
assert workflow_run.sequential_credential_id == "cred_serial"
with patch("skyvern.forge.sdk.workflow.context_manager.app") as context_app:
+ context_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()
context_app.DATABASE.workflow_run_credential_selections = _SelectionRepo()
assert await sequential_context.resolve_credential_parameter_id(sequential, "org_test") == "cred_serial"
assert await parallel_context.resolve_credential_parameter_id(parallel, "org_test") == "cred_parallel"
@@ -943,6 +949,7 @@ async def test_plain_indirect_binding_snapshots_and_runtime_resolves_bound_param
assert workflow_run.sequential_credential_id == "cred_runtime"
with patch("skyvern.forge.sdk.workflow.context_manager.app") as context_app:
+ context_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()
context_app.DATABASE.workflow_run_credential_selections = _SelectionRepo()
assert await context.resolve_credential_parameter_id(login, "org_test") == "cred_runtime"
assert context.get_resolved_credential_parameter_id(login.key) == "cred_runtime"
@@ -1001,6 +1008,7 @@ async def test_runtime_only_indirect_binding_fails_closed_if_resolved_credential
organization = SimpleNamespace(organization_id="org_test")
with patch("skyvern.forge.sdk.workflow.context_manager.app") as mock_app:
+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()
mock_app.DATABASE.workflow_run_credential_selections = _SelectionRepo()
mock_app.DATABASE.credentials.get_credential = AsyncMock(
return_value=SimpleNamespace(credential_id="cred_runtime", run_sequentially=True)
@@ -1047,6 +1055,7 @@ async def test_runtime_credential_registration_proceeds_when_lane_is_safe(
credential_service.get_credential_item = AsyncMock(return_value=SimpleNamespace(credential=credential))
with patch("skyvern.forge.sdk.workflow.context_manager.app") as mock_app:
+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()
mock_app.DATABASE.workflow_run_credential_selections = _SelectionRepo()
mock_app.DATABASE.credentials.get_credential = AsyncMock(return_value=db_credential)
mock_app.DATABASE.workflow_runs.get_workflow_run = AsyncMock(
@@ -1084,6 +1093,7 @@ async def test_keyed_rotation_snapshot_and_runtime_reuse_one_persisted_selection
patch("skyvern.forge.sdk.workflow.context_manager.app") as context_app,
):
selection_app.DATABASE.workflow_run_credential_selections = repo
+ context_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()
context_app.DATABASE.workflow_run_credential_selections = repo
runtime_credential_id = await context.resolve_credential_parameter_id(login, "org_test")
@@ -1209,6 +1219,7 @@ async def _select_render_with_failed_rotation(
patch("skyvern.forge.sdk.workflow.service.app") as mock_app,
patch("skyvern.forge.sdk.workflow.service.select_credential_for_run", select_mock),
):
+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()
mock_app.DATABASE.organizations.get_organization = AsyncMock(
return_value=SimpleNamespace(organization_id="org_test")
)
@@ -1645,6 +1656,7 @@ async def test_retry_retains_credential_pool_binding_when_new_lane_cannot_be_adm
credential_service.get_credential_item = AsyncMock(return_value=SimpleNamespace(credential=credential))
with patch("skyvern.forge.sdk.workflow.context_manager.app") as context_app:
context_app.DATABASE = sqlite_db
+ context_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()
context_app.CREDENTIAL_VAULT_SERVICES.get.return_value = credential_service
context_app.AGENT_FUNCTION.process_registered_credential_item = AsyncMock(
side_effect=lambda *, workflow_run_id, db_credential, credential_item: credential_item
@@ -1766,6 +1778,7 @@ async def test_retry_registers_prepared_binding_after_definition_edit(retry_rota
credential_service.get_credential_item = AsyncMock(return_value=SimpleNamespace(credential=credential))
with patch("skyvern.forge.sdk.workflow.context_manager.app") as context_app:
context_app.DATABASE = database
+ context_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()
context_app.CREDENTIAL_VAULT_SERVICES.get.return_value = credential_service
context_app.AGENT_FUNCTION.process_registered_credential_item = AsyncMock(
side_effect=lambda *, workflow_run_id, db_credential, credential_item: credential_item
@@ -2043,11 +2056,13 @@ async def test_retry_runtime_registration_with_single_credential_definition(
patch("skyvern.forge.sdk.workflow.service.app") as service_app,
):
context_app.DATABASE = database
+ context_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()
context_app.CREDENTIAL_VAULT_SERVICES.get.return_value = credential_service
context_app.AGENT_FUNCTION.process_registered_credential_item = AsyncMock(
side_effect=lambda *, workflow_run_id, db_credential, credential_item: credential_item
)
service_app.DATABASE = database
+ service_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()
service_app.WORKFLOW_CONTEXT_MANAGER.workflow_run_contexts = {}
context = _runtime_context()
context.attempt_number = 2
diff --git a/tests/unit/test_credential_update_params.py b/tests/unit/test_credential_update_params.py
index bf51cf798..2f74609c5 100644
--- a/tests/unit/test_credential_update_params.py
+++ b/tests/unit/test_credential_update_params.py
@@ -1086,8 +1086,8 @@ async def test_validate_browser_profile_id_rejects_other_credential_owned(monkey
)
monkeypatch.setattr(
forge_app.DATABASE.credentials,
- "get_credentials_by_browser_profile_id",
- AsyncMock(return_value=[SimpleNamespace(credential_id="cred_other")]),
+ "get_browser_profile_credential_links",
+ AsyncMock(return_value={"bp_x": [("cred_other", None)]}),
)
with pytest.raises(HTTPException) as exc:
await credentials_routes._validate_credential_browser_profile_id("bp_x", "org_123")
@@ -1103,8 +1103,8 @@ async def test_validate_browser_profile_id_accepts_plain_unowned(monkeypatch: py
)
monkeypatch.setattr(
forge_app.DATABASE.credentials,
- "get_credentials_by_browser_profile_id",
- AsyncMock(return_value=[]),
+ "get_browser_profile_credential_links",
+ AsyncMock(return_value={}),
)
# No raise.
await credentials_routes._validate_credential_browser_profile_id("bp_x", "org_123")
@@ -1119,8 +1119,8 @@ async def test_validate_browser_profile_id_allows_relink_to_same_credential(monk
)
monkeypatch.setattr(
forge_app.DATABASE.credentials,
- "get_credentials_by_browser_profile_id",
- AsyncMock(return_value=[SimpleNamespace(credential_id="cred_self")]),
+ "get_browser_profile_credential_links",
+ AsyncMock(return_value={"bp_x": [("cred_self", None)]}),
)
# Re-linking the profile a credential already owns is a no-op, not a conflict.
await credentials_routes._validate_credential_browser_profile_id(
@@ -1163,8 +1163,8 @@ async def test_create_credential_links_validated_browser_profile_id(monkeypatch:
)
monkeypatch.setattr(
forge_app.DATABASE.credentials,
- "get_credentials_by_browser_profile_id",
- AsyncMock(return_value=[]),
+ "get_browser_profile_credential_links",
+ AsyncMock(return_value={}),
)
update_credential = AsyncMock(return_value=_stored_credential(browser_profile_id="bp_plain", pin=True))
monkeypatch.setattr(forge_app.DATABASE.credentials, "update_credential", update_credential)
@@ -1261,8 +1261,8 @@ async def test_rename_credential_sets_pin_and_validated_browser_profile_id(monke
)
monkeypatch.setattr(
forge_app.DATABASE.credentials,
- "get_credentials_by_browser_profile_id",
- AsyncMock(return_value=[]),
+ "get_browser_profile_credential_links",
+ AsyncMock(return_value={}),
)
update_credential = AsyncMock(return_value=_stored_credential(browser_profile_id="bp_plain", pin=True))
monkeypatch.setattr(forge_app.DATABASE.credentials, "update_credential", update_credential)
@@ -1395,8 +1395,8 @@ async def test_update_credential_route_applies_validated_browser_profile_and_pin
)
monkeypatch.setattr(
forge_app.DATABASE.credentials,
- "get_credentials_by_browser_profile_id",
- AsyncMock(return_value=[]),
+ "get_browser_profile_credential_links",
+ AsyncMock(return_value={}),
)
vault_service = SimpleNamespace(
update_credential=AsyncMock(return_value=_stored_credential()),
@@ -1533,10 +1533,7 @@ async def test_update_credential_conflict_reraises_unrelated_integrity_error(mon
@pytest.mark.asyncio
-async def test_validate_browser_profile_id_relinks_when_owner_soft_deleted(monkeypatch: pytest.MonkeyPatch) -> None:
- # G amendment 1: a soft-deleted owner must NOT reserve the profile. The read-check queries live
- # credentials only (get_credentials_by_browser_profile_id filters deleted_at), and the partial-unique
- # index predicate matches (deleted_at IS NULL), so relinking is allowed.
+async def test_validate_browser_profile_id_rejects_soft_deleted_owner(monkeypatch: pytest.MonkeyPatch) -> None:
monkeypatch.setattr(
forge_app.DATABASE.browser_sessions,
"get_browser_profile",
@@ -1544,10 +1541,11 @@ async def test_validate_browser_profile_id_relinks_when_owner_soft_deleted(monke
)
monkeypatch.setattr(
forge_app.DATABASE.credentials,
- "get_credentials_by_browser_profile_id",
- AsyncMock(return_value=[]), # the soft-deleted owner is filtered out by the repo
+ "get_browser_profile_credential_links",
+ AsyncMock(return_value={"bp_x": [("cred_deleted", "folder_restricted")]}),
)
- await credentials_routes._validate_credential_browser_profile_id("bp_x", "org_123")
+ with pytest.raises(HTTPException, match="already linked to another credential"):
+ await credentials_routes._validate_credential_browser_profile_id("bp_x", "org_123")
@pytest.mark.asyncio
@@ -1563,8 +1561,8 @@ async def test_create_credential_profile_alone_does_not_reset_pin(monkeypatch: p
)
monkeypatch.setattr(
forge_app.DATABASE.credentials,
- "get_credentials_by_browser_profile_id",
- AsyncMock(return_value=[]),
+ "get_browser_profile_credential_links",
+ AsyncMock(return_value={}),
)
update_credential = AsyncMock(return_value=_stored_credential(browser_profile_id="bp_plain"))
monkeypatch.setattr(forge_app.DATABASE.credentials, "update_credential", update_credential)
diff --git a/tests/unit/test_credentials_totp_route_logging.py b/tests/unit/test_credentials_totp_route_logging.py
index 14d334888..1364a1110 100644
--- a/tests/unit/test_credentials_totp_route_logging.py
+++ b/tests/unit/test_credentials_totp_route_logging.py
@@ -7,6 +7,7 @@ import pytest
import structlog.testing
from fastapi import FastAPI, HTTPException, Response
+from skyvern.forge.agent_functions import AgentFunction
from skyvern.forge.sdk.routes import credentials
from skyvern.forge.sdk.routes.routers import base_router, legacy_base_router
from skyvern.forge.sdk.schemas.credentials import Credential, CredentialType, CredentialVaultType, TotpType
@@ -15,6 +16,11 @@ from skyvern.forge.sdk.services.credential.custom_credential_vault_service impor
from skyvern.services.otp_service import OTPValue
[email protected](autouse=True)
+def _oss_agent_function(monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.setattr(credentials.app, "AGENT_FUNCTION", AgentFunction())
+
+
def _raw_row(totp_code_id: str = "otp_raw") -> RawTOTPCode:
return RawTOTPCode(
totp_code_id=totp_code_id,
@@ -193,6 +199,8 @@ async def test_send_totp_code_insufficient_credits_returns_402_when_raw_content_
credentials.app,
"AGENT_FUNCTION",
SimpleNamespace(
+ workflow_folders_restricted=AsyncMock(return_value=False),
+ credential_folders_restricted=AsyncMock(return_value=False),
has_sufficient_credit_for_otp_parse=AsyncMock(return_value=False),
charge_for_otp_parse=charge,
),
@@ -239,6 +247,8 @@ async def test_send_totp_code_insufficient_credits_persists_raw_within_cap(
credentials.app,
"AGENT_FUNCTION",
SimpleNamespace(
+ workflow_folders_restricted=AsyncMock(return_value=False),
+ credential_folders_restricted=AsyncMock(return_value=False),
has_sufficient_credit_for_otp_parse=AsyncMock(return_value=False),
charge_for_otp_parse=charge,
),
diff --git a/tests/unit/test_download_dir_rebind.py b/tests/unit/test_download_dir_rebind.py
index e6c923db6..0ab423f8f 100644
--- a/tests/unit/test_download_dir_rebind.py
+++ b/tests/unit/test_download_dir_rebind.py
@@ -615,6 +615,7 @@ async def test_browser_manager_adoption_rebinds_to_run_dir(browser_manager: Real
):
mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=browser_state)
mock_app.AGENT_FUNCTION.on_browser_context_acquired = AsyncMock()
+ mock_app.AGENT_FUNCTION.enforce_workflow_run_credential_use = AsyncMock()
result = await manager.get_or_create_for_workflow_run(
_workflow_attach_run(),
browser_session_id="bs_block",
@@ -645,6 +646,7 @@ async def test_browser_manager_adoption_skips_rebind_when_session_dir_binding(
):
mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=browser_state)
mock_app.AGENT_FUNCTION.on_browser_context_acquired = AsyncMock()
+ mock_app.AGENT_FUNCTION.enforce_workflow_run_credential_use = AsyncMock()
result = await manager.get_or_create_for_workflow_run(
_workflow_attach_run(),
browser_session_id="bs_block",
@@ -674,6 +676,7 @@ async def test_browser_manager_adoption_rebinds_via_context_page_without_owning_
):
mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=browser_state)
mock_app.AGENT_FUNCTION.on_browser_context_acquired = AsyncMock()
+ mock_app.AGENT_FUNCTION.enforce_workflow_run_credential_use = AsyncMock()
result = await manager.get_or_create_for_workflow_run(
_workflow_attach_run(),
browser_session_id="bs_block",
@@ -700,6 +703,7 @@ async def test_browser_manager_adoption_no_browser_no_page_returns_state(browser
):
mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=browser_state)
mock_app.AGENT_FUNCTION.on_browser_context_acquired = AsyncMock()
+ mock_app.AGENT_FUNCTION.enforce_workflow_run_credential_use = AsyncMock()
result = await manager.get_or_create_for_workflow_run(
_workflow_attach_run(),
browser_session_id="bs_block",
@@ -892,6 +896,7 @@ async def test_browser_manager_adoption_rebind_error_is_fail_open(browser_manage
):
mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=browser_state)
mock_app.AGENT_FUNCTION.on_browser_context_acquired = AsyncMock()
+ mock_app.AGENT_FUNCTION.enforce_workflow_run_credential_use = AsyncMock()
result = await manager.get_or_create_for_workflow_run(
_workflow_attach_run(),
browser_session_id="bs_block",
@@ -1543,6 +1548,7 @@ async def test_real_browser_manager_adoption_resolves_context_run_id(browser_man
patch("skyvern.webeye.real_browser_manager.skyvern_context.current", return_value=ctx),
):
mock_app.AGENT_FUNCTION.on_browser_context_acquired = AsyncMock()
+ mock_app.AGENT_FUNCTION.enforce_workflow_run_credential_use = AsyncMock()
mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=browser_state)
mock_app.DATABASE.browser_sessions.touch_last_activity = AsyncMock()
result = await manager.get_or_create_for_workflow_run(workflow_run, browser_session_id="bs")
diff --git a/tests/unit/test_external_cdp_sessions.py b/tests/unit/test_external_cdp_sessions.py
index 034f5fd57..b321e5899 100644
--- a/tests/unit/test_external_cdp_sessions.py
+++ b/tests/unit/test_external_cdp_sessions.py
@@ -982,7 +982,7 @@ async def test_the_next_step_after_losing_a_registration_fails_with_that_fact_an
) -> None:
session_id = (await register_external(stack.client, timeout=5)).json()["browser_session_id"]
if loss == "expired":
- await backdate_registration(stack, session_id, minutes=5 - 0.5 / 60)
+ await backdate_registration(stack, session_id, minutes=5 - 10 / 60)
run_id = "tsk_1" if run_type == "task" else "wr_1"
generation = await stack.manager.begin_session(
browser_session_id=session_id, runnable_type=run_type, runnable_id=run_id, organization_id=ORG_A
@@ -991,7 +991,7 @@ async def test_the_next_step_after_losing_a_registration_fails_with_that_fact_an
with patch.object(manager_mod, "attach_registered_cdp_browser", AsyncMock(return_value=lost)):
assert await acquire_lease(stack.manager, session_id, run_id, generation) is lost
if loss == "expired":
- await asyncio.wait_for(stack.manager._external_deadlines[session_id], timeout=5)
+ await asyncio.wait_for(stack.manager._external_deadlines[session_id], timeout=15)
if loss in ("closed", "vanished"):
await stack.repo.close_persistent_browser_session(session_id, ORG_A)
context.browser.is_connected.return_value = False
@@ -999,6 +999,7 @@ async def test_the_next_step_after_losing_a_registration_fails_with_that_fact_an
browser_manager.pages[run_id] = lost
launch = AsyncMock()
rbm_app = MagicMock(PERSISTENT_SESSIONS_MANAGER=stack.manager)
+ rbm_app.AGENT_FUNCTION.enforce_workflow_run_credential_use = AsyncMock()
unreachable = AsyncMock(side_effect=ExternalBrowserUnavailable("connection failed"))
with (
@@ -1129,9 +1130,11 @@ async def test_a_later_task_block_on_a_lost_registration_fails_with_its_fact_and
browser_manager = RealBrowserManager()
launch = AsyncMock()
+ browser_app = MagicMock(PERSISTENT_SESSIONS_MANAGER=stack.manager)
+ browser_app.AGENT_FUNCTION.enforce_workflow_run_credential_use = AsyncMock()
with (
mock_block_execute_deps(working_page_url="https://example.test/") as deps,
- patch.object(real_browser_manager_mod, "app", MagicMock(PERSISTENT_SESSIONS_MANAGER=stack.manager)),
+ patch.object(real_browser_manager_mod, "app", browser_app),
patch.object(browser_manager, "_create_browser_state", launch),
pytest.raises(BrowserSessionClosed if end == "closed" else ExternalBrowserUnavailable),
):
diff --git a/tests/unit/test_forge_log.py b/tests/unit/test_forge_log.py
index 348c17011..55c8bcc08 100644
--- a/tests/unit/test_forge_log.py
+++ b/tests/unit/test_forge_log.py
@@ -237,6 +237,7 @@ async def test_browser_runtime_task_pbs_boundary_preserves_owner_log(
raise ValueError("acquisition failed")
with skyvern_context.scoped(owner), patch.object(real_browser_manager, "app") as app:
+ app.AGENT_FUNCTION.enforce_workflow_run_credential_use = AsyncMock()
app.PERSISTENT_SESSIONS_MANAGER.begin_session = AsyncMock(return_value="generation-owner")
app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(side_effect=acquire)
with pytest.raises(ValueError, match="acquisition failed"):
diff --git a/tests/unit/test_non_secret_credential_fields.py b/tests/unit/test_non_secret_credential_fields.py
index 89f2e9bd7..2c0e18921 100644
--- a/tests/unit/test_non_secret_credential_fields.py
+++ b/tests/unit/test_non_secret_credential_fields.py
@@ -54,6 +54,7 @@ async def _register(
app.DATABASE.credentials.get_credential = AsyncMock(return_value=db_credential)
app.CREDENTIAL_VAULT_SERVICES.get.return_value = vault
# Mirror the OSS no-op hook: return the resolved item unchanged.
+ app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()
app.AGENT_FUNCTION.process_registered_credential_item = AsyncMock(
side_effect=lambda *, workflow_run_id, db_credential, credential_item: credential_item
)
diff --git a/tests/unit/test_otp_service.py b/tests/unit/test_otp_service.py
index ca4004cb3..e7edab0f4 100644
--- a/tests/unit/test_otp_service.py
+++ b/tests/unit/test_otp_service.py
@@ -1576,6 +1576,7 @@ class TestPollOtpValueRetry:
mock_sleep: AsyncMock,
) -> None:
mock_settings.VERIFICATION_CODE_POLLING_TIMEOUT_MINS = 15
+ mock_app.AGENT_FUNCTION.enforce_totp_identifier_credential_use = AsyncMock()
mock_app.DATABASE.organizations.get_valid_org_auth_token = AsyncMock(return_value=_mock_org_token())
otp = OTPValue(value="123456", type=OTPType.TOTP)
mock_url.return_value = otp
@@ -1612,6 +1613,7 @@ class TestPollOtpValueRetry:
mock_sleep: AsyncMock,
) -> None:
mock_settings.VERIFICATION_CODE_POLLING_TIMEOUT_MINS = 15
+ mock_app.AGENT_FUNCTION.enforce_totp_identifier_credential_use = AsyncMock()
mock_app.DATABASE.organizations.get_valid_org_auth_token = AsyncMock(return_value=_mock_org_token())
mock_url.return_value = None
otp = OTPValue(value="123456", type=OTPType.TOTP)
@@ -1652,6 +1654,7 @@ class TestPollOtpValueRetry:
start = datetime(2026, 1, 1, 12, 0, 0)
mock_datetime.utcnow.return_value = start
mock_settings.VERIFICATION_CODE_POLLING_TIMEOUT_MINS = 15
+ mock_app.AGENT_FUNCTION.enforce_totp_identifier_credential_use = AsyncMock()
mock_app.DATABASE.organizations.get_valid_org_auth_token = AsyncMock(return_value=_mock_org_token())
mock_url.return_value = None
mock_email.return_value = None
@@ -1725,6 +1728,7 @@ class TestPollOtpValueRetry:
):
mock_datetime.utcnow.side_effect = utcnow_returns
mock_settings.VERIFICATION_CODE_POLLING_TIMEOUT_MINS = 15
+ mock_app.AGENT_FUNCTION.enforce_totp_identifier_credential_use = AsyncMock()
mock_app.DATABASE.organizations.get_valid_org_auth_token = AsyncMock(return_value=_mock_org_token())
raw_identifier = "[email protected]"
raw_url = "https://example.com/mfa?token=secret"
@@ -1855,6 +1859,7 @@ class TestPollOtpValueRetry:
raw_identifier = "[email protected]"
raw_url = "https://example.com/mfa"
mock_settings.VERIFICATION_CODE_POLLING_TIMEOUT_MINS = 15
+ mock_app.AGENT_FUNCTION.enforce_totp_identifier_credential_use = AsyncMock()
mock_app.DATABASE.organizations.get_valid_org_auth_token = AsyncMock(return_value=_mock_org_token())
mock_fetch.return_value = OTPValue(value=raw, type=OTPType.TOTP)
diff --git a/tests/unit/test_real_browser_manager.py b/tests/unit/test_real_browser_manager.py
index 440c55a37..f725f837f 100644
--- a/tests/unit/test_real_browser_manager.py
+++ b/tests/unit/test_real_browser_manager.py
@@ -67,6 +67,13 @@ def make_workflow_run(
return wfr
+@contextmanager
+def patch_browser_manager_app() -> Iterator[MagicMock]:
+ with patch.object(real_browser_manager, "app") as mock_app:
+ mock_app.AGENT_FUNCTION.enforce_workflow_run_credential_use = AsyncMock()
+ yield mock_app
+
+
def configure_browser_context_acquired_hook(mock_app: MagicMock) -> None:
mock_app.AGENT_FUNCTION.on_browser_context_acquired = AsyncMock()
mock_app.DATABASE.browser_sessions.touch_last_activity = AsyncMock()
@@ -245,7 +252,7 @@ async def test_browser_runtime_event_workflow_task_reuse_has_one_acquisition() -
manager = RealBrowserManager()
state = RealBrowserState(pw=MagicMock(), browser_context=MagicMock())
manager.pages["workflow-owner"] = state
- with patch.object(real_browser_manager, "app") as mock_app, capture_logs() as logs:
+ with patch_browser_manager_app() as mock_app, capture_logs() as logs:
configure_browser_context_acquired_hook(mock_app)
await manager.get_or_create_for_task(make_task("task-one", workflow_run_id="workflow-owner"))
await manager.get_or_create_for_task(make_task("task-two", workflow_run_id="workflow-owner"))
@@ -295,7 +302,7 @@ async def test_cached_acquisition_commits_runtime_owner_after_hook(entrypoint: s
with (
skyvern_context.scoped(SkyvernContext(workflow_run_id="new-workflow", task_id="new-task")),
- patch.object(real_browser_manager, "app") as mock_app,
+ patch_browser_manager_app() as mock_app,
capture_logs() as logs,
):
configure_browser_context_acquired_hook(mock_app)
@@ -357,7 +364,7 @@ async def test_browser_request_to_ready_seconds_times_creation_and_skips_reuse()
patch.object(
real_browser_manager.BrowserContextFactory, "create_browser_context", AsyncMock(side_effect=slow_create)
),
- patch.object(real_browser_manager, "app") as mock_app,
+ patch_browser_manager_app() as mock_app,
capture_logs() as logs,
):
configure_browser_context_acquired_hook(mock_app)
@@ -396,7 +403,7 @@ async def test_workflow_session_runtime_attribution_requires_acquisition(cached:
browser_session_runnable_id="session-runnable" if owner == "ambient" else None,
)
),
- patch.object(real_browser_manager, "app") as mock_app,
+ patch_browser_manager_app() as mock_app,
patch.object(real_browser_manager, "_rebind_pbs_download_dir", AsyncMock()),
patch.object(manager, "_start_frame_publisher", AsyncMock()),
patch.object(state, "get_working_page", AsyncMock(return_value=MagicMock())),
@@ -532,7 +539,7 @@ async def test_pbs_workflow_run_cache_hit_on_second_call() -> None:
manager.pages["wfr_child"] = cached_state
workflow_run = make_workflow_run("wfr_child")
- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:
+ with patch_browser_manager_app() as mock_app:
configure_browser_context_acquired_hook(mock_app)
result = await manager.get_or_create_for_workflow_run(
workflow_run=workflow_run,
@@ -557,7 +564,7 @@ async def test_pbs_workflow_run_does_not_inherit_parent_browser() -> None:
pbs_state.get_working_page = AsyncMock(return_value=None)
pbs_state.get_or_create_page = AsyncMock()
- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:
+ with patch_browser_manager_app() as mock_app:
configure_browser_context_acquired_hook(mock_app)
mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=pbs_state)
mock_app.PERSISTENT_SESSIONS_MANAGER.set_browser_state = AsyncMock()
@@ -605,7 +612,7 @@ async def test_pbs_workflow_run_with_synthetic_run_does_not_assert_session_owner
skyvern_context.set(SkyvernContext(workflow_run_id="wfr_synthetic", workflow_run_is_synthetic=True))
try:
with (
- patch("skyvern.webeye.real_browser_manager.app") as mock_app,
+ patch_browser_manager_app() as mock_app,
patch(
"skyvern.webeye.real_browser_manager._rebind_pbs_download_dir",
new_callable=AsyncMock,
@@ -642,7 +649,7 @@ async def test_pbs_workflow_run_without_lease_still_asserts_run_as_expected_owne
pbs_state.get_working_page = AsyncMock(return_value=None)
pbs_state.get_or_create_page = AsyncMock()
- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:
+ with patch_browser_manager_app() as mock_app:
configure_browser_context_acquired_hook(mock_app)
mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=pbs_state)
mock_app.PERSISTENT_SESSIONS_MANAGER.set_browser_state = AsyncMock()
@@ -1049,7 +1056,7 @@ async def test_task_browser_inherits_session_proxy_and_timezone_when_no_browser_
session = make_session(proxy_location=session_proxy)
session.browser_settings = BrowserSettings(timezone_id="Africa/Kampala")
- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:
+ with patch_browser_manager_app() as mock_app:
configure_browser_context_acquired_hook(mock_app)
mock_app.AGENT_FUNCTION.merge_proxy_session_extra_http_headers.side_effect = _merge_cloud_proxy_session_headers
mock_app.PERSISTENT_SESSIONS_MANAGER.begin_session = AsyncMock()
@@ -1081,7 +1088,7 @@ async def test_a_workflow_task_on_an_attached_session_records_the_run_receipt_as
new_browser_state.get_or_create_page = AsyncMock()
new_browser_state.get_working_page = AsyncMock(return_value=_page_reporting("America/New_York", "Africa/Kampala"))
- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:
+ with patch_browser_manager_app() as mock_app:
configure_browser_context_acquired_hook(mock_app)
mock_app.PERSISTENT_SESSIONS_MANAGER.begin_session = AsyncMock()
mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=None)
@@ -1106,7 +1113,7 @@ async def test_task_does_not_cache_a_browser_rejected_by_terminal_session() -> N
candidate = MagicMock()
candidate.get_or_create_page = AsyncMock()
- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:
+ with patch_browser_manager_app() as mock_app:
configure_browser_context_acquired_hook(mock_app)
mock_app.PERSISTENT_SESSIONS_MANAGER.begin_session = AsyncMock()
mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=None)
@@ -1132,7 +1139,7 @@ async def test_task_browser_inherits_session_proxy_pin_when_no_browser_state() -
session = make_session(proxy_location="RESIDENTIAL_ISP", proxy_session_id="abc1234567")
- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:
+ with patch_browser_manager_app() as mock_app:
configure_browser_context_acquired_hook(mock_app)
mock_app.AGENT_FUNCTION.merge_proxy_session_extra_http_headers.side_effect = _merge_cloud_proxy_session_headers
mock_app.PERSISTENT_SESSIONS_MANAGER.begin_session = AsyncMock()
@@ -1165,7 +1172,7 @@ async def test_task_browser_uses_task_proxy_when_session_has_no_proxy() -> None:
session = make_session(proxy_location=None)
- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:
+ with patch_browser_manager_app() as mock_app:
configure_browser_context_acquired_hook(mock_app)
mock_app.PERSISTENT_SESSIONS_MANAGER.begin_session = AsyncMock()
mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=None)
@@ -1195,7 +1202,7 @@ async def test_workflow_run_browser_inherits_session_proxy_when_no_browser_state
session_proxy = "RESIDENTIAL_FR"
session = make_session(proxy_location=session_proxy)
- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:
+ with patch_browser_manager_app() as mock_app:
configure_browser_context_acquired_hook(mock_app)
mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=None)
mock_app.PERSISTENT_SESSIONS_MANAGER.get_session = AsyncMock(return_value=session)
@@ -1222,7 +1229,7 @@ async def test_workflow_does_not_cache_a_browser_rejected_by_terminal_session()
candidate = MagicMock()
candidate.get_or_create_page = AsyncMock()
- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:
+ with patch_browser_manager_app() as mock_app:
configure_browser_context_acquired_hook(mock_app)
mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=None)
mock_app.PERSISTENT_SESSIONS_MANAGER.get_session = AsyncMock(return_value=None)
@@ -1252,7 +1259,7 @@ async def test_workflow_run_browser_inherits_session_proxy_pin_when_no_browser_s
session = make_session(proxy_location="RESIDENTIAL_ISP", proxy_session_id="abc1234567")
- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:
+ with patch_browser_manager_app() as mock_app:
configure_browser_context_acquired_hook(mock_app)
mock_app.AGENT_FUNCTION.merge_proxy_session_extra_http_headers.side_effect = _merge_cloud_proxy_session_headers
mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=None)
@@ -1288,7 +1295,7 @@ async def test_workflow_run_browser_uses_workflow_proxy_when_session_has_no_prox
session = make_session(proxy_location=None)
- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:
+ with patch_browser_manager_app() as mock_app:
configure_browser_context_acquired_hook(mock_app)
mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=None)
mock_app.PERSISTENT_SESSIONS_MANAGER.get_session = AsyncMock(return_value=session)
@@ -1774,7 +1781,7 @@ async def test_script_acquisition_reports_a_live_session_before_the_lease_exists
return pbs_state
with (
- patch("skyvern.webeye.real_browser_manager.app") as mock_app,
+ patch_browser_manager_app() as mock_app,
skyvern_context.scoped(
SkyvernContext(
task_id="tsk_script_policy",
@@ -1825,7 +1832,7 @@ async def test_attached_run_renews_the_session_activity_lease() -> None:
pbs_state.get_or_create_page = AsyncMock()
with (
- patch("skyvern.webeye.real_browser_manager.app") as mock_app,
+ patch_browser_manager_app() as mock_app,
patch.object(real_browser_manager, "SESSION_ACTIVITY_RENEWAL_INTERVAL_SECONDS", 0.01),
):
configure_browser_context_acquired_hook(mock_app)
@@ -1888,7 +1895,7 @@ async def test_session_activity_is_stamped_at_attach_not_an_interval_later() ->
pbs_state.get_or_create_page = AsyncMock()
with (
- patch("skyvern.webeye.real_browser_manager.app") as mock_app,
+ patch_browser_manager_app() as mock_app,
patch.object(real_browser_manager, "SESSION_ACTIVITY_RENEWAL_INTERVAL_SECONDS", 600.0),
):
configure_browser_context_acquired_hook(mock_app)
@@ -1927,7 +1934,7 @@ async def test_session_activity_cadence_is_not_reset_by_new_attaches() -> None:
steady_stamps.append(asyncio.get_running_loop().time())
with (
- patch("skyvern.webeye.real_browser_manager.app") as mock_app,
+ patch_browser_manager_app() as mock_app,
patch.object(real_browser_manager, "SESSION_ACTIVITY_RENEWAL_INTERVAL_SECONDS", 0.4),
):
mock_app.DATABASE.browser_sessions.touch_last_activity = AsyncMock(side_effect=touch)
@@ -1953,7 +1960,7 @@ def test_session_activity_renewer_recreates_event_for_a_new_loop() -> None:
stamps: list[Any] = []
async def run_once() -> None:
- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:
+ with patch_browser_manager_app() as mock_app:
touch = AsyncMock()
mock_app.DATABASE.browser_sessions.touch_last_activity = touch
await manager.begin_session_activity_renewal("pbs_loop")
@@ -1996,7 +2003,7 @@ async def test_failed_script_acquisition_leaves_no_live_session_behind() -> None
# that never started would protect the session from the reaper forever.
manager = RealBrowserManager()
- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:
+ with patch_browser_manager_app() as mock_app:
configure_browser_context_acquired_hook(mock_app)
mock_app.PERSISTENT_SESSIONS_MANAGER.begin_session = AsyncMock(return_value="gen_cold")
mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=None)
@@ -2156,7 +2163,7 @@ async def test_pbs_adoption_rebinds_download_dir_to_run_id() -> None:
pbs_state.get_or_create_page = AsyncMock()
with (
- patch("skyvern.webeye.real_browser_manager.app") as mock_app,
+ patch_browser_manager_app() as mock_app,
patch("skyvern.webeye.real_browser_manager.rebind_download_dir", new_callable=AsyncMock) as mock_rebind,
):
configure_browser_context_acquired_hook(mock_app)
@@ -2207,7 +2214,7 @@ async def test_public_workflow_adoption_keeps_lease_identity_separate_from_downl
pbs_state.get_or_create_page = AsyncMock()
with (
- patch("skyvern.webeye.real_browser_manager.app") as mock_app,
+ patch_browser_manager_app() as mock_app,
patch("skyvern.webeye.real_browser_manager.rebind_download_dir", new_callable=AsyncMock) as mock_rebind,
skyvern_context.scoped(
SkyvernContext(
@@ -2258,7 +2265,7 @@ async def test_pbs_task_adoption_rebinds_regardless_of_remote_interceptor(has_re
pbs_state.get_or_create_page = AsyncMock()
with (
- patch("skyvern.webeye.real_browser_manager.app") as mock_app,
+ patch_browser_manager_app() as mock_app,
patch(
"skyvern.webeye.real_browser_manager._rebind_pbs_download_dir",
new_callable=AsyncMock,
@@ -2299,7 +2306,7 @@ async def test_workflow_task_inherits_workflow_session_lease_without_beginning_t
pbs_state.get_working_page = AsyncMock(return_value=None)
pbs_state.get_or_create_page = AsyncMock()
- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:
+ with patch_browser_manager_app() as mock_app:
configure_browser_context_acquired_hook(mock_app)
mock_app.PERSISTENT_SESSIONS_MANAGER.begin_session = AsyncMock()
mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=pbs_state)
@@ -2335,7 +2342,7 @@ async def test_pbs_adoption_skips_rebind_when_no_browser() -> None:
pbs_state.get_or_create_page = AsyncMock()
with (
- patch("skyvern.webeye.real_browser_manager.app") as mock_app,
+ patch_browser_manager_app() as mock_app,
patch("skyvern.webeye.real_browser_manager.rebind_download_dir", new_callable=AsyncMock) as mock_rebind,
):
configure_browser_context_acquired_hook(mock_app)
@@ -2387,7 +2394,7 @@ async def test_pbs_adoption_skips_rebind_when_session_dir_binding() -> None:
pbs_state.get_or_create_page = AsyncMock()
with (
- patch("skyvern.webeye.real_browser_manager.app") as mock_app,
+ patch_browser_manager_app() as mock_app,
patch("skyvern.webeye.real_browser_manager.rebind_download_dir", new_callable=AsyncMock) as mock_rebind,
):
configure_browser_context_acquired_hook(mock_app)
@@ -2417,7 +2424,7 @@ async def test_pbs_adoption_rebinds_when_run_dir_binding() -> None:
pbs_state.get_or_create_page = AsyncMock()
with (
- patch("skyvern.webeye.real_browser_manager.app") as mock_app,
+ patch_browser_manager_app() as mock_app,
patch("skyvern.webeye.real_browser_manager.rebind_download_dir", new_callable=AsyncMock) as mock_rebind,
):
configure_browser_context_acquired_hook(mock_app)
@@ -2473,7 +2480,7 @@ async def test_pbs_navigate_evicts_and_retries_on_connection_closed_driver_error
fresh = _fresh_pbs_browser_state()
workflow_run = make_workflow_run("wfr_pbs")
- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:
+ with patch_browser_manager_app() as mock_app:
configure_browser_context_acquired_hook(mock_app)
mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(side_effect=[stale, fresh])
mock_app.PERSISTENT_SESSIONS_MANAGER.evict_cached_browser_state = AsyncMock()
@@ -2511,7 +2518,7 @@ async def test_pbs_navigate_does_not_retry_on_unrelated_error() -> None:
)
workflow_run = make_workflow_run("wfr_pbs")
- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:
+ with patch_browser_manager_app() as mock_app:
configure_browser_context_acquired_hook(mock_app)
mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=stale)
mock_app.PERSISTENT_SESSIONS_MANAGER.evict_cached_browser_state = AsyncMock()
@@ -2547,7 +2554,7 @@ async def test_pbs_navigate_does_not_evict_on_page_only_close() -> None:
)
workflow_run = make_workflow_run("wfr_pbs")
- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:
+ with patch_browser_manager_app() as mock_app:
configure_browser_context_acquired_hook(mock_app)
mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=stale)
mock_app.PERSISTENT_SESSIONS_MANAGER.evict_cached_browser_state = AsyncMock()
@@ -2585,7 +2592,7 @@ async def test_pbs_recovery_path_passes_expected_state_to_public_evict() -> None
workflow_run = make_workflow_run("wfr_pbs")
with (
- patch("skyvern.webeye.real_browser_manager.app") as mock_app,
+ patch_browser_manager_app() as mock_app,
patch("skyvern.webeye.real_browser_manager.rebind_download_dir", new_callable=AsyncMock),
):
configure_browser_context_acquired_hook(mock_app)
@@ -2626,7 +2633,7 @@ async def test_pbs_recovery_path_rebinds_download_dir_on_fresh_browser() -> None
workflow_run = make_workflow_run("wfr_pbs")
with (
- patch("skyvern.webeye.real_browser_manager.app") as mock_app,
+ patch_browser_manager_app() as mock_app,
patch("skyvern.webeye.real_browser_manager.rebind_download_dir", new_callable=AsyncMock) as mock_rebind,
):
configure_browser_context_acquired_hook(mock_app)
@@ -2666,7 +2673,7 @@ async def test_pbs_navigate_skips_recovery_when_manager_cannot_reconnect() -> No
)
workflow_run = make_workflow_run("wfr_pbs")
- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:
+ with patch_browser_manager_app() as mock_app:
configure_browser_context_acquired_hook(mock_app)
mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=stale)
mock_app.PERSISTENT_SESSIONS_MANAGER.evict_cached_browser_state = AsyncMock()
@@ -2708,7 +2715,7 @@ async def test_pbs_recovery_falls_through_to_get_or_create_page_when_fresh_state
fresh.get_working_page = AsyncMock(return_value=None)
workflow_run = make_workflow_run("wfr_pbs")
- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:
+ with patch_browser_manager_app() as mock_app:
configure_browser_context_acquired_hook(mock_app)
mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(side_effect=[stale, fresh])
mock_app.PERSISTENT_SESSIONS_MANAGER.evict_cached_browser_state = AsyncMock()
@@ -3302,7 +3309,7 @@ async def test_pbs_second_occupancy_rejected_leaves_no_local_lease() -> None:
manager = RealBrowserManager()
task = make_task("tsk_second", workflow_run_id=None)
- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:
+ with patch_browser_manager_app() as mock_app:
configure_browser_context_acquired_hook(mock_app)
mock_app.PERSISTENT_SESSIONS_MANAGER.begin_session = AsyncMock(
side_effect=BrowserSessionAlreadyOccupiedError("pbs_busy", "wr_first_owner")
@@ -3747,7 +3754,7 @@ async def test_a_run_occupying_a_persistent_session_drops_a_previous_runs_dialog
dialog_handler.set_run_dialog_policy(context, "dismiss", None, "wr_dialog_previous")
try:
- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:
+ with patch_browser_manager_app() as mock_app:
configure_browser_context_acquired_hook(mock_app)
mock_app.PERSISTENT_SESSIONS_MANAGER.get_browser_state = AsyncMock(return_value=pbs_state)
mock_app.PERSISTENT_SESSIONS_MANAGER.set_browser_state = AsyncMock()
@@ -3776,7 +3783,7 @@ async def test_a_child_run_inheriting_its_parents_browser_keeps_the_parents_dial
dialog_handler.set_run_dialog_policy(context, "accept", None, "wr_dialog_parent")
try:
- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:
+ with patch_browser_manager_app() as mock_app:
configure_browser_context_acquired_hook(mock_app)
with patch.object(manager, "_start_frame_publisher", AsyncMock()):
result = await manager.get_or_create_for_workflow_run(
@@ -3807,7 +3814,7 @@ async def test_a_nested_run_keeps_every_live_ancestors_dialog_answer() -> None:
dialog_handler.set_run_dialog_policy(context, "accept", None, run_id)
try:
- with patch("skyvern.webeye.real_browser_manager.app") as mock_app:
+ with patch_browser_manager_app() as mock_app:
configure_browser_context_acquired_hook(mock_app)
mock_app.WORKFLOW_CONTEXT_MANAGER.has_workflow_run_context = lambda run_id: run_id in live
with patch.object(manager, "_start_frame_publisher", AsyncMock()):
@@ -4116,7 +4123,7 @@ async def test_run_timezone_receipt_claims_the_workflow_version_only_for_a_brows
bound_workflow_permanent_id="wpid_tz" if bound_key else None,
bound_key=bound_key,
)
- with patch.object(real_browser_manager, "app") as mock_app:
+ with patch_browser_manager_app() as mock_app:
mock_app.PERSISTENT_SESSIONS_MANAGER.get_session = AsyncMock(return_value=session)
record = mock_app.DATABASE.workflow_runs.record_workflow_run_browser_settings_receipt = AsyncMock()
await real_browser_manager._record_run_timezone_receipt(
diff --git a/tests/unit/test_totp_identifier_fallback.py b/tests/unit/test_totp_identifier_fallback.py
index 456697d73..f6f0d013b 100644
--- a/tests/unit/test_totp_identifier_fallback.py
+++ b/tests/unit/test_totp_identifier_fallback.py
@@ -57,6 +57,7 @@ async def test_register_credential_parameter_uses_db_totp_identifier(monkeypatch
DATABASE=FakeDatabase(),
CREDENTIAL_VAULT_SERVICES={CredentialVaultType.BITWARDEN: FakeCredentialService()},
AGENT_FUNCTION=SimpleNamespace(
+ enforce_credential_use=AsyncMock(),
parse_enterprise_totp_secret=AsyncMock(return_value=None),
process_registered_credential_item=process_item,
),
@@ -122,6 +123,7 @@ async def _register_with_credential(
DATABASE=FakeDatabase(),
CREDENTIAL_VAULT_SERVICES={CredentialVaultType.BITWARDEN: FakeCredentialService()},
AGENT_FUNCTION=SimpleNamespace(
+ enforce_credential_use=AsyncMock(),
parse_enterprise_totp_secret=AsyncMock(return_value=None),
process_registered_credential_item=process_item,
),
diff --git a/tests/unit/test_workflow_run_parameter_batching.py b/tests/unit/test_workflow_run_parameter_batching.py
index 546688acd..9608956e8 100644
--- a/tests/unit/test_workflow_run_parameter_batching.py
+++ b/tests/unit/test_workflow_run_parameter_batching.py
@@ -643,6 +643,7 @@ async def test_setup_workflow_run_still_validates_provided_credential_for_at_wil
with patch("skyvern.forge.sdk.workflow.service.app") as mock_app:
mock_app.DATABASE.workflows.get_browser_action_policy = AsyncMock(return_value=None)
mock_app.EXPERIMENTATION_PROVIDER.is_feature_enabled_cached = AsyncMock(return_value=False)
+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()
mock_app.AGENT_FUNCTION.should_use_flex_llm_routing = AsyncMock(return_value=False)
mock_app.DATABASE.credentials.get_credentials_by_ids = AsyncMock(return_value=[])
@@ -672,6 +673,7 @@ async def test_setup_workflow_run_credential_with_default_uses_default() -> None
with patch("skyvern.forge.sdk.workflow.service.app") as mock_app:
mock_app.DATABASE.workflows.get_browser_action_policy = AsyncMock(return_value=None)
mock_app.EXPERIMENTATION_PROVIDER.is_feature_enabled_cached = AsyncMock(return_value=False)
+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()
mock_app.AGENT_FUNCTION.should_use_flex_llm_routing = AsyncMock(return_value=False)
mock_app.DATABASE.credentials.get_credentials_by_ids = AsyncMock(
return_value=[SimpleNamespace(credential_id="cred_id_0")]
@@ -896,7 +898,7 @@ async def test_setup_workflow_run_validates_credentials_before_preparing_managed
organization=organization,
)
- service._validate_credential_ids.assert_awaited_once_with(["cred_missing"], organization)
+ service._validate_credential_ids.assert_awaited_once_with(["cred_missing"], organization, workflow_run_id="wr_test")
service._resolve_and_stamp_run_seed.assert_not_awaited()
service.create_workflow_run_parameters.assert_not_awaited()
service.mark_workflow_run_as_failed.assert_awaited_once()
@@ -921,6 +923,7 @@ async def test_setup_workflow_run_batches_credential_validation() -> None:
mock_app.DATABASE.workflows.get_browser_action_policy = AsyncMock(return_value=None)
mock_app.EXPERIMENTATION_PROVIDER.is_feature_enabled_cached = AsyncMock(return_value=False)
+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()
mock_app.AGENT_FUNCTION.should_use_flex_llm_routing = AsyncMock(return_value=False)
mock_app.DATABASE.credentials.get_credentials_by_ids = AsyncMock(
return_value=[SimpleNamespace(credential_id=f"cred_id_{i}") for i in range(3)]
@@ -982,6 +985,7 @@ async def test_setup_workflow_run_raises_invalid_credential_when_missing() -> No
mock_app.DATABASE.workflows.get_browser_action_policy = AsyncMock(return_value=None)
mock_app.EXPERIMENTATION_PROVIDER.is_feature_enabled_cached = AsyncMock(return_value=False)
+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()
mock_app.AGENT_FUNCTION.should_use_flex_llm_routing = AsyncMock(return_value=False)
mock_app.DATABASE.credentials.get_credentials_by_ids = AsyncMock(return_value=[])
@@ -1015,6 +1019,7 @@ async def test_setup_workflow_run_surfaces_all_missing_credentials() -> None:
mock_app.DATABASE.workflows.get_browser_action_policy = AsyncMock(return_value=None)
mock_app.EXPERIMENTATION_PROVIDER.is_feature_enabled_cached = AsyncMock(return_value=False)
+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()
mock_app.AGENT_FUNCTION.should_use_flex_llm_routing = AsyncMock(return_value=False)
# Only cred_id_0 exists; cred_id_1 and cred_id_2 are missing.
mock_app.DATABASE.credentials.get_credentials_by_ids = AsyncMock(
@@ -1054,6 +1059,7 @@ async def test_setup_workflow_run_dedupes_repeated_credential_ids() -> None:
mock_app.DATABASE.workflows.get_browser_action_policy = AsyncMock(return_value=None)
mock_app.EXPERIMENTATION_PROVIDER.is_feature_enabled_cached = AsyncMock(return_value=False)
+ mock_app.AGENT_FUNCTION.enforce_credential_use = AsyncMock()
mock_app.AGENT_FUNCTION.should_use_flex_llm_routing = AsyncMock(return_value=False)
mock_app.DATABASE.credentials.get_credentials_by_ids = AsyncMock(
return_value=[SimpleNamespace(credential_id="cred_shared")]